tailwind-styled-v4 5.0.35 → 5.0.37

package/dist/next.mjs

@@ -1,8 +1,8 @@
 import { createRequire } from 'module';
-import * as fs9 from 'fs';
-import fs9__default from 'fs';
-import * as path10 from 'path';
-import path10__default from 'path';
+import * as fs10 from 'fs';
+import fs10__default from 'fs';
+import * as path11 from 'path';
+import path11__default from 'path';
 import 'crypto';
 import { fileURLToPath } from 'url';
 import { z } from 'zod';
@@ -62,11 +62,11 @@ function resolvePath(...segments) {
     return segments.join("/").replace(/\/+/g, "/");
   }
 }
-function existsSync(path11) {
+function existsSync(path12) {
   if (isBrowser) return false;
   try {
     const nodeFs = __require(NODE_FS);
-    return nodeFs.existsSync(path11);
+    return nodeFs.existsSync(path12);
   } catch {
     return false;
   }
@@ -140,7 +140,7 @@ function resolveNativeBinary(runtimeDir) {
   }
   const envPath = process.env.TW_NATIVE_PATH?.trim();
   if (envPath) {
-    if (fs9.existsSync(envPath)) {
+    if (fs10.existsSync(envPath)) {
       return { path: envPath, source: "env", platform, tried };
     }
     tried.push(`env:${envPath} (not found)`);
@@ -149,7 +149,7 @@ function resolveNativeBinary(runtimeDir) {
   for (const pkg of prebuiltPkgs) {
     try {
       const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
-      if (fs9.existsSync(candidate)) {
+      if (fs10.existsSync(candidate)) {
         return { path: candidate, source: "prebuilt", platform, tried };
       }
       tried.push(`prebuilt:${pkg} (resolved but missing)`);
@@ -160,13 +160,13 @@ function resolveNativeBinary(runtimeDir) {
   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 ["..", path10.join("..", ".."), path10.join("..", "..", "..")]) {
-      const pkgRoot = path10.resolve(runtimeDir, depth);
+    for (const depth of ["..", path11.join("..", ".."), path11.join("..", "..", "..")]) {
+      const pkgRoot = path11.resolve(runtimeDir, depth);
       for (const bin of BINARY_NAMES_SELF) {
         for (const suffix of ["", `.${platform}`, `.${napiPlatform}`]) {
-          const candidate = path10.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
+          const candidate = path11.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
           tried.push(`self-bundled:${candidate}`);
-          if (fs9.existsSync(candidate)) {
+          if (fs10.existsSync(candidate)) {
             return { path: candidate, source: "prebuilt", platform, tried };
           }
         }
@@ -178,29 +178,29 @@ function resolveNativeBinary(runtimeDir) {
   const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
   const localCandidates = [];
   for (const bin of BINARY_NAMES) {
-    localCandidates.push(path10.resolve(base, `${bin}.node`));
-    localCandidates.push(path10.resolve(base, "..", `${bin}.node`));
-    localCandidates.push(path10.resolve(base, `${bin}.${platform}.node`));
-    localCandidates.push(path10.resolve(base, `${bin}.${napiPlatform}.node`));
+    localCandidates.push(path11.resolve(base, `${bin}.node`));
+    localCandidates.push(path11.resolve(base, "..", `${bin}.node`));
+    localCandidates.push(path11.resolve(base, `${bin}.${platform}.node`));
+    localCandidates.push(path11.resolve(base, `${bin}.${napiPlatform}.node`));
   }
   for (const startDir of [cwd, base]) {
     let dir = startDir;
     for (let i = 0; i < 6; i++) {
-      const nativeDir = path10.resolve(dir, "native");
+      const nativeDir = path11.resolve(dir, "native");
       for (const bin of BINARY_NAMES) {
-        localCandidates.push(path10.resolve(nativeDir, `${bin}.node`));
-        localCandidates.push(path10.resolve(nativeDir, `${bin}.${platform}.node`));
-        localCandidates.push(path10.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
-        localCandidates.push(path10.resolve(nativeDir, "target", "release", `${bin}.node`));
+        localCandidates.push(path11.resolve(nativeDir, `${bin}.node`));
+        localCandidates.push(path11.resolve(nativeDir, `${bin}.${platform}.node`));
+        localCandidates.push(path11.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
+        localCandidates.push(path11.resolve(nativeDir, "target", "release", `${bin}.node`));
       }
-      const parent = path10.resolve(dir, "..");
+      const parent = path11.resolve(dir, "..");
       if (parent === dir) break;
       dir = parent;
     }
   }
   for (const candidate of localCandidates) {
     tried.push(`local:${candidate}`);
-    if (fs9.existsSync(candidate)) {
+    if (fs10.existsSync(candidate)) {
       return { path: candidate, source: "local", platform, tried };
     }
   }
@@ -227,7 +227,7 @@ var _loadNative, log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttemp
 var init_nativeBridge = __esm({
   "packages/domain/compiler/src/nativeBridge.ts"() {
     init_src2();
-    _loadNative = (path11) => __require(path11);
+    _loadNative = (path12) => __require(path12);
     log = (...args) => {
       if (process.env.DEBUG?.includes("compiler:native")) {
         console.log("[compiler:native]", ...args);
@@ -2381,7 +2381,7 @@ var init_src = __esm({
     };
     scanProjectUsage = (dirs, cwd) => {
       const { batchExtractClasses: batchExtractClasses2 } = _require2("./parser");
-      const files = dirs.map((dir) => path10__default.resolve(cwd, dir));
+      const files = dirs.map((dir) => path11__default.resolve(cwd, dir));
       const results = batchExtractClasses2(files) || [];
       const combined = {};
       for (const result of results) {
@@ -2398,13 +2398,13 @@ var init_src = __esm({
       const classes = scanProjectUsage(scanDirs, cwd || process.cwd());
       const allClasses = Object.keys(classes).sort();
       if (outputPath) {
-        fs9__default.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
+        fs10__default.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
       }
       return allClasses;
     };
     loadSafelist = (safelistPath) => {
       try {
-        const content = fs9__default.readFileSync(safelistPath, "utf-8");
+        const content = fs10__default.readFileSync(safelistPath, "utf-8");
         return JSON.parse(content);
       } catch {
         return [];
@@ -2418,8 +2418,8 @@ var init_src = __esm({
         "tailwind.config.cjs"
       ];
       for (const file of configFiles) {
-        const fullPath = path10__default.join(cwd, file);
-        if (fs9__default.existsSync(fullPath)) {
+        const fullPath = path11__default.join(cwd, file);
+        if (fs10__default.existsSync(fullPath)) {
           const mod = __require(fullPath);
           return mod.default || mod;
         }
@@ -2429,9 +2429,9 @@ var init_src = __esm({
     getContentPaths = (cwd = process.cwd()) => {
       return {
         content: [
-          path10__default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
-          path10__default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
-          path10__default.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
+          path11__default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
+          path11__default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
+          path11__default.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
         ]
       };
     };
@@ -2889,17 +2889,17 @@ function getNative() {
 function* walkSourceFiles(dir) {
   let entries;
   try {
-    entries = fs9__default.readdirSync(dir, { withFileTypes: true });
+    entries = fs10__default.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path10__default.join(dir, entry.name);
+    const fullPath = path11__default.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (IGNORE_PATTERNS.some((p) => entry.name === p || entry.name.startsWith(p))) continue;
       yield* walkSourceFiles(fullPath);
     } else if (entry.isFile()) {
-      const ext = path10__default.extname(entry.name);
+      const ext = path11__default.extname(entry.name);
       if (SOURCE_EXTENSIONS.has(ext)) yield fullPath;
     }
   }
@@ -2963,7 +2963,7 @@ function extractStaticStateCss(srcDir, options = {}) {
         allConfigs.push(...configs);
         if (verbose) {
           process.stderr.write(
-            `[tw:static-state] ${path10__default.relative(srcDir, filePath)}: ${configs.length} komponen
+            `[tw:static-state] ${path11__default.relative(srcDir, filePath)}: ${configs.length} komponen
 `
           );
         }
@@ -2974,7 +2974,7 @@ function extractStaticStateCss(srcDir, options = {}) {
       if (filesScanned >= maxFiles) break;
       let source;
       try {
-        source = fs9__default.readFileSync(filePath, "utf-8");
+        source = fs10__default.readFileSync(filePath, "utf-8");
       } catch {
         continue;
       }
@@ -2987,7 +2987,7 @@ function extractStaticStateCss(srcDir, options = {}) {
         allConfigs.push(...configs);
         if (verbose) {
           process.stderr.write(
-            `[tw:static-state] ${path10__default.relative(srcDir, filePath)}: ${configs.length} komponen
+            `[tw:static-state] ${path11__default.relative(srcDir, filePath)}: ${configs.length} komponen
 `
           );
         }
@@ -3081,12 +3081,12 @@ function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
     resolvedCss: options.resolvedCss || ""
     // ← ensure always passed
   });
-  const twClassesDir = path10__default.join(path10__default.dirname(safelistPath), "tw-classes");
-  fs9__default.mkdirSync(twClassesDir, { recursive: true });
-  const stateFilePath = path10__default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+  const twClassesDir = path11__default.join(path11__default.dirname(safelistPath), "tw-classes");
+  fs10__default.mkdirSync(twClassesDir, { recursive: true });
+  const stateFilePath = path11__default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
   if (result.rulesGenerated === 0) {
     try {
-      fs9__default.writeFileSync(
+      fs10__default.writeFileSync(
         stateFilePath,
         "/* tw-state-static.css \u2014 tidak ada state rules yang di-generate */\n",
         "utf-8"
@@ -3096,7 +3096,7 @@ function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
     return `[tw:static-state] tidak ada state rules yang di-generate (${result.filesScanned} files di-scan)`;
   }
   try {
-    fs9__default.writeFileSync(stateFilePath, result.generatedCss, "utf-8");
+    fs10__default.writeFileSync(stateFilePath, result.generatedCss, "utf-8");
     return [
       `[tw:static-state] ${result.rulesGenerated} static state rules di-generate`,
       `  \u2192 ${result.filesScanned} files scanned, ${result.filesWithStates} dengan states`,
@@ -3126,8 +3126,8 @@ function setGlobalLogFile(filePath) {
   _globalLogFile = filePath;
   _logFileInitialized = false;
   try {
-    fs9__default.mkdirSync(path10__default.dirname(filePath), { recursive: true });
-    fs9__default.writeFileSync(
+    fs10__default.mkdirSync(path11__default.dirname(filePath), { recursive: true });
+    fs10__default.writeFileSync(
       filePath,
       `# tailwind-styled build log \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}
 `,
@@ -3140,7 +3140,7 @@ function setGlobalLogFile(filePath) {
 function writeToFile(line) {
   if (!_globalLogFile || !_logFileInitialized) return;
   try {
-    fs9__default.appendFileSync(_globalLogFile, line);
+    fs10__default.appendFileSync(_globalLogFile, line);
   } catch {
   }
 }
@@ -3205,9 +3205,9 @@ function createDebugLogger(namespace, label) {
     }
   };
 }
-function formatIssuePath(path11) {
-  if (!path11 || path11.length === 0) return "(root)";
-  return path11.map(
+function formatIssuePath(path12) {
+  if (!path12 || path12.length === 0) return "(root)";
+  return path12.map(
     (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
   ).join(".");
 }
@@ -3215,9 +3215,9 @@ function loadNativeBinding(options) {
   const { runtimeDir, candidates, isValid } = options;
   const loadErrors = [];
   for (const candidate of candidates) {
-    const candidatePath = path10__default.resolve(runtimeDir, candidate);
+    const candidatePath = path11__default.resolve(runtimeDir, candidate);
     try {
-      if (!fs9__default.existsSync(candidatePath) && !fs9__default.existsSync(candidatePath + ".node")) {
+      if (!fs10__default.existsSync(candidatePath) && !fs10__default.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -3249,9 +3249,9 @@ function resolveNativeBindingCandidates(options) {
     }
   }
   if (!includeDefaultCandidates) return candidates;
-  if (fs9__default.existsSync(runtimeDir)) {
+  if (fs10__default.existsSync(runtimeDir)) {
     try {
-      for (const entry of fs9__default.readdirSync(runtimeDir)) {
+      for (const entry of fs10__default.readdirSync(runtimeDir)) {
         if (entry.endsWith(".node")) candidates.push(entry);
       }
     } catch {
@@ -3260,21 +3260,21 @@ function resolveNativeBindingCandidates(options) {
   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(path10__default.resolve(runtimeDir, `${bin}.node`));
-    candidates.push(path10__default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
-    candidates.push(path10__default.resolve(runtimeDir, "..", "native", `${bin}.node`));
-    candidates.push(path10__default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path10__default.resolve(process.cwd(), "native", `${bin}.node`));
-    candidates.push(path10__default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path10__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
-    candidates.push(path10__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path10__default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path11__default.resolve(runtimeDir, `${bin}.node`));
+    candidates.push(path11__default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
+    candidates.push(path11__default.resolve(runtimeDir, "..", "native", `${bin}.node`));
+    candidates.push(path11__default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path11__default.resolve(process.cwd(), "native", `${bin}.node`));
+    candidates.push(path11__default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path11__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path11__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path11__default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
   }
   return Array.from(new Set(candidates));
 }
 function resolveRuntimeDir(dir, importMetaUrl) {
   try {
-    return path10__default.dirname(fileURLToPath(importMetaUrl));
+    return path11__default.dirname(fileURLToPath(importMetaUrl));
   } catch {
     return process.cwd();
   }
@@ -3319,8 +3319,8 @@ var init_src2 = __esm({
       /** Buat TwError dari ZodError — dukung shape Zod v3 (`errors`) dan v4 (`issues`). */
       static fromZod(err) {
         const first = err.issues?.[0] ?? err.errors?.[0];
-        const path11 = formatIssuePath(first?.path);
-        const message = first ? `${path11}: ${first.message}` : "Schema validation failed";
+        const path12 = formatIssuePath(first?.path);
+        const message = first ? `${path12}: ${first.message}` : "Schema validation failed";
         return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
       }
       static wrap(source, code, err) {
@@ -3376,7 +3376,7 @@ function getDirname() {
     return __dirname;
   }
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    return path10__default.dirname(fileURLToPath(import.meta.url));
+    return path11__default.dirname(fileURLToPath(import.meta.url));
   }
   return process.cwd();
 }
@@ -3695,12 +3695,12 @@ init_src2();
 // packages/domain/scanner/src/cache-native.ts
 init_native_bridge();
 function defaultCachePath(rootDir, cacheDir) {
-  const dir = cacheDir ? path10__default.resolve(rootDir, cacheDir) : path10__default.join(process.cwd(), ".cache", "tailwind-styled");
-  return path10__default.join(dir, "scanner-cache.json");
+  const dir = cacheDir ? path11__default.resolve(rootDir, cacheDir) : path11__default.join(process.cwd(), ".cache", "tailwind-styled");
+  return path11__default.join(dir, "scanner-cache.json");
 }
 function readCache(rootDir, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs9__default.mkdirSync(path10__default.dirname(cachePath), { recursive: true });
+  fs10__default.mkdirSync(path11__default.dirname(cachePath), { recursive: true });
   const result = cacheReadNative(cachePath);
   if (!result) return [];
   return result.entries.map((e) => ({
@@ -3715,7 +3715,7 @@ function readCache(rootDir, cacheDir) {
 }
 function writeCache(rootDir, entries, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs9__default.mkdirSync(path10__default.dirname(cachePath), { recursive: true });
+  fs10__default.mkdirSync(path11__default.dirname(cachePath), { recursive: true });
   const success = cacheWriteNative(cachePath, entries);
   if (!success) {
     throw new Error(
@@ -3740,12 +3740,12 @@ init_native_bridge();
 
 // packages/domain/scanner/src/schemas.ts
 init_src2();
-var formatIssuePath2 = (path11) => path11.length > 0 ? path11.map(
+var formatIssuePath2 = (path12) => path12.length > 0 ? path12.map(
   (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
 ).join(".") : "<root>";
 var formatIssues2 = (error) => error.issues.map((issue) => {
-  const path11 = formatIssuePath2(issue.path);
-  return `${path11}: ${issue.message}`;
+  const path12 = formatIssuePath2(issue.path);
+  return `${path12}: ${issue.message}`;
 }).join("; ");
 var parseWithSchema2 = (schema, data, label) => {
   const parsed = schema.safeParse(data);
@@ -3805,7 +3805,7 @@ function getRuntimeDir() {
     return __dirname;
   }
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    return path10__default.dirname(fileURLToPath(import.meta.url));
+    return path11__default.dirname(fileURLToPath(import.meta.url));
   }
   return process.cwd();
 }
@@ -3820,7 +3820,7 @@ var createNativeParserLoader = () => {
   const loadNativeParserBinding = () => {
     if (_state.binding !== void 0) return _state.binding;
     const runtimeDir = getRuntimeDir();
-    const req = createRequire(path10__default.join(runtimeDir, "noop.cjs"));
+    const req = createRequire(path11__default.join(runtimeDir, "noop.cjs"));
     const _platform = process.platform;
     const _arch = process.arch;
     const _platformArch = `${_platform}-${_arch}`;
@@ -3828,27 +3828,27 @@ var createNativeParserLoader = () => {
     const candidates = [
       // ── binaryName baru: tailwind-styled-native (napi-rs naming) ──
       // cwd = repo root saat run dari root, atau package dir saat workspaces
-      path10__default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
-      path10__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
-      path10__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path11__default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
+      path11__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
+      path11__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/
-      path10__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
-      path10__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
-      path10__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path11__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
+      path11__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
+      path11__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // runtimeDir = dist/ → naik 4 level ke repo root (monorepo dev case)
-      path10__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
-      path10__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path11__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
+      path11__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // 3 level fallback (jika package di-nest lebih dangkal)
-      path10__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
-      path10__default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path11__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
+      path11__default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // ── binaryName lama: tailwind_styled_parser (backward compat) ──
-      path10__default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
-      path10__default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
-      path10__default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
-      path10__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
-      path10__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
-      path10__default.resolve(
+      path11__default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
+      path11__default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
+      path11__default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
+      path11__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
+      path11__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
+      path11__default.resolve(
         runtimeDir,
         "..",
         "..",
@@ -3860,7 +3860,7 @@ var createNativeParserLoader = () => {
       )
     ];
     for (const fullPath of candidates) {
-      if (!fs9__default.existsSync(fullPath)) continue;
+      if (!fs10__default.existsSync(fullPath)) continue;
       try {
         const required = req(fullPath);
         if (required && (typeof required.extractClassesFromSource === "function" || typeof required.parseClasses === "function" || typeof required.parse_classes === "function")) {
@@ -3901,19 +3901,19 @@ function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
     if (!currentDir) continue;
     const entries = (() => {
       try {
-        return fs9__default.readdirSync(currentDir, { withFileTypes: true });
+        return fs10__default.readdirSync(currentDir, { withFileTypes: true });
       } catch {
         return [];
       }
     })();
     for (const entry of entries) {
-      const fullPath = path10__default.join(currentDir, entry.name);
+      const fullPath = path11__default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (!ignoreDirectories.has(entry.name)) directories.push(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      if (!extensionSet.has(path10__default.extname(entry.name))) continue;
+      if (!extensionSet.has(path11__default.extname(entry.name))) continue;
       candidates.push(fullPath);
     }
   }
@@ -3997,7 +3997,7 @@ function scanWorkspace2(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return fs9__default.statSync(filePath);
+          return fs10__default.statSync(filePath);
         } catch {
           return null;
         }
@@ -4023,7 +4023,7 @@ function scanWorkspace2(rootDir, options = {}) {
     for (const { filePath, stat, size, cached } of ranked) {
       const content = (() => {
         try {
-          return fs9__default.readFileSync(filePath, "utf8");
+          return fs10__default.readFileSync(filePath, "utf8");
         } catch {
           return null;
         }
@@ -4086,6 +4086,70 @@ function scanWorkspace2(rootDir, options = {}) {
 
 // packages/presentation/next/src/withTailwindStyled.ts
 init_src2();
+
+// packages/presentation/next/src/incrementalOrchestrator.ts
+init_src();
+var _fingerprintCache = /* @__PURE__ */ new Map();
+function getNative2() {
+  try {
+    return getNativeBridge();
+  } catch {
+    return null;
+  }
+}
+function fingerprintFile(filePath) {
+  try {
+    const stat = fs10__default.statSync(filePath);
+    const native = getNative2();
+    if (native?.create_fingerprint) {
+      const content = fs10__default.readFileSync(filePath, "utf-8");
+      const hash = native.create_fingerprint(filePath, content);
+      return { hash, mtime: stat.mtimeMs };
+    }
+    return { hash: `${stat.mtimeMs}-${stat.size}`, mtime: stat.mtimeMs };
+  } catch {
+    return null;
+  }
+}
+function hasSourceChanged(sourceFiles) {
+  if (_fingerprintCache.size === 0) {
+    for (const f of sourceFiles) {
+      const fp = fingerprintFile(f);
+      if (fp) _fingerprintCache.set(f, fp);
+    }
+    return true;
+  }
+  let changed = false;
+  for (const f of sourceFiles) {
+    const prev = _fingerprintCache.get(f);
+    const curr = fingerprintFile(f);
+    if (!curr) continue;
+    if (!prev || prev.hash !== curr.hash) {
+      changed = true;
+      _fingerprintCache.set(f, curr);
+    }
+  }
+  for (const f of sourceFiles) {
+    if (!_fingerprintCache.has(f)) {
+      const fp = fingerprintFile(f);
+      if (fp) {
+        _fingerprintCache.set(f, fp);
+        changed = true;
+      }
+    }
+  }
+  return changed;
+}
+function isIncrementalEnabled(cwd) {
+  try {
+    const configPath = path11__default.join(cwd, "tailwind-styled.config.json");
+    if (!fs10__default.existsSync(configPath)) return false;
+    const config = JSON.parse(fs10__default.readFileSync(configPath, "utf-8"));
+    return config.compiler?.incremental === true;
+  } catch {
+    return false;
+  }
+}
 var _fileStaticCssMap = /* @__PURE__ */ new Map();
 function setFileStaticCss(filepath, css) {
   if (css && css.trim()) {
@@ -4119,14 +4183,14 @@ var StaticCssWebpackPlugin = class _StaticCssWebpackPlugin {
   static PLUGIN_NAME = "TailwindStyledStaticCss";
   outPath;
   constructor(safelistPath) {
-    this.outPath = path10__default.join(path10__default.dirname(safelistPath), "_tw-state-static.css");
+    this.outPath = path11__default.join(path11__default.dirname(safelistPath), "_tw-state-static.css");
   }
   apply(compiler) {
     compiler.hooks.done.tap(_StaticCssWebpackPlugin.PLUGIN_NAME, () => {
       try {
         const content = buildContent(_fileStaticCssMap);
-        fs9__default.mkdirSync(path10__default.dirname(this.outPath), { recursive: true });
-        fs9__default.writeFileSync(
+        fs10__default.mkdirSync(path11__default.dirname(this.outPath), { recursive: true });
+        fs10__default.writeFileSync(
           this.outPath,
           HEADER + (content || "/* no static rules yet */") + "\n",
           "utf-8"
@@ -4160,12 +4224,12 @@ var resolveLoaderPath2 = (basename) => {
   } catch {
     const runtimeDir = resolveRuntimeDir2();
     const candidates = [
-      path10__default.resolve(runtimeDir, `${basename}.mjs`),
-      path10__default.resolve(runtimeDir, `${basename}.js`),
-      path10__default.resolve(runtimeDir, `${basename}.cjs`)
+      path11__default.resolve(runtimeDir, `${basename}.mjs`),
+      path11__default.resolve(runtimeDir, `${basename}.js`),
+      path11__default.resolve(runtimeDir, `${basename}.cjs`)
     ];
     for (const candidate of candidates) {
-      if (fs9__default.existsSync(candidate)) {
+      if (fs10__default.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -4203,7 +4267,7 @@ var createLoaderOptions = (options) => {
     preserveImports: true
   };
   if (options.verbose !== void 0) opts.verbose = options.verbose;
-  opts.safelistPath = options.safelistPath ?? path10__default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
+  opts.safelistPath = options.safelistPath ?? path11__default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
   return Object.freeze(opts);
 };
 var buildTurbopackRules = (loaderPath, loaderOptions) => {
@@ -4216,7 +4280,7 @@ var buildTurbopackRules = (loaderPath, loaderOptions) => {
     ])
   );
 };
-var normalizeLoaderPath = (loaderPath) => path10__default.resolve(loaderPath);
+var normalizeLoaderPath = (loaderPath) => path11__default.resolve(loaderPath);
 var applyWebpackRule = (config, options, loaderPath) => {
   const loaderOptions = createLoaderOptions(options);
   const rules = config.module?.rules ?? [];
@@ -4233,7 +4297,7 @@ var applyWebpackRule = (config, options, loaderPath) => {
     enforce: "pre",
     use: [{ loader: loaderPath, options: loaderOptions }]
   };
-  const safelistPath = loaderOptions.safelistPath ?? path10__default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
+  const safelistPath = loaderOptions.safelistPath ?? path11__default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
   const pluginAlreadyRegistered = (config.plugins ?? []).some(
     (p) => p?.constructor?.name === StaticCssWebpackPlugin.PLUGIN_NAME
   );
@@ -4333,17 +4397,17 @@ function withTailwindStyled(options = {}) {
           return fullCss.slice(startIdx, endIdx + 1);
         };
         var extractUtilitiesLayer = extractUtilitiesLayer2;
-        const twClassesDir = path10__default.join(path10__default.dirname(safelistPath), "tw-classes");
-        fs9__default.mkdirSync(twClassesDir, { recursive: true });
-        setGlobalLogFile(path10__default.join(twClassesDir, "_tw-build.log"));
-        fs9__default.writeFileSync(
-          path10__default.join(twClassesDir, "_start.txt"),
+        const twClassesDir = path11__default.join(path11__default.dirname(safelistPath), "tw-classes");
+        fs10__default.mkdirSync(twClassesDir, { recursive: true });
+        setGlobalLogFile(path11__default.join(twClassesDir, "_tw-build.log"));
+        fs10__default.writeFileSync(
+          path11__default.join(twClassesDir, "_start.txt"),
           String(Date.now()),
           "utf-8"
         );
-        const stateStaticPath = path10__default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+        const stateStaticPath = path11__default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
         try {
-          fs9__default.writeFileSync(
+          fs10__default.writeFileSync(
             stateStaticPath,
             "/* tw-state-static.css \u2014 placeholder, akan di-generate setelah scan */\n",
             "utf-8"
@@ -4359,14 +4423,14 @@ function withTailwindStyled(options = {}) {
             "src/index.css",
             "styles/globals.css"
           ];
-          const safelistDir = path10__default.dirname(safelistPath);
+          const safelistDir = path11__default.dirname(safelistPath);
           for (const candidate of CSS_CANDIDATES) {
-            const candidatePath = path10__default.join(process.cwd(), candidate);
-            if (!fs9__default.existsSync(candidatePath)) continue;
-            const content = fs9__default.readFileSync(candidatePath, "utf-8");
+            const candidatePath = path11__default.join(process.cwd(), candidate);
+            if (!fs10__default.existsSync(candidatePath)) continue;
+            const content = fs10__default.readFileSync(candidatePath, "utf-8");
             if (content.includes("_tw-state-static.css")) break;
-            const globalsDir = path10__default.dirname(candidatePath);
-            const rel = path10__default.relative(globalsDir, stateStaticPath).replace(/\\/g, "/");
+            const globalsDir = path11__default.dirname(candidatePath);
+            const rel = path11__default.relative(globalsDir, stateStaticPath).replace(/\\/g, "/");
             const importLine = `@import "./${rel}";`;
             const tailwindImportRe = /(@import\s+["']tailwindcss["']\s*;[^\n]*\n?)/;
             let updated;
@@ -4380,7 +4444,7 @@ function withTailwindStyled(options = {}) {
               updated = `${importLine}
 ${content}`;
             }
-            fs9__default.writeFileSync(candidatePath, updated, "utf-8");
+            fs10__default.writeFileSync(candidatePath, updated, "utf-8");
             if (options.verbose) {
               console.log(
                 `[tailwind-styled] Auto-injected "${importLine}" into ${candidate}`
@@ -4392,27 +4456,27 @@ ${content}`;
         }
         if (!process.env.TW_NATIVE_PATH) {
           const runtimeDir = resolveRuntimeDir2();
-          const nativePath = path10__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node");
-          if (fs9__default.existsSync(nativePath)) {
+          const nativePath = path11__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node");
+          if (fs10__default.existsSync(nativePath)) {
             process.env.TW_NATIVE_PATH = nativePath;
           }
         }
-        const srcDir = path10__default.join(process.cwd(), "src");
-        if (fs9__default.existsSync(srcDir)) {
+        const srcDir = path11__default.join(process.cwd(), "src");
+        if (fs10__default.existsSync(srcDir)) {
           try {
             const result = scanWorkspace2(srcDir);
             if (result.uniqueClasses.length > 0) {
               let atomicWriteFile2 = function(filePath, content) {
                 const tmpPath = `${filePath}.tmp`;
                 try {
-                  fs9__default.writeFileSync(tmpPath, content, "utf-8");
-                  fs9__default.renameSync(tmpPath, filePath);
+                  fs10__default.writeFileSync(tmpPath, content, "utf-8");
+                  fs10__default.renameSync(tmpPath, filePath);
                 } catch {
                   try {
-                    fs9__default.unlinkSync(tmpPath);
+                    fs10__default.unlinkSync(tmpPath);
                   } catch {
                   }
-                  fs9__default.writeFileSync(filePath, content, "utf-8");
+                  fs10__default.writeFileSync(filePath, content, "utf-8");
                 }
               };
               var atomicWriteFile = atomicWriteFile2;
@@ -4475,14 +4539,14 @@ ${content}`;
                 "styles/globals.css"
               ];
               try {
-                const twConfigPath = path10__default.join(process.cwd(), "tailwind-styled.config.json");
-                if (fs9__default.existsSync(twConfigPath)) {
-                  const twConfig = JSON.parse(fs9__default.readFileSync(twConfigPath, "utf-8"));
+                const twConfigPath = path11__default.join(process.cwd(), "tailwind-styled.config.json");
+                if (fs10__default.existsSync(twConfigPath)) {
+                  const twConfig = JSON.parse(fs10__default.readFileSync(twConfigPath, "utf-8"));
                   const cssEntry = twConfig.css?.entry;
                   if (cssEntry) {
-                    const cssEntryPath = path10__default.join(process.cwd(), cssEntry);
-                    if (fs9__default.existsSync(cssEntryPath)) {
-                      cssEntryContent = fs9__default.readFileSync(cssEntryPath, "utf-8");
+                    const cssEntryPath = path11__default.join(process.cwd(), cssEntry);
+                    if (fs10__default.existsSync(cssEntryPath)) {
+                      cssEntryContent = fs10__default.readFileSync(cssEntryPath, "utf-8");
                     }
                   }
                 }
@@ -4490,9 +4554,9 @@ ${content}`;
               }
               if (!cssEntryContent) {
                 for (const candidate of CSS_CANDIDATES) {
-                  const candidatePath = path10__default.join(process.cwd(), candidate);
-                  if (fs9__default.existsSync(candidatePath)) {
-                    cssEntryContent = fs9__default.readFileSync(candidatePath, "utf-8");
+                  const candidatePath = path11__default.join(process.cwd(), candidate);
+                  if (fs10__default.existsSync(candidatePath)) {
+                    cssEntryContent = fs10__default.readFileSync(candidatePath, "utf-8");
                     break;
                   }
                 }
@@ -4500,46 +4564,52 @@ ${content}`;
               if (cssEntryContent) {
                 cssEntryContent = cssEntryContent.replace(/@source\s+["'][^"']+["']\s*;?\s*/g, "").replace(/←[^\n]*/g, "").trim();
               }
-              const initialScanPath = path10__default.join(twClassesDir, "_initial-scan.css");
-              if (!fs9__default.existsSync(initialScanPath)) {
+              const initialScanPath = path11__default.join(twClassesDir, "_initial-scan.css");
+              if (!fs10__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_src(), 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 */
+              const sourceFiles = result.files?.map((f) => f.file) ?? [];
+              const incremental = isIncrementalEnabled(process.cwd());
+              if (incremental && fs10__default.existsSync(initialScanPath) && !hasSourceChanged(sourceFiles)) {
+                if (options.verbose) console.log("[tailwind-styled] Incremental: tidak ada perubahan, skip regenerate CSS");
+              } else {
+                void (async () => {
+                  try {
+                    const compiler = await Promise.resolve().then(() => (init_src(), 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}`
+                      );
+                      const summary = appendStaticStateCssToSafelist(srcDir, safelistPath, {
+                        verbose: options.verbose ?? false,
+                        resolvedCss: css
+                      });
+                      if (options.verbose) console.log(summary);
+                    }
+                  } catch (err) {
+                    throw new Error(
+                      `[tailwind-styled] generateCssForClasses gagal \u2014 build-time CSS generation wajib berhasil.
+${err.message}`,
+                      { cause: err }
                     );
-                    const summary = appendStaticStateCssToSafelist(srcDir, safelistPath, {
-                      verbose: options.verbose ?? false,
-                      resolvedCss: css
-                    });
-                    if (options.verbose) console.log(summary);
                   }
-                } catch (err) {
-                  throw new Error(
-                    `[tailwind-styled] generateCssForClasses gagal \u2014 build-time CSS generation wajib berhasil.
-${err.message}`,
-                    { cause: err }
-                  );
-                }
-              })();
+                })();
+              }
             }
           } catch (e) {
             throw new Error(