tailwind-styled-v4 5.0.0 → 5.0.1

package/dist/vite.js

@@ -1,11 +1,4177 @@
-import './chunk-VZEJV27B.js';
-import fs from 'fs';
-import path from 'path';
-import { runLoaderTransform, generateSafelist } from '@tailwind-styled/compiler';
-import { createEngine } from '@tailwind-styled/engine';
-import { scanWorkspaceAsync } from '@tailwind-styled/scanner';
-
-/* tailwind-styled-v4 v4 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tailwindMerge = require('tailwind-merge');
+var fs3 = require('fs');
+var module$1 = require('module');
+var os = require('os');
+var path10 = require('path');
+var url = require('url');
+var crypto = require('crypto');
+var worker_threads = require('worker_threads');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs3__default = /*#__PURE__*/_interopDefault(fs3);
+var os__default = /*#__PURE__*/_interopDefault(os);
+var path10__default = /*#__PURE__*/_interopDefault(path10);
+
+/* tailwind-styled-v4 v5.0.1 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+function mergeClassesStatic(classes) {
+  return tailwindMerge.twMerge(classes);
+}
+var init_classMerger = __esm({
+  "packages/compiler/src/classMerger.ts"() {
+  }
+});
+function getPlatformExtension() {
+  const platform = os__default.default.platform();
+  switch (platform) {
+    case "win32":
+      return ".node";
+    case "darwin":
+      return ".dylib";
+    case "linux":
+      return ".so";
+    default:
+      return ".node";
+  }
+}
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function resolveRuntimeDir(dirnameValue, moduleImportUrl) {
+  if (typeof dirnameValue === "string" && dirnameValue.length > 0) return dirnameValue;
+  return path10__default.default.dirname(url.fileURLToPath(moduleImportUrl));
+}
+function resolveNativeBindingCandidates(options) {
+  const out = [];
+  const envVarNames = options.envVarNames ?? ["TWS_NATIVE_PATH"];
+  for (const envVarName of envVarNames) {
+    const raw = process.env[envVarName]?.trim();
+    if (!raw) continue;
+    const resolved = path10__default.default.resolve(raw);
+    if (options.enforceNodeExtensionForEnvPath) {
+      if (path10__default.default.extname(resolved).toLowerCase() !== ".node") {
+        throw new Error(
+          `Invalid native binding path from ${envVarName}="${raw}". Expected a .node file.`
+        );
+      }
+    }
+    out.push(resolved);
+  }
+  if (options.includeDefaultCandidates !== false) {
+    const ext = options.platformExtension ?? getPlatformExtension();
+    const defaultBindingName = `tailwind_styled_parser${ext}`;
+    out.push(path10__default.default.resolve(process.cwd(), "native", defaultBindingName));
+    out.push(path10__default.default.resolve(options.runtimeDir, "..", "..", "..", "native", defaultBindingName));
+  }
+  return Array.from(new Set(out));
+}
+function parseDebugToken(namespace, token) {
+  if (token === "*" || token === namespace || token === "tailwind-styled:*") return true;
+  return token.endsWith("*") && namespace.startsWith(token.slice(0, -1));
+}
+function isDebugNamespaceEnabled(namespace) {
+  if (process.env.TWS_DEBUG === "1" || process.env.TAILWIND_STYLED_DEBUG === "1") return true;
+  const raw = process.env.DEBUG;
+  if (!raw) return false;
+  return raw.split(",").map((token) => token.trim()).some((token) => parseDebugToken(namespace, token));
+}
+function createDebugLogger(namespace, label = namespace) {
+  const debugEnabled = isDebugNamespaceEnabled(namespace);
+  return (message) => {
+    if (!debugEnabled) return;
+    console.debug(`[${label}] ${message}`);
+  };
+}
+function loadNativeBinding(options) {
+  const req = module$1.createRequire(path10__default.default.join(options.runtimeDir, "noop.cjs"));
+  const loadErrors = [];
+  for (const candidate of options.candidates) {
+    if (!fs3__default.default.existsSync(candidate)) continue;
+    try {
+      const mod = req(candidate);
+      if (options.isValid(mod)) {
+        return {
+          binding: mod,
+          loadedPath: candidate,
+          loadErrors
+        };
+      }
+      loadErrors.push({
+        path: candidate,
+        message: options.invalidExportMessage
+      });
+    } catch (error) {
+      loadErrors.push({
+        path: candidate,
+        message: formatErrorMessage(error)
+      });
+    }
+  }
+  return {
+    binding: null,
+    loadedPath: null,
+    loadErrors
+  };
+}
+var init_nativeBinding = __esm({
+  "packages/shared/src/nativeBinding.ts"() {
+  }
+});
+
+// packages/shared/src/logger.ts
+function getEnvLevel() {
+  const env = process.env.TWS_LOG_LEVEL?.toLowerCase();
+  if (env && env in LEVELS) return env;
+  return process.env.TWS_DEBUG_SCANNER === "1" ? "debug" : "info";
+}
+function createLogger(prefix, level) {
+  let currentLevel = getEnvLevel();
+  const log5 = (msgLevel, stream, args) => {
+    if (LEVELS[msgLevel] > LEVELS[currentLevel]) return;
+    const line = `[${prefix}] ${args.map(String).join(" ")}
+`;
+    process[stream].write(line);
+  };
+  return {
+    error: (...a) => log5("error", "stderr", a),
+    warn: (...a) => log5("warn", "stderr", a),
+    info: (...a) => log5("info", "stdout", a),
+    debug: (...a) => log5("debug", "stderr", a),
+    setLevel: (l) => {
+      currentLevel = l;
+    }
+  };
+}
+var LEVELS;
+var init_logger = __esm({
+  "packages/shared/src/logger.ts"() {
+    LEVELS = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
+    createLogger("tailwind-styled");
+  }
+});
+function hashContent(content, algorithm = "md5", length = 8) {
+  return crypto.createHash(algorithm).update(content).digest("hex").slice(0, length);
+}
+var init_hash = __esm({
+  "packages/shared/src/hash.ts"() {
+  }
+});
+
+// packages/shared/src/index.ts
+var init_src = __esm({
+  "packages/shared/src/index.ts"() {
+    init_nativeBinding();
+    init_logger();
+    init_hash();
+  }
+});
+
+// packages/compiler/src/nativeBridge.ts
+var nativeBridge_exports = {};
+__export(nativeBridge_exports, {
+  adaptNativeResult: () => adaptNativeResult,
+  getNativeBridge: () => getNativeBridge,
+  resetNativeBridgeCache: () => resetNativeBridgeCache
+});
+function tryRequire(id) {
+  try {
+    const mod = requireFromRuntime(id);
+    return mod ?? null;
+  } catch (error) {
+    log.debug(
+      `native bridge load miss ${id}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+function getNativeBridge() {
+  if (cachedBridge !== void 0) {
+    if (cachedBridge === null) {
+      throw new Error(
+        `[tailwind-styled/compiler v5] Native binding is required but not available.
+Please ensure:
+  1. The native module is properly installed
+  2. You have run: npm run build:native (or use prebuilt binary)
+  3. TWS_NO_NATIVE environment variable is not set
+
+For help, see: https://tailwind-styled.dev/docs/install`
+      );
+    }
+    return cachedBridge;
+  }
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_NO_RUST === "1") {
+    cachedBridge = null;
+    throw new Error(
+      `[tailwind-styled/compiler v5] Native binding is required.
+The TWS_NO_NATIVE or TWS_NO_RUST environment variable is set, which disables native binding.
+Please unset this environment variable to use the native compiler.`
+    );
+  }
+  const candidates = [
+    "@tailwind-styled/native",
+    path10__default.default.resolve(process.cwd(), "native", "index.mjs"),
+    path10__default.default.resolve(runtimeDir, "..", "..", "native", "index.mjs"),
+    path10__default.default.resolve(runtimeDir, "..", "..", "..", "native", "index.mjs"),
+    path10__default.default.resolve(process.cwd(), "native", "index.node"),
+    path10__default.default.resolve(runtimeDir, "..", "..", "native", "index.node"),
+    path10__default.default.resolve(runtimeDir, "..", "..", "..", "native", "index.node")
+  ];
+  for (const candidate of candidates) {
+    const bridge = tryRequire(candidate);
+    if (bridge) {
+      log.debug(`native bridge loaded from ${candidate}`);
+      cachedBridge = bridge;
+      return cachedBridge;
+    }
+  }
+  cachedBridge = null;
+  throw new Error(
+    `[tailwind-styled/compiler v5] Native binding not found.
+Tried loading from:
+` + candidates.map((c) => `  - ${c}`).join("\n") + `
+
+Please build the native module:
+  npm run build:native
+
+Or install a prebuilt binary for your platform.`
+  );
+}
+function resetNativeBridgeCache() {
+  cachedBridge = void 0;
+}
+function adaptNativeResult(raw) {
+  let rsc;
+  if (raw.rscJson) {
+    try {
+      const parsed = JSON.parse(raw.rscJson);
+      rsc = {
+        isServer: parsed.isServer,
+        needsClientDirective: parsed.needsClientDirective,
+        clientReasons: []
+      };
+    } catch {
+    }
+  }
+  let metadata;
+  if (raw.metadataJson) {
+    try {
+      metadata = JSON.parse(raw.metadataJson);
+    } catch {
+    }
+  }
+  return {
+    code: raw.code,
+    classes: raw.classes,
+    changed: raw.changed,
+    rsc,
+    metadata
+  };
+}
+var runtimeDir, requireFromRuntime, cachedBridge, log;
+var init_nativeBridge = __esm({
+  "packages/compiler/src/nativeBridge.ts"() {
+    init_src();
+    runtimeDir = typeof __dirname === "string" && __dirname.length > 0 ? __dirname : process.cwd();
+    requireFromRuntime = typeof module !== "undefined" && typeof module.require === "function" ? module.require.bind(module) : module$1.createRequire(path10__default.default.join(runtimeDir, "noop.cjs"));
+    log = createLogger("compiler:native");
+  }
+});
+
+// packages/compiler/src/twDetector.ts
+var TEMPLATE_RE, OBJECT_RE, EXTEND_RE;
+var init_twDetector = __esm({
+  "packages/compiler/src/twDetector.ts"() {
+    TEMPLATE_RE = /\btw\.(server\.)?(\w+)`((?:[^`\\]|\\.)*)`/g;
+    OBJECT_RE = /\btw\.(server\.)?(\w+)\(\s*(\{[\s\S]*?\})\s*\)/g;
+    EXTEND_RE = /(\w+)\.extend`((?:[^`\\]|\\.)*)`/g;
+  }
+});
+
+// packages/compiler/src/cssCompiler.ts
+var cssCompiler_exports = {};
+__export(cssCompiler_exports, {
+  buildStyleTag: () => buildStyleTag,
+  compileCssFromClasses: () => compileCssFromClasses
+});
+function getBinding() {
+  if (_binding !== void 0) {
+    if (_binding === null) {
+      throw new Error(
+        `[tailwind-styled/compiler v5] Native CSS binding is required but not available.
+Please ensure the native module is properly built.`
+      );
+    }
+    return _binding;
+  }
+  if (process.env.TWS_NO_NATIVE === "1") {
+    _binding = null;
+    throw new Error(
+      `[tailwind-styled/compiler v5] Native binding is required.
+The TWS_NO_NATIVE environment variable is set, which disables native binding.`
+    );
+  }
+  const req = typeof __require === "function" ? __require : module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('vite.js', document.baseURI).href)));
+  const candidates = [
+    path10__default.default.resolve(process.cwd(), "native", "tailwind_styled_parser.node"),
+    path10__default.default.resolve(__dirname, "..", "..", "..", "..", "native", "tailwind_styled_parser.node")
+  ];
+  for (const c of candidates) {
+    try {
+      const mod = req(c);
+      if (mod?.compileCss) {
+        _binding = mod;
+        return _binding;
+      }
+    } catch {
+    }
+  }
+  _binding = null;
+  throw new Error(
+    `[tailwind-styled/compiler v5] Native CSS binding not found.
+Tried loading from:
+` + candidates.map((c) => `  - ${c}`).join("\n") + `
+
+Please build the native module.`
+  );
+}
+function compileCssFromClasses(classes, options = {}) {
+  const binding = getBinding();
+  const prefix = options.prefix ?? null;
+  const r = binding.compileCss(classes, prefix);
+  return {
+    css: r.css,
+    resolvedClasses: r.resolvedClasses,
+    unknownClasses: r.unknownClasses,
+    sizeBytes: r.sizeBytes,
+    engine: "rust"
+  };
+}
+function buildStyleTag(classes) {
+  const { css } = compileCssFromClasses(classes);
+  return css ? `<style data-tailwind-styled>${css}</style>` : "";
+}
+var _binding;
+var init_cssCompiler = __esm({
+  "packages/compiler/src/cssCompiler.ts"() {
+  }
+});
+
+// packages/compiler/src/classExtractor.ts
+function extractAllClasses(source) {
+  const { getNativeBridge: getNativeBridge2 } = (init_nativeBridge(), __toCommonJS(nativeBridge_exports));
+  const native = getNativeBridge2();
+  if (!native?.extractClassesFromSourceNative) {
+    throw new Error(
+      `[tailwind-styled/compiler v5] extractClassesFromSourceNative is required but not available.
+Please ensure the native module is properly built.`
+    );
+  }
+  const result = native.extractClassesFromSourceNative(source);
+  if (!result || result.length < 0) {
+    throw new Error(
+      `[tailwind-styled/compiler v5] extractClassesFromSourceNative returned invalid result.`
+    );
+  }
+  return result.sort();
+}
+var init_classExtractor = __esm({
+  "packages/compiler/src/classExtractor.ts"() {
+    init_twDetector();
+    new RegExp(TEMPLATE_RE.source, "g");
+    new RegExp(OBJECT_RE.source, "g");
+    new RegExp(EXTEND_RE.source, "g");
+  }
+});
+function ensureCacheDir() {
+  if (!fs3__default.default.existsSync(CACHE_DIR)) {
+    fs3__default.default.mkdirSync(CACHE_DIR, { recursive: true });
+  }
+}
+function loadHashCache() {
+  try {
+    if (fs3__default.default.existsSync(HASH_CACHE_FILE)) {
+      const raw = fs3__default.default.readFileSync(HASH_CACHE_FILE, "utf-8");
+      return new Map(Object.entries(JSON.parse(raw)));
+    }
+  } catch {
+  }
+  return /* @__PURE__ */ new Map();
+}
+function saveHashCache(cache) {
+  try {
+    ensureCacheDir();
+    const obj = Object.fromEntries(cache);
+    fs3__default.default.writeFileSync(HASH_CACHE_FILE, JSON.stringify(obj, null, 2));
+  } catch {
+  }
+}
+function loadGraphCache() {
+  try {
+    if (fs3__default.default.existsSync(GRAPH_CACHE_FILE)) {
+      const raw = fs3__default.default.readFileSync(GRAPH_CACHE_FILE, "utf-8");
+      const data = JSON.parse(raw);
+      return new Map(Object.entries(data));
+    }
+  } catch {
+  }
+  return /* @__PURE__ */ new Map();
+}
+function saveGraphCache(graph) {
+  try {
+    ensureCacheDir();
+    const obj = Object.fromEntries(graph);
+    fs3__default.default.writeFileSync(GRAPH_CACHE_FILE, JSON.stringify(obj, null, 2));
+  } catch {
+  }
+}
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = h * 16777619 >>> 0;
+  }
+  return h;
+}
+function toBase36(n, len = 4) {
+  const chars = "0123456789abcdefghijklmnopqrstuvwxyz";
+  let result = "";
+  let num = n;
+  for (let i = 0; i < len; i++) {
+    result = chars[num % 36] + result;
+    num = Math.floor(num / 36);
+  }
+  return result;
+}
+function hashFileContent(content) {
+  return hashContent(content, "md5", 8);
+}
+function makeAtomicClass(declaration, modifier) {
+  const key = modifier ? `${declaration}::${modifier}` : declaration;
+  return `tw-${toBase36(fnv1a(key))}`;
+}
+function computeDiff(oldNodes, newNodes) {
+  const oldMap = new Map(oldNodes.map((n) => [n.atomicClass, n]));
+  const newMap = new Map(newNodes.map((n) => [n.atomicClass, n]));
+  const added = [];
+  const removed = [];
+  for (const [cls, node] of newMap) {
+    if (!oldMap.has(cls)) added.push(node);
+  }
+  for (const cls of oldMap.keys()) {
+    if (!newMap.has(cls)) removed.push(cls);
+  }
+  return {
+    added,
+    removed,
+    noChange: added.length === 0 && removed.length === 0
+  };
+}
+function nodeToCSS(node) {
+  const { atomicClass, declaration, modifier } = node;
+  if (!modifier) {
+    return `.${atomicClass}{${declaration}}`;
+  }
+  if (modifier.startsWith("@")) {
+    return `${modifier}{.${atomicClass}{${declaration}}}`;
+  }
+  return `.${atomicClass}${modifier}{${declaration}}`;
+}
+function parseClassesToNodes(classes) {
+  const nodes = [];
+  for (const cls of classes) {
+    const node = parseOneClass(cls);
+    if (node) nodes.push(node);
+  }
+  return nodes;
+}
+function parseOneClass(cls) {
+  const colonIdx = cls.lastIndexOf(":");
+  let modifier;
+  let utility;
+  if (colonIdx > 0) {
+    const modStr = cls.slice(0, colonIdx);
+    utility = cls.slice(colonIdx + 1);
+    modifier = resolveModifier(modStr);
+  } else {
+    utility = cls;
+  }
+  const declaration = twToDeclaration(utility);
+  if (!declaration) return null;
+  const atomicClass = makeAtomicClass(declaration, modifier);
+  return { twClass: cls, declaration, modifier, atomicClass };
+}
+function resolveModifier(mod) {
+  const pseudoMap = {
+    hover: ":hover",
+    focus: ":focus",
+    active: ":active",
+    disabled: ":disabled",
+    visited: ":visited",
+    checked: ":checked",
+    first: ":first-child",
+    last: ":last-child",
+    odd: ":nth-child(odd)",
+    even: ":nth-child(even)"
+  };
+  const mediaMap = {
+    sm: "@media (min-width: 640px)",
+    md: "@media (min-width: 768px)",
+    lg: "@media (min-width: 1024px)",
+    xl: "@media (min-width: 1280px)",
+    "2xl": "@media (min-width: 1536px)",
+    dark: "@media (prefers-color-scheme: dark)",
+    print: "@media print"
+  };
+  return pseudoMap[mod] ?? mediaMap[mod] ?? `:${mod}`;
+}
+function twToDeclaration(cls) {
+  const sp = cls.match(/^(p|px|py|pt|pb|pl|pr|m|mx|my|mt|mb|ml|mr|gap)-([\d.]+)$/);
+  if (sp) {
+    const propMap = {
+      p: "padding",
+      px: "padding-inline",
+      py: "padding-block",
+      pt: "padding-top",
+      pb: "padding-bottom",
+      pl: "padding-left",
+      pr: "padding-right",
+      m: "margin",
+      mx: "margin-inline",
+      my: "margin-block",
+      mt: "margin-top",
+      mb: "margin-bottom",
+      ml: "margin-left",
+      mr: "margin-right",
+      gap: "gap"
+    };
+    return `${propMap[sp[1]]}: ${parseFloat(sp[2]) * 0.25}rem`;
+  }
+  const w = cls.match(/^w-(.+)$/);
+  if (w) return `width: ${sizeVal(w[1])}`;
+  const h = cls.match(/^h-(.+)$/);
+  if (h) return `height: ${sizeVal(h[1])}`;
+  const op = cls.match(/^opacity-(\d+)$/);
+  if (op) return `opacity: ${parseInt(op[1], 10) / 100}`;
+  const z = cls.match(/^z-(\d+)$/);
+  if (z) return `z-index: ${z[1]}`;
+  const map = {
+    block: "display: block",
+    "inline-block": "display: inline-block",
+    flex: "display: flex",
+    "inline-flex": "display: inline-flex",
+    grid: "display: grid",
+    hidden: "display: none",
+    relative: "position: relative",
+    absolute: "position: absolute",
+    fixed: "position: fixed",
+    sticky: "position: sticky",
+    "flex-row": "flex-direction: row",
+    "flex-col": "flex-direction: column",
+    "items-center": "align-items: center",
+    "items-start": "align-items: flex-start",
+    "items-end": "align-items: flex-end",
+    "justify-center": "justify-content: center",
+    "justify-between": "justify-content: space-between",
+    "justify-start": "justify-content: flex-start",
+    "justify-end": "justify-content: flex-end",
+    "font-thin": "font-weight: 100",
+    "font-light": "font-weight: 300",
+    "font-normal": "font-weight: 400",
+    "font-medium": "font-weight: 500",
+    "font-semibold": "font-weight: 600",
+    "font-bold": "font-weight: 700",
+    "font-extrabold": "font-weight: 800",
+    "text-xs": "font-size: 0.75rem",
+    "text-sm": "font-size: 0.875rem",
+    "text-base": "font-size: 1rem",
+    "text-lg": "font-size: 1.125rem",
+    "text-xl": "font-size: 1.25rem",
+    "text-2xl": "font-size: 1.5rem",
+    "text-3xl": "font-size: 1.875rem",
+    "text-4xl": "font-size: 2.25rem",
+    rounded: "border-radius: 0.25rem",
+    "rounded-md": "border-radius: 0.375rem",
+    "rounded-lg": "border-radius: 0.5rem",
+    "rounded-xl": "border-radius: 0.75rem",
+    "rounded-full": "border-radius: 9999px",
+    "overflow-hidden": "overflow: hidden",
+    "overflow-auto": "overflow: auto",
+    "cursor-pointer": "cursor: pointer",
+    "cursor-default": "cursor: default",
+    "select-none": "user-select: none",
+    "pointer-events-none": "pointer-events: none",
+    truncate: "overflow: hidden; text-overflow: ellipsis; white-space: nowrap",
+    transition: "transition-property: color,background-color,border-color,opacity,box-shadow,transform; transition-duration: 150ms"
+  };
+  return map[cls] ?? null;
+}
+function sizeVal(v) {
+  const num = parseFloat(v);
+  if (!Number.isNaN(num)) return `${num * 0.25}rem`;
+  const special = {
+    full: "100%",
+    screen: "100vw",
+    auto: "auto",
+    min: "min-content",
+    max: "max-content",
+    fit: "fit-content"
+  };
+  return special[v] ?? v;
+}
+function getIncrementalEngine(opts) {
+  if (!_engine) {
+    _engine = new IncrementalEngine(opts);
+  }
+  return _engine;
+}
+var CACHE_DIR, HASH_CACHE_FILE, GRAPH_CACHE_FILE, GlobalAtomicRegistry, CssDiffWriter, IncrementalEngine, _engine;
+var init_incrementalEngine = __esm({
+  "packages/compiler/src/incrementalEngine.ts"() {
+    init_src();
+    CACHE_DIR = ".tw-cache";
+    HASH_CACHE_FILE = path10__default.default.join(CACHE_DIR, "file-hashes.json");
+    GRAPH_CACHE_FILE = path10__default.default.join(CACHE_DIR, "dep-graph.json");
+    GlobalAtomicRegistry = class {
+      constructor() {
+        this.entries = /* @__PURE__ */ new Map();
+      }
+      /** Tambah node dari file tertentu */
+      add(filepath, node) {
+        const existing = this.entries.get(node.atomicClass);
+        if (existing) {
+          existing.sources.add(filepath);
+        } else {
+          this.entries.set(node.atomicClass, {
+            node,
+            sources: /* @__PURE__ */ new Set([filepath])
+          });
+        }
+      }
+      /** Hapus referensi dari file tertentu; jika tidak ada source lain, rule dihapus */
+      remove(filepath, atomicClass) {
+        const entry = this.entries.get(atomicClass);
+        if (!entry) return false;
+        entry.sources.delete(filepath);
+        if (entry.sources.size === 0) {
+          this.entries.delete(atomicClass);
+          return true;
+        }
+        return false;
+      }
+      /** Cek apakah rule ada di registry global */
+      has(atomicClass) {
+        return this.entries.has(atomicClass);
+      }
+      /** Semua entries untuk CSS generation */
+      all() {
+        return Array.from(this.entries.values()).map((e) => e.node);
+      }
+      /** Total unique rules */
+      size() {
+        return this.entries.size;
+      }
+    };
+    CssDiffWriter = class {
+      constructor(outputPath) {
+        this.ruleMap = /* @__PURE__ */ new Map();
+        this.dirty = false;
+        this.outputPath = outputPath;
+        this.loadFromDisk();
+      }
+      loadFromDisk() {
+        try {
+          if (fs3__default.default.existsSync(this.outputPath)) {
+            const css = fs3__default.default.readFileSync(this.outputPath, "utf-8");
+            const ruleRe = /(\.tw-[a-z0-9]+(?::[\w-]+)?)\{([^}]+)\}|(@[^{]+)\{(\.tw-[a-z0-9]+)\{([^}]+)\}\}/g;
+            let m;
+            while ((m = ruleRe.exec(css)) !== null) {
+              if (m[1]) {
+                const cls = m[1].replace(/\.[^:]+:.*/, (match) => match.split(".")[1].split(":")[0]);
+                this.ruleMap.set(cls, m[0]);
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      /** Apply diff ke internal map */
+      applyDiff(diff) {
+        if (diff.noChange) return;
+        for (const node of diff.added) {
+          this.ruleMap.set(node.atomicClass, nodeToCSS(node));
+        }
+        for (const cls of diff.removed) {
+          this.ruleMap.delete(cls);
+        }
+        this.dirty = true;
+      }
+      /** Write ke disk jika ada perubahan. Async untuk tidak block loader. */
+      async flush() {
+        if (!this.dirty) return;
+        try {
+          ensureCacheDir();
+          const css = Array.from(this.ruleMap.values()).join("\n");
+          await fs3__default.default.promises.writeFile(this.outputPath, css, "utf-8");
+          this.dirty = false;
+        } catch {
+        }
+      }
+      /** Sync flush untuk build end */
+      flushSync() {
+        if (!this.dirty) return;
+        try {
+          ensureCacheDir();
+          const css = Array.from(this.ruleMap.values()).join("\n");
+          fs3__default.default.writeFileSync(this.outputPath, css, "utf-8");
+          this.dirty = false;
+        } catch {
+        }
+      }
+      size() {
+        return this.ruleMap.size;
+      }
+    };
+    IncrementalEngine = class {
+      constructor(opts = {}) {
+        // Stats untuk current build session
+        this.stats = {
+          totalFiles: 0,
+          changedFiles: 0,
+          skippedFiles: 0,
+          addedRules: 0,
+          removedRules: 0,
+          buildTimeMs: 0
+        };
+        this.sessionStart = Date.now();
+        this.opts = {
+          outputPath: opts.outputPath ?? path10__default.default.join(CACHE_DIR, "atomic.css"),
+          persistCache: opts.persistCache ?? true,
+          verbose: opts.verbose ?? false
+        };
+        this.hashCache = this.opts.persistCache ? loadHashCache() : /* @__PURE__ */ new Map();
+        this.depGraph = this.opts.persistCache ? loadGraphCache() : /* @__PURE__ */ new Map();
+        this.globalReg = new GlobalAtomicRegistry();
+        this.cssWriter = new CssDiffWriter(this.opts.outputPath);
+        for (const [filepath, nodes] of this.depGraph) {
+          for (const node of nodes) {
+            this.globalReg.add(filepath, node);
+          }
+        }
+      }
+      /**
+       * Proses satu file. Core method dipanggil oleh webpack/turbopack loader.
+       *
+       * @param filepath      - Absolute path ke file
+       * @param source        - Source code file (untuk hashing)
+       * @param extractedNodes - Style nodes yang di-extract compiler dari file ini
+       * @returns ProcessResult dengan diff dan stats
+       */
+      processFile(filepath, source, extractedNodes) {
+        const t0 = Date.now();
+        this.stats.totalFiles++;
+        const currentHash = hashFileContent(source);
+        const cachedHash = this.hashCache.get(filepath);
+        if (cachedHash === currentHash) {
+          this.stats.skippedFiles++;
+          this.log(`[skip] ${path10__default.default.relative(process.cwd(), filepath)}`);
+          return {
+            filepath,
+            changed: false,
+            diff: { added: [], removed: [], noChange: true },
+            durationMs: Date.now() - t0
+          };
+        }
+        this.hashCache.set(filepath, currentHash);
+        this.stats.changedFiles++;
+        this.log(`[change] ${path10__default.default.relative(process.cwd(), filepath)}`);
+        const oldNodes = this.depGraph.get(filepath) ?? [];
+        const diff = computeDiff(oldNodes, extractedNodes);
+        this.depGraph.set(filepath, extractedNodes);
+        const trulyRemoved = [];
+        for (const cls of diff.removed) {
+          const wasRemoved = this.globalReg.remove(filepath, cls);
+          if (wasRemoved) trulyRemoved.push(cls);
+        }
+        const trulyAdded = [];
+        for (const node of diff.added) {
+          if (!this.globalReg.has(node.atomicClass)) {
+            trulyAdded.push(node);
+          }
+          this.globalReg.add(filepath, node);
+        }
+        const finalDiff = {
+          added: trulyAdded,
+          removed: trulyRemoved,
+          noChange: trulyAdded.length === 0 && trulyRemoved.length === 0
+        };
+        this.cssWriter.applyDiff(finalDiff);
+        this.stats.addedRules += trulyAdded.length;
+        this.stats.removedRules += trulyRemoved.length;
+        return {
+          filepath,
+          changed: true,
+          diff: finalDiff,
+          durationMs: Date.now() - t0
+        };
+      }
+      /**
+       * Dipanggil di akhir build. Flush CSS ke disk, persist cache.
+       */
+      async buildEnd() {
+        this.stats.buildTimeMs = Date.now() - this.sessionStart;
+        await this.cssWriter.flush();
+        if (this.opts.persistCache) {
+          saveHashCache(this.hashCache);
+          saveGraphCache(this.depGraph);
+        }
+        this.log(
+          `[build] done in ${this.stats.buildTimeMs}ms | changed: ${this.stats.changedFiles}/${this.stats.totalFiles} files | +${this.stats.addedRules} -${this.stats.removedRules} rules | total rules: ${this.cssWriter.size()}`
+        );
+      }
+      /** Sync version untuk webpack buildEnd hook */
+      buildEndSync() {
+        this.stats.buildTimeMs = Date.now() - this.sessionStart;
+        this.cssWriter.flushSync();
+        if (this.opts.persistCache) {
+          saveHashCache(this.hashCache);
+          saveGraphCache(this.depGraph);
+        }
+      }
+      /**
+       * Invalidate satu file (untuk hot reload — file dihapus atau renamed).
+       */
+      invalidateFile(filepath) {
+        const oldNodes = this.depGraph.get(filepath) ?? [];
+        for (const node of oldNodes) {
+          this.globalReg.remove(filepath, node.atomicClass);
+        }
+        this.depGraph.delete(filepath);
+        this.hashCache.delete(filepath);
+        this.log(`[invalidate] ${path10__default.default.relative(process.cwd(), filepath)}`);
+      }
+      /** Get all active style nodes — untuk full CSS generation */
+      getAllNodes() {
+        return this.globalReg.all();
+      }
+      /** Get stats untuk current build session */
+      getStats() {
+        return { ...this.stats, buildTimeMs: Date.now() - this.sessionStart };
+      }
+      /** Get output CSS path */
+      getOutputPath() {
+        return this.opts.outputPath;
+      }
+      /** Reset stats untuk build session baru */
+      resetStats() {
+        this.stats = {
+          totalFiles: 0,
+          changedFiles: 0,
+          skippedFiles: 0,
+          addedRules: 0,
+          removedRules: 0,
+          buildTimeMs: 0
+        };
+        this.sessionStart = Date.now();
+      }
+      /** Reset semua cache — untuk clean build */
+      reset() {
+        this.hashCache.clear();
+        this.depGraph.clear();
+        this.globalReg = new GlobalAtomicRegistry();
+        this.cssWriter = new CssDiffWriter(this.opts.outputPath);
+        this.resetStats();
+        this.log("[reset] incremental cache cleared");
+      }
+      log(msg) {
+        if (this.opts.verbose) {
+          console.log(`[tailwind-styled/incremental] ${msg}`);
+        }
+      }
+    };
+    _engine = null;
+  }
+});
+
+// packages/compiler/src/styleBucketSystem.ts
+function classifyNode(node) {
+  if (node.modifier?.startsWith("@")) return "responsive";
+  const declarations = node.declaration.split(";").map((d) => d.trim()).filter(Boolean);
+  const firstProp = declarations[0]?.split(":")[0]?.trim();
+  if (!firstProp) return "unknown";
+  if (PROPERTY_BUCKET_MAP[firstProp]) return PROPERTY_BUCKET_MAP[firstProp];
+  for (const [prefix, bucket] of Object.entries(PROPERTY_BUCKET_MAP)) {
+    if (firstProp.startsWith(prefix)) return bucket;
+  }
+  return "unknown";
+}
+function nodeToCSS2(node) {
+  const { atomicClass, declaration, modifier } = node;
+  if (!modifier) {
+    return `.${atomicClass}{${declaration}}`;
+  }
+  if (modifier.startsWith("@")) {
+    return `${modifier}{.${atomicClass}{${declaration}}}`;
+  }
+  return `.${atomicClass}${modifier}{${declaration}}`;
+}
+function getBucketEngine() {
+  if (!_bucketEngine) _bucketEngine = new BucketEngine();
+  return _bucketEngine;
+}
+var BUCKET_ORDER, PROPERTY_BUCKET_MAP, BucketEngine, _bucketEngine;
+var init_styleBucketSystem = __esm({
+  "packages/compiler/src/styleBucketSystem.ts"() {
+    BUCKET_ORDER = [
+      "reset",
+      "layout",
+      "spacing",
+      "sizing",
+      "typography",
+      "visual",
+      "interaction",
+      "responsive",
+      "unknown"
+    ];
+    PROPERTY_BUCKET_MAP = {
+      // Layout
+      display: "layout",
+      position: "layout",
+      flex: "layout",
+      "flex-direction": "layout",
+      "flex-wrap": "layout",
+      "flex-grow": "layout",
+      "flex-shrink": "layout",
+      "flex-basis": "layout",
+      grid: "layout",
+      "grid-template": "layout",
+      "grid-column": "layout",
+      "grid-row": "layout",
+      "align-items": "layout",
+      "align-self": "layout",
+      "align-content": "layout",
+      "justify-content": "layout",
+      "justify-items": "layout",
+      "justify-self": "layout",
+      "place-items": "layout",
+      "place-content": "layout",
+      overflow: "layout",
+      "overflow-x": "layout",
+      "overflow-y": "layout",
+      "z-index": "layout",
+      float: "layout",
+      clear: "layout",
+      visibility: "layout",
+      // Spacing
+      padding: "spacing",
+      "padding-top": "spacing",
+      "padding-bottom": "spacing",
+      "padding-left": "spacing",
+      "padding-right": "spacing",
+      "padding-inline": "spacing",
+      "padding-block": "spacing",
+      margin: "spacing",
+      "margin-top": "spacing",
+      "margin-bottom": "spacing",
+      "margin-left": "spacing",
+      "margin-right": "spacing",
+      "margin-inline": "spacing",
+      "margin-block": "spacing",
+      gap: "spacing",
+      "column-gap": "spacing",
+      "row-gap": "spacing",
+      inset: "spacing",
+      "inset-inline": "spacing",
+      "inset-block": "spacing",
+      top: "spacing",
+      bottom: "spacing",
+      left: "spacing",
+      right: "spacing",
+      // Sizing
+      width: "sizing",
+      height: "sizing",
+      "max-width": "sizing",
+      "min-width": "sizing",
+      "max-height": "sizing",
+      "min-height": "sizing",
+      "aspect-ratio": "sizing",
+      // Typography
+      "font-size": "typography",
+      "font-weight": "typography",
+      "font-family": "typography",
+      "font-style": "typography",
+      "line-height": "typography",
+      "letter-spacing": "typography",
+      "text-align": "typography",
+      "text-decoration": "typography",
+      "text-transform": "typography",
+      "text-overflow": "typography",
+      "white-space": "typography",
+      "word-break": "typography",
+      "word-wrap": "typography",
+      "vertical-align": "typography",
+      // Visual
+      color: "visual",
+      background: "visual",
+      "background-color": "visual",
+      "background-image": "visual",
+      "background-size": "visual",
+      "background-position": "visual",
+      "background-repeat": "visual",
+      border: "visual",
+      "border-top": "visual",
+      "border-bottom": "visual",
+      "border-left": "visual",
+      "border-right": "visual",
+      "border-inline": "visual",
+      "border-block": "visual",
+      "border-color": "visual",
+      "border-width": "visual",
+      "border-style": "visual",
+      "border-radius": "visual",
+      "box-shadow": "visual",
+      opacity: "visual",
+      outline: "visual",
+      "outline-color": "visual",
+      "outline-width": "visual",
+      fill: "visual",
+      stroke: "visual",
+      "text-shadow": "visual",
+      "mix-blend-mode": "visual",
+      "object-fit": "visual",
+      "object-position": "visual",
+      // Interaction
+      cursor: "interaction",
+      "pointer-events": "interaction",
+      "user-select": "interaction",
+      transition: "interaction",
+      "transition-property": "interaction",
+      "transition-duration": "interaction",
+      "transition-timing-function": "interaction",
+      "transition-delay": "interaction",
+      transform: "interaction",
+      translate: "interaction",
+      rotate: "interaction",
+      scale: "interaction",
+      animation: "interaction",
+      "will-change": "interaction",
+      "scroll-behavior": "interaction",
+      "scroll-snap-type": "interaction",
+      // Reset (jarang dipakai langsung tapi handle untuk completeness)
+      "box-sizing": "reset",
+      appearance: "reset",
+      all: "reset"
+    };
+    BucketEngine = class {
+      constructor() {
+        this.buckets = /* @__PURE__ */ new Map();
+        for (const b of BUCKET_ORDER) {
+          this.buckets.set(b, /* @__PURE__ */ new Map());
+        }
+      }
+      /**
+       * Tambah StyleNode ke bucket yang tepat.
+       * Idempotent — atomic class yang sama tidak akan duplikat.
+       */
+      add(node) {
+        const bucket = classifyNode(node);
+        this.buckets.get(bucket).set(node.atomicClass, node);
+      }
+      /**
+       * Hapus node dari bucket (untuk incremental update).
+       */
+      remove(atomicClass) {
+        for (const bucket of this.buckets.values()) {
+          if (bucket.delete(atomicClass)) break;
+        }
+      }
+      /**
+       * Apply CssDiff dari incremental engine.
+       */
+      applyDiff(diff) {
+        for (const node of diff.added) this.add(node);
+        for (const cls of diff.removed) this.remove(cls);
+      }
+      /**
+       * Emit seluruh CSS dalam urutan bucket yang deterministic.
+       *
+       * @param comments - Tambahkan komentar section per bucket. Default: true
+       * @returns CSS string yang siap di-write ke file
+       */
+      emit(comments = true) {
+        const sections = [];
+        for (const bucketName of BUCKET_ORDER) {
+          const nodes = this.buckets.get(bucketName);
+          if (nodes.size === 0) continue;
+          const rules = [];
+          for (const node of nodes.values()) {
+            rules.push(nodeToCSS2(node));
+          }
+          if (rules.length === 0) continue;
+          if (comments) {
+            sections.push(`/* \u2500\u2500 ${bucketName} \u2500\u2500 */`);
+          }
+          sections.push(...rules);
+        }
+        return sections.join("\n");
+      }
+      /**
+       * Emit dengan @layer CSS untuk native browser layering.
+       * Lebih powerful — browser respects layer order untuk specificity.
+       *
+       * @example output:
+       * @layer tw-layout, tw-spacing, tw-visual, tw-responsive;
+       * @layer tw-layout { .tw-a1 { display: flex } }
+       */
+      emitLayered() {
+        const layerNames = BUCKET_ORDER.filter(
+          (b) => b !== "unknown" && this.buckets.get(b).size > 0
+        ).map((b) => `tw-${b}`);
+        if (layerNames.length === 0) return "";
+        const parts = [`@layer ${layerNames.join(", ")};`, ""];
+        for (const bucketName of BUCKET_ORDER) {
+          const nodes = this.buckets.get(bucketName);
+          if (nodes.size === 0) continue;
+          const rules = Array.from(nodes.values()).map(nodeToCSS2).join("\n  ");
+          parts.push(`@layer tw-${bucketName} {
+  ${rules}
+}`);
+        }
+        return parts.join("\n");
+      }
+      /** Semua nodes dari semua bucket (untuk full registry access) */
+      allNodes() {
+        const all = [];
+        for (const bucket of this.buckets.values()) {
+          for (const node of bucket.values()) {
+            all.push(node);
+          }
+        }
+        return all;
+      }
+      /** Stats per bucket */
+      stats() {
+        const perBucket = {};
+        let total = 0;
+        for (const [name, nodes] of this.buckets) {
+          perBucket[name] = nodes.size;
+          total += nodes.size;
+        }
+        return { totalNodes: total, perBucket };
+      }
+      /** Clear semua bucket */
+      clear() {
+        for (const bucket of this.buckets.values()) {
+          bucket.clear();
+        }
+      }
+    };
+    _bucketEngine = null;
+  }
+});
+
+// packages/compiler/src/atomicCss.ts
+var atomicCss_exports = {};
+__export(atomicCss_exports, {
+  clearAtomicRegistry: () => clearAtomicRegistry,
+  generateAtomicCss: () => generateAtomicCss,
+  getAtomicRegistry: () => getAtomicRegistry,
+  parseAtomicClass: () => parseAtomicClass,
+  toAtomicClasses: () => toAtomicClasses
+});
+function sizeValue(v) {
+  const num = Number(v);
+  if (!Number.isNaN(num)) return `${num * 0.25}rem`;
+  const special = {
+    full: "100%",
+    screen: "100vw",
+    auto: "auto",
+    min: "min-content",
+    max: "max-content",
+    fit: "fit-content",
+    svw: "100svw",
+    svh: "100svh"
+  };
+  return special[v] ?? v;
+}
+function textSize(v) {
+  const map = {
+    xs: "0.75rem",
+    sm: "0.875rem",
+    base: "1rem",
+    lg: "1.125rem",
+    xl: "1.25rem",
+    "2xl": "1.5rem",
+    "3xl": "1.875rem",
+    "4xl": "2.25rem",
+    "5xl": "3rem",
+    "6xl": "3.75rem",
+    "7xl": "4.5rem",
+    "8xl": "6rem",
+    "9xl": "8rem"
+  };
+  return map[v] ?? v;
+}
+function fontWeight(v) {
+  const map = {
+    thin: "100",
+    extralight: "200",
+    light: "300",
+    normal: "400",
+    medium: "500",
+    semibold: "600",
+    bold: "700",
+    extrabold: "800",
+    black: "900"
+  };
+  return map[v] ?? v;
+}
+function leadingValue(v) {
+  const map = {
+    none: "1",
+    tight: "1.25",
+    snug: "1.375",
+    normal: "1.5",
+    relaxed: "1.625",
+    loose: "2"
+  };
+  return map[v] ?? v;
+}
+function roundedValue(v) {
+  const map = {
+    "": "0.25rem",
+    sm: "0.125rem",
+    md: "0.375rem",
+    lg: "0.5rem",
+    xl: "0.75rem",
+    "2xl": "1rem",
+    "3xl": "1.5rem",
+    full: "9999px",
+    none: "0"
+  };
+  return map[v] ?? `${v}rem`;
+}
+function sanitizeClassName(cls) {
+  return cls.replace(/[/:[\].!%]/g, "_");
+}
+function parseAtomicClass(twClass) {
+  if (REGISTRY.has(twClass)) return REGISTRY.get(twClass);
+  const colonIdx = twClass.lastIndexOf(":");
+  const modifier = colonIdx > -1 ? twClass.slice(0, colonIdx) : void 0;
+  const base = colonIdx > -1 ? twClass.slice(colonIdx + 1) : twClass;
+  const dashIdx = base.indexOf("-");
+  if (dashIdx === -1) return null;
+  const prefix = base.slice(0, dashIdx);
+  const value = base.slice(dashIdx + 1);
+  const mapping = TW_PROPERTY_MAP[prefix];
+  if (!mapping) return null;
+  const cssValue = mapping.transform ? mapping.transform(value) : value;
+  const atomicName = `_tw_${sanitizeClassName(twClass)}`;
+  const rule = {
+    twClass,
+    atomicName,
+    property: mapping.prop,
+    value: cssValue,
+    modifier
+  };
+  REGISTRY.set(twClass, rule);
+  return rule;
+}
+function generateAtomicCss(rules) {
+  const lines = [];
+  for (const rule of rules) {
+    const selector = `.${rule.atomicName}`;
+    if (rule.modifier) {
+      const breakpoints = {
+        sm: "640px",
+        md: "768px",
+        lg: "1024px",
+        xl: "1280px",
+        "2xl": "1536px"
+      };
+      if (breakpoints[rule.modifier]) {
+        lines.push(
+          `@media (min-width: ${breakpoints[rule.modifier]}) {`,
+          `  ${selector} { ${rule.property}: ${rule.value}; }`,
+          `}`
+        );
+        continue;
+      }
+      lines.push(`${selector}:${rule.modifier} { ${rule.property}: ${rule.value}; }`);
+    } else {
+      lines.push(`${selector} { ${rule.property}: ${rule.value}; }`);
+    }
+  }
+  return lines.join("\n");
+}
+function toAtomicClasses(twClasses) {
+  const parts = twClasses.split(/\s+/).filter(Boolean);
+  const atomicNames = [];
+  const rules = [];
+  const unknownClasses = [];
+  for (const cls of parts) {
+    const rule = parseAtomicClass(cls);
+    if (rule) {
+      atomicNames.push(rule.atomicName);
+      rules.push(rule);
+    } else {
+      unknownClasses.push(cls);
+      atomicNames.push(cls);
+    }
+  }
+  return {
+    atomicClasses: atomicNames.join(" "),
+    rules,
+    unknownClasses
+  };
+}
+function getAtomicRegistry() {
+  return REGISTRY;
+}
+function clearAtomicRegistry() {
+  REGISTRY.clear();
+}
+var REGISTRY, TW_PROPERTY_MAP;
+var init_atomicCss = __esm({
+  "packages/compiler/src/atomicCss.ts"() {
+    REGISTRY = /* @__PURE__ */ new Map();
+    TW_PROPERTY_MAP = {
+      // Spacing
+      p: { prop: "padding", transform: (v) => `${Number(v) * 0.25}rem` },
+      px: { prop: "padding-inline", transform: (v) => `${Number(v) * 0.25}rem` },
+      py: { prop: "padding-block", transform: (v) => `${Number(v) * 0.25}rem` },
+      pt: { prop: "padding-top", transform: (v) => `${Number(v) * 0.25}rem` },
+      pb: { prop: "padding-bottom", transform: (v) => `${Number(v) * 0.25}rem` },
+      pl: { prop: "padding-left", transform: (v) => `${Number(v) * 0.25}rem` },
+      pr: { prop: "padding-right", transform: (v) => `${Number(v) * 0.25}rem` },
+      m: { prop: "margin", transform: (v) => `${Number(v) * 0.25}rem` },
+      mx: { prop: "margin-inline", transform: (v) => `${Number(v) * 0.25}rem` },
+      my: { prop: "margin-block", transform: (v) => `${Number(v) * 0.25}rem` },
+      mt: { prop: "margin-top", transform: (v) => `${Number(v) * 0.25}rem` },
+      mb: { prop: "margin-bottom", transform: (v) => `${Number(v) * 0.25}rem` },
+      ml: { prop: "margin-left", transform: (v) => `${Number(v) * 0.25}rem` },
+      mr: { prop: "margin-right", transform: (v) => `${Number(v) * 0.25}rem` },
+      gap: { prop: "gap", transform: (v) => `${Number(v) * 0.25}rem` },
+      // Sizing
+      w: { prop: "width", transform: sizeValue },
+      h: { prop: "height", transform: sizeValue },
+      // Typography
+      text: { prop: "font-size", transform: textSize },
+      font: { prop: "font-weight", transform: fontWeight },
+      leading: { prop: "line-height", transform: leadingValue },
+      // Misc
+      opacity: { prop: "opacity", transform: (v) => String(Number(v) / 100) },
+      z: { prop: "z-index" },
+      rounded: { prop: "border-radius", transform: (v) => roundedValue(v) }
+    };
+  }
+});
+
+// packages/compiler/src/context.ts
+var CompileContext;
+var init_context = __esm({
+  "packages/compiler/src/context.ts"() {
+    CompileContext = class {
+      constructor(input) {
+        this.filepath = input.filepath;
+        this.source = input.source;
+        this.options = input.options;
+        this.result = null;
+        this.done = false;
+        this.engine = "none";
+      }
+    };
+  }
+});
+
+// packages/compiler/src/pipeline.ts
+var Pipeline;
+var init_pipeline = __esm({
+  "packages/compiler/src/pipeline.ts"() {
+    Pipeline = class {
+      constructor() {
+        this.steps = [];
+      }
+      use(step) {
+        this.steps.push(step);
+        return this;
+      }
+      run(ctx) {
+        for (const step of this.steps) {
+          step(ctx);
+          if (ctx.done) break;
+        }
+        return ctx;
+      }
+    };
+  }
+});
+function makeCacheKey(input) {
+  const options = {
+    mode: input.options.mode,
+    autoClientBoundary: input.options.autoClientBoundary,
+    addDataAttr: input.options.addDataAttr,
+    hoist: input.options.hoist,
+    filename: input.options.filename ?? input.filepath,
+    deadStyleElimination: input.options.deadStyleElimination
+  };
+  return crypto.createHash("sha1").update(input.filepath).update("").update(input.source).update("").update(JSON.stringify(options)).digest("hex");
+}
+function cloneTransformResult(result) {
+  return {
+    code: result.code,
+    classes: [...result.classes],
+    changed: result.changed,
+    rsc: result.rsc ? {
+      isServer: result.rsc.isServer,
+      needsClientDirective: result.rsc.needsClientDirective,
+      clientReasons: [...result.rsc.clientReasons]
+    } : void 0
+  };
+}
+function cloneCoreCompileResult(result) {
+  return {
+    result: cloneTransformResult(result.result),
+    engine: result.engine,
+    cacheHit: result.cacheHit,
+    metadata: result.metadata ? result.metadata.map((m) => ({ ...m })) : void 0,
+    css: result.css
+  };
+}
+function persistCache(key, value) {
+  compileCache.set(key, { ...value, cacheHit: false });
+  if (compileCache.size <= MAX_CACHE_ENTRIES) return;
+  const oldestKey = compileCache.keys().next().value;
+  if (oldestKey) compileCache.delete(oldestKey);
+}
+function createPassthrough(source) {
+  return { code: source, classes: [], changed: false };
+}
+function compileWithCore(input) {
+  return compilerCore.compile(input);
+}
+var MAX_CACHE_ENTRIES, compileCache, CompilerCore, compilerCore;
+var init_coreCompiler = __esm({
+  "packages/compiler/src/coreCompiler.ts"() {
+    init_context();
+    init_nativeBridge();
+    init_pipeline();
+    MAX_CACHE_ENTRIES = 512;
+    compileCache = /* @__PURE__ */ new Map();
+    CompilerCore = class {
+      constructor() {
+        this.pipeline = new Pipeline().use((ctx) => this.nativeStep(ctx));
+      }
+      compile(input) {
+        const cacheKey = makeCacheKey(input);
+        const cached = compileCache.get(cacheKey);
+        if (cached) {
+          const hit = cloneCoreCompileResult(cached);
+          hit.cacheHit = true;
+          return hit;
+        }
+        const ctx = new CompileContext(input);
+        this.pipeline.run(ctx);
+        const result = ctx.result ?? createPassthrough(input.source);
+        let cssOutput;
+        if (ctx.options.deadStyleElimination && result.classes.length > 0) {
+          cssOutput = this.runDeadStyleElimination(result.classes, input.options);
+        }
+        const compiled = {
+          result,
+          engine: ctx.engine,
+          cacheHit: false,
+          metadata: ctx.metadata,
+          css: cssOutput
+        };
+        persistCache(cacheKey, compiled);
+        return cloneCoreCompileResult(compiled);
+      }
+      runDeadStyleElimination(classes, options) {
+        if (classes.length === 0) return "";
+        const native = getNativeBridge();
+        if (native?.analyzeClassesNative) {
+          try {
+            const filesJson = JSON.stringify([{ file: "compiled", classes }]);
+            const analysis = native.analyzeClassesNative(filesJson, process.cwd(), 0);
+            if (analysis && analysis.safelist) {
+              const deadClasses = /* @__PURE__ */ new Set();
+              const safelistSet = new Set(analysis.safelist);
+              for (const cls of classes) {
+                if (!safelistSet.has(cls)) {
+                  deadClasses.add(cls);
+                }
+              }
+              if (deadClasses.size > 0) {
+                return "";
+              }
+            }
+          } catch {
+          }
+        }
+        return "";
+      }
+      /**
+       * v5: Native step now THROWS if native binding is unavailable.
+       * Previously returned early to allow JS fallback.
+       */
+      nativeStep(ctx) {
+        const native = getNativeBridge();
+        if (!native?.transformSourceNative) {
+          throw new Error(
+            `[tailwind-styled/compiler v5] transformSourceNative is required but not available.
+Please ensure the native module is properly built with transform support.`
+          );
+        }
+        const opts = {};
+        if (ctx.options.mode) opts.mode = ctx.options.mode;
+        if (ctx.options.filename ?? ctx.filepath) opts.filename = ctx.options.filename ?? ctx.filepath;
+        const raw = native.transformSourceNative(ctx.source, opts);
+        if (raw === null) {
+          throw new Error(
+            `[tailwind-styled/compiler v5] Native transform returned null for: ${ctx.filepath}
+This indicates an issue with the native module.`
+          );
+        }
+        const adapted = adaptNativeResult(raw);
+        ctx.result = adapted;
+        ctx.metadata = adapted.metadata;
+        ctx.engine = "native";
+        ctx.done = true;
+      }
+      /**
+       * v5: JS pipeline has been removed.
+       * Previously used as fallback when native was unavailable.
+       *
+       * @throws Error always - JS pipeline is no longer supported in v5
+       * @deprecated JS pipeline was removed in v5
+       */
+      jsStep(ctx) {
+        throw new Error(
+          `[tailwind-styled/compiler v5] JS pipeline is no longer supported.
+The native binding is required for all transformations.`
+        );
+      }
+    };
+    compilerCore = new CompilerCore();
+  }
+});
+
+// packages/compiler/src/routeCssCollector.ts
+function registerFileClasses(filepath, classes) {
+  if (!_collector.files.has(filepath)) {
+    _collector.files.set(filepath, /* @__PURE__ */ new Set());
+  }
+  const fileSet = _collector.files.get(filepath);
+  classes.forEach((c) => fileSet.add(c));
+  const route = fileToRoute(filepath);
+  if (route) {
+    if (!_collector.routes.has(route)) {
+      _collector.routes.set(route, /* @__PURE__ */ new Set());
+    }
+    _collector.routes.get(route).add(filepath);
+  }
+}
+function fileToRoute(filepath) {
+  const normalized = filepath.replace(/\\/g, "/");
+  if (normalized.includes("/layout.") || normalized.includes("/loading.") || normalized.includes("/error.")) {
+    return "__global";
+  }
+  const pageMatch = normalized.match(/\/app\/(.+?)\/page\.[tj]sx?$/);
+  if (pageMatch) return `/${pageMatch[1]}`;
+  const rootPage = normalized.match(/\/app\/page\.[tj]sx?$/);
+  if (rootPage) return "/";
+  const pagesMatch = normalized.match(/\/pages\/(.+?)\.[tj]sx?$/);
+  if (pagesMatch) {
+    const route = pagesMatch[1].replace(/\/index$/, "");
+    return `/${route}`;
+  }
+  if (normalized.includes("/components/") || normalized.includes("/ui/") || normalized.includes("/shared/")) {
+    return "__global";
+  }
+  return null;
+}
+var _collector;
+var init_routeCssCollector = __esm({
+  "packages/compiler/src/routeCssCollector.ts"() {
+    _collector = {
+      files: /* @__PURE__ */ new Map(),
+      routes: /* @__PURE__ */ new Map(),
+      global: /* @__PURE__ */ new Set()
+    };
+  }
+});
+
+// packages/compiler/src/loaderCore.ts
+function shouldSkipFile(filepath) {
+  return SKIP_PATHS.some((p) => filepath.includes(p)) || !/\.[jt]sx?$/.test(filepath);
+}
+function runLoaderTransform(ctx) {
+  const { filepath, source, options } = ctx;
+  const passthrough = { code: source, changed: false, classes: [] };
+  if (shouldSkipFile(filepath)) return passthrough;
+  try {
+    if (options.incremental !== false) {
+      const engine = getIncrementalEngine({ verbose: options.verbose });
+      const precheck = engine.processFile(filepath, source, []);
+      if (!precheck.changed) return passthrough;
+    }
+    const compiled = compileWithCore({
+      filepath,
+      source,
+      options: { ...options, filename: filepath }
+    });
+    if (!compiled.result.changed) return passthrough;
+    return finalize(
+      compiled.result,
+      filepath,
+      options,
+      compiled.engine,
+      compiled.cacheHit,
+      compiled.metadata
+    );
+  } catch (err) {
+    if (process.env.NODE_ENV !== "production") {
+      const name = filepath.split(/[/\\]/).pop();
+      console.warn(`[tailwind-styled] Transform failed for ${name}:`, err);
+    }
+    return passthrough;
+  }
+}
+function finalize(result, filepath, options, engine, cacheHit, metadata) {
+  if (!result.changed) {
+    return { code: result.code, changed: false, classes: [] };
+  }
+  if (options.routeCss && result.classes.length > 0) {
+    registerFileClasses(filepath, result.classes);
+  }
+  if (options.incremental !== false) {
+    try {
+      const engineInst = getIncrementalEngine({ verbose: options.verbose });
+      const nodes = parseClassesToNodes(result.classes);
+      const diff = engineInst.processFile(filepath, result.code, nodes);
+      getBucketEngine().applyDiff(diff.diff);
+    } catch {
+    }
+  }
+  if (options.verbose) {
+    const env = result.rsc?.isServer ? "server" : "client";
+    const name = filepath.split(/[/\\]/).pop();
+    const pathHint = result.rsc ? ` (${env})` : "";
+    const cacheText = cacheHit ? " cache-hit" : "";
+    const metaText = metadata?.length ? ` [${metadata.length} compound]` : "";
+    console.log(
+      `[tailwind-styled] ${name} -> ${result.classes.length} classes${pathHint} [${engine}${cacheText}]${metaText}`
+    );
+  }
+  return {
+    code: result.code,
+    changed: result.changed,
+    classes: result.classes,
+    rsc: result.rsc,
+    engine,
+    cacheHit,
+    metadata
+  };
+}
+var SKIP_PATHS;
+var init_loaderCore = __esm({
+  "packages/compiler/src/loaderCore.ts"() {
+    init_coreCompiler();
+    init_incrementalEngine();
+    init_routeCssCollector();
+    init_styleBucketSystem();
+    SKIP_PATHS = ["node_modules", ".next", ".rspack-dist", ".turbo", "dist/", "out/"];
+  }
+});
+
+// packages/preset/src/defaultPreset.ts
+var defaultPreset_exports = {};
+__export(defaultPreset_exports, {
+  defaultGlobalCss: () => defaultGlobalCss,
+  defaultPreset: () => defaultPreset,
+  defaultThemeCss: () => defaultThemeCss,
+  designTokens: () => designTokens,
+  generateTailwindConfig: () => generateTailwindConfig,
+  generateTailwindCss: () => generateTailwindCss
+});
+function generateTailwindCss(contentPaths = STANDARD_CONTENT_PATHS) {
+  return `@import "tailwindcss";
+
+@theme {
+  /* colors */
+  --color-primary: #3b82f6;
+  --color-primary-hover: #2563eb;
+  --color-primary-active: #1d4ed8;
+  --color-primary-foreground: #ffffff;
+  --color-secondary: #6366f1;
+  --color-secondary-hover: #4f46e5;
+  --color-secondary-active: #4338ca;
+  --color-secondary-foreground: #ffffff;
+  --color-accent: #f59e0b;
+  --color-accent-hover: #d97706;
+  --color-accent-active: #b45309;
+  --color-accent-foreground: #000000;
+  --color-success: #10b981;
+  --color-success-foreground: #ffffff;
+  --color-warning: #f59e0b;
+  --color-warning-foreground: #000000;
+  --color-danger: #ef4444;
+  --color-danger-foreground: #ffffff;
+  --color-info: #3b82f6;
+  --color-info-foreground: #ffffff;
+  --color-surface: #18181b;
+  --color-border: #27272a;
+  --color-muted: #71717a;
+  --color-subtle: #3f3f46;
+
+  /* fonts */
+  --font-sans: InterVariable, Inter, system-ui, sans-serif;
+  --font-mono: JetBrains Mono, Fira Code, Consolas, monospace;
+
+  /* spacing */
+  --spacing-1: 0.25rem;
+  --spacing-2: 0.5rem;
+  --spacing-3: 0.75rem;
+  --spacing-4: 1rem;
+  --spacing-5: 1.25rem;
+  --spacing-6: 1.5rem;
+  --spacing-8: 2rem;
+  --spacing-10: 2.5rem;
+  --spacing-12: 3rem;
+  --spacing-16: 4rem;
+
+  /* breakpoints */
+  --breakpoint-sm: 40rem;
+  --breakpoint-md: 48rem;
+  --breakpoint-lg: 64rem;
+  --breakpoint-xl: 80rem;
+  --breakpoint-2xl: 96rem;
+
+  /* border radius */
+  --radius-sm: 0.25rem;
+  --radius-md: 0.5rem;
+  --radius-lg: 0.75rem;
+  --radius-xl: 1rem;
+  --radius-2xl: 1.5rem;
+  --radius-full: 9999px;
+
+  /* animations */
+  --animate-fade-in: fadeIn 0.2s ease-out;
+  --animate-fade-out: fadeOut 0.2s ease-in;
+  --animate-slide-up: slideUp 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+  --animate-slide-down: slideDown 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+  --animate-scale-in: scaleIn 0.2s ease-out;
+}
+
+@keyframes fadeIn {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+@keyframes fadeOut {
+  from { opacity: 1; }
+  to { opacity: 0; }
+}
+@keyframes slideUp {
+  from { transform: translateY(8px); opacity: 0; }
+  to { transform: translateY(0); opacity: 1; }
+}
+@keyframes slideDown {
+  from { transform: translateY(-8px); opacity: 0; }
+  to { transform: translateY(0); opacity: 1; }
+}
+@keyframes scaleIn {
+  from { transform: scale(0.95); opacity: 0; }
+  to { transform: scale(1); opacity: 1; }
+}
+
+@source ${contentPaths.join("\n@source ")}
+`;
+}
+function generateTailwindConfig(safelistPath = ".tailwind-styled-safelist.json", contentPaths = STANDARD_CONTENT_PATHS) {
+  return `import type { Config } from "tailwindcss"
+import { defaultPreset } from "tailwind-styled-v4/preset"
+
+// Auto-generated safelist dari tailwind-styled-v4 compiler
+const safelist = (() => {
+  try { return require(${JSON.stringify(safelistPath)}) as string[] }
+  catch { return [] }
+})()
+
+export default {
+  presets: [defaultPreset],
+  content: ${JSON.stringify(contentPaths, null, 2)},
+  safelist,
+} satisfies Config
+`;
+}
+var STANDARD_CONTENT_PATHS, designTokens, defaultPreset, defaultThemeCss, defaultGlobalCss;
+var init_defaultPreset = __esm({
+  "packages/preset/src/defaultPreset.ts"() {
+    STANDARD_CONTENT_PATHS = [
+      // Next.js App Router
+      "./src/**/*.{tsx,ts,jsx,js,mdx}",
+      "./app/**/*.{tsx,ts,jsx,js,mdx}",
+      "./pages/**/*.{tsx,ts,jsx,js,mdx}",
+      "./components/**/*.{tsx,ts,jsx,js,mdx}",
+      // Vite / React
+      "./src/**/*.{tsx,ts,jsx,js}",
+      "./index.html",
+      // Monorepo
+      "../../packages/**/src/**/*.{tsx,ts,jsx,js}"
+    ];
+    designTokens = {
+      colors: {
+        primary: { DEFAULT: "#3b82f6", hover: "#2563eb", active: "#1d4ed8", foreground: "#ffffff" },
+        secondary: { DEFAULT: "#6366f1", hover: "#4f46e5", active: "#4338ca", foreground: "#ffffff" },
+        accent: { DEFAULT: "#f59e0b", hover: "#d97706", active: "#b45309", foreground: "#000000" },
+        success: { DEFAULT: "#10b981", foreground: "#ffffff" },
+        warning: { DEFAULT: "#f59e0b", foreground: "#000000" },
+        danger: { DEFAULT: "#ef4444", foreground: "#ffffff" },
+        info: { DEFAULT: "#3b82f6", foreground: "#ffffff" },
+        surface: "#18181b",
+        border: "#27272a",
+        muted: "#71717a",
+        subtle: "#3f3f46"
+      },
+      spacing: {
+        1: "0.25rem",
+        2: "0.5rem",
+        3: "0.75rem",
+        4: "1rem",
+        5: "1.25rem",
+        6: "1.5rem",
+        8: "2rem",
+        10: "2.5rem",
+        12: "3rem",
+        16: "4rem"
+      },
+      breakpoints: {
+        sm: "40rem",
+        md: "48rem",
+        lg: "64rem",
+        xl: "80rem",
+        "2xl": "96rem"
+      },
+      fontWeight: {
+        normal: "400",
+        medium: "500",
+        semibold: "600",
+        bold: "700"
+      },
+      fontFamily: {
+        sans: ["InterVariable", "Inter", "system-ui", "sans-serif"],
+        mono: ["JetBrains Mono", "Fira Code", "Consolas", "monospace"]
+      },
+      borderRadius: {
+        sm: "0.25rem",
+        DEFAULT: "0.5rem",
+        md: "0.5rem",
+        lg: "0.75rem",
+        xl: "1rem",
+        "2xl": "1.5rem",
+        full: "9999px"
+      },
+      animation: {
+        "fade-in": "fadeIn 0.2s ease-out",
+        "fade-out": "fadeOut 0.2s ease-in",
+        "slide-up": "slideUp 0.3s cubic-bezier(0.16, 1, 0.3, 1)",
+        "slide-down": "slideDown 0.3s cubic-bezier(0.16, 1, 0.3, 1)",
+        "scale-in": "scaleIn 0.2s ease-out"
+      },
+      keyframes: {
+        fadeIn: { from: { opacity: "0" }, to: { opacity: "1" } },
+        fadeOut: { from: { opacity: "1" }, to: { opacity: "0" } },
+        slideUp: {
+          from: { transform: "translateY(8px)", opacity: "0" },
+          to: { transform: "translateY(0)", opacity: "1" }
+        },
+        slideDown: {
+          from: { transform: "translateY(-8px)", opacity: "0" },
+          to: { transform: "translateY(0)", opacity: "1" }
+        },
+        scaleIn: {
+          from: { transform: "scale(0.95)", opacity: "0" },
+          to: { transform: "scale(1)", opacity: "1" }
+        }
+      }
+    };
+    defaultPreset = {
+      content: STANDARD_CONTENT_PATHS,
+      darkMode: "class",
+      theme: {
+        extend: {
+          colors: designTokens.colors,
+          fontFamily: designTokens.fontFamily,
+          borderRadius: designTokens.borderRadius,
+          animation: designTokens.animation,
+          keyframes: designTokens.keyframes
+        }
+      },
+      plugins: []
+    };
+    defaultThemeCss = `@import "tailwindcss";
+
+@theme {
+  /* colors */
+  --color-primary: #3b82f6;
+  --color-primary-hover: #2563eb;
+  --color-primary-active: #1d4ed8;
+  --color-primary-foreground: #ffffff;
+  --color-secondary: #6366f1;
+  --color-secondary-hover: #4f46e5;
+  --color-secondary-active: #4338ca;
+  --color-secondary-foreground: #ffffff;
+  --color-accent: #f59e0b;
+  --color-accent-hover: #d97706;
+  --color-accent-active: #b45309;
+  --color-accent-foreground: #000000;
+  --color-success: #10b981;
+  --color-success-foreground: #ffffff;
+  --color-warning: #f59e0b;
+  --color-warning-foreground: #000000;
+  --color-danger: #ef4444;
+  --color-danger-foreground: #ffffff;
+  --color-info: #3b82f6;
+  --color-info-foreground: #ffffff;
+  --color-surface: #18181b;
+  --color-border: #27272a;
+  --color-muted: #71717a;
+  --color-subtle: #3f3f46;
+
+  /* fonts */
+  --font-sans: InterVariable, Inter, system-ui, sans-serif;
+  --font-mono: JetBrains Mono, Fira Code, Consolas, monospace;
+
+  /* spacing */
+  --spacing-1: 0.25rem;
+  --spacing-2: 0.5rem;
+  --spacing-3: 0.75rem;
+  --spacing-4: 1rem;
+  --spacing-5: 1.25rem;
+  --spacing-6: 1.5rem;
+  --spacing-8: 2rem;
+  --spacing-10: 2.5rem;
+  --spacing-12: 3rem;
+  --spacing-16: 4rem;
+
+  /* breakpoints */
+  --breakpoint-sm: 40rem;
+  --breakpoint-md: 48rem;
+  --breakpoint-lg: 64rem;
+  --breakpoint-xl: 80rem;
+  --breakpoint-2xl: 96rem;
+
+  /* border radius */
+  --radius-sm: 0.25rem;
+  --radius-md: 0.5rem;
+  --radius-lg: 0.75rem;
+  --radius-xl: 1rem;
+  --radius-2xl: 1.5rem;
+  --radius-full: 9999px;
+
+  /* animations */
+  --animate-fade-in: fadeIn 0.2s ease-out;
+  --animate-fade-out: fadeOut 0.2s ease-in;
+  --animate-slide-up: slideUp 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+  --animate-slide-down: slideDown 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+  --animate-scale-in: scaleIn 0.2s ease-out;
+}
+
+@keyframes fadeIn {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+@keyframes fadeOut {
+  from { opacity: 1; }
+  to { opacity: 0; }
+}
+@keyframes slideUp {
+  from { transform: translateY(8px); opacity: 0; }
+  to { transform: translateY(0); opacity: 1; }
+}
+@keyframes slideDown {
+  from { transform: translateY(-8px); opacity: 0; }
+  to { transform: translateY(0); opacity: 1; }
+}
+@keyframes scaleIn {
+  from { transform: scale(0.95); opacity: 0; }
+  to { transform: scale(1); opacity: 1; }
+}`;
+    defaultGlobalCss = `@import "tailwindcss";
+
+@theme {
+  /* colors */
+  --color-primary: #3b82f6;
+  --color-primary-hover: #2563eb;
+  --color-primary-active: #1d4ed8;
+  --color-primary-foreground: #ffffff;
+  --color-secondary: #6366f1;
+  --color-secondary-hover: #4f46e5;
+  --color-secondary-active: #4338ca;
+  --color-secondary-foreground: #ffffff;
+  --color-accent: #f59e0b;
+  --color-accent-hover: #d97706;
+  --color-accent-active: #b45309;
+  --color-accent-foreground: #000000;
+  --color-success: #10b981;
+  --color-success-foreground: #ffffff;
+  --color-warning: #f59e0b;
+  --color-warning-foreground: #000000;
+  --color-danger: #ef4444;
+  --color-danger-foreground: #ffffff;
+  --color-info: #3b82f6;
+  --color-info-foreground: #ffffff;
+  --color-surface: #18181b;
+  --color-border: #27272a;
+  --color-muted: #71717a;
+  --color-subtle: #3f3f46;
+
+  /* fonts */
+  --font-sans: InterVariable, Inter, system-ui, sans-serif;
+  --font-mono: JetBrains Mono, Fira Code, Consolas, monospace;
+
+  /* spacing */
+  --spacing-1: 0.25rem;
+  --spacing-2: 0.5rem;
+  --spacing-3: 0.75rem;
+  --spacing-4: 1rem;
+  --spacing-5: 1.25rem;
+  --spacing-6: 1.5rem;
+  --spacing-8: 2rem;
+  --spacing-10: 2.5rem;
+  --spacing-12: 3rem;
+  --spacing-16: 4rem;
+
+  /* breakpoints */
+  --breakpoint-sm: 40rem;
+  --breakpoint-md: 48rem;
+  --breakpoint-lg: 64rem;
+  --breakpoint-xl: 80rem;
+  --breakpoint-2xl: 96rem;
+
+  /* border radius */
+  --radius-sm: 0.25rem;
+  --radius-md: 0.5rem;
+  --radius-lg: 0.75rem;
+  --radius-xl: 1rem;
+  --radius-2xl: 1.5rem;
+  --radius-full: 9999px;
+
+  /* animations */
+  --animate-fade-in: fadeIn 0.2s ease-out;
+  --animate-fade-out: fadeOut 0.2s ease-in;
+  --animate-slide-up: slideUp 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+  --animate-slide-down: slideDown 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+  --animate-scale-in: scaleIn 0.2s ease-out;
+}
+
+@keyframes fadeIn {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+@keyframes fadeOut {
+  from { opacity: 1; }
+  to { opacity: 0; }
+}
+@keyframes slideUp {
+  from { transform: translateY(8px); opacity: 0; }
+  to { transform: translateY(0); opacity: 1; }
+}
+@keyframes slideDown {
+  from { transform: translateY(-8px); opacity: 0; }
+  to { transform: translateY(0); opacity: 1; }
+}
+@keyframes scaleIn {
+  from { transform: scale(0.95); opacity: 0; }
+  to { transform: scale(1); opacity: 1; }
+}
+
+/* tailwind-styled-v4 \u2014 zero-config base styles */
+*, *::before, *::after {
+  box-sizing: border-box;
+}
+
+html {
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  text-rendering: optimizeLegibility;
+}
+
+body {
+  margin: 0;
+  font-family: var(--font-sans, system-ui, sans-serif);
+  background: var(--color-surface, #18181b);
+  color: var(--color-foreground, #fafafa);
+}
+`;
+  }
+});
+function loadTailwindConfig(cwd = process.cwd()) {
+  if (_cachedConfig && _cachedCwd === cwd) return _cachedConfig;
+  _cachedCwd = cwd;
+  for (const file of CONFIG_FILES) {
+    const fullPath = path10__default.default.join(cwd, file);
+    if (fs3__default.default.existsSync(fullPath)) {
+      try {
+        const mod = __require(fullPath);
+        const config = mod.default ?? mod;
+        _cachedConfig = config;
+        console.log(`[tailwind-styled-v4] Using config: ${file}`);
+        return config;
+      } catch {
+      }
+    }
+  }
+  console.log("[tailwind-styled-v4] No tailwind config found \u2192 using built-in preset");
+  const { defaultPreset: defaultPreset2 } = (init_defaultPreset(), __toCommonJS(defaultPreset_exports));
+  _cachedConfig = defaultPreset2;
+  return defaultPreset2;
+}
+var CONFIG_FILES, _cachedConfig, _cachedCwd;
+var init_loadTailwindConfig = __esm({
+  "packages/compiler/src/loadTailwindConfig.ts"() {
+    CONFIG_FILES = [
+      "tailwind.config.ts",
+      "tailwind.config.js",
+      "tailwind.config.mjs",
+      "tailwind.config.cjs"
+    ];
+    _cachedConfig = null;
+    _cachedCwd = "";
+  }
+});
+function scanDir(dir, files = []) {
+  if (!fs3__default.default.existsSync(dir)) return files;
+  const entries = fs3__default.default.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist") continue;
+    const fullPath = path10__default.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      scanDir(fullPath, files);
+    } else if (SCAN_EXTENSIONS.some((ext) => entry.name.endsWith(ext))) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function generateSafelist(scanDirs, outputPath = ".tailwind-styled-safelist.json", cwd = process.cwd()) {
+  const allClasses = /* @__PURE__ */ new Set();
+  for (const dir of scanDirs) {
+    const absDir = path10__default.default.isAbsolute(dir) ? dir : path10__default.default.resolve(cwd, dir);
+    const files = scanDir(absDir);
+    for (const file of files) {
+      try {
+        const source = fs3__default.default.readFileSync(file, "utf-8");
+        const classes = extractAllClasses(source);
+        classes.forEach((c) => allClasses.add(c));
+      } catch {
+      }
+    }
+  }
+  const sorted = Array.from(allClasses).sort();
+  const absOutput = path10__default.default.isAbsolute(outputPath) ? outputPath : path10__default.default.resolve(cwd, outputPath);
+  fs3__default.default.writeFileSync(absOutput, JSON.stringify(sorted, null, 2));
+  console.log(`[tailwind-styled-v4] Safelist: ${sorted.length} classes \u2192 ${absOutput}`);
+  return sorted;
+}
+var SCAN_EXTENSIONS;
+var init_safelistGenerator = __esm({
+  "packages/compiler/src/safelistGenerator.ts"() {
+    init_classExtractor();
+    SCAN_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+  }
+});
+async function generateCssForClasses(classes, config, cwd = process.cwd()) {
+  try {
+    const { compileCssFromClasses: compileCssFromClasses2 } = (init_cssCompiler(), __toCommonJS(cssCompiler_exports));
+    const result = compileCssFromClasses2(classes);
+    if (result?.css && result.resolvedClasses.length > 0) {
+      const resolveRate = result.resolvedClasses.length / classes.length;
+      if (resolveRate >= 0.5) return result.css;
+    }
+  } catch {
+  }
+  const twConfig = config ?? loadTailwindConfig(cwd);
+  try {
+    return await generateViaTailwindV4(classes, twConfig, cwd);
+  } catch {
+  }
+  return generateManualCss(classes);
+}
+async function generateViaTailwindV4(classes, _config, cwd) {
+  const virtualCss = [
+    `@import "tailwindcss";`,
+    `@layer utilities {`,
+    `  /* Generated by tailwind-styled-v4 */`,
+    `}`
+  ].join("\n");
+  const postcss = __require("postcss");
+  const tailwindcss = __require("@tailwindcss/postcss");
+  const result = await postcss([
+    tailwindcss({
+      optimize: { minify: false }
+    })
+  ]).process(virtualCss, {
+    from: path10__default.default.join(cwd, "virtual.css")
+  });
+  return filterCssForClasses(result.css, classes);
+}
+function generateManualCss(classes) {
+  const { generateAtomicCss: generateAtomicCss2, parseAtomicClass: parseAtomicClass2 } = (init_atomicCss(), __toCommonJS(atomicCss_exports));
+  const rules = classes.map((c) => parseAtomicClass2(c)).filter(Boolean);
+  if (rules.length === 0) return "";
+  const header = `/* Generated by tailwind-styled-v4 \u2014 ${(/* @__PURE__ */ new Date()).toISOString()} */
+`;
+  return header + generateAtomicCss2(rules);
+}
+function filterCssForClasses(fullCss, classes) {
+  new Set(classes);
+  const lines = fullCss.split("\n");
+  const kept = [];
+  let inBlock = false;
+  let keepBlock = false;
+  let braceDepth = 0;
+  for (const line of lines) {
+    if (line.includes("@layer base") || line.includes("*, *::before")) {
+      kept.push(line);
+      continue;
+    }
+    if (!inBlock) {
+      const isOurClass = classes.some((cls) => {
+        const escaped = cls.replace(/[:/[\].!%]/g, "\\$&");
+        return line.includes(`.${escaped}`) || line.includes(`.${cls}`);
+      });
+      if (isOurClass) {
+        keepBlock = true;
+        inBlock = true;
+        braceDepth = 0;
+      }
+    }
+    if (inBlock) {
+      if (keepBlock) kept.push(line);
+      if (line.includes("{")) braceDepth++;
+      if (line.includes("}")) {
+        braceDepth--;
+        if (braceDepth <= 0) {
+          inBlock = false;
+          keepBlock = false;
+        }
+      }
+    }
+  }
+  return kept.join("\n");
+}
+var init_tailwindEngine = __esm({
+  "packages/compiler/src/tailwindEngine.ts"() {
+    init_loadTailwindConfig();
+  }
+});
+
+// packages/compiler/src/index.ts
+var init_src2 = __esm({
+  "packages/compiler/src/index.ts"() {
+    init_classExtractor();
+    init_classMerger();
+    init_loaderCore();
+    init_safelistGenerator();
+    init_tailwindEngine();
+  }
+});
+
+// packages/scanner/src/native-bridge.ts
+var native_bridge_exports = {};
+__export(native_bridge_exports, {
+  cachePriorityNative: () => cachePriorityNative,
+  cacheReadNative: () => cacheReadNative,
+  cacheWriteNative: () => cacheWriteNative,
+  extractClassesNative: () => extractClassesNative,
+  hasNativeScannerBinding: () => hasNativeScannerBinding,
+  hashContentNative: () => hashContentNative,
+  isRustCacheAvailable: () => isRustCacheAvailable,
+  scanWorkspaceNative: () => scanWorkspaceNative
+});
+function getBinding2() {
+  if (_binding2 !== void 0) {
+    if (_binding2 === null) {
+      throwNativeBindingError();
+    }
+    return _binding2;
+  }
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_NO_RUST === "1") {
+    _loadError = "Native loading is disabled by TWS_NO_NATIVE or TWS_NO_RUST environment variable.";
+    _binding2 = null;
+    _candidatePaths = [];
+    throwNativeBindingError();
+  }
+  const runtimeDir2 = typeof __dirname === "string" ? __dirname : process.cwd();
+  _candidatePaths = [
+    path10__default.default.resolve(process.cwd(), "native", "tailwind_styled_parser.node"),
+    path10__default.default.resolve(runtimeDir2, "..", "..", "..", "native", "tailwind_styled_parser.node")
+  ];
+  const req = typeof __require === "function" ? __require : module$1.createRequire(path10__default.default.join(runtimeDir2, "noop.cjs"));
+  for (const c of _candidatePaths) {
+    try {
+      const mod = req(c);
+      if (mod?.scanWorkspace || mod?.extractClassesFromSource || mod?.hashFileContent || mod?.cacheRead || mod?.cacheWrite) {
+        _binding2 = mod;
+        return _binding2;
+      }
+    } catch (error) {
+      _loadError = error instanceof Error ? error.message : String(error);
+    }
+  }
+  _binding2 = null;
+  throwNativeBindingError();
+}
+function throwNativeBindingError() {
+  const lines = [
+    "FATAL: Native scanner binding not found.",
+    "",
+    "This package requires the Rust native binding 'tailwind_styled_parser.node'.",
+    "The binding was not found in any of these paths:",
+    ..._candidatePaths.map((p) => `  - ${p}`),
+    ""
+  ];
+  if (_loadError) {
+    lines.push("Load error:", `  ${_loadError}`, "");
+  }
+  lines.push(
+    "To fix this, run:",
+    "  npm run build:rust",
+    "",
+    "This will build the native Rust module from the 'native/' directory.",
+    "If you're using this package in a CI/CD environment, ensure Rust toolchain is installed",
+    "and 'npm run build:rust' is executed before running tests or building."
+  );
+  throw new Error(lines.join("\n"));
+}
+function scanWorkspaceNative(root, extensions) {
+  return getBinding2().scanWorkspace(root, extensions ?? null);
+}
+function extractClassesNative(source) {
+  const result = getBinding2().extractClassesFromSource?.(source);
+  if (result === null || result === void 0) {
+    throw new Error("Native extractClassesFromSource returned null/undefined");
+  }
+  return result;
+}
+function hashContentNative(content) {
+  const result = getBinding2().hashFileContent?.(content);
+  if (result === null || result === void 0) {
+    throw new Error("Native hashFileContent returned null/undefined");
+  }
+  return result;
+}
+function isRustCacheAvailable() {
+  return true;
+}
+function hasNativeScannerBinding() {
+  try {
+    getBinding2();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cacheReadNative(cachePath) {
+  const result = getBinding2().cacheRead?.(cachePath);
+  if (result === null || result === void 0) {
+    throw new Error("Native cacheRead returned null/undefined");
+  }
+  return result;
+}
+function cacheWriteNative(cachePath, entries) {
+  const result = getBinding2().cacheWrite?.(cachePath, entries);
+  if (result === null || result === void 0) {
+    throw new Error("Native cacheWrite returned null/undefined");
+  }
+  return result;
+}
+function cachePriorityNative(mtimeMs, size, cachedMtimeMs, cachedSize, cachedHitCount, cachedLastSeenMs, nowMs = Date.now()) {
+  const result = getBinding2().cachePriority?.(
+    mtimeMs,
+    size,
+    cachedMtimeMs,
+    cachedSize,
+    cachedHitCount,
+    cachedLastSeenMs,
+    nowMs
+  );
+  if (result === null || result === void 0) {
+    throw new Error("Native cachePriority returned null/undefined");
+  }
+  return result;
+}
+var _binding2, _loadError, _candidatePaths;
+var init_native_bridge = __esm({
+  "packages/scanner/src/native-bridge.ts"() {
+    _binding2 = void 0;
+    _loadError = null;
+    _candidatePaths = [];
+  }
+});
+function defaultCachePath(rootDir, cacheDir) {
+  const dir = cacheDir ? path10__default.default.resolve(rootDir, cacheDir) : path10__default.default.join(process.cwd(), ".cache", "tailwind-styled");
+  return path10__default.default.join(dir, "scanner-cache.json");
+}
+function readCache(rootDir, cacheDir) {
+  const cachePath = defaultCachePath(rootDir, cacheDir);
+  const result = cacheReadNative(cachePath);
+  return result.entries.map((e) => ({
+    file: e.file,
+    classes: e.classes,
+    hash: e.hash,
+    mtimeMs: e.mtimeMs,
+    size: e.size,
+    hitCount: e.hitCount
+  }));
+}
+function writeCache(rootDir, entries, cacheDir) {
+  const cachePath = defaultCachePath(rootDir, cacheDir);
+  const success = cacheWriteNative(cachePath, entries);
+  if (!success) {
+    throw new Error(
+      "Native cacheWrite failed. Run 'npm run build:rust' to rebuild native bindings."
+    );
+  }
+}
+function filePriority(mtimeMs, size, cached, nowMs = Date.now()) {
+  return cachePriorityNative(
+    mtimeMs,
+    size,
+    cached?.mtimeMs ?? 0,
+    cached?.size ?? 0,
+    cached?.hitCount ?? 0,
+    cached?.lastSeenMs ?? 0,
+    nowMs
+  );
+}
+var init_cache_native = __esm({
+  "packages/scanner/src/cache-native.ts"() {
+    init_native_bridge();
+  }
+});
+function canUseCjsRequire() {
+  return typeof __require === "function";
+}
+function debugNative(message) {
+  log2.debug(`[native] ${message}`);
+}
+function loadNativeParserBinding() {
+  if (nativeParserBinding !== void 0) return nativeParserBinding;
+  if (!canUseCjsRequire()) {
+    nativeParserBinding = null;
+    nativeParserInitError = "require is unavailable in current module format";
+    debugNative(`fallback to JS: ${nativeParserInitError}`);
+    return nativeParserBinding;
+  }
+  const candidates = [
+    path10__default.default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
+    path10__default.default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node")
+  ];
+  for (const fullPath of candidates) {
+    if (!fs3__default.default.existsSync(fullPath)) continue;
+    try {
+      const required = __require(fullPath);
+      if (required && typeof required.parse_classes === "function") {
+        nativeParserBinding = required;
+        debugNative(`using native parser from ${fullPath}`);
+        return nativeParserBinding;
+      }
+    } catch (error) {
+      nativeParserInitError = error instanceof Error ? error.message : String(error);
+    }
+  }
+  nativeParserBinding = null;
+  if (!nativeParserInitError) {
+    nativeParserInitError = "native .node binding not found";
+  }
+  debugNative(`fallback to JS: ${nativeParserInitError}`);
+  return nativeParserBinding;
+}
+function normalizeWithNativeParser(tokens) {
+  const binding = loadNativeParserBinding();
+  if (!binding || typeof binding.parse_classes !== "function") {
+    throw new Error(
+      "Native parser binding is required but not available. Run 'npm run build:rust' to build it."
+    );
+  }
+  try {
+    const parsed = binding.parse_classes(tokens.join(" "));
+    const normalized = parsed.map((item) => item.raw?.trim() ?? "").filter(Boolean);
+    return Array.from(new Set(normalized));
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Native parser failed: ${errorMessage}. Run 'npm run build:rust' to rebuild.`);
+  }
+}
+function resolveScannerWorkerModulePath() {
+  const runtimeDir2 = typeof __dirname === "string" && __dirname.length > 0 ? __dirname : path10__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('vite.js', document.baseURI).href))));
+  const candidates = [
+    path10__default.default.resolve(runtimeDir2, "index.cjs"),
+    path10__default.default.resolve(runtimeDir2, "index.js"),
+    path10__default.default.resolve(runtimeDir2, "index.ts")
+  ];
+  for (const candidate of candidates) {
+    if (fs3__default.default.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function scanWorkspaceInWorker(rootDir, options) {
+  const modulePath = resolveScannerWorkerModulePath();
+  if (!modulePath) {
+    return Promise.reject(new Error("scanner worker module path could not be resolved"));
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const worker = new worker_threads.Worker(SCAN_WORKER_BOOTSTRAP, {
+      eval: true,
+      workerData: { modulePath, rootDir, options }
+    });
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      void worker.terminate();
+      reject(new Error(`scanner worker timed out after ${SCAN_WORKER_TIMEOUT_MS}ms`));
+    }, SCAN_WORKER_TIMEOUT_MS);
+    const finish = (callback) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      callback();
+    };
+    worker.once("message", (payload) => {
+      const message = payload;
+      finish(() => {
+        if (message?.ok) {
+          resolve(message.result);
+          return;
+        }
+        reject(new Error(message?.error ?? "scanner worker failed without an error message"));
+      });
+    });
+    worker.once("error", (error) => {
+      finish(() => reject(error));
+    });
+    worker.once("exit", (code) => {
+      if (code !== 0) {
+        finish(() => reject(new Error(`scanner worker exited with code ${code}`)));
+      }
+    });
+  });
+}
+function buildExtensionSet(includeExtensions) {
+  return new Set(includeExtensions);
+}
+function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
+  const candidates = [];
+  const directories = [rootDir];
+  while (directories.length > 0) {
+    const currentDir = directories.pop();
+    if (!currentDir) continue;
+    let entries = [];
+    try {
+      entries = fs3__default.default.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = path10__default.default.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!ignoreDirectories.has(entry.name)) directories.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!extensionSet.has(path10__default.default.extname(entry.name))) continue;
+      candidates.push(fullPath);
+    }
+  }
+  return candidates;
+}
+function toCacheSize(size) {
+  if (!Number.isFinite(size)) return 0;
+  const normalized = Math.max(0, Math.trunc(size));
+  return Math.min(normalized, 4294967295);
+}
+function extractClassesJs(source) {
+  return extractAllClasses(source);
+}
+function scanSource(source) {
+  const nativeBinding = loadNativeParserBinding();
+  if (nativeBinding && typeof nativeBinding.parse_classes === "function") {
+    try {
+      const baseClasses = extractClassesJs(source);
+      const nativeNormalized = normalizeWithNativeParser(baseClasses);
+      return nativeNormalized;
+    } catch (error) {
+      throw error;
+    }
+  }
+  throw new Error(
+    "Native parser binding is required but not available. Run 'npm run build:rust' to build it."
+  );
+}
+function isScannableFile(filePath, includeExtensions = DEFAULT_EXTENSIONS) {
+  return includeExtensions.includes(path10__default.default.extname(filePath));
+}
+function scanFile(filePath) {
+  const source = fs3__default.default.readFileSync(filePath, "utf8");
+  const hash = hashContentNative(source) ?? void 0;
+  return {
+    file: filePath,
+    classes: scanSource(source),
+    ...hash ? { hash } : {}
+  };
+}
+function scanWorkspace(rootDir, options = {}) {
+  const includeExtensions = options.includeExtensions ?? DEFAULT_EXTENSIONS;
+  const extensionSet = buildExtensionSet(includeExtensions);
+  const ignoreDirectories = new Set(options.ignoreDirectories ?? DEFAULT_IGNORES);
+  const useCache = options.useCache ?? true;
+  options.smartInvalidation ?? true;
+  const files = [];
+  const unique = /* @__PURE__ */ new Set();
+  const candidates = collectCandidates(rootDir, ignoreDirectories, extensionSet);
+  const processResult = (result) => {
+    files.push(result);
+    for (const cls of result.classes) unique.add(cls);
+  };
+  const { scanWorkspaceNative: scanWorkspaceNative2 } = (init_native_bridge(), __toCommonJS(native_bridge_exports));
+  if (!options.cacheDir && !useCache) {
+    const nativeResult = scanWorkspaceNative2(rootDir, includeExtensions);
+    if (nativeResult) {
+      return {
+        files: nativeResult.files.map((f) => ({
+          file: f.file,
+          classes: f.classes
+        })),
+        totalFiles: nativeResult.totalFiles,
+        uniqueClasses: nativeResult.uniqueClasses
+      };
+    }
+  }
+  if (useCache && isRustCacheAvailable()) {
+    let cacheEntries = [];
+    try {
+      cacheEntries = readCache(rootDir, options.cacheDir);
+    } catch (error) {
+      cacheEntries = [];
+      log2.debug(
+        `cache read failed, continuing without persisted cache: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    const cacheMap = new Map(cacheEntries.map((entry) => [entry.file, entry]));
+    const nowMs = Date.now();
+    const ranked = [];
+    for (const filePath of candidates) {
+      let stat;
+      try {
+        stat = fs3__default.default.statSync(filePath);
+      } catch {
+        continue;
+      }
+      const size = toCacheSize(stat.size);
+      const cached = cacheMap.get(filePath);
+      const priority = filePriority(
+        stat.mtimeMs,
+        size,
+        cached ? {
+          mtimeMs: cached.mtimeMs,
+          size: cached.size,
+          hitCount: cached.hitCount,
+          lastSeenMs: 0
+        } : void 0,
+        nowMs
+      );
+      ranked.push({ filePath, stat, size, cached, priority });
+    }
+    ranked.sort((a, b) => b.priority - a.priority);
+    const updatedEntries = [];
+    for (const { filePath, stat, size, cached } of ranked) {
+      let content;
+      try {
+        content = fs3__default.default.readFileSync(filePath, "utf8");
+      } catch {
+        continue;
+      }
+      const hash = hashContentNative(content);
+      if (cached && cached.hash === hash && cached.mtimeMs === stat.mtimeMs && cached.size === size) {
+        log2.debug(`cache HIT ${filePath}`);
+        processResult({ file: filePath, classes: cached.classes });
+        updatedEntries.push({
+          file: filePath,
+          classes: cached.classes,
+          hash: cached.hash,
+          mtimeMs: stat.mtimeMs,
+          size,
+          hitCount: (cached.hitCount ?? 0) + 1
+        });
+        continue;
+      }
+      log2.debug(`cache MISS ${filePath}`);
+      const classes = scanSource(content);
+      processResult({ file: filePath, classes });
+      updatedEntries.push({
+        file: filePath,
+        classes,
+        hash,
+        mtimeMs: stat.mtimeMs,
+        size,
+        hitCount: 1
+      });
+    }
+    try {
+      writeCache(rootDir, updatedEntries, options.cacheDir);
+    } catch (error) {
+      log2.debug(`cache write failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return {
+      files,
+      totalFiles: files.length,
+      uniqueClasses: Array.from(unique).sort()
+    };
+  }
+  for (const filePath of candidates) {
+    processResult(scanFile(filePath));
+  }
+  return {
+    files,
+    totalFiles: files.length,
+    uniqueClasses: Array.from(unique).sort()
+  };
+}
+async function scanWorkspaceAsync(rootDir, options = {}) {
+  if (process.env.TWS_DISABLE_SCANNER_WORKER === "1") {
+    return scanWorkspace(rootDir, options);
+  }
+  try {
+    return await scanWorkspaceInWorker(rootDir, options);
+  } catch (error) {
+    log2.debug(
+      `worker scan failed, falling back to sync scanner: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return scanWorkspace(rootDir, options);
+  }
+}
+var log2, SCAN_WORKER_TIMEOUT_MS, SCAN_WORKER_BOOTSTRAP, nativeParserBinding, nativeParserInitError, DEFAULT_EXTENSIONS, DEFAULT_IGNORES;
+var init_src3 = __esm({
+  "packages/scanner/src/index.ts"() {
+    init_src2();
+    init_src();
+    init_cache_native();
+    init_native_bridge();
+    log2 = createLogger("scanner");
+    SCAN_WORKER_TIMEOUT_MS = 12e4;
+    SCAN_WORKER_BOOTSTRAP = `
+const { parentPort, workerData } = require("node:worker_threads")
+try {
+  const scanner = require(workerData.modulePath)
+  const result = scanner.scanWorkspace(workerData.rootDir, workerData.options ?? {})
+  parentPort.postMessage({ ok: true, result })
+} catch (error) {
+  parentPort.postMessage({
+    ok: false,
+    error: error instanceof Error ? error.message : String(error),
+  })
+}
+`;
+    nativeParserInitError = null;
+    DEFAULT_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"];
+    DEFAULT_IGNORES = ["node_modules", ".git", ".next", "dist", "out", ".turbo", ".cache"];
+  }
+});
+function formatErrorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+async function pathExists(filePath) {
+  try {
+    await fs3__default.default.promises.access(filePath, fs3__default.default.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sanitizeTopLimit(value) {
+  if (!Number.isFinite(value)) return DEFAULT_TOP_LIMIT;
+  return Math.max(1, Math.trunc(value));
+}
+function sanitizeFrequentThreshold(value) {
+  if (!Number.isFinite(value)) return DEFAULT_FREQUENT_THRESHOLD;
+  return Math.max(1, Math.trunc(value));
+}
+var DEFAULT_TOP_LIMIT, DEFAULT_FREQUENT_THRESHOLD, DEBUG_NAMESPACE, debugLog;
+var init_utils = __esm({
+  "packages/analyzer/src/utils.ts"() {
+    init_src();
+    DEFAULT_TOP_LIMIT = 10;
+    DEFAULT_FREQUENT_THRESHOLD = 2;
+    DEBUG_NAMESPACE = "tailwind-styled:analyzer";
+    debugLog = createDebugLogger(DEBUG_NAMESPACE, "tailwind-styled/analyzer");
+  }
+});
+
+// packages/analyzer/src/binding.ts
+function isAnalyzerModule(module2) {
+  const candidate = module2;
+  return typeof candidate?.analyzeClasses === "function";
+}
+function getNativeBinding() {
+  if (bindingCache !== void 0) return bindingCache;
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_NO_RUST === "1") {
+    bindingCandidateCache = [];
+    bindingLoadErrorsCache = [];
+    loadedBindingPathCache = null;
+    debugLog("native binding disabled by TWS_NO_NATIVE/TWS_NO_RUST");
+    bindingCache = null;
+    return bindingCache;
+  }
+  const runtimeDir2 = resolveRuntimeDir(
+    typeof __dirname === "string" ? __dirname : void 0,
+    (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('vite.js', document.baseURI).href))
+  );
+  const candidates = resolveNativeBindingCandidates({
+    runtimeDir: runtimeDir2,
+    envVarNames: ["TWS_NATIVE_PATH"]
+  });
+  const { binding, loadErrors, loadedPath } = loadNativeBinding({
+    runtimeDir: runtimeDir2,
+    candidates,
+    isValid: isAnalyzerModule,
+    invalidExportMessage: "Module loaded but missing `analyzeClasses` export."
+  });
+  bindingCandidateCache = candidates;
+  bindingLoadErrorsCache = loadErrors;
+  loadedBindingPathCache = loadedPath;
+  if (binding) {
+    debugLog(`native binding loaded from: ${loadedPath}`);
+    bindingCache = binding;
+    return bindingCache;
+  }
+  if (bindingLoadErrorsCache.length > 0) {
+    debugLog(
+      `native binding load failed for ${bindingLoadErrorsCache.length} candidate(s): ${bindingLoadErrorsCache.map((entry) => `${entry.path} (${entry.message})`).join("; ")}`
+    );
+  } else {
+    debugLog("native binding not found in any candidate path");
+  }
+  bindingCache = null;
+  return bindingCache;
+}
+function requireNativeBinding() {
+  const binding = getNativeBinding();
+  if (binding?.analyzeClasses) return binding;
+  const lines = [
+    "Native analyzer binding not found. Ensure `tailwind_styled_parser.node` is built."
+  ];
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_NO_RUST === "1") {
+    lines.push("Native loading is disabled by TWS_NO_NATIVE/TWS_NO_RUST.");
+  } else {
+    lines.push("Checked paths:");
+    for (const candidate of bindingCandidateCache) lines.push(`- ${candidate}`);
+    if (bindingLoadErrorsCache.length > 0) {
+      lines.push("Load errors:");
+      for (const failure of bindingLoadErrorsCache) {
+        lines.push(`- ${failure.path}: ${failure.message}`);
+      }
+    }
+  }
+  throw new Error(lines.join("\n"));
+}
+function requireNativeCssCompiler() {
+  const binding = requireNativeBinding();
+  if (typeof binding.compileCss === "function") return binding;
+  const loadedPathText = loadedBindingPathCache ? ` (${loadedBindingPathCache})` : "";
+  throw new Error(`Native analyzer compileCss binding is missing in v5${loadedPathText}.`);
+}
+var bindingCache, bindingCandidateCache, bindingLoadErrorsCache, loadedBindingPathCache;
+var init_binding = __esm({
+  "packages/analyzer/src/binding.ts"() {
+    init_src();
+    init_utils();
+    bindingCandidateCache = [];
+    bindingLoadErrorsCache = [];
+    loadedBindingPathCache = null;
+  }
+});
+function splitVariantAndBase(className) {
+  const parts = className.split(":");
+  if (parts.length <= 1) return { variantKey: "", base: className };
+  const base = parts.pop() ?? className;
+  return { variantKey: parts.join(":"), base };
+}
+function isArbitraryUtility(baseClass) {
+  return baseClass.includes("[") && baseClass.includes("]");
+}
+function resolveConflictGroup(base) {
+  if (isArbitraryUtility(base)) return null;
+  if (["block", "inline", "inline-block", "inline-flex", "flex", "grid", "hidden"].includes(base))
+    return "display";
+  if (base.startsWith("bg-")) return "bg";
+  if (base.startsWith("text-")) return "text";
+  if (base.startsWith("font-")) return "font";
+  if (base.startsWith("rounded")) return "rounded";
+  if (base.startsWith("shadow")) return "shadow";
+  if (base.startsWith("border-")) return "border";
+  if (base.startsWith("opacity-")) return "opacity";
+  if (base.startsWith("w-") || base.startsWith("min-w-") || base.startsWith("max-w-"))
+    return "width";
+  if (base.startsWith("h-") || base.startsWith("min-h-") || base.startsWith("max-h-"))
+    return "height";
+  if (base.startsWith("p-") || base.startsWith("px-") || base.startsWith("py-")) return "padding";
+  if (base.startsWith("m-") || base.startsWith("mx-") || base.startsWith("my-")) return "margin";
+  return null;
+}
+function detectConflicts(usages) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const usage of usages) {
+    const { variantKey, base } = splitVariantAndBase(usage.name);
+    const group = resolveConflictGroup(base);
+    if (!group) continue;
+    const key = `${variantKey}::${group}`;
+    const bucket = buckets.get(key) ?? {
+      variantKey,
+      group,
+      classes: /* @__PURE__ */ new Set()
+    };
+    bucket.classes.add(usage.name);
+    buckets.set(key, bucket);
+  }
+  const conflicts = [];
+  const conflictedClassNames = /* @__PURE__ */ new Set();
+  for (const bucket of buckets.values()) {
+    if (bucket.classes.size <= 1) continue;
+    const classes = Array.from(bucket.classes).sort();
+    for (const className of classes) conflictedClassNames.add(className);
+    const variantLabel = bucket.variantKey.length > 0 ? bucket.variantKey : "base";
+    conflicts.push({
+      className: bucket.group,
+      variants: bucket.variantKey.length > 0 ? bucket.variantKey.split(":") : [],
+      classes,
+      message: `Multiple ${bucket.group} utilities detected for "${variantLabel}".`
+    });
+  }
+  conflicts.sort((left, right) => {
+    if (right.classes.length !== left.classes.length)
+      return right.classes.length - left.classes.length;
+    return left.className.localeCompare(right.className);
+  });
+  return { conflicts, conflictedClassNames };
+}
+function isSupportedTailwindConfigPath(configPath) {
+  return SUPPORTED_TAILWIND_CONFIG_EXTENSIONS.has(path10__default.default.extname(configPath).toLowerCase());
+}
+async function resolveTailwindConfigPath(root, explicitPath) {
+  if (explicitPath) {
+    const resolved = path10__default.default.resolve(root, explicitPath);
+    if (!await pathExists(resolved)) return null;
+    return resolved;
+  }
+  const candidates = [
+    "tailwind.config.ts",
+    "tailwind.config.js",
+    "tailwind.config.cjs",
+    "tailwind.config.mjs"
+  ];
+  for (const candidate of candidates) {
+    const fullPath = path10__default.default.resolve(root, candidate);
+    if (await pathExists(fullPath)) return fullPath;
+  }
+  return null;
+}
+function collectSafelistFromConfig(config) {
+  const raw = config.safelist;
+  if (!Array.isArray(raw)) return [];
+  const out = /* @__PURE__ */ new Set();
+  for (const entry of raw) {
+    if (typeof entry === "string" && entry.length > 0) {
+      out.add(entry);
+      continue;
+    }
+    if (!entry || typeof entry !== "object") continue;
+    const pattern = entry.pattern;
+    if (typeof pattern === "string" && pattern.length > 0) {
+      out.add(pattern);
+    }
+  }
+  return Array.from(out);
+}
+function collectCustomUtilities(config) {
+  const out = /* @__PURE__ */ new Set();
+  const theme = config.theme;
+  if (!theme || typeof theme !== "object") return out;
+  const extend = theme.extend;
+  if (!extend || typeof extend !== "object") return out;
+  for (const [section, value] of Object.entries(extend)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    for (const key of Object.keys(value)) {
+      out.add(`${section}-${key}`);
+      if (section === "colors") {
+        out.add(`bg-${key}`);
+        out.add(`text-${key}`);
+        out.add(`border-${key}`);
+      } else if (section === "spacing") {
+        out.add(`p-${key}`);
+        out.add(`m-${key}`);
+        out.add(`gap-${key}`);
+        out.add(`w-${key}`);
+        out.add(`h-${key}`);
+      } else if (section === "fontSize") {
+        out.add(`text-${key}`);
+      } else if (section === "borderRadius") {
+        out.add(`rounded-${key}`);
+      } else if (section === "boxShadow") {
+        out.add(`shadow-${key}`);
+      }
+    }
+  }
+  return out;
+}
+async function collectSafelistFromSource(configPath) {
+  const source = await fs3__default.default.promises.readFile(configPath, "utf8");
+  const safelistBlock = source.match(/safelist\s*:\s*\[([\s\S]*?)\]/m)?.[1];
+  if (!safelistBlock) return [];
+  const out = /* @__PURE__ */ new Set();
+  const tokenRegex = /["'`]([^"'`]+)["'`]/g;
+  let token = tokenRegex.exec(safelistBlock);
+  while (token) {
+    const value = token[1].trim();
+    if (value.length > 0) out.add(value);
+    token = tokenRegex.exec(safelistBlock);
+  }
+  return Array.from(out);
+}
+async function loadTailwindConfig2(root, semanticOption) {
+  const startMs = Date.now();
+  const configPath = await resolveTailwindConfigPath(root, semanticOption?.tailwindConfigPath);
+  if (!configPath) return null;
+  if (!isSupportedTailwindConfigPath(configPath)) {
+    return {
+      path: configPath,
+      loaded: false,
+      warning: `Unsupported Tailwind config extension at "${configPath}". Supported extensions: .ts, .js, .cjs, .mjs.`,
+      safelist: /* @__PURE__ */ new Set(),
+      customUtilities: /* @__PURE__ */ new Set()
+    };
+  }
+  const configStat = await fs3__default.default.promises.stat(configPath).catch(() => null);
+  if (configStat) {
+    const cached = tailwindConfigCache.get(configPath);
+    if (cached && cached.mtimeMs === configStat.mtimeMs && cached.size === configStat.size) {
+      debugLog(
+        `tailwind config cache hit: ${configPath} (${cached.config.safelist.size} safelist entries)`
+      );
+      return cached.config;
+    }
+  }
+  let config = null;
+  let warning;
+  try {
+    const cacheBustToken = Math.trunc(configStat?.mtimeMs ?? Date.now());
+    const imported = await import(`${url.pathToFileURL(configPath).href}?tws_mtime=${cacheBustToken}`);
+    const candidate = imported.default ?? imported;
+    if (isRecord(candidate)) {
+      config = candidate;
+    } else if (typeof candidate === "function") {
+      const evaluated = candidate();
+      if (isRecord(evaluated)) {
+        config = evaluated;
+      } else {
+        warning = "Tailwind config export function must return an object.";
+      }
+    } else {
+      warning = "Tailwind config export must be an object or a function returning an object.";
+    }
+  } catch (error) {
+    warning = formatErrorMessage2(error);
+  }
+  const safelist = /* @__PURE__ */ new Set();
+  const customUtilities = /* @__PURE__ */ new Set();
+  if (config) {
+    for (const item of collectSafelistFromConfig(config)) safelist.add(item);
+    for (const item of collectCustomUtilities(config)) customUtilities.add(item);
+  }
+  if (safelist.size === 0) {
+    try {
+      for (const item of await collectSafelistFromSource(configPath)) safelist.add(item);
+    } catch (error) {
+      debugLog(
+        `failed to parse safelist from source at "${configPath}": ${formatErrorMessage2(error)}`
+      );
+    }
+  }
+  const loaded = {
+    path: configPath,
+    loaded: config !== null,
+    warning,
+    safelist,
+    customUtilities
+  };
+  if (configStat) {
+    tailwindConfigCache.set(configPath, {
+      mtimeMs: configStat.mtimeMs,
+      size: configStat.size,
+      config: loaded
+    });
+  }
+  debugLog(
+    `tailwind config loaded from "${configPath}" in ${Date.now() - startMs}ms (loaded=${loaded.loaded}, safelist=${loaded.safelist.size}, custom=${loaded.customUtilities.size})`
+  );
+  return loaded;
+}
+function utilityPrefix(baseClass) {
+  const normalized = baseClass.startsWith("-") ? baseClass.slice(1) : baseClass;
+  if (normalized.includes("[") && normalized.includes("]")) return "arbitrary";
+  if (normalized.startsWith("min-w-")) return "min-w";
+  if (normalized.startsWith("max-w-")) return "max-w";
+  if (normalized.startsWith("min-h-")) return "min-h";
+  if (normalized.startsWith("max-h-")) return "max-h";
+  if (normalized.startsWith("space-x-")) return "space-x";
+  if (normalized.startsWith("space-y-")) return "space-y";
+  if (normalized.startsWith("inline-")) return "inline";
+  if (normalized.startsWith("border-")) return "border";
+  if (normalized.startsWith("text-")) return "text";
+  if (normalized.startsWith("bg-")) return "bg";
+  if (normalized.startsWith("rounded")) return "rounded";
+  if (normalized.startsWith("shadow")) return "shadow";
+  const hyphen = normalized.indexOf("-");
+  if (hyphen < 0) return normalized;
+  return normalized.slice(0, hyphen);
+}
+function isKnownTailwindClass(className, safelist, customUtilities) {
+  if (safelist.has(className) || customUtilities.has(className)) return true;
+  const { base } = splitVariantAndBase(className);
+  if (customUtilities.has(base)) return true;
+  const prefix = utilityPrefix(base);
+  return KNOWN_UTILITY_PREFIXES.has(prefix);
+}
+async function buildSemanticReport(usages, root, semanticOption) {
+  const loadedConfig = await loadTailwindConfig2(root, semanticOption);
+  const safelist = loadedConfig?.safelist ?? /* @__PURE__ */ new Set();
+  const customUtilities = loadedConfig?.customUtilities ?? /* @__PURE__ */ new Set();
+  const usageNames = new Set(usages.map((usage) => usage.name));
+  const unusedClasses = Array.from(safelist).filter((className) => !usageNames.has(className)).sort().map((className) => ({ name: className, count: 0, isUnused: true }));
+  const unknownClasses = usages.filter((usage) => !isKnownTailwindClass(usage.name, safelist, customUtilities)).map((usage) => ({ ...usage, isUnused: true }));
+  const { conflicts } = detectConflicts(usages);
+  return {
+    unusedClasses,
+    unknownClasses,
+    conflicts,
+    ...loadedConfig ? {
+      tailwindConfig: {
+        path: loadedConfig.path,
+        loaded: loadedConfig.loaded,
+        safelistCount: loadedConfig.safelist.size,
+        customUtilityCount: loadedConfig.customUtilities.size,
+        ...loadedConfig.warning ? { warning: loadedConfig.warning } : {}
+      }
+    } : {}
+  };
+}
+var SUPPORTED_TAILWIND_CONFIG_EXTENSIONS, KNOWN_UTILITY_PREFIXES, tailwindConfigCache;
+var init_semantic = __esm({
+  "packages/analyzer/src/semantic.ts"() {
+    init_utils();
+    SUPPORTED_TAILWIND_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".cjs", ".mjs"]);
+    KNOWN_UTILITY_PREFIXES = /* @__PURE__ */ new Set([
+      "absolute",
+      "align",
+      "animate",
+      "arbitrary",
+      "aspect",
+      "backdrop",
+      "basis",
+      "bg",
+      "block",
+      "border",
+      "bottom",
+      "col",
+      "container",
+      "contents",
+      "cursor",
+      "dark",
+      "display",
+      "divide",
+      "fill",
+      "fixed",
+      "flex",
+      "float",
+      "font",
+      "from",
+      "gap",
+      "grid",
+      "grow",
+      "h",
+      "hidden",
+      "inset",
+      "inline",
+      "isolate",
+      "items",
+      "justify",
+      "left",
+      "leading",
+      "line",
+      "list",
+      "m",
+      "max-h",
+      "max-w",
+      "mb",
+      "min-h",
+      "min-w",
+      "ml",
+      "mr",
+      "mt",
+      "mx",
+      "my",
+      "object",
+      "opacity",
+      "order",
+      "origin",
+      "outline",
+      "overflow",
+      "overscroll",
+      "p",
+      "pb",
+      "pe",
+      "perspective",
+      "place",
+      "pl",
+      "pointer",
+      "position",
+      "pr",
+      "ps",
+      "pt",
+      "px",
+      "py",
+      "relative",
+      "right",
+      "ring",
+      "rotate",
+      "rounded",
+      "row",
+      "scale",
+      "shadow",
+      "shrink",
+      "size",
+      "skew",
+      "snap",
+      "space-x",
+      "space-y",
+      "sr",
+      "start",
+      "static",
+      "sticky",
+      "stroke",
+      "table",
+      "text",
+      "to",
+      "top",
+      "touch",
+      "tracking",
+      "transform",
+      "transition",
+      "translate",
+      "truncate",
+      "underline",
+      "via",
+      "visible",
+      "w",
+      "whitespace",
+      "z"
+    ]);
+    tailwindConfigCache = /* @__PURE__ */ new Map();
+  }
+});
+function normalizeScan(scan, includeClass) {
+  if (!includeClass) return scan;
+  const filteredFiles = scan.files.map((file) => ({
+    file: file.file,
+    classes: file.classes.filter((className) => includeClass(className))
+  }));
+  const unique = /* @__PURE__ */ new Set();
+  for (const file of filteredFiles) {
+    for (const className of file.classes) unique.add(className);
+  }
+  return {
+    files: filteredFiles,
+    totalFiles: scan.totalFiles,
+    uniqueClasses: Array.from(unique).sort()
+  };
+}
+function collectClassCounts(scan) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of scan.files) {
+    for (const className of file.classes) {
+      counts.set(className, (counts.get(className) ?? 0) + 1);
+    }
+  }
+  return counts;
+}
+function buildClassUsage(counts) {
+  return Array.from(counts.entries()).map(([name, count]) => ({ name, count })).sort((left, right) => {
+    if (right.count !== left.count) return right.count - left.count;
+    return left.name.localeCompare(right.name);
+  });
+}
+function buildDistribution(usages) {
+  const distribution = {
+    "1": 0,
+    "2-3": 0,
+    "4-7": 0,
+    "8+": 0
+  };
+  for (const usage of usages) {
+    if (usage.count === 1) {
+      distribution["1"] += 1;
+      continue;
+    }
+    if (usage.count <= 3) {
+      distribution["2-3"] += 1;
+      continue;
+    }
+    if (usage.count <= 7) {
+      distribution["4-7"] += 1;
+      continue;
+    }
+    distribution["8+"] += 1;
+  }
+  return distribution;
+}
+async function analyzeWorkspace(root, options = {}) {
+  const startedAtMs = Date.now();
+  const resolvedRoot = path10__default.default.resolve(root);
+  const scanStartedAtMs = Date.now();
+  let scan;
+  try {
+    scan = await scanWorkspaceAsync(resolvedRoot, options.scanner);
+  } catch (error) {
+    throw new Error(`Failed to scan workspace at "${resolvedRoot}": ${formatErrorMessage2(error)}`, {
+      cause: error
+    });
+  }
+  debugLog(
+    `scanWorkspaceAsync processed ${scan.totalFiles} files in ${Date.now() - scanStartedAtMs}ms`
+  );
+  const normalizedScan = normalizeScan(scan, options.includeClass);
+  const topLimit = sanitizeTopLimit(options.classStats?.top);
+  const frequentThreshold = sanitizeFrequentThreshold(options.classStats?.frequentThreshold);
+  const binding = requireNativeBinding();
+  const filesJson = JSON.stringify(
+    normalizedScan.files.map((file) => ({ file: file.file, classes: file.classes }))
+  );
+  let nativeReport = null;
+  try {
+    nativeReport = binding.analyzeClasses(filesJson, resolvedRoot, topLimit);
+  } catch (error) {
+    throw new Error(`Native analyzer failed for "${resolvedRoot}": ${formatErrorMessage2(error)}`, {
+      cause: error
+    });
+  }
+  if (!nativeReport) {
+    throw new Error(`Native analyzer returned no report for "${resolvedRoot}".`);
+  }
+  const counts = collectClassCounts(normalizedScan);
+  let all = buildClassUsage(counts);
+  let semanticReport;
+  if (options.semantic) {
+    const semanticOption = typeof options.semantic === "object" ? options.semantic : void 0;
+    const semanticStartedAtMs = Date.now();
+    try {
+      semanticReport = await buildSemanticReport(all, resolvedRoot, semanticOption);
+    } catch (error) {
+      throw new Error(
+        `Failed to build semantic report for "${resolvedRoot}": ${formatErrorMessage2(error)}`,
+        { cause: error }
+      );
+    }
+    debugLog(`semantic report built in ${Date.now() - semanticStartedAtMs}ms`);
+    if (semanticReport.conflicts.length > 0) {
+      const conflicted = new Set(semanticReport.conflicts.flatMap((conflict) => conflict.classes));
+      all = all.map(
+        (usage) => conflicted.has(usage.name) ? { ...usage, isConflict: true } : usage
+      );
+    }
+  }
+  const top = all.slice(0, topLimit);
+  const frequent = all.filter((usage) => usage.count >= frequentThreshold).slice(0, topLimit);
+  const unique = all.filter((usage) => usage.count === 1);
+  const totalClassOccurrences = all.reduce((sum, usage) => sum + usage.count, 0);
+  debugLog(
+    `analyzeWorkspace completed in ${Date.now() - startedAtMs}ms (files=${normalizedScan.totalFiles}, uniqueClasses=${all.length})`
+  );
+  return {
+    root: nativeReport.root || resolvedRoot,
+    totalFiles: nativeReport.totalFiles,
+    uniqueClassCount: all.length,
+    totalClassOccurrences,
+    classStats: {
+      all,
+      top,
+      frequent,
+      unique,
+      distribution: buildDistribution(all)
+    },
+    safelist: all.map((usage) => usage.name),
+    ...semanticReport ? { semantic: semanticReport } : {}
+  };
+}
+var init_analyzeWorkspace = __esm({
+  "packages/analyzer/src/analyzeWorkspace.ts"() {
+    init_src3();
+    init_binding();
+    init_semantic();
+    init_utils();
+  }
+});
+
+// packages/analyzer/src/classToCss.ts
+function normalizeClassInput(input) {
+  if (typeof input === "string") {
+    return input.split(/\s+/).map((item) => item.trim()).filter((item) => item.length > 0);
+  }
+  if (!Array.isArray(input)) {
+    throw new TypeError("classToCss input must be a string or an array of strings.");
+  }
+  const out = [];
+  for (const item of input) {
+    if (typeof item !== "string") {
+      throw new TypeError("classToCss input array must contain only strings.");
+    }
+    const value = item.trim();
+    if (value.length > 0) out.push(value);
+  }
+  return out;
+}
+function normalizeClassToCssOptions(options) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new TypeError("classToCss options must be an object.");
+  }
+  const strict = options.strict ?? false;
+  if (typeof strict !== "boolean") {
+    throw new TypeError("classToCss options.strict must be a boolean when provided.");
+  }
+  const prefix = options.prefix ?? null;
+  if (prefix !== null && typeof prefix !== "string") {
+    throw new TypeError("classToCss options.prefix must be a string or null when provided.");
+  }
+  return { prefix, strict };
+}
+function mergeDeclarationMap(target, css) {
+  const ruleRegex = /\{([^}]*)\}/g;
+  let ruleMatch = ruleRegex.exec(css);
+  while (ruleMatch) {
+    const body = ruleMatch[1];
+    for (const raw of body.split(";")) {
+      const declaration = raw.trim();
+      if (declaration.length === 0) continue;
+      const colonIndex = declaration.indexOf(":");
+      if (colonIndex <= 0) continue;
+      const property = declaration.slice(0, colonIndex).trim();
+      const value = declaration.slice(colonIndex + 1).trim();
+      if (property.length === 0 || value.length === 0) continue;
+      if (target.has(property)) target.delete(property);
+      target.set(property, value);
+    }
+    ruleMatch = ruleRegex.exec(css);
+  }
+}
+function declarationMapToString(declarationMap) {
+  return Array.from(declarationMap.entries()).map(([property, value]) => `${property}: ${value}`).join("; ");
+}
+async function classToCss(input, options = {}) {
+  const inputClasses = normalizeClassInput(input);
+  const normalizedOptions = normalizeClassToCssOptions(options);
+  if (inputClasses.length === 0) {
+    return {
+      inputClasses: [],
+      css: "",
+      declarations: "",
+      resolvedClasses: [],
+      unknownClasses: [],
+      sizeBytes: 0
+    };
+  }
+  const binding = requireNativeCssCompiler();
+  const prefix = normalizedOptions.prefix;
+  const cssChunks = [];
+  const resolvedClasses = [];
+  const unknownClasses = [];
+  let sizeBytes = 0;
+  const declarationMap = /* @__PURE__ */ new Map();
+  for (const className of inputClasses) {
+    let compiled = null;
+    try {
+      compiled = binding.compileCss([className], prefix);
+    } catch (error) {
+      throw new Error(
+        `Native analyzer failed while compiling class "${className}": ${formatErrorMessage2(error)}`,
+        { cause: error }
+      );
+    }
+    if (!compiled) {
+      throw new Error(`Native analyzer returned no result for class "${className}".`);
+    }
+    cssChunks.push(compiled.css);
+    resolvedClasses.push(...compiled.resolvedClasses);
+    unknownClasses.push(...compiled.unknownClasses);
+    sizeBytes += compiled.sizeBytes;
+    mergeDeclarationMap(declarationMap, compiled.css);
+  }
+  const uniqueUnknown = Array.from(new Set(unknownClasses));
+  if (normalizedOptions.strict && uniqueUnknown.length > 0) {
+    throw new Error(`Unknown Tailwind classes: ${uniqueUnknown.join(", ")}`);
+  }
+  return {
+    inputClasses,
+    css: cssChunks.filter((chunk) => chunk.length > 0).join("\n"),
+    declarations: declarationMapToString(declarationMap),
+    resolvedClasses: Array.from(new Set(resolvedClasses)),
+    unknownClasses: uniqueUnknown,
+    sizeBytes
+  };
+}
+var init_classToCss = __esm({
+  "packages/analyzer/src/classToCss.ts"() {
+    init_binding();
+    init_utils();
+  }
+});
+
+// packages/analyzer/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  __internal: () => __internal,
+  analyzeWorkspace: () => analyzeWorkspace,
+  classToCss: () => classToCss
+});
+var __internal;
+var init_src4 = __esm({
+  "packages/analyzer/src/index.ts"() {
+    init_analyzeWorkspace();
+    init_classToCss();
+    init_semantic();
+    __internal = {
+      normalizeClassInput,
+      splitVariantAndBase,
+      resolveConflictGroup,
+      collectClassCounts,
+      buildDistribution,
+      utilityPrefix
+    };
+  }
+});
+
+// packages/vite/src/plugin.ts
+init_src2();
+
+// packages/engine/src/index.ts
+init_src2();
+init_src3();
+init_src();
+
+// packages/engine/src/incremental.ts
+init_src3();
+init_src();
+var _binding3 = void 0;
+var _loadError2 = null;
+var _candidatePaths2 = [];
+function getNativeEngineBinding() {
+  if (_binding3 !== void 0) {
+    if (_binding3 === null) {
+      throwNativeBindingError2();
+    }
+    return _binding3;
+  }
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_NO_RUST === "1") {
+    _loadError2 = "Native loading is disabled by TWS_NO_NATIVE or TWS_NO_RUST environment variable.";
+    _binding3 = null;
+    _candidatePaths2 = [];
+    throwNativeBindingError2();
+  }
+  const runtimeDir2 = typeof __dirname === "string" ? __dirname : process.cwd();
+  _candidatePaths2 = [
+    path10__default.default.resolve(process.cwd(), "native", "tailwind_styled_parser.node"),
+    path10__default.default.resolve(runtimeDir2, "..", "..", "..", "native", "tailwind_styled_parser.node")
+  ];
+  const req = typeof __require === "function" ? __require : module$1.createRequire(path10__default.default.join(runtimeDir2, "noop.cjs"));
+  for (const c of _candidatePaths2) {
+    try {
+      const mod = req(c);
+      if (mod?.computeIncrementalDiff || mod?.processFileChange || mod?.hashFileContent) {
+        _binding3 = mod;
+        return _binding3;
+      }
+    } catch (error) {
+      _loadError2 = error instanceof Error ? error.message : String(error);
+    }
+  }
+  _binding3 = null;
+  throwNativeBindingError2();
+}
+function throwNativeBindingError2() {
+  const lines = [
+    "FATAL: Native engine binding not found.",
+    "",
+    "This package requires the Rust native binding 'tailwind_styled_parser.node'.",
+    "The binding was not found in any of these paths:",
+    ..._candidatePaths2.map((p) => `  - ${p}`),
+    ""
+  ];
+  if (_loadError2) {
+    lines.push("Load error:", `  ${_loadError2}`, "");
+  }
+  lines.push(
+    "To fix this, run:",
+    "  npm run build:rust",
+    "",
+    "This will build the native Rust module from the 'native/' directory.",
+    "If you're using this package in a CI/CD environment, ensure Rust toolchain is installed",
+    "and 'npm run build:rust' is executed before running tests or building."
+  );
+  throw new Error(lines.join("\n"));
+}
+
+// packages/engine/src/incremental.ts
+var DEFAULT_EXTENSIONS2 = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"];
+var log3 = createLogger("engine:incremental");
+function rebuildWorkspaceResult(byFile) {
+  const files = Array.from(byFile.values());
+  const unique = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    for (const cls of file.classes) unique.add(cls);
+  }
+  return {
+    files,
+    totalFiles: files.length,
+    uniqueClasses: Array.from(unique).sort()
+  };
+}
+function applyClassDiff(existing, added, removed) {
+  const next = new Set(existing);
+  for (const cls of added) next.add(cls);
+  for (const cls of removed) next.delete(cls);
+  return Array.from(next);
+}
+function areClassSetsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  const bSet = new Set(b);
+  for (const cls of a) {
+    if (!bSet.has(cls)) return false;
+  }
+  return true;
+}
+function applyIncrementalChange(previous, filePath, type, scanner) {
+  const includeExtensions = scanner?.includeExtensions ?? DEFAULT_EXTENSIONS2;
+  if (!isScannableFile(filePath, includeExtensions)) return previous;
+  const byFile = new Map(previous.files.map((f) => [path10__default.default.resolve(f.file), f]));
+  const normalizedPath = path10__default.default.resolve(filePath);
+  const native = getNativeEngineBinding();
+  if (native?.processFileChange) {
+    try {
+      if (type === "unlink") {
+        const existing2 = byFile.get(normalizedPath);
+        log3.debug(`native unlink ${normalizedPath}`);
+        native.processFileChange(normalizedPath, existing2?.classes ?? [], null);
+        byFile.delete(normalizedPath);
+        return rebuildWorkspaceResult(byFile);
+      }
+      log3.debug(`native change ${normalizedPath}`);
+      const scanned = scanFile(normalizedPath);
+      const content = fs3__default.default.readFileSync(normalizedPath, "utf8");
+      const diff = native.processFileChange(normalizedPath, scanned.classes, content);
+      const existing = byFile.get(normalizedPath);
+      if (diff && existing) {
+        log3.debug(`native diff ${normalizedPath} +${diff.added.length} -${diff.removed.length}`);
+        const diffApplied = applyClassDiff(existing.classes, diff.added, diff.removed);
+        const classes = areClassSetsEqual(diffApplied, scanned.classes) ? diffApplied : scanned.classes;
+        byFile.set(normalizedPath, { file: normalizedPath, classes });
+      } else {
+        log3.debug(`native diff cold-sync ${normalizedPath}`);
+        byFile.set(normalizedPath, { file: normalizedPath, classes: scanned.classes });
+      }
+      return rebuildWorkspaceResult(byFile);
+    } catch (error) {
+      log3.warn(
+        "native processFileChange failed, using JS fallback:",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  log3.debug(`js fallback ${type} ${normalizedPath}`);
+  if (type === "unlink") {
+    byFile.delete(normalizedPath);
+  } else {
+    byFile.set(normalizedPath, scanFile(normalizedPath));
+  }
+  return rebuildWorkspaceResult(byFile);
+}
+
+// packages/engine/src/metrics.ts
+var EngineMetricsCollector = class {
+  constructor() {
+    this.eventsReceived = 0;
+    this.eventsProcessed = 0;
+    this.batchesProcessed = 0;
+    this.incrementalUpdates = 0;
+    this.fullRescans = 0;
+    this.skippedLargeFiles = 0;
+    this.queueMaxSize = 0;
+    this.lastBuildMs = 0;
+    this.totalBuildMs = 0;
+  }
+  markEventReceived(queueSize) {
+    this.eventsReceived += 1;
+    if (queueSize > this.queueMaxSize) this.queueMaxSize = queueSize;
+  }
+  markBatchProcessed(batchSize) {
+    this.batchesProcessed += 1;
+    this.eventsProcessed += batchSize;
+  }
+  markIncremental() {
+    this.incrementalUpdates += 1;
+  }
+  markFullRescan() {
+    this.fullRescans += 1;
+  }
+  markSkippedLargeFile() {
+    this.skippedLargeFiles += 1;
+  }
+  markBuildDuration(ms) {
+    this.lastBuildMs = ms;
+    this.totalBuildMs += ms;
+  }
+  snapshot() {
+    const avgBuildMs = this.batchesProcessed > 0 ? this.totalBuildMs / this.batchesProcessed : 0;
+    return {
+      eventsReceived: this.eventsReceived,
+      eventsProcessed: this.eventsProcessed,
+      batchesProcessed: this.batchesProcessed,
+      incrementalUpdates: this.incrementalUpdates,
+      fullRescans: this.fullRescans,
+      skippedLargeFiles: this.skippedLargeFiles,
+      queueMaxSize: this.queueMaxSize,
+      lastBuildMs: this.lastBuildMs,
+      avgBuildMs
+    };
+  }
+};
+
+// packages/engine/src/plugin-api.ts
+async function runBeforeScan(plugins, context) {
+  for (const plugin of plugins) {
+    await plugin.beforeScan?.(context);
+  }
+}
+async function runAfterScan(plugins, scan, context) {
+  let current = scan;
+  for (const plugin of plugins) {
+    const next = await plugin.afterScan?.(current, context);
+    if (next !== void 0) current = next;
+  }
+  return current;
+}
+async function runTransformClasses(plugins, classes, context) {
+  let current = classes;
+  for (const plugin of plugins) {
+    const next = await plugin.transformClasses?.(current, context);
+    if (next !== void 0) current = next;
+  }
+  return current;
+}
+async function runBeforeBuild(plugins, scan, context) {
+  for (const plugin of plugins) {
+    await plugin.beforeBuild?.(scan, context);
+  }
+}
+async function runAfterBuild(plugins, result, context) {
+  let current = result;
+  for (const plugin of plugins) {
+    const next = await plugin.afterBuild?.(current, context);
+    if (next !== void 0) current = next;
+  }
+  return current;
+}
+async function runOnError(plugins, error, context) {
+  for (const plugin of plugins) {
+    await plugin.onError?.(error, context);
+  }
+}
+async function runBeforeWatch(plugins, context) {
+  for (const plugin of plugins) {
+    await plugin.beforeWatch?.(context);
+  }
+}
+async function runAfterWatch(plugins, context) {
+  for (const plugin of plugins) {
+    await plugin.afterWatch?.(context);
+  }
+}
+var DEFAULT_IGNORES2 = ["node_modules", ".git", ".next", "dist", "out", ".turbo", ".cache"];
+function watchWorkspace(rootDir, onEvent, options = {}) {
+  const ignoreDirectories = new Set(options.ignoreDirectories ?? DEFAULT_IGNORES2);
+  const watchers = /* @__PURE__ */ new Map();
+  const restartTimers = /* @__PURE__ */ new Map();
+  const debounceMs = options.debounceMs ?? 100;
+  const pending = /* @__PURE__ */ new Map();
+  const shouldIgnore = (targetPath) => {
+    const parts = targetPath.split(path10__default.default.sep);
+    return parts.some((part) => ignoreDirectories.has(part));
+  };
+  const enqueue = (event) => {
+    const key = `${event.type}:${event.filePath}`;
+    const existing = pending.get(key);
+    if (existing) clearTimeout(existing);
+    const timer = setTimeout(() => {
+      pending.delete(key);
+      onEvent(event);
+    }, debounceMs);
+    pending.set(key, timer);
+  };
+  const safeUnwatch = (dir) => {
+    const watcher = watchers.get(dir);
+    if (!watcher) return;
+    try {
+      watcher.close();
+    } catch {
+    }
+    watchers.delete(dir);
+  };
+  const scheduleRestart = (dir) => {
+    const previous = restartTimers.get(dir);
+    if (previous) clearTimeout(previous);
+    const timer = setTimeout(() => {
+      restartTimers.delete(dir);
+      watchDir(dir);
+    }, 250);
+    restartTimers.set(dir, timer);
+  };
+  const watchDir = (dir) => {
+    if (watchers.has(dir) || shouldIgnore(dir) || !fs3__default.default.existsSync(dir)) return;
+    try {
+      const stat = fs3__default.default.lstatSync(dir);
+      if (!stat.isDirectory() || stat.isSymbolicLink()) return;
+    } catch {
+      return;
+    }
+    const watcher = fs3__default.default.watch(dir, { persistent: true }, (_eventType, fileName) => {
+      if (!fileName) return;
+      const fullPath = path10__default.default.join(dir, fileName.toString());
+      if (shouldIgnore(fullPath)) return;
+      if (fs3__default.default.existsSync(fullPath)) {
+        try {
+          const stat = fs3__default.default.lstatSync(fullPath);
+          if (stat.isSymbolicLink()) return;
+          if (stat.isDirectory()) {
+            watchDir(fullPath);
+            return;
+          }
+          enqueue({ type: "change", filePath: fullPath });
+          return;
+        } catch {
+        }
+      }
+      enqueue({ type: "unlink", filePath: fullPath });
+    });
+    watcher.on("error", (error) => {
+      safeUnwatch(dir);
+      const watcherError = error instanceof Error ? error : new Error(String(error));
+      options.onError?.(watcherError, dir);
+      scheduleRestart(dir);
+    });
+    watchers.set(dir, watcher);
+    for (const entry of fs3__default.default.readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      watchDir(path10__default.default.join(dir, entry.name));
+    }
+  };
+  watchDir(path10__default.default.resolve(rootDir));
+  return {
+    close() {
+      for (const timer of pending.values()) clearTimeout(timer);
+      pending.clear();
+      for (const timer of restartTimers.values()) clearTimeout(timer);
+      restartTimers.clear();
+      for (const watcher of watchers.values()) watcher.close();
+      watchers.clear();
+    }
+  };
+}
+
+// packages/engine/src/index.ts
+var DEFAULT_LARGE_FILE_THRESHOLD_BYTES = 10 * 1024 * 1024;
+var DEFAULT_FLUSH_DEBOUNCE_MS = 100;
+var DEFAULT_MAX_EVENTS_PER_FLUSH = 100;
+var log4 = createLogger("engine");
+async function loadTailwindConfigFromPath(root, tailwindConfigPath) {
+  if (!tailwindConfigPath) return void 0;
+  const configPath = path10__default.default.resolve(root, tailwindConfigPath);
+  if (!fs3__default.default.existsSync(configPath)) {
+    throw new Error(`tailwindConfigPath not found: ${configPath}`);
+  }
+  const imported = await import(url.pathToFileURL(configPath).href);
+  const config = imported.default ?? imported;
+  return config;
+}
+async function tryRunAnalyzer(root, scan) {
+  try {
+    const { __internal: __internal2 } = await Promise.resolve().then(() => (init_src4(), src_exports));
+    const counts = __internal2.collectClassCounts(scan);
+    const classUsage = {};
+    for (const [name, count] of counts) {
+      classUsage[name] = count;
+    }
+    return {
+      unusedClasses: Array.from(counts.keys()).filter((c) => counts.get(c) === 0),
+      classConflicts: [],
+      classUsage
+    };
+  } catch (e) {
+    log4.warn("Analyzer not available:", String(e));
+    return void 0;
+  }
+}
+async function buildFromScan(scan, root, options, tailwindConfig) {
+  const plugins = options.plugins ?? [];
+  const context = { root, timestamp: Date.now() };
+  await runBeforeBuild(plugins, scan, context);
+  const transformedClasses = await runTransformClasses(plugins, scan.uniqueClasses, context);
+  const mergedClassList = mergeClassesStatic(transformedClasses.join(" "));
+  let css = "";
+  if (options.compileCss !== false && mergedClassList.length > 0) {
+    css = await generateCssForClasses(
+      mergedClassList.split(/\s+/).filter(Boolean),
+      tailwindConfig,
+      root
+    );
+  }
+  let analysis;
+  if (options.analyze) {
+    analysis = await tryRunAnalyzer(root, scan);
+  }
+  const result = {
+    scan,
+    mergedClassList,
+    css,
+    analysis
+  };
+  return runAfterBuild(plugins, result, context);
+}
+async function createEngine(options = {}) {
+  const root = options.root ?? process.cwd();
+  const resolvedRoot = path10__default.default.resolve(root);
+  const plugins = options.plugins ?? [];
+  let cachedTailwindConfig;
+  let tailwindConfigLoaded = false;
+  const getTailwindConfig = async () => {
+    if (tailwindConfigLoaded) return cachedTailwindConfig;
+    cachedTailwindConfig = await loadTailwindConfigFromPath(
+      resolvedRoot,
+      options.tailwindConfigPath
+    );
+    tailwindConfigLoaded = true;
+    return cachedTailwindConfig;
+  };
+  const reportEngineError = async (error) => {
+    const normalized = error instanceof Error ? error : new Error(String(error));
+    const context = { root: resolvedRoot, timestamp: Date.now() };
+    try {
+      await runOnError(plugins, normalized, context);
+    } catch (pluginError) {
+      log4.error(
+        "plugin onError hook failed:",
+        pluginError instanceof Error ? pluginError.message : String(pluginError)
+      );
+    }
+    log4.error(normalized.message);
+    return normalized;
+  };
+  const doScan = async () => {
+    try {
+      const context = { root: resolvedRoot, timestamp: Date.now() };
+      await runBeforeScan(plugins, context);
+      const scan = await scanWorkspaceAsync(resolvedRoot, options.scanner);
+      return await runAfterScan(plugins, scan, context);
+    } catch (error) {
+      throw await reportEngineError(error);
+    }
+  };
+  return {
+    scan: doScan,
+    async build() {
+      const scan = await doScan();
+      try {
+        return await buildFromScan(scan, resolvedRoot, options, await getTailwindConfig());
+      } catch (error) {
+        throw await reportEngineError(error);
+      }
+    },
+    async watch(onEvent, watchOptions = {}) {
+      const flushDebounceMs = watchOptions.debounceMs ?? DEFAULT_FLUSH_DEBOUNCE_MS;
+      const maxEventsPerFlush = watchOptions.maxEventsPerFlush ?? DEFAULT_MAX_EVENTS_PER_FLUSH;
+      const largeFileThreshold = watchOptions.largeFileThreshold ?? DEFAULT_LARGE_FILE_THRESHOLD_BYTES;
+      const tailwindConfig = await getTailwindConfig();
+      const watchContext = { root: resolvedRoot, timestamp: Date.now() };
+      await runBeforeWatch(plugins, watchContext);
+      let currentScan = await doScan();
+      try {
+        onEvent({
+          type: "initial",
+          result: await buildFromScan(currentScan, resolvedRoot, options, tailwindConfig)
+        });
+      } catch (error) {
+        const normalized = await reportEngineError(error);
+        onEvent({ type: "error", error: normalized.message });
+        throw normalized;
+      }
+      let timer = null;
+      const queue = [];
+      const metrics = new EngineMetricsCollector();
+      const scheduleFlush = () => {
+        if (timer) return;
+        timer = setTimeout(() => {
+          timer = null;
+          void flushBatch();
+        }, flushDebounceMs);
+      };
+      const shouldForceFullRescan = (event) => {
+        if (event.type === "unlink") return false;
+        try {
+          const stat = fs3__default.default.statSync(event.filePath);
+          if (stat.size > largeFileThreshold) {
+            metrics.markSkippedLargeFile();
+            return true;
+          }
+        } catch {
+          return false;
+        }
+        return false;
+      };
+      const flushBatch = async () => {
+        if (queue.length === 0) return;
+        const batch = queue.splice(0, maxEventsPerFlush);
+        metrics.markBatchProcessed(batch.length);
+        let forceRescan = false;
+        for (const event of batch) {
+          if (shouldForceFullRescan(event)) {
+            forceRescan = true;
+            break;
+          }
+        }
+        const lastEvent = batch[batch.length - 1];
+        let emittedType = lastEvent.type;
+        try {
+          if (forceRescan) {
+            currentScan = await doScan();
+            metrics.markFullRescan();
+            emittedType = "full-rescan";
+          } else {
+            for (const event of batch) {
+              currentScan = applyIncrementalChange(
+                currentScan,
+                event.filePath,
+                event.type,
+                options.scanner
+              );
+              metrics.markIncremental();
+            }
+          }
+        } catch (error) {
+          const normalized = await reportEngineError(error);
+          log4.warn("incremental path failed, forcing full rescan:", normalized.message);
+          currentScan = await doScan();
+          metrics.markFullRescan();
+          emittedType = "full-rescan";
+        }
+        try {
+          const started = Date.now();
+          const result = await buildFromScan(currentScan, resolvedRoot, options, tailwindConfig);
+          metrics.markBuildDuration(Date.now() - started);
+          onEvent({
+            type: emittedType,
+            filePath: lastEvent.filePath,
+            result,
+            metrics: metrics.snapshot()
+          });
+        } catch (error) {
+          const normalized = await reportEngineError(error);
+          onEvent({
+            type: "error",
+            filePath: lastEvent.filePath,
+            error: normalized.message,
+            metrics: metrics.snapshot()
+          });
+        }
+        if (queue.length > 0) scheduleFlush();
+      };
+      const watcher = watchWorkspace(
+        resolvedRoot,
+        (event) => {
+          queue.push(event);
+          metrics.markEventReceived(queue.length);
+          scheduleFlush();
+        },
+        {
+          ignoreDirectories: options.scanner?.ignoreDirectories,
+          debounceMs: flushDebounceMs,
+          onError: (error, directory) => {
+            void reportEngineError(error);
+            onEvent({
+              type: "error",
+              filePath: directory,
+              error: error.message,
+              metrics: metrics.snapshot()
+            });
+          }
+        }
+      );
+      return {
+        async close() {
+          if (timer) clearTimeout(timer);
+          watcher.close();
+          await runAfterWatch(plugins, watchContext);
+        }
+      };
+    }
+  };
+}
+
+// packages/vite/src/plugin.ts
+init_src3();
 function warnDeprecated(options, key, message) {
   if (options[key] !== void 0) {
     console.warn(`[tailwind-styled-v4] Warning: '${key}' is deprecated in v5. ${message}`);
@@ -54,9 +4220,7 @@ function tailwindStyledPlugin(opts = {}) {
       const output = runLoaderTransform({
         filepath,
         source,
-        options: loaderOptions,
-        isDev
-      });
+        options: loaderOptions});
       if (!output.changed) return null;
       return { code: output.code, map: null };
     },
@@ -65,8 +4229,8 @@ function tailwindStyledPlugin(opts = {}) {
       if (doSafelist) {
         try {
           generateSafelist(
-            scanDirs.map((d) => path.resolve(root, d)),
-            path.resolve(root, safelistOutput),
+            scanDirs.map((d) => path10__default.default.resolve(root, d)),
+            path10__default.default.resolve(root, safelistOutput),
             root
           );
         } catch (e) {
@@ -75,8 +4239,8 @@ function tailwindStyledPlugin(opts = {}) {
       }
       try {
         const report = await scanWorkspaceAsync(root);
-        const reportPath = path.resolve(root, scanReportOutput);
-        fs.writeFileSync(
+        const reportPath = path10__default.default.resolve(root, scanReportOutput);
+        fs3__default.default.writeFileSync(
           reportPath,
           JSON.stringify(
             {
@@ -123,6 +4287,7 @@ function tailwindStyledPlugin(opts = {}) {
 }
 var plugin_default = tailwindStyledPlugin;
 
-export { plugin_default as default, tailwindStyledPlugin };
+exports.default = plugin_default;
+exports.tailwindStyledPlugin = tailwindStyledPlugin;
 //# sourceMappingURL=vite.js.map
 //# sourceMappingURL=vite.js.map