tailwind-styled-v4 4.0.0 → 5.0.1

package/dist/engine.mjs

@@ -0,0 +1,3005 @@
+import { twMerge } from 'tailwind-merge';
+import fs3 from 'fs';
+import { createRequire } from 'module';
+import os from 'os';
+import path8 from 'path';
+import { pathToFileURL, fileURLToPath } from 'url';
+import { Worker } from 'worker_threads';
+
+/* 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 twMerge(classes);
+}
+var init_classMerger = __esm({
+  "packages/compiler/src/classMerger.ts"() {
+  }
+});
+function getPlatformExtension() {
+  const platform = os.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 path8.dirname(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 = path8.resolve(raw);
+    if (options.enforceNodeExtensionForEnvPath) {
+      if (path8.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(path8.resolve(process.cwd(), "native", defaultBindingName));
+    out.push(path8.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 = createRequire(path8.join(options.runtimeDir, "noop.cjs"));
+  const loadErrors = [];
+  for (const candidate of options.candidates) {
+    if (!fs3.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");
+  }
+});
+
+// packages/shared/src/index.ts
+var init_src = __esm({
+  "packages/shared/src/index.ts"() {
+    init_nativeBinding();
+    init_logger();
+  }
+});
+
+// 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",
+    path8.resolve(process.cwd(), "native", "index.mjs"),
+    path8.resolve(runtimeDir, "..", "..", "native", "index.mjs"),
+    path8.resolve(runtimeDir, "..", "..", "..", "native", "index.mjs"),
+    path8.resolve(process.cwd(), "native", "index.node"),
+    path8.resolve(runtimeDir, "..", "..", "native", "index.node"),
+    path8.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) : createRequire(path8.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 : createRequire(import.meta.url);
+  const candidates = [
+    path8.resolve(process.cwd(), "native", "tailwind_styled_parser.node"),
+    path8.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");
+  }
+});
+
+// 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/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 = path8.join(cwd, file);
+    if (fs3.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 = "";
+  }
+});
+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: path8.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_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 = [
+    path8.resolve(process.cwd(), "native", "tailwind_styled_parser.node"),
+    path8.resolve(runtimeDir2, "..", "..", "..", "native", "tailwind_styled_parser.node")
+  ];
+  const req = typeof __require === "function" ? __require : createRequire(path8.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 ? path8.resolve(rootDir, cacheDir) : path8.join(process.cwd(), ".cache", "tailwind-styled");
+  return path8.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 = [
+    path8.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
+    path8.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node")
+  ];
+  for (const fullPath of candidates) {
+    if (!fs3.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 : path8.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path8.resolve(runtimeDir2, "index.cjs"),
+    path8.resolve(runtimeDir2, "index.js"),
+    path8.resolve(runtimeDir2, "index.ts")
+  ];
+  for (const candidate of candidates) {
+    if (fs3.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(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.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = path8.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!ignoreDirectories.has(entry.name)) directories.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!extensionSet.has(path8.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(path8.extname(filePath));
+}
+function scanFile(filePath) {
+  const source = fs3.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.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.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.promises.access(filePath, fs3.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,
+    import.meta.url
+  );
+  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(path8.extname(configPath).toLowerCase());
+}
+async function resolveTailwindConfigPath(root, explicitPath) {
+  if (explicitPath) {
+    const resolved = path8.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 = path8.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.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.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(`${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 = path8.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/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 = [
+    path8.resolve(process.cwd(), "native", "tailwind_styled_parser.node"),
+    path8.resolve(runtimeDir2, "..", "..", "..", "native", "tailwind_styled_parser.node")
+  ];
+  const req = typeof __require === "function" ? __require : createRequire(path8.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) => [path8.resolve(f.file), f]));
+  const normalizedPath = path8.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.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(path8.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.existsSync(dir)) return;
+    try {
+      const stat = fs3.lstatSync(dir);
+      if (!stat.isDirectory() || stat.isSymbolicLink()) return;
+    } catch {
+      return;
+    }
+    const watcher = fs3.watch(dir, { persistent: true }, (_eventType, fileName) => {
+      if (!fileName) return;
+      const fullPath = path8.join(dir, fileName.toString());
+      if (shouldIgnore(fullPath)) return;
+      if (fs3.existsSync(fullPath)) {
+        try {
+          const stat = fs3.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.readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      watchDir(path8.join(dir, entry.name));
+    }
+  };
+  watchDir(path8.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 = path8.resolve(root, tailwindConfigPath);
+  if (!fs3.existsSync(configPath)) {
+    throw new Error(`tailwindConfigPath not found: ${configPath}`);
+  }
+  const imported = await import(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 = path8.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.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);
+        }
+      };
+    }
+  };
+}
+
+export { createEngine };
+//# sourceMappingURL=engine.mjs.map
+//# sourceMappingURL=engine.mjs.map