tailwind-styled-v4 5.0.10 → 5.0.11

package/dist/next.mjs

@@ -1,44 +1,42 @@
-import { z } from 'zod';
-import fs2 from 'fs';
 import { createRequire } from 'module';
-import path2 from 'path';
+import * as fs5 from 'fs';
+import fs5__default from 'fs';
+import * as path5 from 'path';
+import path5__default from 'path';
 import 'crypto';
-import 'url';
+import { fileURLToPath } from 'url';
+import { z } from 'zod';
+import 'worker_threads';
 
 /* tailwind-styled-v4 v5.0.4 | 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 formatIssues = (error) => error.issues.map((issue) => {
-  const p = issue.path.length > 0 ? issue.path.join(".") : "<root>";
-  return `${p}: ${issue.message}`;
-}).join("; ");
-var parseWithSchema = (schema, data, label) => {
-  const parsed = schema.safeParse(data);
-  if (parsed.success) return parsed.data;
-  throw new TypeError(`${label}: ${formatIssues(parsed.error)}`);
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var NextAdapterOptionsSchema = z.object({
-  mode: z.literal("zero-runtime").optional(),
-  autoClientBoundary: z.boolean().optional(),
-  addDataAttr: z.boolean().optional(),
-  hoist: z.boolean().optional(),
-  routeCss: z.boolean().optional(),
-  incremental: z.boolean().optional(),
-  verbose: z.boolean().optional(),
-  include: z.instanceof(RegExp).optional(),
-  exclude: z.instanceof(RegExp).optional()
-});
-var parseNextAdapterOptions = (options) => parseWithSchema(NextAdapterOptionsSchema, options ?? {}, "next adapter options are invalid");
+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);
 
 // packages/domain/shared/src/workerResolver.ts
-var isBrowser = typeof window !== "undefined" || typeof document !== "undefined";
-var NODE_URL = typeof window === "undefined" || typeof document === "undefined" ? "node:url" : null;
-var NODE_FS = typeof window === "undefined" || typeof document === "undefined" ? "node:fs" : null;
-var NODE_PATH = typeof window === "undefined" || typeof document === "undefined" ? "node:path" : null;
 function getDirnameFromUrl(importMetaUrl) {
   if (!importMetaUrl) return "";
   if (isBrowser) return "";
@@ -64,11 +62,11 @@ function resolvePath(...segments) {
     return segments.join("/").replace(/\/+/g, "/");
   }
 }
-function existsSync(path3) {
+function existsSync(path7) {
   if (isBrowser) return false;
   try {
     const nodeFs = __require(NODE_FS);
-    return nodeFs.existsSync(path3);
+    return nodeFs.existsSync(path7);
   } catch {
     return false;
   }
@@ -118,9 +116,1685 @@ function resolveLoaderPath(loaderBasename, importMetaUrl) {
     subdirs: [".", "loaders", "lib"]
   }).path;
 }
+var isBrowser, NODE_URL, NODE_FS, NODE_PATH;
+var init_workerResolver = __esm({
+  "packages/domain/shared/src/workerResolver.ts"() {
+    isBrowser = typeof window !== "undefined" || typeof document !== "undefined";
+    NODE_URL = typeof window === "undefined" || typeof document === "undefined" ? "node:url" : null;
+    NODE_FS = typeof window === "undefined" || typeof document === "undefined" ? "node:fs" : null;
+    NODE_PATH = typeof window === "undefined" || typeof document === "undefined" ? "node:path" : null;
+  }
+});
+function platformKey() {
+  if (isBrowser2) return "browser";
+  return `${process.platform}-${process.arch}`;
+}
+function resolveNativeBinary(runtimeDir) {
+  const platform = platformKey();
+  const tried = [];
+  if (isBrowser2) {
+    return { path: null, source: "not-found", platform, tried: ["not available in browser"] };
+  }
+  if (process.env.TWS_DISABLE_NATIVE === "1") {
+    return { path: null, source: "not-found", platform, tried: [] };
+  }
+  const envPath = process.env.TW_NATIVE_PATH?.trim();
+  if (envPath) {
+    if (fs5.existsSync(envPath)) {
+      return { path: envPath, source: "env", platform, tried };
+    }
+    tried.push(`env:${envPath} (not found)`);
+  }
+  const prebuiltPkgs = PLATFORM_MAP[platform] ?? [];
+  for (const pkg of prebuiltPkgs) {
+    try {
+      const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
+      if (fs5.existsSync(candidate)) {
+        return { path: candidate, source: "prebuilt", platform, tried };
+      }
+      tried.push(`prebuilt:${pkg} (resolved but missing)`);
+    } catch {
+      tried.push(`prebuilt:${pkg} (not installed)`);
+    }
+  }
+  const napiPlatform = platform === "linux-x64" ? "linux-x64-gnu" : platform === "linux-arm64" ? "linux-arm64-gnu" : platform;
+  const BINARY_NAMES_SELF = ["tailwind-styled-native", "tailwind_styled_parser"];
+  if (runtimeDir) {
+    for (const depth of ["..", path5.join("..", ".."), path5.join("..", "..", "..")]) {
+      const pkgRoot = path5.resolve(runtimeDir, depth);
+      for (const bin of BINARY_NAMES_SELF) {
+        for (const suffix of ["", `.${platform}`, `.${napiPlatform}`]) {
+          const candidate = path5.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
+          tried.push(`self-bundled:${candidate}`);
+          if (fs5.existsSync(candidate)) {
+            return { path: candidate, source: "prebuilt", platform, tried };
+          }
+        }
+      }
+    }
+  }
+  const cwd = process.cwd();
+  const base = runtimeDir ?? cwd;
+  const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
+  const localCandidates = [];
+  for (const bin of BINARY_NAMES) {
+    localCandidates.push(path5.resolve(base, `${bin}.node`));
+    localCandidates.push(path5.resolve(base, "..", `${bin}.node`));
+    localCandidates.push(path5.resolve(base, `${bin}.${platform}.node`));
+    localCandidates.push(path5.resolve(base, `${bin}.${napiPlatform}.node`));
+  }
+  for (const startDir of [cwd, base]) {
+    let dir = startDir;
+    for (let i = 0; i < 6; i++) {
+      const nativeDir = path5.resolve(dir, "native");
+      for (const bin of BINARY_NAMES) {
+        localCandidates.push(path5.resolve(nativeDir, `${bin}.node`));
+        localCandidates.push(path5.resolve(nativeDir, `${bin}.${platform}.node`));
+        localCandidates.push(path5.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
+        localCandidates.push(path5.resolve(nativeDir, "target", "release", `${bin}.node`));
+      }
+      const parent = path5.resolve(dir, "..");
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  for (const candidate of localCandidates) {
+    tried.push(`local:${candidate}`);
+    if (fs5.existsSync(candidate)) {
+      return { path: candidate, source: "local", platform, tried };
+    }
+  }
+  return { path: null, source: "not-found", platform, tried };
+}
+var isBrowser2, _require, PLATFORM_MAP;
+var init_native_resolution = __esm({
+  "packages/domain/shared/src/native-resolution.ts"() {
+    isBrowser2 = typeof window !== "undefined" || typeof document !== "undefined";
+    _require = typeof __require !== "undefined" ? __require : createRequire(import.meta.url);
+    PLATFORM_MAP = {
+      "linux-x64": ["@tailwind-styled/native-linux-x64-gnu", "@tailwind-styled/native-linux-x64"],
+      "linux-arm64": ["@tailwind-styled/native-linux-arm64-gnu", "@tailwind-styled/native-linux-arm64"],
+      "darwin-x64": ["@tailwind-styled/native-darwin-x64"],
+      "darwin-arm64": ["@tailwind-styled/native-darwin-arm64"],
+      "win32-x64": ["@tailwind-styled/native-win32-x64-msvc", "@tailwind-styled/native-win32-x64"],
+      "win32-arm64": ["@tailwind-styled/native-win32-arm64-msvc", "@tailwind-styled/native-win32-arm64"]
+    };
+  }
+});
+function createLogger(namespace) {
+  const prefix = `[${namespace}]`;
+  return {
+    warn(...args) {
+      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+`);
+    },
+    debug(...args) {
+      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+`);
+    },
+    error(...args) {
+      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+`);
+    },
+    log(...args) {
+      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+`);
+    }
+  };
+}
+function createDebugLogger(namespace, label) {
+  const prefix = `[${namespace}]`;
+  return (msg) => {
+    if (process.env.DEBUG?.includes(namespace) || process.env.TW_DEBUG) {
+      console.debug(prefix, msg);
+    }
+  };
+}
+function formatIssuePath(path7) {
+  if (!path7 || path7.length === 0) return "(root)";
+  return path7.map(
+    (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
+  ).join(".");
+}
+function loadNativeBinding(options) {
+  const { runtimeDir, candidates, isValid } = options;
+  const loadErrors = [];
+  for (const candidate of candidates) {
+    const candidatePath = path5__default.resolve(runtimeDir, candidate);
+    try {
+      if (!fs5__default.existsSync(candidatePath) && !fs5__default.existsSync(candidatePath + ".node")) {
+        continue;
+      }
+      const mod = requireNativeModule(candidatePath);
+      if (mod && isValid(mod)) {
+        return { binding: mod, loadErrors, loadedPath: candidatePath };
+      }
+      loadErrors.push({ path: candidatePath, message: options.invalidExportMessage });
+    } catch (e) {
+      loadErrors.push({ path: candidatePath, message: e instanceof Error ? e.message : String(e) });
+    }
+  }
+  return { binding: null, loadErrors };
+}
+function requireNativeModule(p) {
+  return _require2(p);
+}
+function resolveNativeBindingCandidates(options) {
+  const {
+    envVarNames = ["TW_NATIVE_PATH", "TWS_NATIVE_PATH"],
+    includeDefaultCandidates = true,
+    enforceNodeExtensionForEnvPath = false
+  } = options;
+  const runtimeDir = options.runtimeDir || process.cwd();
+  const candidates = [];
+  for (const envVar of envVarNames) {
+    const envPath = process.env[envVar];
+    if (envPath) {
+      candidates.push(enforceNodeExtensionForEnvPath && !envPath.endsWith(".node") ? envPath + ".node" : envPath);
+    }
+  }
+  if (!includeDefaultCandidates) return candidates;
+  if (fs5__default.existsSync(runtimeDir)) {
+    try {
+      for (const entry of fs5__default.readdirSync(runtimeDir)) {
+        if (entry.endsWith(".node")) candidates.push(entry);
+      }
+    } catch {
+    }
+  }
+  const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
+  const napiPlatform = process.platform === "linux" && process.arch === "x64" ? "linux-x64-gnu" : process.platform === "linux" && process.arch === "arm64" ? "linux-arm64-gnu" : `${process.platform}-${process.arch}`;
+  for (const bin of BINARY_NAMES) {
+    candidates.push(path5__default.resolve(runtimeDir, `${bin}.node`));
+    candidates.push(path5__default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
+    candidates.push(path5__default.resolve(runtimeDir, "..", "native", `${bin}.node`));
+    candidates.push(path5__default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path5__default.resolve(process.cwd(), "native", `${bin}.node`));
+    candidates.push(path5__default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path5__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path5__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path5__default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
+  }
+  return Array.from(new Set(candidates));
+}
+function resolveRuntimeDir(dir, importMetaUrl) {
+  try {
+    return path5__default.dirname(fileURLToPath(importMetaUrl));
+  } catch {
+    return process.cwd();
+  }
+}
+var TwError, _require2;
+var init_src = __esm({
+  "packages/domain/shared/src/index.ts"() {
+    init_workerResolver();
+    init_native_resolution();
+    TwError = class _TwError extends Error {
+      /** @deprecated Gunakan source */
+      domain;
+      source;
+      code;
+      originalCause;
+      constructor(domainOrSource, code, message, cause) {
+        super(message);
+        this.name = "TwError";
+        this.domain = domainOrSource;
+        this.source = domainOrSource;
+        this.code = code;
+        this.originalCause = cause;
+        if (Error.captureStackTrace) Error.captureStackTrace(this, _TwError);
+      }
+      static fromIo(code, message) {
+        return new _TwError("io", code, message);
+      }
+      static fromCompile(code, message) {
+        return new _TwError("compile", code, message);
+      }
+      static fromRust(err) {
+        if (err instanceof _TwError) return err;
+        if (err instanceof Error) return new _TwError("rust", "RUST_ERROR", err.message, err);
+        if (err && typeof err === "object") {
+          const e = err;
+          return new _TwError("rust", e.code ?? "RUST_ERROR", e.message ?? String(err), err);
+        }
+        return new _TwError("rust", "RUST_ERROR", String(err), err);
+      }
+      /** Buat TwError dari ZodError — dukung shape Zod v3 (`errors`) dan v4 (`issues`). */
+      static fromZod(err) {
+        const first = err.issues?.[0] ?? err.errors?.[0];
+        const path7 = formatIssuePath(first?.path);
+        const message = first ? `${path7}: ${first.message}` : "Schema validation failed";
+        return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
+      }
+      static wrap(source, code, err) {
+        if (err instanceof _TwError) return err;
+        if (err instanceof Error) return new _TwError(source, code, err.message, err);
+        return new _TwError(source, code, String(err), err);
+      }
+      toString() {
+        return `TwError [${this.source}:${this.code}] ${this.message}`;
+      }
+      toJSON() {
+        return { name: this.name, source: this.source, code: this.code, message: this.message };
+      }
+      toCliMessage() {
+        return `[${this.source.toUpperCase()}:${this.code}] ${this.message}`;
+      }
+    };
+    _require2 = createRequire(import.meta.url);
+  }
+});
+
+// packages/domain/scanner/src/native-bridge.ts
+var native_bridge_exports = {};
+__export(native_bridge_exports, {
+  batchExtractClassesNative: () => batchExtractClassesNative,
+  cachePriorityNative: () => cachePriorityNative,
+  cacheReadNative: () => cacheReadNative,
+  cacheWriteNative: () => cacheWriteNative,
+  collectFilesNative: () => collectFilesNative,
+  computeCacheStatsNative: () => computeCacheStatsNative,
+  extractClassesNative: () => extractClassesNative,
+  generateSubComponentTypesNative: () => generateSubComponentTypesNative,
+  hasNativeScannerBinding: () => hasNativeScannerBinding,
+  hasNativeWatchBinding: () => hasNativeWatchBinding,
+  hashContentNative: () => hashContentNative,
+  isRustCacheAvailable: () => isRustCacheAvailable,
+  pollWatchEventsNative: () => pollWatchEventsNative,
+  pruneStaleEntriesNative: () => pruneStaleEntriesNative,
+  rebuildWorkspaceResultNative: () => rebuildWorkspaceResultNative,
+  resetScannerBridgeCache: () => resetScannerBridgeCache,
+  scanCacheGet: () => scanCacheGet,
+  scanCacheInvalidate: () => scanCacheInvalidate,
+  scanCachePut: () => scanCachePut,
+  scanCacheStats: () => scanCacheStats,
+  scanFileNative: () => scanFileNative,
+  scanFilesBatchNative: () => scanFilesBatchNative,
+  scanWorkspaceNative: () => scanWorkspaceNative,
+  startWatchNative: () => startWatchNative,
+  stopWatchNative: () => stopWatchNative
+});
+function getDirname() {
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  }
+  if (typeof import.meta !== "undefined" && import.meta.url) {
+    return path5__default.dirname(fileURLToPath(import.meta.url));
+  }
+  return process.cwd();
+}
+function scanWorkspaceNative(root, extensions) {
+  return scannerGetBinding().scanWorkspace(root, extensions ?? null);
+}
+function extractClassesNative(source) {
+  const result = scannerGetBinding().extractClassesFromSource?.(source);
+  if (result === null || result === void 0) {
+    throw new TwError(
+      "rust",
+      "SCANNER_EXTRACT_FAILED",
+      "Native extractClassesFromSource returned null/undefined"
+    );
+  }
+  return result;
+}
+function hashContentNative(content) {
+  const result = scannerGetBinding().hashFileContent?.(content);
+  if (result === null || result === void 0) {
+    throw new TwError(
+      "rust",
+      "SCANNER_HASH_FAILED",
+      "Native hashFileContent returned null/undefined"
+    );
+  }
+  return result;
+}
+function isRustCacheAvailable() {
+  return true;
+}
+function hasNativeScannerBinding() {
+  try {
+    scannerBridgeLoader.get();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cacheReadNative(cachePath) {
+  const result = scannerGetBinding().cacheRead?.(cachePath);
+  if (result === null || result === void 0) {
+    throw new TwError(
+      "rust",
+      "SCANNER_CACHE_READ_FAILED",
+      "Native cacheRead returned null/undefined"
+    );
+  }
+  return result;
+}
+function cacheWriteNative(cachePath, entries) {
+  const result = scannerGetBinding().cacheWrite?.(cachePath, entries);
+  if (result === null || result === void 0) {
+    throw new TwError(
+      "rust",
+      "SCANNER_CACHE_WRITE_FAILED",
+      "Native cacheWrite returned null/undefined"
+    );
+  }
+  return result;
+}
+function cachePriorityNative(mtimeMs, size, cachedMtimeMs, cachedSize, cachedHitCount, cachedLastSeenMs, nowMs = Date.now()) {
+  const result = scannerGetBinding().cachePriority?.(
+    mtimeMs,
+    size,
+    cachedMtimeMs,
+    cachedSize,
+    cachedHitCount,
+    cachedLastSeenMs,
+    nowMs
+  );
+  if (result === null || result === void 0) {
+    throw new TwError(
+      "rust",
+      "SCANNER_CACHE_PRIORITY_FAILED",
+      "Native cachePriority returned null/undefined"
+    );
+  }
+  return result;
+}
+function batchExtractClassesNative(filePaths) {
+  const binding = scannerGetBinding();
+  if (!binding.batchExtractClasses) {
+    throw new Error("FATAL: Native binding 'batchExtractClasses' is required but not available.");
+  }
+  return binding.batchExtractClasses(filePaths) ?? [];
+}
+function scanCacheGet(filePath, contentHash) {
+  const binding = scannerGetBinding();
+  if (!binding.scanCacheGet) {
+    throw new Error("FATAL: Native binding 'scanCacheGet' is required but not available.");
+  }
+  return binding.scanCacheGet(filePath, contentHash) ?? null;
+}
+function scanCachePut(filePath, contentHash, classes, mtimeMs, size) {
+  const binding = scannerGetBinding();
+  if (!binding.scanCachePut) {
+    throw new Error("FATAL: Native binding 'scanCachePut' is required but not available.");
+  }
+  binding.scanCachePut(filePath, contentHash, classes, mtimeMs, size);
+}
+function scanCacheInvalidate(filePath) {
+  const binding = scannerGetBinding();
+  if (!binding.scanCacheInvalidate) {
+    throw new Error("FATAL: Native binding 'scanCacheInvalidate' is required but not available.");
+  }
+  binding.scanCacheInvalidate(filePath);
+}
+function scanCacheStats() {
+  const binding = scannerGetBinding();
+  if (!binding.scanCacheStats) {
+    throw new Error("FATAL: Native binding 'scanCacheStats' is required but not available.");
+  }
+  return binding.scanCacheStats();
+}
+function scanFileNative(filePath) {
+  const binding = scannerGetBinding();
+  if (!binding.scanFile) {
+    throw new Error("FATAL: Native binding 'scanFile' is required but not available.");
+  }
+  return binding.scanFile(filePath);
+}
+function collectFilesNative(root, extensions, ignoreDirs) {
+  const binding = scannerGetBinding();
+  if (!binding.collectFiles) return null;
+  return binding.collectFiles(root, extensions, ignoreDirs);
+}
+function scanFilesBatchNative(filePaths) {
+  const binding = scannerGetBinding();
+  if (!binding.scanFilesBatch) {
+    return filePaths.map((fp) => {
+      try {
+        const r = binding.scanFile?.(fp);
+        return r ? { file: r.file, classes: r.classes, hash: r.hash ?? "" } : { file: fp, classes: [], hash: "" };
+      } catch {
+        return { file: fp, classes: [], hash: "" };
+      }
+    });
+  }
+  return binding.scanFilesBatch(filePaths);
+}
+function generateSubComponentTypesNative(root, outputPath) {
+  const binding = scannerGetBinding();
+  if (!binding.generateSubComponentTypes) return null;
+  return binding.generateSubComponentTypes(root, outputPath ?? null);
+}
+function pruneStaleEntriesNative(entries, maxAgeMs, checkExists) {
+  const binding = scannerGetBinding();
+  if (!binding.pruneStaleEntries) return null;
+  return binding.pruneStaleEntries(
+    entries.map((e) => ({ file: e.file, lastSeenMs: e.lastSeenMs ?? 0 })),
+    maxAgeMs ?? null,
+    checkExists ?? null
+  );
+}
+function rebuildWorkspaceResultNative(files) {
+  const binding = scannerBridgeLoader.get();
+  if (!binding?.rebuildWorkspaceResult) return null;
+  try {
+    return binding.rebuildWorkspaceResult(files);
+  } catch {
+    return null;
+  }
+}
+function computeCacheStatsNative(filesClasses, sizes, top) {
+  const binding = scannerGetBinding();
+  if (!binding.computeCacheStats) return null;
+  return binding.computeCacheStats(filesClasses, sizes, top ?? null);
+}
+function startWatchNative(rootDir) {
+  try {
+    const binding = scannerGetBinding();
+    if (!binding.startWatch) return null;
+    return binding.startWatch(rootDir);
+  } catch {
+    return null;
+  }
+}
+function pollWatchEventsNative(handleId) {
+  try {
+    const binding = scannerGetBinding();
+    if (!binding.pollWatchEvents) return [];
+    return binding.pollWatchEvents(handleId);
+  } catch {
+    return [];
+  }
+}
+function stopWatchNative(handleId) {
+  try {
+    const binding = scannerGetBinding();
+    if (!binding.stopWatch) return false;
+    return binding.stopWatch(handleId);
+  } catch {
+    return false;
+  }
+}
+function hasNativeWatchBinding() {
+  try {
+    const binding = scannerGetBinding();
+    return !!(binding.startWatch && binding.pollWatchEvents && binding.stopWatch);
+  } catch {
+    return false;
+  }
+}
+var log, isValidScannerBinding, createScannerBridgeLoader, scannerBridgeLoader, scannerGetBinding, resetScannerBridgeCache;
+var init_native_bridge = __esm({
+  "packages/domain/scanner/src/native-bridge.ts"() {
+    init_src();
+    log = createDebugLogger("scanner:native");
+    isValidScannerBinding = (module) => {
+      const candidate = module;
+      return !!(candidate && (candidate.scanWorkspace || candidate.extractClassesFromSource || candidate.hashFileContent || candidate.cacheRead || candidate.cacheWrite));
+    };
+    createScannerBridgeLoader = () => {
+      const _state = {
+        binding: void 0,
+        loadError: null,
+        candidatePaths: []
+      };
+      const 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:",
+          ..._state.candidatePaths.map((p) => `  - ${p}`),
+          ""
+        ];
+        if (_state.loadError) {
+          lines.push("Load error:", `  ${_state.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 TwError("rust", "SCANNER_NATIVE_BINDING_NOT_FOUND", lines.join("\n"));
+      };
+      const scannerGetBinding2 = () => {
+        const cachedBinding = _state.binding;
+        if (cachedBinding !== void 0) {
+          if (cachedBinding !== null) {
+            return cachedBinding;
+          }
+          return throwNativeBindingError();
+        }
+        const runtimeDir = getDirname();
+        const candidates = resolveNativeBindingCandidates({
+          runtimeDir,
+          includeDefaultCandidates: true
+        });
+        _state.candidatePaths = candidates;
+        const { binding, loadErrors } = loadNativeBinding({
+          runtimeDir,
+          candidates,
+          isValid: isValidScannerBinding,
+          invalidExportMessage: "Module loaded but missing expected scanner binding functions"
+        });
+        if (binding) {
+          log(`scanner native binding loaded successfully`);
+          _state.binding = binding;
+          return _state.binding;
+        }
+        if (loadErrors.length > 0) {
+          _state.loadError = loadErrors.map((e) => `${e.path}: ${e.message}`).join("; ");
+        }
+        _state.binding = null;
+        return throwNativeBindingError();
+      };
+      return {
+        get: scannerGetBinding2,
+        scannerGetBinding: scannerGetBinding2,
+        reset: () => {
+          _state.binding = void 0;
+          _state.loadError = null;
+          _state.candidatePaths = [];
+        }
+      };
+    };
+    scannerBridgeLoader = createScannerBridgeLoader();
+    scannerGetBinding = scannerBridgeLoader.get;
+    resetScannerBridgeCache = scannerBridgeLoader.reset;
+  }
+});
+
+// packages/domain/compiler/src/nativeBridge.ts
+var _loadNative, log3, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge, resetNativeBridgeCache, adaptNativeResult;
+var init_nativeBridge = __esm({
+  "packages/domain/compiler/src/nativeBridge.ts"() {
+    init_src();
+    _loadNative = (path7) => __require(path7);
+    log3 = (...args) => {
+      if (process.env.DEBUG?.includes("compiler:native")) {
+        console.log("[compiler:native]", ...args);
+      }
+    };
+    NATIVE_UNAVAILABLE_MESSAGE = "[tailwind-styled/compiler v5] Native binding is required but not available.\nThis package requires native Rust bindings. There is no JavaScript fallback.\nPlease ensure:\n  1. The native module is properly installed\n  2. You have run: npm run build:rust (or use prebuilt binary)\n\nFor help, see: https://tailwind-styled.dev/docs/install";
+    nativeBridge = null;
+    bridgeLoadAttempted = false;
+    bridgeLoadError = null;
+    isValidNativeBridge = (mod) => {
+      const m = mod;
+      return !!(typeof m.transformSource === "function" || typeof m.extractAllClasses === "function" || typeof m.hasTwUsage === "function");
+    };
+    getNativeBridge = () => {
+      if (nativeBridge) {
+        return nativeBridge;
+      }
+      if (bridgeLoadAttempted) {
+        if (bridgeLoadError) {
+          throw bridgeLoadError;
+        }
+        throw new Error(NATIVE_UNAVAILABLE_MESSAGE);
+      }
+      bridgeLoadAttempted = true;
+      try {
+        const runtimeDir = resolveRuntimeDir(void 0, import.meta.url);
+        const result = resolveNativeBinary(runtimeDir);
+        if (result.path && result.path.endsWith(".node")) {
+          try {
+            const binding = _loadNative(result.path);
+            if (isValidNativeBridge(binding)) {
+              nativeBridge = binding;
+              log3("Native bridge loaded successfully from:", result.path);
+              return nativeBridge;
+            }
+          } catch (e) {
+            log3("Failed to require native binding:", e);
+          }
+        }
+        throw new Error(`${NATIVE_UNAVAILABLE_MESSAGE}
+
+Tried paths: ${result.tried.join("\n")}`);
+      } catch (err) {
+        bridgeLoadError = err instanceof Error ? err : new Error(String(err));
+        log3("Failed to load native bridge:", bridgeLoadError.message);
+        throw bridgeLoadError;
+      }
+    };
+    resetNativeBridgeCache = () => {
+      nativeBridge = null;
+      bridgeLoadAttempted = false;
+      bridgeLoadError = null;
+      log3("Native bridge cache reset");
+    };
+    adaptNativeResult = (raw) => {
+      return {
+        code: raw.code ?? "",
+        classes: raw.classes ?? [],
+        changed: raw.changed ?? false,
+        rsc: raw.rscJson ? JSON.parse(raw.rscJson) : void 0,
+        metadata: raw.metadataJson ? JSON.parse(raw.metadataJson) : void 0
+      };
+    };
+    if (typeof process !== "undefined" && !bridgeLoadAttempted) {
+      try {
+        getNativeBridge();
+      } catch {
+      }
+    }
+  }
+});
+
+// packages/domain/compiler/src/tailwindEngine.ts
+var tailwindEngine_exports = {};
+__export(tailwindEngine_exports, {
+  generateRawCss: () => generateRawCss,
+  processTailwindCssWithTargets: () => processTailwindCssWithTargets,
+  runCssPipeline: () => runCssPipeline,
+  runCssPipelineSync: () => runCssPipelineSync
+});
+function loadTailwindEngine() {
+  if (_twEngine) return _twEngine;
+  if (_twEngineError) throw _twEngineError;
+  try {
+    const tw = require2("tailwindcss");
+    if (typeof tw.compile !== "function") {
+      throw new Error("tailwindcss v4 not found \u2014 compile() API missing. Check tailwindcss version >= 4.");
+    }
+    _twEngine = tw;
+    return _twEngine;
+  } catch (e) {
+    _twEngineError = e instanceof Error ? e : new Error(String(e));
+    throw _twEngineError;
+  }
+}
+async function generateRawCss(classes, cssEntryContent, root) {
+  if (classes.length === 0) return "";
+  const tw = loadTailwindEngine();
+  const input = cssEntryContent ?? "@import 'tailwindcss';";
+  const { readFileSync, existsSync: existsSync3 } = await import('fs');
+  const { dirname, resolve: resolve2 } = await import('path');
+  const projectRoot = root ?? process.cwd();
+  const req = createRequire(resolve2(projectRoot, "package.json"));
+  const loadStylesheet = async (id, base) => {
+    try {
+      const cssId = id === "tailwindcss" ? "tailwindcss/index.css" : id === "tailwindcss/preflight" ? "tailwindcss/preflight.css" : id === "tailwindcss/utilities" ? "tailwindcss/utilities.css" : id === "tailwindcss/theme" ? "tailwindcss/theme.css" : id;
+      const pkgPath = req.resolve(cssId);
+      return {
+        content: readFileSync(pkgPath, "utf-8"),
+        base: dirname(pkgPath)
+      };
+    } catch {
+      try {
+        const absPath = resolve2(base, id);
+        if (existsSync3(absPath)) {
+          return { content: readFileSync(absPath, "utf-8"), base: dirname(absPath) };
+        }
+      } catch {
+      }
+      return { content: "", base };
+    }
+  };
+  const compiler = await Promise.resolve(tw.compile(input, { loadStylesheet }));
+  return compiler.build(classes);
+}
+function postProcessWithLightning(rawCss) {
+  if (!rawCss) return "";
+  const native = getNativeBridge();
+  if (typeof native.processTailwindCssLightning !== "function") {
+    throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
+  }
+  const result = native.processTailwindCssLightning(rawCss);
+  return result?.css ?? rawCss;
+}
+async function runCssPipeline(classes, cssEntryContent, root, minify = true) {
+  const unique = [...new Set(classes.filter(Boolean))];
+  if (unique.length === 0) {
+    return { css: "", classes: [], sizeBytes: 0, optimized: false };
+  }
+  const rawCss = await generateRawCss(unique, cssEntryContent, root);
+  const native = getNativeBridge();
+  const hasLightning = minify && typeof native.processTailwindCssLightning === "function";
+  const finalCss = hasLightning ? postProcessWithLightning(rawCss) : rawCss;
+  return {
+    css: finalCss,
+    classes: unique,
+    sizeBytes: finalCss.length,
+    optimized: hasLightning
+  };
+}
+function runCssPipelineSync(_classes) {
+  return { css: "", classes: [], sizeBytes: 0, optimized: false };
+}
+function processTailwindCssWithTargets(css, targets) {
+  const native = getNativeBridge();
+  if (!native?.processTailwindCssWithTargets) {
+    throw new Error("FATAL: Native binding 'processTailwindCssWithTargets' is required but not available.");
+  }
+  const result = native.processTailwindCssWithTargets(css, targets ?? null);
+  return (result?.css ?? css).trim();
+}
+var require2, _twEngine, _twEngineError;
+var init_tailwindEngine = __esm({
+  "packages/domain/compiler/src/tailwindEngine.ts"() {
+    init_nativeBridge();
+    require2 = createRequire(import.meta.url);
+    _twEngine = null;
+    _twEngineError = null;
+  }
+});
+
+// packages/domain/compiler/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BucketEngine: () => BucketEngine,
+  IncrementalEngine: () => IncrementalEngine,
+  adaptNativeResult: () => adaptNativeResult,
+  analyzeClassUsage: () => analyzeClassUsage,
+  analyzeClasses: () => analyzeClasses,
+  analyzeFile: () => analyzeFile,
+  analyzeRsc: () => analyzeRsc,
+  analyzeVariantUsage: () => analyzeVariantUsage,
+  astExtractClasses: () => astExtractClasses,
+  batchExtractClasses: () => batchExtractClasses,
+  bucketSort: () => bucketSort,
+  buildStyleTag: () => buildStyleTag,
+  checkAgainstSafelist: () => checkAgainstSafelist,
+  classifyAndSortClasses: () => classifyAndSortClasses,
+  classifyNode: () => classifyNode,
+  compileCssFromClasses: () => compileCssFromClasses,
+  compileCssNative: () => compileCssNative,
+  compileVariantTable: () => compileVariantTable,
+  compileVariants: () => compileVariants,
+  detectConflicts: () => detectConflicts,
+  diffClassLists: () => diffClassLists,
+  eliminateDeadCss: () => eliminateDeadCss,
+  extractAllClasses: () => extractAllClasses,
+  extractClassesFromSource: () => extractClassesFromSource,
+  extractComponentUsage: () => extractComponentUsage,
+  fileToRoute: () => fileToRoute,
+  findDeadVariants: () => findDeadVariants,
+  generateCssForClasses: () => generateCssForClasses,
+  generateSafelist: () => generateSafelist,
+  getAllRoutes: () => getAllRoutes,
+  getBucketEngine: () => getBucketEngine,
+  getContentPaths: () => getContentPaths,
+  getIncrementalEngine: () => getIncrementalEngine,
+  getNativeBridge: () => getNativeBridge,
+  getRouteClasses: () => getRouteClasses,
+  hasTwUsage: () => hasTwUsage,
+  hoistComponents: () => hoistComponents,
+  injectClientDirective: () => injectClientDirective,
+  injectServerOnlyComment: () => injectServerOnlyComment,
+  isAlreadyTransformed: () => isAlreadyTransformed,
+  loadSafelist: () => loadSafelist,
+  loadTailwindConfig: () => loadTailwindConfig,
+  mergeClassesStatic: () => mergeClassesStatic,
+  mergeCssDeclarations: () => mergeCssDeclarations,
+  normalizeAndDedupClasses: () => normalizeAndDedupClasses,
+  normalizeClasses: () => normalizeClasses,
+  optimizeCss: () => optimizeCss,
+  parseClasses: () => parseClasses,
+  registerFileClasses: () => registerFileClasses,
+  registerGlobalClasses: () => registerGlobalClasses,
+  resetBucketEngine: () => resetBucketEngine,
+  resetIncrementalEngine: () => resetIncrementalEngine,
+  resetNativeBridgeCache: () => resetNativeBridgeCache,
+  runElimination: () => runElimination,
+  runLoaderTransform: () => runLoaderTransform,
+  scanProjectUsage: () => scanProjectUsage,
+  shouldProcess: () => shouldProcess,
+  shouldSkipFile: () => shouldSkipFile,
+  transformSource: () => transformSource
+});
+var transformSource, hasTwUsage, isAlreadyTransformed, shouldProcess, compileCssFromClasses, buildStyleTag, compileCssNative, generateCssForClasses, extractAllClasses, extractClassesFromSource, astExtractClasses, parseClasses, normalizeClasses, mergeClassesStatic, normalizeAndDedupClasses, eliminateDeadCss, findDeadVariants, runElimination, optimizeCss, scanProjectUsage, extractComponentUsage, diffClassLists, batchExtractClasses, checkAgainstSafelist, hoistComponents, compileVariantTable, compileVariants, classifyAndSortClasses, mergeCssDeclarations, analyzeClassUsage, analyzeRsc, analyzeFile, analyzeVariantUsage, injectClientDirective, injectServerOnlyComment, analyzeClasses, generateSafelist, loadSafelist, loadTailwindConfig, getContentPaths, runLoaderTransform, shouldSkipFile, fileToRoute, getAllRoutes, getRouteClasses, registerFileClasses, registerGlobalClasses, _incrementalEngineInstance, getIncrementalEngine, resetIncrementalEngine, IncrementalEngine, getBucketEngine, resetBucketEngine, BucketEngine, classifyNode, detectConflicts, bucketSort;
+var init_src2 = __esm({
+  "packages/domain/compiler/src/index.ts"() {
+    init_nativeBridge();
+    transformSource = (source, opts) => {
+      const native = getNativeBridge();
+      if (!native?.transformSource) {
+        throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
+      }
+      const result = native.transformSource(source, opts);
+      if (!result) {
+        throw new Error("FATAL: transformSource returned null");
+      }
+      return result;
+    };
+    hasTwUsage = (source) => {
+      const native = getNativeBridge();
+      if (!native?.hasTwUsage) {
+        throw new Error("FATAL: Native binding 'hasTwUsage' is required but not available.");
+      }
+      return native.hasTwUsage(source);
+    };
+    isAlreadyTransformed = (source) => {
+      const native = getNativeBridge();
+      if (!native?.isAlreadyTransformed) {
+        throw new Error("FATAL: Native binding 'isAlreadyTransformed' is required but not available.");
+      }
+      return native.isAlreadyTransformed(source);
+    };
+    shouldProcess = (source) => {
+      return hasTwUsage(source) && !isAlreadyTransformed(source);
+    };
+    compileCssFromClasses = (classes, prefix) => {
+      const native = getNativeBridge();
+      if (!native?.transformSource) {
+        throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
+      }
+      const result = native.transformSource(classes.join(" "), { prefix: prefix ?? "" });
+      if (!result) {
+        throw new Error("FATAL: transformSource returned null");
+      }
+      return result;
+    };
+    buildStyleTag = (classes) => {
+      const result = compileCssFromClasses(classes);
+      return result?.code ? `<style data-tailwind-styled>${result.code}</style>` : "";
+    };
+    compileCssNative = (classes, prefix = null) => {
+      return compileCssFromClasses(classes, prefix);
+    };
+    generateCssForClasses = async (classes, _tailwindConfig, root, cssEntryContent, minify = false) => {
+      const { runCssPipeline: runCssPipeline2 } = await Promise.resolve().then(() => (init_tailwindEngine(), tailwindEngine_exports));
+      const result = await runCssPipeline2(classes, cssEntryContent, root, minify);
+      return result.css;
+    };
+    extractAllClasses = (source) => {
+      const native = getNativeBridge();
+      if (!native?.extractAllClasses) {
+        throw new Error("FATAL: Native binding 'extractAllClasses' is required but not available.");
+      }
+      return native.extractAllClasses(source) || [];
+    };
+    extractClassesFromSource = (source) => {
+      const native = getNativeBridge();
+      if (!native?.extractClassesFromSource) {
+        throw new Error("FATAL: Native binding 'extractClassesFromSource' is required but not available.");
+      }
+      const result = native.extractClassesFromSource(source);
+      return Array.isArray(result) ? result.join(" ") : String(result || "");
+    };
+    astExtractClasses = (source, filename) => {
+      const native = getNativeBridge();
+      if (!native?.extractClassesFromSource) {
+        throw new Error("FATAL: Native binding 'extractClassesFromSource' is required but not available.");
+      }
+      return native.extractClassesFromSource(source) || [];
+    };
+    parseClasses = (raw) => {
+      const native = getNativeBridge();
+      if (!native?.parseClasses) {
+        throw new Error("FATAL: Native binding 'parseClasses' is required but not available.");
+      }
+      return native.parseClasses(raw) || [];
+    };
+    normalizeClasses = (raw) => {
+      const result = normalizeAndDedupClasses(raw);
+      return result?.normalized || "";
+    };
+    mergeClassesStatic = (classes) => {
+      const result = normalizeAndDedupClasses(classes);
+      return result?.normalized || "";
+    };
+    normalizeAndDedupClasses = (raw) => {
+      const native = getNativeBridge();
+      if (!native?.normalizeAndDedupClasses) {
+        throw new Error("FATAL: Native binding 'normalizeAndDedupClasses' is required but not available.");
+      }
+      const result = native.normalizeAndDedupClasses(raw);
+      return result || { normalized: "", duplicatesRemoved: 0, uniqueCount: 0 };
+    };
+    eliminateDeadCss = (css, deadClasses) => {
+      const native = getNativeBridge();
+      if (!native?.processTailwindCssLightning) {
+        throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
+      }
+      const deadSet = deadClasses;
+      const pruned = css.split(/(?<=\})\s*/).filter((rule) => {
+        const m = rule.match(/\.([a-zA-Z0-9_-]+)/);
+        return !m || !deadSet.has(m[1]);
+      }).join("\n");
+      const compiled = native.processTailwindCssLightning(pruned);
+      return (compiled?.css ?? pruned).trim();
+    };
+    findDeadVariants = (variantConfig, usage) => {
+      const unused = [];
+      const configs = Array.isArray(variantConfig) ? variantConfig : [{ name: "__root__", variants: variantConfig }];
+      for (const component of configs) {
+        const componentUsage = usage[component.name] ?? /* @__PURE__ */ new Set();
+        const variants = component.variants;
+        for (const [key, values] of Object.entries(variants)) {
+          for (const [value] of Object.entries(values)) {
+            if (!componentUsage.has(`${key}:${value}`)) {
+              unused.push(`${component.name !== "__root__" ? `${component.name}/` : ""}${key}:${value}`);
+            }
+          }
+        }
+      }
+      return {
+        unusedCount: unused.length,
+        unused
+      };
+    };
+    runElimination = (css, scanResult) => {
+      const native = getNativeBridge();
+      if (!native?.detectDeadCode) {
+        throw new Error("FATAL: Native binding 'detectDeadCode' is required but not available.");
+      }
+      const dead = native.detectDeadCode(
+        JSON.stringify(scanResult),
+        css
+      );
+      return eliminateDeadCss(css, new Set(dead.deadInCss ?? []));
+    };
+    optimizeCss = (css) => {
+      const native = getNativeBridge();
+      if (!native?.detectDeadCode) {
+        throw new Error("FATAL: Native binding 'detectDeadCode' is required but not available.");
+      }
+      const deadResult = native.detectDeadCode(
+        JSON.stringify({ uniqueClasses: [] }),
+        css
+      );
+      if (!native?.processTailwindCssLightning) {
+        throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
+      }
+      const deadSet = new Set(deadResult.deadInCss ?? []);
+      const pruned = css.split(/(?<=\})\s*/).filter((rule) => {
+        const selectorMatch = rule.match(/\.([a-zA-Z0-9_-]+)/);
+        if (!selectorMatch) return true;
+        return !deadSet.has(selectorMatch[1]);
+      }).join("\n");
+      const compiled = native.processTailwindCssLightning(pruned);
+      return (compiled?.css ?? pruned).trim();
+    };
+    scanProjectUsage = (dirs, cwd) => {
+      const path7 = __require("path");
+      const files = dirs.map((dir) => path7.resolve(cwd, dir));
+      const results = batchExtractClasses(files) || [];
+      const combined = {};
+      for (const result of results) {
+        if (result.ok && result.classes) {
+          for (const cls of result.classes) {
+            if (!combined[cls]) combined[cls] = {};
+            combined[cls][result.file] = /* @__PURE__ */ new Set([cls]);
+          }
+        }
+      }
+      return combined;
+    };
+    extractComponentUsage = (source) => {
+      const native = getNativeBridge();
+      if (!native?.extractComponentUsage) {
+        throw new Error("FATAL: Native binding 'extractComponentUsage' is required but not available.");
+      }
+      return native.extractComponentUsage(source) || [];
+    };
+    diffClassLists = (previous, current) => {
+      const native = getNativeBridge();
+      if (!native?.diffClassLists) {
+        throw new Error("FATAL: Native binding 'diffClassLists' is required but not available.");
+      }
+      return native.diffClassLists(previous, current) || { added: [], removed: [], unchanged: [], hasChanges: false };
+    };
+    batchExtractClasses = (filePaths) => {
+      const native = getNativeBridge();
+      if (!native?.batchExtractClasses) {
+        throw new Error("FATAL: Native binding 'batchExtractClasses' is required but not available.");
+      }
+      return native.batchExtractClasses(filePaths) || [];
+    };
+    checkAgainstSafelist = (classes, safelist) => {
+      const native = getNativeBridge();
+      if (!native?.checkAgainstSafelist) {
+        throw new Error("FATAL: Native binding 'checkAgainstSafelist' is required but not available.");
+      }
+      return native.checkAgainstSafelist(classes, safelist) || { matched: [], unmatched: [], safelistSize: 0 };
+    };
+    hoistComponents = (source) => {
+      const native = getNativeBridge();
+      if (!native?.hoistComponents) {
+        throw new Error("FATAL: Native binding 'hoistComponents' is required but not available.");
+      }
+      return native.hoistComponents(source) || { code: source, hoisted: [], warnings: [] };
+    };
+    compileVariantTable = (configJson) => {
+      const native = getNativeBridge();
+      if (!native?.compileVariantTable) {
+        throw new Error("FATAL: Native binding 'compileVariantTable' is required but not available.");
+      }
+      return native.compileVariantTable(configJson) || { id: "", tableJson: "{}", keys: [], defaultKey: "", combinations: 0 };
+    };
+    compileVariants = (componentId, config) => {
+      return compileVariantTable(JSON.stringify({ componentId, ...config }));
+    };
+    classifyAndSortClasses = (classes) => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return native.classifyAndSortClasses(classes) || [];
+    };
+    mergeCssDeclarations = (cssChunks) => {
+      const native = getNativeBridge();
+      if (!native?.mergeCssDeclarations) {
+        throw new Error("FATAL: Native binding 'mergeCssDeclarations' is required but not available.");
+      }
+      return native.mergeCssDeclarations(cssChunks) || { declarationsJson: "{}", declarationString: "", count: 0 };
+    };
+    analyzeClassUsage = (classes, scanResultJson, css) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClassUsage) {
+        throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
+      }
+      return native.analyzeClassUsage(classes, scanResultJson, css) || [];
+    };
+    analyzeRsc = (source, filename) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeRsc) {
+        throw new Error("FATAL: Native binding 'analyzeRsc' is required but not available.");
+      }
+      return native.analyzeRsc(source, filename) || { isServer: true, needsClientDirective: false, clientReasons: [] };
+    };
+    analyzeFile = (source, filename) => {
+      const rsc = analyzeRsc(source, filename);
+      return {
+        isServer: rsc?.isServer ?? true,
+        needsClientDirective: rsc?.needsClientDirective ?? false,
+        clientReasons: rsc?.clientReasons ?? [],
+        interactiveClasses: [],
+        canStaticResolveVariants: true
+      };
+    };
+    analyzeVariantUsage = (source, componentName, variantKeys) => {
+      analyzeRsc(source, componentName);
+      return {
+        resolved: {},
+        dynamic: []
+      };
+    };
+    injectClientDirective = (source) => {
+      if (!source.includes('"use client"') && !source.includes("'use client'")) {
+        return '"use client";\n' + source;
+      }
+      return source;
+    };
+    injectServerOnlyComment = (source) => {
+      return `/* @server-only */
+${source}`;
+    };
+    analyzeClasses = (filesJson, cwd, flags) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClasses) {
+        throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
+      }
+      return native.analyzeClasses(filesJson, cwd, flags);
+    };
+    generateSafelist = (scanDirs, outputPath, cwd) => {
+      const classes = scanProjectUsage(scanDirs, cwd || process.cwd());
+      const allClasses = Object.keys(classes).sort();
+      if (outputPath) {
+        const fs6 = __require("fs");
+        fs6.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
+      }
+      return allClasses;
+    };
+    loadSafelist = (safelistPath) => {
+      const fs6 = __require("fs");
+      try {
+        const content = fs6.readFileSync(safelistPath, "utf-8");
+        return JSON.parse(content);
+      } catch {
+        return [];
+      }
+    };
+    loadTailwindConfig = (cwd = process.cwd()) => {
+      const fs6 = __require("fs");
+      const path7 = __require("path");
+      const configFiles = [
+        "tailwind.config.ts",
+        "tailwind.config.js",
+        "tailwind.config.mjs",
+        "tailwind.config.cjs"
+      ];
+      for (const file of configFiles) {
+        const fullPath = path7.join(cwd, file);
+        if (fs6.existsSync(fullPath)) {
+          const mod = __require(fullPath);
+          return mod.default || mod;
+        }
+      }
+      return {};
+    };
+    getContentPaths = (cwd = process.cwd()) => {
+      const path7 = __require("path");
+      return {
+        content: [
+          path7.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
+          path7.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
+          path7.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
+        ]
+      };
+    };
+    runLoaderTransform = (ctx) => {
+      const { filepath, source, options } = ctx;
+      const result = transformSource(source, { filename: filepath, ...options });
+      return {
+        code: result?.code || "",
+        changed: result?.changed || false,
+        classes: result?.classes || []
+      };
+    };
+    shouldSkipFile = (filepath) => {
+      const SKIP_PATHS = ["node_modules", ".next", ".rspack-dist", ".turbo", "dist/", "out/"];
+      const skipExtensions = [".css", ".json", ".md", ".txt", ".yaml", ".yml"];
+      for (const p of SKIP_PATHS) {
+        if (filepath.includes(p)) return true;
+      }
+      for (const ext of skipExtensions) {
+        if (filepath.endsWith(ext)) return true;
+      }
+      return false;
+    };
+    fileToRoute = (filepath) => {
+      const normalized = filepath.replace(/\\/g, "/");
+      if (normalized.includes("/layout.") || normalized.includes("/loading.") || normalized.includes("/error.")) {
+        return "__global";
+      }
+      const pageMatch = normalized.match(/\/app\/(.+?)\/page\.[tj]sx?$/);
+      if (pageMatch) return `/${pageMatch[1]}`;
+      const rootPage = normalized.match(/\/app\/page\.[tj]sx?$/);
+      if (rootPage) return "/";
+      return null;
+    };
+    getAllRoutes = () => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClasses) {
+        throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
+      }
+      return ["/", "__global"];
+    };
+    getRouteClasses = (_route) => {
+      return /* @__PURE__ */ new Set();
+    };
+    registerFileClasses = (_filepath, _classes) => {
+    };
+    registerGlobalClasses = (_classes) => {
+    };
+    _incrementalEngineInstance = null;
+    getIncrementalEngine = () => {
+      if (!_incrementalEngineInstance) {
+        _incrementalEngineInstance = new IncrementalEngine();
+      }
+      return _incrementalEngineInstance;
+    };
+    resetIncrementalEngine = () => {
+      _incrementalEngineInstance = null;
+    };
+    IncrementalEngine = class {
+      compile(source) {
+        return transformSource(source);
+      }
+    };
+    getBucketEngine = () => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return {
+        add: (className) => className,
+        get: (_bucket) => []
+      };
+    };
+    resetBucketEngine = () => {
+    };
+    BucketEngine = class {
+      add(className) {
+        return className;
+      }
+    };
+    classifyNode = (_node) => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return "unknown";
+    };
+    detectConflicts = (classes) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClassUsage) {
+        throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
+      }
+      return [];
+    };
+    bucketSort = (classes) => {
+      return classifyAndSortClasses(classes).map((c) => c.raw ?? c);
+    };
+  }
+});
+var formatIssues = (error) => error.issues.map((issue) => {
+  const p = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+  return `${p}: ${issue.message}`;
+}).join("; ");
+var parseWithSchema = (schema, data, label) => {
+  const parsed = schema.safeParse(data);
+  if (parsed.success) return parsed.data;
+  throw new TypeError(`${label}: ${formatIssues(parsed.error)}`);
+};
+var NextAdapterOptionsSchema = z.object({
+  mode: z.literal("zero-runtime").optional(),
+  autoClientBoundary: z.boolean().optional(),
+  addDataAttr: z.boolean().optional(),
+  hoist: z.boolean().optional(),
+  routeCss: z.boolean().optional(),
+  incremental: z.boolean().optional(),
+  verbose: z.boolean().optional(),
+  include: z.instanceof(RegExp).optional(),
+  exclude: z.instanceof(RegExp).optional()
+});
+var parseNextAdapterOptions = (options) => parseWithSchema(NextAdapterOptionsSchema, options ?? {}, "next adapter options are invalid");
+
+// packages/presentation/next/src/withTailwindStyled.ts
+init_src();
+
+// packages/domain/scanner/src/index.ts
+init_src();
+
+// packages/domain/scanner/src/cache-native.ts
+init_native_bridge();
+function defaultCachePath(rootDir, cacheDir) {
+  const dir = cacheDir ? path5__default.resolve(rootDir, cacheDir) : path5__default.join(process.cwd(), ".cache", "tailwind-styled");
+  return path5__default.join(dir, "scanner-cache.json");
+}
+function readCache(rootDir, cacheDir) {
+  const cachePath = defaultCachePath(rootDir, cacheDir);
+  fs5__default.mkdirSync(path5__default.dirname(cachePath), { recursive: true });
+  const result = cacheReadNative(cachePath);
+  if (!result) return [];
+  return result.entries.map((e) => ({
+    file: e.file,
+    classes: e.classes,
+    hash: e.hash,
+    mtimeMs: e.mtimeMs,
+    size: e.size,
+    hitCount: e.hitCount,
+    lastSeenMs: e.lastSeenMs
+  }));
+}
+function writeCache(rootDir, entries, cacheDir) {
+  const cachePath = defaultCachePath(rootDir, cacheDir);
+  fs5__default.mkdirSync(path5__default.dirname(cachePath), { recursive: true });
+  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
+  );
+}
 
-// packages/domain/shared/src/index.ts
-createRequire(import.meta.url);
+// packages/domain/scanner/src/index.ts
+init_native_bridge();
+
+// packages/domain/scanner/src/schemas.ts
+init_src();
+var formatIssuePath2 = (path7) => path7.length > 0 ? path7.map(
+  (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
+).join(".") : "<root>";
+var formatIssues2 = (error) => error.issues.map((issue) => {
+  const path7 = formatIssuePath2(issue.path);
+  return `${path7}: ${issue.message}`;
+}).join("; ");
+var parseWithSchema2 = (schema, data, label) => {
+  const parsed = schema.safeParse(data);
+  if (parsed.success) return parsed.data;
+  const details = formatIssues2(parsed.error);
+  throw new TwError(
+    "validation",
+    "SCHEMA_VALIDATION_FAILED",
+    details ? `${label}: ${details}` : label,
+    parsed.error
+  );
+};
+var NonNegativeIntegerSchema = z.number().int().min(0);
+var ScanWorkspaceOptionsSchema = z.object({
+  includeExtensions: z.array(z.string()).optional(),
+  ignoreDirectories: z.array(z.string()).optional(),
+  useCache: z.boolean().optional(),
+  cacheDir: z.string().min(1).optional(),
+  smartInvalidation: z.boolean().optional()
+});
+var ScanFileResultSchema = z.object({
+  file: z.string(),
+  classes: z.array(z.string()),
+  hash: z.string().optional()
+});
+var ScanWorkspaceResultSchema = z.object({
+  files: z.array(ScanFileResultSchema),
+  totalFiles: NonNegativeIntegerSchema,
+  uniqueClasses: z.array(z.string())
+}).refine((value) => value.totalFiles === value.files.length, {
+  message: "scan result totalFiles must match files.length",
+  path: ["totalFiles"]
+});
+z.object({
+  rootDir: z.string().min(1),
+  options: ScanWorkspaceOptionsSchema.optional()
+});
+var ScannerWorkerSuccessMessageSchema = z.object({
+  ok: z.literal(true),
+  result: ScanWorkspaceResultSchema
+});
+var ScannerWorkerErrorMessageSchema = z.object({
+  ok: z.literal(false),
+  error: z.string().optional()
+});
+z.union([
+  ScannerWorkerSuccessMessageSchema,
+  ScannerWorkerErrorMessageSchema
+]);
+var parseScanWorkspaceOptions = (options) => parseWithSchema2(ScanWorkspaceOptionsSchema, options ?? {}, "scanner options are invalid");
+var parseScanWorkspaceResult = (result) => parseWithSchema2(ScanWorkspaceResultSchema, result, "scanner workspace result is invalid");
+
+// packages/domain/scanner/src/index.ts
+var log2 = createLogger("scanner");
+function getRuntimeDir() {
+  if (typeof __dirname !== "undefined" && __dirname.length > 0) {
+    return __dirname;
+  }
+  if (typeof import.meta !== "undefined" && import.meta.url) {
+    return path5__default.dirname(fileURLToPath(import.meta.url));
+  }
+  return process.cwd();
+}
+var createNativeParserLoader = () => {
+  const _state = {
+    binding: void 0,
+    initError: null
+  };
+  const debugNative = (message) => {
+    log2.debug(`[native] ${message}`);
+  };
+  const loadNativeParserBinding = () => {
+    if (_state.binding !== void 0) return _state.binding;
+    const runtimeDir = getRuntimeDir();
+    const req = createRequire(path5__default.join(runtimeDir, "noop.cjs"));
+    const _platform = process.platform;
+    const _arch = process.arch;
+    const _platformArch = `${_platform}-${_arch}`;
+    const _platformArchGnu = _platformArch === "linux-x64" ? "linux-x64-gnu" : _platformArch === "linux-arm64" ? "linux-arm64-gnu" : _platformArch;
+    const candidates = [
+      // ── binaryName baru: tailwind-styled-native (napi-rs naming) ──
+      // cwd = repo root saat run dari root, atau package dir saat workspaces
+      path5__default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
+      path5__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
+      path5__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      // runtimeDir = dist/ → naik 1 level ke package root (npm install case)
+      // e.g. node_modules/tailwind-styled-v4/dist/ → node_modules/tailwind-styled-v4/native/
+      path5__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
+      path5__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
+      path5__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      // runtimeDir = dist/ → naik 4 level ke repo root (monorepo dev case)
+      path5__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
+      path5__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      // 3 level fallback (jika package di-nest lebih dangkal)
+      path5__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
+      path5__default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      // ── binaryName lama: tailwind_styled_parser (backward compat) ──
+      path5__default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
+      path5__default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
+      path5__default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
+      path5__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
+      path5__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
+      path5__default.resolve(
+        runtimeDir,
+        "..",
+        "..",
+        "..",
+        "native",
+        "build",
+        "Release",
+        "tailwind_styled_parser.node"
+      )
+    ];
+    for (const fullPath of candidates) {
+      if (!fs5__default.existsSync(fullPath)) continue;
+      try {
+        const required = req(fullPath);
+        if (required && (typeof required.extractClassesFromSource === "function" || typeof required.parseClasses === "function" || typeof required.parse_classes === "function")) {
+          _state.binding = required;
+          debugNative(`using native parser from ${fullPath}`);
+          return _state.binding;
+        }
+      } catch (error) {
+        _state.initError = error instanceof Error ? error.message : String(error);
+      }
+    }
+    _state.binding = null;
+    if (!_state.initError) {
+      _state.initError = "native .node binding not found";
+    }
+    debugNative(`native binding not available: ${_state.initError}`);
+    return _state.binding;
+  };
+  return {
+    get: loadNativeParserBinding,
+    reset: () => {
+      _state.binding = void 0;
+      _state.initError = null;
+    }
+  };
+};
+var nativeParserLoader = createNativeParserLoader();
+var DEFAULT_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"];
+var DEFAULT_IGNORES = ["node_modules", ".git", ".next", "dist", "out", ".turbo", ".cache"];
+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;
+    const entries = (() => {
+      try {
+        return fs5__default.readdirSync(currentDir, { withFileTypes: true });
+      } catch {
+        return [];
+      }
+    })();
+    for (const entry of entries) {
+      const fullPath = path5__default.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!ignoreDirectories.has(entry.name)) directories.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!extensionSet.has(path5__default.extname(entry.name))) continue;
+      candidates.push(fullPath);
+    }
+  }
+  return candidates;
+}
+function toCacheSize(size) {
+  if (!Number.isFinite(size)) return 0;
+  const normalized = Math.max(0, Math.trunc(size));
+  return Math.min(normalized, 4294967295);
+}
+function scanSource(source) {
+  const nativeBinding = nativeParserLoader.get();
+  if (nativeBinding?.extractClassesFromSource) {
+    const result = nativeBinding.extractClassesFromSource(source);
+    if (Array.isArray(result)) {
+      return Array.from(new Set(result.filter(Boolean)));
+    }
+    if (result !== null && result !== void 0 && Array.isArray(result.classes)) {
+      return Array.from(new Set(result.classes.filter(Boolean)));
+    }
+  }
+  throw new Error(
+    "FATAL: Native parser binding is required but not available.\nThis package requires native Rust bindings.\n\nResolution steps:\n1. Build the native Rust module: npm run build:rust"
+  );
+}
+function scanFile(filePath) {
+  const { scanFileNative: scanFileNative2 } = (init_native_bridge(), __toCommonJS(native_bridge_exports));
+  const result = scanFileNative2(filePath);
+  if (!result.ok) {
+    throw new Error(`scanFile failed for ${filePath}: ${result.error ?? "unknown error"}`);
+  }
+  return {
+    file: result.file,
+    classes: result.classes,
+    ...result.hash ? { hash: result.hash } : {}
+  };
+}
+function scanWorkspace(rootDir, options = {}) {
+  const normalizedOptions = parseScanWorkspaceOptions(options);
+  const includeExtensions = normalizedOptions.includeExtensions ?? DEFAULT_EXTENSIONS;
+  const extensionSet = buildExtensionSet(includeExtensions);
+  const ignoreDirectories = new Set(normalizedOptions.ignoreDirectories ?? DEFAULT_IGNORES);
+  const useCache = normalizedOptions.useCache ?? true;
+  normalizedOptions.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 (!normalizedOptions.cacheDir && !useCache) {
+    const nativeResult = scanWorkspaceNative2(rootDir, includeExtensions);
+    if (nativeResult) {
+      return parseScanWorkspaceResult({
+        files: nativeResult.files.map((f) => ({
+          file: f.file,
+          classes: f.classes,
+          ...f.hash ? { hash: f.hash } : {}
+        })),
+        totalFiles: nativeResult.totalFiles,
+        uniqueClasses: nativeResult.uniqueClasses
+      });
+    }
+  }
+  if (useCache && isRustCacheAvailable()) {
+    const cacheEntries = (() => {
+      try {
+        return readCache(rootDir, normalizedOptions.cacheDir);
+      } catch (error) {
+        log2.debug(
+          `cache read failed, continuing without persisted cache: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return [];
+      }
+    })();
+    const cacheMap = new Map(cacheEntries.map((entry) => [entry.file, entry]));
+    const nowMs = Date.now();
+    const ranked = [];
+    for (const filePath of candidates) {
+      const stat = (() => {
+        try {
+          return fs5__default.statSync(filePath);
+        } catch {
+          return null;
+        }
+      })();
+      if (!stat) 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) {
+      const content = (() => {
+        try {
+          return fs5__default.readFileSync(filePath, "utf8");
+        } catch {
+          return null;
+        }
+      })();
+      if (!content) 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, normalizedOptions.cacheDir);
+    } catch (error) {
+      log2.debug(`cache write failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return parseScanWorkspaceResult({
+      files,
+      totalFiles: files.length,
+      uniqueClasses: Array.from(unique).sort()
+    });
+  }
+  const batchNative = nativeParserLoader.get()?.batchExtractClassesNative;
+  if (batchNative) {
+    const batchResults = batchNative(candidates);
+    for (const r of batchResults ?? []) {
+      if (r.ok) processResult({ file: r.file, classes: r.classes });
+    }
+  } else {
+    for (const filePath of candidates) {
+      processResult(scanFile(filePath));
+    }
+  }
+  return parseScanWorkspaceResult({
+    files,
+    totalFiles: files.length,
+    uniqueClasses: Array.from(unique).sort()
+  });
+}
 
 // packages/presentation/next/src/withTailwindStyled.ts
 function getDirnameFromUrl2(importMetaUrl) {
@@ -136,20 +1810,20 @@ function getDirnameFromUrl2(importMetaUrl) {
   const lastSlash = Math.max(importMetaUrl.lastIndexOf("/"), importMetaUrl.lastIndexOf("\\"));
   return lastSlash > 0 ? importMetaUrl.slice(0, lastSlash) : "";
 }
-var require2 = createRequire(import.meta.url);
-var resolveRuntimeDir = () => getDirnameFromUrl2(import.meta.url);
+var require3 = createRequire(import.meta.url);
+var resolveRuntimeDir2 = () => getDirnameFromUrl2(import.meta.url);
 var resolveLoaderPath2 = (basename) => {
   try {
     return resolveLoaderPath(basename, import.meta.url);
   } catch {
-    const runtimeDir = resolveRuntimeDir();
+    const runtimeDir = resolveRuntimeDir2();
     const candidates = [
-      path2.resolve(runtimeDir, `${basename}.mjs`),
-      path2.resolve(runtimeDir, `${basename}.js`),
-      path2.resolve(runtimeDir, `${basename}.cjs`)
+      path5__default.resolve(runtimeDir, `${basename}.mjs`),
+      path5__default.resolve(runtimeDir, `${basename}.js`),
+      path5__default.resolve(runtimeDir, `${basename}.cjs`)
     ];
     for (const candidate of candidates) {
-      if (fs2.existsSync(candidate)) {
+      if (fs5__default.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -160,8 +1834,8 @@ var resolveLoaderPath2 = (basename) => {
 };
 function checkNextVersion() {
   try {
-    const pkgPath = require2.resolve("next/package.json");
-    const { version } = require2(pkgPath);
+    const pkgPath = require3.resolve("next/package.json");
+    const { version } = require3(pkgPath);
     const major = Number.parseInt(version.split(".")[0], 10);
     if (major < 15) {
       console.warn(
@@ -187,19 +1861,20 @@ var createLoaderOptions = (options) => {
     preserveImports: true
   };
   if (options.verbose !== void 0) opts.verbose = options.verbose;
-  opts.safelistPath = options.safelistPath ?? path2.join(process.cwd(), "__tw_safelist.css");
+  opts.safelistPath = options.safelistPath ?? path5__default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
   return Object.freeze(opts);
 };
 var buildTurbopackRules = (loaderPath, loaderOptions) => {
   const extensions = ["js", "jsx", "ts", "tsx", "mjs", "cjs"];
   return Object.fromEntries(
     extensions.map((ext) => [
-      `*.${ext}`,
+      `**/*.${ext}`,
+      // ← recursive glob: match semua subdirectory, bukan hanya root
       { loaders: [{ loader: loaderPath, options: loaderOptions }] }
     ])
   );
 };
-var normalizeLoaderPath = (loaderPath) => path2.resolve(loaderPath);
+var normalizeLoaderPath = (loaderPath) => path5__default.resolve(loaderPath);
 var applyWebpackRule = (config, options, loaderPath) => {
   const loaderOptions = createLoaderOptions(options);
   const rules = config.module?.rules ?? [];
@@ -223,6 +1898,7 @@ var applyWebpackRule = (config, options, loaderPath) => {
     rules: [...rules, tailwindStyledRule]
   };
   const externalPackages = [
+    "tailwind-styled-v4",
     "@tailwind-styled/shared",
     "@tailwind-styled/compiler",
     "@tailwind-styled/engine",
@@ -288,9 +1964,204 @@ function withTailwindStyled(options = {}) {
   return function wrap(nextConfig = {}) {
     const previousWebpack = nextConfig.webpack;
     const loaderOptions = createLoaderOptions(normalizedOptions);
+    try {
+      const safelistPath = loaderOptions.safelistPath;
+      if (safelistPath) {
+        let extractUtilitiesLayer2 = function(fullCss) {
+          const minified = fullCss.indexOf("@layer utilities{");
+          const spaced = fullCss.indexOf("@layer utilities {");
+          const startIdx = minified !== -1 ? minified : spaced !== -1 ? spaced : -1;
+          if (startIdx === -1) return "";
+          let depth = 0;
+          let endIdx = startIdx;
+          for (let i = startIdx; i < fullCss.length; i++) {
+            if (fullCss[i] === "{") depth++;
+            else if (fullCss[i] === "}") {
+              depth--;
+              if (depth === 0) {
+                endIdx = i;
+                break;
+              }
+            }
+          }
+          return fullCss.slice(startIdx, endIdx + 1);
+        };
+        var extractUtilitiesLayer = extractUtilitiesLayer2;
+        const twClassesDir = path5__default.join(path5__default.dirname(safelistPath), "tw-classes");
+        fs5__default.mkdirSync(twClassesDir, { recursive: true });
+        fs5__default.writeFileSync(
+          path5__default.join(twClassesDir, "_start.txt"),
+          String(Date.now()),
+          "utf-8"
+        );
+        if (!process.env.TW_NATIVE_PATH) {
+          const runtimeDir = resolveRuntimeDir2();
+          const nativePath = path5__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node");
+          if (fs5__default.existsSync(nativePath)) {
+            process.env.TW_NATIVE_PATH = nativePath;
+          }
+        }
+        const srcDir = path5__default.join(process.cwd(), "src");
+        if (fs5__default.existsSync(srcDir)) {
+          try {
+            const result = scanWorkspace(srcDir);
+            if (result.uniqueClasses.length > 0) {
+              let atomicWriteFile2 = function(filePath, content) {
+                const tmpPath = `${filePath}.tmp`;
+                try {
+                  fs5__default.writeFileSync(tmpPath, content, "utf-8");
+                  fs5__default.renameSync(tmpPath, filePath);
+                } catch {
+                  try {
+                    fs5__default.unlinkSync(tmpPath);
+                  } catch {
+                  }
+                  fs5__default.writeFileSync(filePath, content, "utf-8");
+                }
+              };
+              var atomicWriteFile = atomicWriteFile2;
+              const VALID_VARIANT_PREFIXES = /* @__PURE__ */ new Set([
+                "hover",
+                "focus",
+                "active",
+                "disabled",
+                "visited",
+                "checked",
+                "first",
+                "last",
+                "odd",
+                "even",
+                "focus-within",
+                "focus-visible",
+                "placeholder",
+                "before",
+                "after",
+                "dark",
+                "sm",
+                "md",
+                "lg",
+                "xl",
+                "2xl",
+                "motion-reduce",
+                "motion-safe",
+                "group",
+                "peer",
+                "aria",
+                "data",
+                "supports",
+                "not",
+                "has",
+                "is",
+                "where",
+                "rtl",
+                "ltr",
+                "open",
+                "print",
+                "portrait",
+                "landscape"
+              ]);
+              const filteredClasses = result.uniqueClasses.filter((cls) => {
+                if (cls.includes(":")) {
+                  const prefix = cls.split(":")[0];
+                  if (!VALID_VARIANT_PREFIXES.has(prefix ?? "")) return false;
+                }
+                if (/\[[\d]+\.[\d]{2,}(?:px|rem|em|vh|vw|%)\]/.test(cls)) return false;
+                if (/\[[\d]{5,}(?:px|rem|em)?\]/.test(cls)) return false;
+                return true;
+              });
+              let cssEntryContent = null;
+              const CSS_CANDIDATES = [
+                "src/app/globals.css",
+                "src/globals.css",
+                "src/styles/globals.css",
+                "src/tailwind.css",
+                "src/index.css",
+                "styles/globals.css"
+              ];
+              try {
+                const twConfigPath = path5__default.join(process.cwd(), "tailwind-styled.config.json");
+                if (fs5__default.existsSync(twConfigPath)) {
+                  const twConfig = JSON.parse(fs5__default.readFileSync(twConfigPath, "utf-8"));
+                  const cssEntry = twConfig.css?.entry;
+                  if (cssEntry) {
+                    const cssEntryPath = path5__default.join(process.cwd(), cssEntry);
+                    if (fs5__default.existsSync(cssEntryPath)) {
+                      cssEntryContent = fs5__default.readFileSync(cssEntryPath, "utf-8");
+                    }
+                  }
+                }
+              } catch {
+              }
+              if (!cssEntryContent) {
+                for (const candidate of CSS_CANDIDATES) {
+                  const candidatePath = path5__default.join(process.cwd(), candidate);
+                  if (fs5__default.existsSync(candidatePath)) {
+                    cssEntryContent = fs5__default.readFileSync(candidatePath, "utf-8");
+                    break;
+                  }
+                }
+              }
+              if (cssEntryContent) {
+                cssEntryContent = cssEntryContent.replace(/@source\s+["'][^"']+["']\s*;?\s*/g, "").replace(/←[^\n]*/g, "").trim();
+              }
+              const initialScanPath = path5__default.join(twClassesDir, "_initial-scan.css");
+              if (!fs5__default.existsSync(initialScanPath)) {
+                atomicWriteFile2(
+                  initialScanPath,
+                  "/* tw-classes: initial scan \u2014 generating... */\n@layer utilities {}\n"
+                );
+              }
+              void (async () => {
+                try {
+                  const compiler = await Promise.resolve().then(() => (init_src2(), src_exports));
+                  const generateCssForClasses2 = compiler.generateCssForClasses;
+                  const css = await generateCssForClasses2(
+                    filteredClasses,
+                    {},
+                    process.cwd(),
+                    cssEntryContent ?? void 0,
+                    process.env.NODE_ENV === "production"
+                    // minify hanya di production
+                  );
+                  if (css) {
+                    const utilitiesOnly = extractUtilitiesLayer2(css);
+                    atomicWriteFile2(
+                      initialScanPath,
+                      `/* tw-classes: initial scan \u2014 auto-generated by withTailwindStyled */
+${utilitiesOnly}`
+                    );
+                  }
+                } catch (err) {
+                  console.warn("[tailwind-styled] generateCssForClasses gagal, fallback ke empty rules:", err.message?.split("\n")[0]);
+                  const css = [
+                    "/* tw-safelist: initial scan \u2014 auto-generated by withTailwindStyled (fallback) */",
+                    "@layer utilities {",
+                    filteredClasses.map((cls) => `.${cls.replace(/([^a-zA-Z0-9_-])/g, "\\$1")} {}`).join("\n"),
+                    "}"
+                  ].join("\n");
+                  atomicWriteFile2(initialScanPath, css);
+                }
+              })();
+            }
+          } catch (e) {
+            console.warn("[tailwind-styled] Initial scan skipped:", e.message?.split("\n")[0]);
+          }
+        }
+      }
+    } catch {
+    }
     return {
       ...nextConfig,
       webpack(config, webpackOptions) {
+        if (webpackOptions.dev) {
+          if (typeof previousWebpack !== "function") return config;
+          try {
+            const r = previousWebpack(config, webpackOptions);
+            return r instanceof Promise ? r : r;
+          } catch {
+            return config;
+          }
+        }
         const apply = (resolvedConfig) => {
           const finalConfig = applyWebpackRule(resolvedConfig, normalizedOptions, webpackLoaderPath);
           if (!finalConfig.externals) {
@@ -319,6 +2190,20 @@ function withTailwindStyled(options = {}) {
           });
         }
       },
+      serverExternalPackages: [
+        .../* @__PURE__ */ new Set([
+          ...nextConfig.serverExternalPackages ?? [],
+          "tailwind-styled-v4",
+          "@tailwind-styled/core",
+          "@tailwind-styled/shared",
+          "@tailwind-styled/compiler",
+          "@tailwind-styled/engine",
+          "@tailwind-styled/analyzer",
+          "@tailwind-styled/scanner",
+          "@tailwind-styled/plugin",
+          "@tailwind-styled/runtime-css"
+        ])
+      ],
       turbopack: {
         ...nextConfig.turbopack ?? {},
         rules: mergeTurbopackRules(