tailwind-styled-v4 5.0.35 → 5.0.36

package/dist/next.js

@@ -1,8 +1,8 @@
 'use strict';
 
 var module$1 = require('module');
-var fs9 = require('fs');
-var path10 = require('path');
+var fs10 = require('fs');
+var path11 = require('path');
 require('crypto');
 var url = require('url');
 var zod = require('zod');
@@ -27,8 +27,8 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs9__namespace = /*#__PURE__*/_interopNamespace(fs9);
-var path10__namespace = /*#__PURE__*/_interopNamespace(path10);
+var fs10__namespace = /*#__PURE__*/_interopNamespace(fs10);
+var path11__namespace = /*#__PURE__*/_interopNamespace(path11);
 
 /* tailwind-styled-v4 v5.0.4 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
 var __defProp = Object.defineProperty;
@@ -84,11 +84,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;
   }
@@ -162,7 +162,7 @@ function resolveNativeBinary(runtimeDir) {
   }
   const envPath = process.env.TW_NATIVE_PATH?.trim();
   if (envPath) {
-    if (fs9__namespace.existsSync(envPath)) {
+    if (fs10__namespace.existsSync(envPath)) {
       return { path: envPath, source: "env", platform, tried };
     }
     tried.push(`env:${envPath} (not found)`);
@@ -171,7 +171,7 @@ function resolveNativeBinary(runtimeDir) {
   for (const pkg of prebuiltPkgs) {
     try {
       const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
-      if (fs9__namespace.existsSync(candidate)) {
+      if (fs10__namespace.existsSync(candidate)) {
         return { path: candidate, source: "prebuilt", platform, tried };
       }
       tried.push(`prebuilt:${pkg} (resolved but missing)`);
@@ -182,13 +182,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__namespace.join("..", ".."), path10__namespace.join("..", "..", "..")]) {
-      const pkgRoot = path10__namespace.resolve(runtimeDir, depth);
+    for (const depth of ["..", path11__namespace.join("..", ".."), path11__namespace.join("..", "..", "..")]) {
+      const pkgRoot = path11__namespace.resolve(runtimeDir, depth);
       for (const bin of BINARY_NAMES_SELF) {
         for (const suffix of ["", `.${platform}`, `.${napiPlatform}`]) {
-          const candidate = path10__namespace.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
+          const candidate = path11__namespace.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
           tried.push(`self-bundled:${candidate}`);
-          if (fs9__namespace.existsSync(candidate)) {
+          if (fs10__namespace.existsSync(candidate)) {
             return { path: candidate, source: "prebuilt", platform, tried };
           }
         }
@@ -200,29 +200,29 @@ function resolveNativeBinary(runtimeDir) {
   const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
   const localCandidates = [];
   for (const bin of BINARY_NAMES) {
-    localCandidates.push(path10__namespace.resolve(base, `${bin}.node`));
-    localCandidates.push(path10__namespace.resolve(base, "..", `${bin}.node`));
-    localCandidates.push(path10__namespace.resolve(base, `${bin}.${platform}.node`));
-    localCandidates.push(path10__namespace.resolve(base, `${bin}.${napiPlatform}.node`));
+    localCandidates.push(path11__namespace.resolve(base, `${bin}.node`));
+    localCandidates.push(path11__namespace.resolve(base, "..", `${bin}.node`));
+    localCandidates.push(path11__namespace.resolve(base, `${bin}.${platform}.node`));
+    localCandidates.push(path11__namespace.resolve(base, `${bin}.${napiPlatform}.node`));
   }
   for (const startDir of [cwd, base]) {
     let dir = startDir;
     for (let i = 0; i < 6; i++) {
-      const nativeDir = path10__namespace.resolve(dir, "native");
+      const nativeDir = path11__namespace.resolve(dir, "native");
       for (const bin of BINARY_NAMES) {
-        localCandidates.push(path10__namespace.resolve(nativeDir, `${bin}.node`));
-        localCandidates.push(path10__namespace.resolve(nativeDir, `${bin}.${platform}.node`));
-        localCandidates.push(path10__namespace.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
-        localCandidates.push(path10__namespace.resolve(nativeDir, "target", "release", `${bin}.node`));
+        localCandidates.push(path11__namespace.resolve(nativeDir, `${bin}.node`));
+        localCandidates.push(path11__namespace.resolve(nativeDir, `${bin}.${platform}.node`));
+        localCandidates.push(path11__namespace.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
+        localCandidates.push(path11__namespace.resolve(nativeDir, "target", "release", `${bin}.node`));
       }
-      const parent = path10__namespace.resolve(dir, "..");
+      const parent = path11__namespace.resolve(dir, "..");
       if (parent === dir) break;
       dir = parent;
     }
   }
   for (const candidate of localCandidates) {
     tried.push(`local:${candidate}`);
-    if (fs9__namespace.existsSync(candidate)) {
+    if (fs10__namespace.existsSync(candidate)) {
       return { path: candidate, source: "local", platform, tried };
     }
   }
@@ -249,7 +249,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);
@@ -2403,7 +2403,7 @@ var init_src = __esm({
     };
     scanProjectUsage = (dirs, cwd) => {
       const { batchExtractClasses: batchExtractClasses2 } = _require2("./parser");
-      const files = dirs.map((dir) => path10__namespace.default.resolve(cwd, dir));
+      const files = dirs.map((dir) => path11__namespace.default.resolve(cwd, dir));
       const results = batchExtractClasses2(files) || [];
       const combined = {};
       for (const result of results) {
@@ -2420,13 +2420,13 @@ var init_src = __esm({
       const classes = scanProjectUsage(scanDirs, cwd || process.cwd());
       const allClasses = Object.keys(classes).sort();
       if (outputPath) {
-        fs9__namespace.default.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
+        fs10__namespace.default.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
       }
       return allClasses;
     };
     loadSafelist = (safelistPath) => {
       try {
-        const content = fs9__namespace.default.readFileSync(safelistPath, "utf-8");
+        const content = fs10__namespace.default.readFileSync(safelistPath, "utf-8");
         return JSON.parse(content);
       } catch {
         return [];
@@ -2440,8 +2440,8 @@ var init_src = __esm({
         "tailwind.config.cjs"
       ];
       for (const file of configFiles) {
-        const fullPath = path10__namespace.default.join(cwd, file);
-        if (fs9__namespace.default.existsSync(fullPath)) {
+        const fullPath = path11__namespace.default.join(cwd, file);
+        if (fs10__namespace.default.existsSync(fullPath)) {
           const mod = __require(fullPath);
           return mod.default || mod;
         }
@@ -2451,9 +2451,9 @@ var init_src = __esm({
     getContentPaths = (cwd = process.cwd()) => {
       return {
         content: [
-          path10__namespace.default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
-          path10__namespace.default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
-          path10__namespace.default.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
+          path11__namespace.default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
+          path11__namespace.default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
+          path11__namespace.default.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
         ]
       };
     };
@@ -2911,17 +2911,17 @@ function getNative() {
 function* walkSourceFiles(dir) {
   let entries;
   try {
-    entries = fs9__namespace.default.readdirSync(dir, { withFileTypes: true });
+    entries = fs10__namespace.default.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path10__namespace.default.join(dir, entry.name);
+    const fullPath = path11__namespace.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__namespace.default.extname(entry.name);
+      const ext = path11__namespace.default.extname(entry.name);
       if (SOURCE_EXTENSIONS.has(ext)) yield fullPath;
     }
   }
@@ -2985,7 +2985,7 @@ function extractStaticStateCss(srcDir, options = {}) {
         allConfigs.push(...configs);
         if (verbose) {
           process.stderr.write(
-            `[tw:static-state] ${path10__namespace.default.relative(srcDir, filePath)}: ${configs.length} komponen
+            `[tw:static-state] ${path11__namespace.default.relative(srcDir, filePath)}: ${configs.length} komponen
 `
           );
         }
@@ -2996,7 +2996,7 @@ function extractStaticStateCss(srcDir, options = {}) {
       if (filesScanned >= maxFiles) break;
       let source;
       try {
-        source = fs9__namespace.default.readFileSync(filePath, "utf-8");
+        source = fs10__namespace.default.readFileSync(filePath, "utf-8");
       } catch {
         continue;
       }
@@ -3009,7 +3009,7 @@ function extractStaticStateCss(srcDir, options = {}) {
         allConfigs.push(...configs);
         if (verbose) {
           process.stderr.write(
-            `[tw:static-state] ${path10__namespace.default.relative(srcDir, filePath)}: ${configs.length} komponen
+            `[tw:static-state] ${path11__namespace.default.relative(srcDir, filePath)}: ${configs.length} komponen
 `
           );
         }
@@ -3103,12 +3103,12 @@ function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
     resolvedCss: options.resolvedCss || ""
     // ← ensure always passed
   });
-  const twClassesDir = path10__namespace.default.join(path10__namespace.default.dirname(safelistPath), "tw-classes");
-  fs9__namespace.default.mkdirSync(twClassesDir, { recursive: true });
-  const stateFilePath = path10__namespace.default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+  const twClassesDir = path11__namespace.default.join(path11__namespace.default.dirname(safelistPath), "tw-classes");
+  fs10__namespace.default.mkdirSync(twClassesDir, { recursive: true });
+  const stateFilePath = path11__namespace.default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
   if (result.rulesGenerated === 0) {
     try {
-      fs9__namespace.default.writeFileSync(
+      fs10__namespace.default.writeFileSync(
         stateFilePath,
         "/* tw-state-static.css \u2014 tidak ada state rules yang di-generate */\n",
         "utf-8"
@@ -3118,7 +3118,7 @@ function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
     return `[tw:static-state] tidak ada state rules yang di-generate (${result.filesScanned} files di-scan)`;
   }
   try {
-    fs9__namespace.default.writeFileSync(stateFilePath, result.generatedCss, "utf-8");
+    fs10__namespace.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`,
@@ -3148,8 +3148,8 @@ function setGlobalLogFile(filePath) {
   _globalLogFile = filePath;
   _logFileInitialized = false;
   try {
-    fs9__namespace.default.mkdirSync(path10__namespace.default.dirname(filePath), { recursive: true });
-    fs9__namespace.default.writeFileSync(
+    fs10__namespace.default.mkdirSync(path11__namespace.default.dirname(filePath), { recursive: true });
+    fs10__namespace.default.writeFileSync(
       filePath,
       `# tailwind-styled build log \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}
 `,
@@ -3162,7 +3162,7 @@ function setGlobalLogFile(filePath) {
 function writeToFile(line) {
   if (!_globalLogFile || !_logFileInitialized) return;
   try {
-    fs9__namespace.default.appendFileSync(_globalLogFile, line);
+    fs10__namespace.default.appendFileSync(_globalLogFile, line);
   } catch {
   }
 }
@@ -3227,9 +3227,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(".");
 }
@@ -3237,9 +3237,9 @@ function loadNativeBinding(options) {
   const { runtimeDir, candidates, isValid } = options;
   const loadErrors = [];
   for (const candidate of candidates) {
-    const candidatePath = path10__namespace.default.resolve(runtimeDir, candidate);
+    const candidatePath = path11__namespace.default.resolve(runtimeDir, candidate);
     try {
-      if (!fs9__namespace.default.existsSync(candidatePath) && !fs9__namespace.default.existsSync(candidatePath + ".node")) {
+      if (!fs10__namespace.default.existsSync(candidatePath) && !fs10__namespace.default.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -3271,9 +3271,9 @@ function resolveNativeBindingCandidates(options) {
     }
   }
   if (!includeDefaultCandidates) return candidates;
-  if (fs9__namespace.default.existsSync(runtimeDir)) {
+  if (fs10__namespace.default.existsSync(runtimeDir)) {
     try {
-      for (const entry of fs9__namespace.default.readdirSync(runtimeDir)) {
+      for (const entry of fs10__namespace.default.readdirSync(runtimeDir)) {
         if (entry.endsWith(".node")) candidates.push(entry);
       }
     } catch {
@@ -3282,21 +3282,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__namespace.default.resolve(runtimeDir, `${bin}.node`));
-    candidates.push(path10__namespace.default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
-    candidates.push(path10__namespace.default.resolve(runtimeDir, "..", "native", `${bin}.node`));
-    candidates.push(path10__namespace.default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path10__namespace.default.resolve(process.cwd(), "native", `${bin}.node`));
-    candidates.push(path10__namespace.default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path10__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
-    candidates.push(path10__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path10__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path11__namespace.default.resolve(runtimeDir, `${bin}.node`));
+    candidates.push(path11__namespace.default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
+    candidates.push(path11__namespace.default.resolve(runtimeDir, "..", "native", `${bin}.node`));
+    candidates.push(path11__namespace.default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path11__namespace.default.resolve(process.cwd(), "native", `${bin}.node`));
+    candidates.push(path11__namespace.default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path11__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path11__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path11__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
   }
   return Array.from(new Set(candidates));
 }
 function resolveRuntimeDir(dir, importMetaUrl) {
   try {
-    return path10__namespace.default.dirname(url.fileURLToPath(importMetaUrl));
+    return path11__namespace.default.dirname(url.fileURLToPath(importMetaUrl));
   } catch {
     return process.cwd();
   }
@@ -3341,8 +3341,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) {
@@ -3398,7 +3398,7 @@ function getDirname() {
     return __dirname;
   }
   if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('next.js', document.baseURI).href)) }) !== "undefined" && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('next.js', document.baseURI).href))) {
-    return path10__namespace.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('next.js', document.baseURI).href))));
+    return path11__namespace.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('next.js', document.baseURI).href))));
   }
   return process.cwd();
 }
@@ -3717,12 +3717,12 @@ init_src2();
 // packages/domain/scanner/src/cache-native.ts
 init_native_bridge();
 function defaultCachePath(rootDir, cacheDir) {
-  const dir = cacheDir ? path10__namespace.default.resolve(rootDir, cacheDir) : path10__namespace.default.join(process.cwd(), ".cache", "tailwind-styled");
-  return path10__namespace.default.join(dir, "scanner-cache.json");
+  const dir = cacheDir ? path11__namespace.default.resolve(rootDir, cacheDir) : path11__namespace.default.join(process.cwd(), ".cache", "tailwind-styled");
+  return path11__namespace.default.join(dir, "scanner-cache.json");
 }
 function readCache(rootDir, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs9__namespace.default.mkdirSync(path10__namespace.default.dirname(cachePath), { recursive: true });
+  fs10__namespace.default.mkdirSync(path11__namespace.default.dirname(cachePath), { recursive: true });
   const result = cacheReadNative(cachePath);
   if (!result) return [];
   return result.entries.map((e) => ({
@@ -3737,7 +3737,7 @@ function readCache(rootDir, cacheDir) {
 }
 function writeCache(rootDir, entries, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs9__namespace.default.mkdirSync(path10__namespace.default.dirname(cachePath), { recursive: true });
+  fs10__namespace.default.mkdirSync(path11__namespace.default.dirname(cachePath), { recursive: true });
   const success = cacheWriteNative(cachePath, entries);
   if (!success) {
     throw new Error(
@@ -3762,12 +3762,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);
@@ -3827,7 +3827,7 @@ function getRuntimeDir() {
     return __dirname;
   }
   if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('next.js', document.baseURI).href)) }) !== "undefined" && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('next.js', document.baseURI).href))) {
-    return path10__namespace.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('next.js', document.baseURI).href))));
+    return path11__namespace.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('next.js', document.baseURI).href))));
   }
   return process.cwd();
 }
@@ -3842,7 +3842,7 @@ var createNativeParserLoader = () => {
   const loadNativeParserBinding = () => {
     if (_state.binding !== void 0) return _state.binding;
     const runtimeDir = getRuntimeDir();
-    const req = module$1.createRequire(path10__namespace.default.join(runtimeDir, "noop.cjs"));
+    const req = module$1.createRequire(path11__namespace.default.join(runtimeDir, "noop.cjs"));
     const _platform = process.platform;
     const _arch = process.arch;
     const _platformArch = `${_platform}-${_arch}`;
@@ -3850,27 +3850,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__namespace.default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
-      path10__namespace.default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
-      path10__namespace.default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path11__namespace.default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
+      path11__namespace.default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
+      path11__namespace.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__namespace.default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
-      path10__namespace.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
-      path10__namespace.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path11__namespace.default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
+      path11__namespace.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
+      path11__namespace.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // runtimeDir = dist/ → naik 4 level ke repo root (monorepo dev case)
-      path10__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
-      path10__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path11__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
+      path11__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // 3 level fallback (jika package di-nest lebih dangkal)
-      path10__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
-      path10__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path11__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
+      path11__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // ── binaryName lama: tailwind_styled_parser (backward compat) ──
-      path10__namespace.default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
-      path10__namespace.default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
-      path10__namespace.default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
-      path10__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
-      path10__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
-      path10__namespace.default.resolve(
+      path11__namespace.default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
+      path11__namespace.default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
+      path11__namespace.default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
+      path11__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
+      path11__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
+      path11__namespace.default.resolve(
         runtimeDir,
         "..",
         "..",
@@ -3882,7 +3882,7 @@ var createNativeParserLoader = () => {
       )
     ];
     for (const fullPath of candidates) {
-      if (!fs9__namespace.default.existsSync(fullPath)) continue;
+      if (!fs10__namespace.default.existsSync(fullPath)) continue;
       try {
         const required = req(fullPath);
         if (required && (typeof required.extractClassesFromSource === "function" || typeof required.parseClasses === "function" || typeof required.parse_classes === "function")) {
@@ -3923,19 +3923,19 @@ function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
     if (!currentDir) continue;
     const entries = (() => {
       try {
-        return fs9__namespace.default.readdirSync(currentDir, { withFileTypes: true });
+        return fs10__namespace.default.readdirSync(currentDir, { withFileTypes: true });
       } catch {
         return [];
       }
     })();
     for (const entry of entries) {
-      const fullPath = path10__namespace.default.join(currentDir, entry.name);
+      const fullPath = path11__namespace.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__namespace.default.extname(entry.name))) continue;
+      if (!extensionSet.has(path11__namespace.default.extname(entry.name))) continue;
       candidates.push(fullPath);
     }
   }
@@ -4019,7 +4019,7 @@ function scanWorkspace2(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return fs9__namespace.default.statSync(filePath);
+          return fs10__namespace.default.statSync(filePath);
         } catch {
           return null;
         }
@@ -4045,7 +4045,7 @@ function scanWorkspace2(rootDir, options = {}) {
     for (const { filePath, stat, size, cached } of ranked) {
       const content = (() => {
         try {
-          return fs9__namespace.default.readFileSync(filePath, "utf8");
+          return fs10__namespace.default.readFileSync(filePath, "utf8");
         } catch {
           return null;
         }
@@ -4108,6 +4108,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__namespace.default.statSync(filePath);
+    const native = getNative2();
+    if (native?.create_fingerprint) {
+      const content = fs10__namespace.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__namespace.default.join(cwd, "tailwind-styled.config.json");
+    if (!fs10__namespace.default.existsSync(configPath)) return false;
+    const config = JSON.parse(fs10__namespace.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()) {
@@ -4141,14 +4205,14 @@ var StaticCssWebpackPlugin = class _StaticCssWebpackPlugin {
   static PLUGIN_NAME = "TailwindStyledStaticCss";
   outPath;
   constructor(safelistPath) {
-    this.outPath = path10__namespace.default.join(path10__namespace.default.dirname(safelistPath), "_tw-state-static.css");
+    this.outPath = path11__namespace.default.join(path11__namespace.default.dirname(safelistPath), "_tw-state-static.css");
   }
   apply(compiler) {
     compiler.hooks.done.tap(_StaticCssWebpackPlugin.PLUGIN_NAME, () => {
       try {
         const content = buildContent(_fileStaticCssMap);
-        fs9__namespace.default.mkdirSync(path10__namespace.default.dirname(this.outPath), { recursive: true });
-        fs9__namespace.default.writeFileSync(
+        fs10__namespace.default.mkdirSync(path11__namespace.default.dirname(this.outPath), { recursive: true });
+        fs10__namespace.default.writeFileSync(
           this.outPath,
           HEADER + (content || "/* no static rules yet */") + "\n",
           "utf-8"
@@ -4182,12 +4246,12 @@ var resolveLoaderPath2 = (basename) => {
   } catch {
     const runtimeDir = resolveRuntimeDir2();
     const candidates = [
-      path10__namespace.default.resolve(runtimeDir, `${basename}.mjs`),
-      path10__namespace.default.resolve(runtimeDir, `${basename}.js`),
-      path10__namespace.default.resolve(runtimeDir, `${basename}.cjs`)
+      path11__namespace.default.resolve(runtimeDir, `${basename}.mjs`),
+      path11__namespace.default.resolve(runtimeDir, `${basename}.js`),
+      path11__namespace.default.resolve(runtimeDir, `${basename}.cjs`)
     ];
     for (const candidate of candidates) {
-      if (fs9__namespace.default.existsSync(candidate)) {
+      if (fs10__namespace.default.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -4225,7 +4289,7 @@ var createLoaderOptions = (options) => {
     preserveImports: true
   };
   if (options.verbose !== void 0) opts.verbose = options.verbose;
-  opts.safelistPath = options.safelistPath ?? path10__namespace.default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
+  opts.safelistPath = options.safelistPath ?? path11__namespace.default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
   return Object.freeze(opts);
 };
 var buildTurbopackRules = (loaderPath, loaderOptions) => {
@@ -4238,7 +4302,7 @@ var buildTurbopackRules = (loaderPath, loaderOptions) => {
     ])
   );
 };
-var normalizeLoaderPath = (loaderPath) => path10__namespace.default.resolve(loaderPath);
+var normalizeLoaderPath = (loaderPath) => path11__namespace.default.resolve(loaderPath);
 var applyWebpackRule = (config, options, loaderPath) => {
   const loaderOptions = createLoaderOptions(options);
   const rules = config.module?.rules ?? [];
@@ -4255,7 +4319,7 @@ var applyWebpackRule = (config, options, loaderPath) => {
     enforce: "pre",
     use: [{ loader: loaderPath, options: loaderOptions }]
   };
-  const safelistPath = loaderOptions.safelistPath ?? path10__namespace.default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
+  const safelistPath = loaderOptions.safelistPath ?? path11__namespace.default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
   const pluginAlreadyRegistered = (config.plugins ?? []).some(
     (p) => p?.constructor?.name === StaticCssWebpackPlugin.PLUGIN_NAME
   );
@@ -4355,17 +4419,17 @@ function withTailwindStyled(options = {}) {
           return fullCss.slice(startIdx, endIdx + 1);
         };
         var extractUtilitiesLayer = extractUtilitiesLayer2;
-        const twClassesDir = path10__namespace.default.join(path10__namespace.default.dirname(safelistPath), "tw-classes");
-        fs9__namespace.default.mkdirSync(twClassesDir, { recursive: true });
-        setGlobalLogFile(path10__namespace.default.join(twClassesDir, "_tw-build.log"));
-        fs9__namespace.default.writeFileSync(
-          path10__namespace.default.join(twClassesDir, "_start.txt"),
+        const twClassesDir = path11__namespace.default.join(path11__namespace.default.dirname(safelistPath), "tw-classes");
+        fs10__namespace.default.mkdirSync(twClassesDir, { recursive: true });
+        setGlobalLogFile(path11__namespace.default.join(twClassesDir, "_tw-build.log"));
+        fs10__namespace.default.writeFileSync(
+          path11__namespace.default.join(twClassesDir, "_start.txt"),
           String(Date.now()),
           "utf-8"
         );
-        const stateStaticPath = path10__namespace.default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+        const stateStaticPath = path11__namespace.default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
         try {
-          fs9__namespace.default.writeFileSync(
+          fs10__namespace.default.writeFileSync(
             stateStaticPath,
             "/* tw-state-static.css \u2014 placeholder, akan di-generate setelah scan */\n",
             "utf-8"
@@ -4381,14 +4445,14 @@ function withTailwindStyled(options = {}) {
             "src/index.css",
             "styles/globals.css"
           ];
-          const safelistDir = path10__namespace.default.dirname(safelistPath);
+          const safelistDir = path11__namespace.default.dirname(safelistPath);
           for (const candidate of CSS_CANDIDATES) {
-            const candidatePath = path10__namespace.default.join(process.cwd(), candidate);
-            if (!fs9__namespace.default.existsSync(candidatePath)) continue;
-            const content = fs9__namespace.default.readFileSync(candidatePath, "utf-8");
+            const candidatePath = path11__namespace.default.join(process.cwd(), candidate);
+            if (!fs10__namespace.default.existsSync(candidatePath)) continue;
+            const content = fs10__namespace.default.readFileSync(candidatePath, "utf-8");
             if (content.includes("_tw-state-static.css")) break;
-            const globalsDir = path10__namespace.default.dirname(candidatePath);
-            const rel = path10__namespace.default.relative(globalsDir, stateStaticPath).replace(/\\/g, "/");
+            const globalsDir = path11__namespace.default.dirname(candidatePath);
+            const rel = path11__namespace.default.relative(globalsDir, stateStaticPath).replace(/\\/g, "/");
             const importLine = `@import "./${rel}";`;
             const tailwindImportRe = /(@import\s+["']tailwindcss["']\s*;[^\n]*\n?)/;
             let updated;
@@ -4402,7 +4466,7 @@ function withTailwindStyled(options = {}) {
               updated = `${importLine}
 ${content}`;
             }
-            fs9__namespace.default.writeFileSync(candidatePath, updated, "utf-8");
+            fs10__namespace.default.writeFileSync(candidatePath, updated, "utf-8");
             if (options.verbose) {
               console.log(
                 `[tailwind-styled] Auto-injected "${importLine}" into ${candidate}`
@@ -4414,27 +4478,27 @@ ${content}`;
         }
         if (!process.env.TW_NATIVE_PATH) {
           const runtimeDir = resolveRuntimeDir2();
-          const nativePath = path10__namespace.default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node");
-          if (fs9__namespace.default.existsSync(nativePath)) {
+          const nativePath = path11__namespace.default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node");
+          if (fs10__namespace.default.existsSync(nativePath)) {
             process.env.TW_NATIVE_PATH = nativePath;
           }
         }
-        const srcDir = path10__namespace.default.join(process.cwd(), "src");
-        if (fs9__namespace.default.existsSync(srcDir)) {
+        const srcDir = path11__namespace.default.join(process.cwd(), "src");
+        if (fs10__namespace.default.existsSync(srcDir)) {
           try {
             const result = scanWorkspace2(srcDir);
             if (result.uniqueClasses.length > 0) {
               let atomicWriteFile2 = function(filePath, content) {
                 const tmpPath = `${filePath}.tmp`;
                 try {
-                  fs9__namespace.default.writeFileSync(tmpPath, content, "utf-8");
-                  fs9__namespace.default.renameSync(tmpPath, filePath);
+                  fs10__namespace.default.writeFileSync(tmpPath, content, "utf-8");
+                  fs10__namespace.default.renameSync(tmpPath, filePath);
                 } catch {
                   try {
-                    fs9__namespace.default.unlinkSync(tmpPath);
+                    fs10__namespace.default.unlinkSync(tmpPath);
                   } catch {
                   }
-                  fs9__namespace.default.writeFileSync(filePath, content, "utf-8");
+                  fs10__namespace.default.writeFileSync(filePath, content, "utf-8");
                 }
               };
               var atomicWriteFile = atomicWriteFile2;
@@ -4497,14 +4561,14 @@ ${content}`;
                 "styles/globals.css"
               ];
               try {
-                const twConfigPath = path10__namespace.default.join(process.cwd(), "tailwind-styled.config.json");
-                if (fs9__namespace.default.existsSync(twConfigPath)) {
-                  const twConfig = JSON.parse(fs9__namespace.default.readFileSync(twConfigPath, "utf-8"));
+                const twConfigPath = path11__namespace.default.join(process.cwd(), "tailwind-styled.config.json");
+                if (fs10__namespace.default.existsSync(twConfigPath)) {
+                  const twConfig = JSON.parse(fs10__namespace.default.readFileSync(twConfigPath, "utf-8"));
                   const cssEntry = twConfig.css?.entry;
                   if (cssEntry) {
-                    const cssEntryPath = path10__namespace.default.join(process.cwd(), cssEntry);
-                    if (fs9__namespace.default.existsSync(cssEntryPath)) {
-                      cssEntryContent = fs9__namespace.default.readFileSync(cssEntryPath, "utf-8");
+                    const cssEntryPath = path11__namespace.default.join(process.cwd(), cssEntry);
+                    if (fs10__namespace.default.existsSync(cssEntryPath)) {
+                      cssEntryContent = fs10__namespace.default.readFileSync(cssEntryPath, "utf-8");
                     }
                   }
                 }
@@ -4512,9 +4576,9 @@ ${content}`;
               }
               if (!cssEntryContent) {
                 for (const candidate of CSS_CANDIDATES) {
-                  const candidatePath = path10__namespace.default.join(process.cwd(), candidate);
-                  if (fs9__namespace.default.existsSync(candidatePath)) {
-                    cssEntryContent = fs9__namespace.default.readFileSync(candidatePath, "utf-8");
+                  const candidatePath = path11__namespace.default.join(process.cwd(), candidate);
+                  if (fs10__namespace.default.existsSync(candidatePath)) {
+                    cssEntryContent = fs10__namespace.default.readFileSync(candidatePath, "utf-8");
                     break;
                   }
                 }
@@ -4522,46 +4586,52 @@ ${content}`;
               if (cssEntryContent) {
                 cssEntryContent = cssEntryContent.replace(/@source\s+["'][^"']+["']\s*;?\s*/g, "").replace(/←[^\n]*/g, "").trim();
               }
-              const initialScanPath = path10__namespace.default.join(twClassesDir, "_initial-scan.css");
-              if (!fs9__namespace.default.existsSync(initialScanPath)) {
+              const initialScanPath = path11__namespace.default.join(twClassesDir, "_initial-scan.css");
+              if (!fs10__namespace.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__namespace.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(