tailwind-styled-v4 5.1.21 → 5.1.23

package/dist/next.mjs

@@ -65,11 +65,11 @@ function resolvePath(...segments) {
     return segments.join("/").replace(/\/+/g, "/");
   }
 }
-function existsSync(path14) {
+function existsSync(path15) {
   if (isBrowser) return false;
   try {
     const nodeFs = __require(NODE_FS);
-    return nodeFs.existsSync(path14);
+    return nodeFs.existsSync(path15);
   } catch {
     return false;
   }
@@ -250,7 +250,7 @@ var init_nativeBridge = __esm({
     "use strict";
     init_esm_shims();
     init_src2();
-    _loadNative = (path14) => __require(path14);
+    _loadNative = (path15) => __require(path15);
     log = (...args) => {
       if (process.env.DEBUG?.includes("compiler:native")) {
         console.log("[compiler:native]", ...args);
@@ -2286,6 +2286,320 @@ var init_routeGraph = __esm({
   }
 });
 
+// packages/domain/compiler/src/semanticComponentAnalyzer.ts
+function inferSemanticFromTag(tag) {
+  const tagLower = tag.toLowerCase();
+  const semanticMap = {
+    "button": "button",
+    "a": "link",
+    "nav": "navigation",
+    "h1": "heading",
+    "h2": "heading",
+    "h3": "heading",
+    "h4": "heading",
+    "h5": "heading",
+    "h6": "heading",
+    "p": "paragraph",
+    "ul": "list",
+    "ol": "list",
+    "input": "input",
+    "form": "form",
+    "dialog": "dialog",
+    "select": "select",
+    "textarea": "input"
+  };
+  return semanticMap[tagLower] ?? "custom";
+}
+function extractSemanticMetadata(config) {
+  const metadata = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (key.startsWith("@")) {
+      metadata[key] = value;
+    }
+  }
+  return metadata;
+}
+function analyzeComponentSemantics(componentName, config) {
+  const metadata = extractSemanticMetadata(config);
+  const tag = config.tag ?? "div";
+  let semantic = inferSemanticFromTag(tag);
+  if (metadata["@semantic"]) {
+    semantic = metadata["@semantic"];
+  }
+  const stateProperties = /* @__PURE__ */ new Map();
+  if (metadata["@state"]) {
+    for (const [key, value] of Object.entries(metadata["@state"])) {
+      if (typeof value === "string") {
+        stateProperties.set(key, value);
+      }
+    }
+  }
+  return {
+    componentName,
+    tag,
+    semantic,
+    metadata,
+    stateProperties
+  };
+}
+function getAriaRoleForSemantic(semantic) {
+  const roleMap = {
+    "button": "button",
+    "link": "link",
+    "navigation": "navigation",
+    "heading": "heading",
+    "paragraph": void 0,
+    // paragraph tidak perlu explicit role
+    "list": "list",
+    "input": "textbox",
+    "form": "form",
+    "dialog": "dialog",
+    "alert": "alert",
+    "tab": "tab",
+    "checkbox": "checkbox",
+    "radio": "radio",
+    "select": "listbox",
+    "custom": void 0
+  };
+  return roleMap[semantic];
+}
+function analyzeComponentBatch(components) {
+  const results = /* @__PURE__ */ new Map();
+  for (const [name, config] of components) {
+    const analysis = analyzeComponentSemantics(name, config);
+    results.set(name, analysis);
+  }
+  return results;
+}
+function validateSemanticMetadata(metadata) {
+  const issues = [];
+  const validSemantics = [
+    "button",
+    "link",
+    "navigation",
+    "heading",
+    "paragraph",
+    "list",
+    "input",
+    "form",
+    "dialog",
+    "alert",
+    "tab",
+    "checkbox",
+    "radio",
+    "select",
+    "custom"
+  ];
+  if (metadata["@semantic"] && !validSemantics.includes(metadata["@semantic"])) {
+    issues.push(`Invalid @semantic value: ${metadata["@semantic"]}`);
+  }
+  if (metadata["@aria"]) {
+    if (typeof metadata["@aria"] !== "object" || Array.isArray(metadata["@aria"])) {
+      issues.push("@aria must be object");
+    }
+  }
+  if (metadata["@state"]) {
+    if (typeof metadata["@state"] !== "object" || Array.isArray(metadata["@state"])) {
+      issues.push("@state must be object");
+    }
+    for (const [key, value] of Object.entries(metadata["@state"])) {
+      if (typeof value !== "string") {
+        issues.push(`@state.${key} must be string (ARIA property name)`);
+      }
+    }
+  }
+  return issues;
+}
+var init_semanticComponentAnalyzer = __esm({
+  "packages/domain/compiler/src/semanticComponentAnalyzer.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// packages/domain/compiler/src/typeGeneratorFromMetadata.ts
+function generateJsDocFromSemantic(analysis) {
+  const lines = [
+    "/**",
+    ` * ${analysis.componentName}`,
+    ` * `,
+    ` * Semantic intent: ${analysis.semantic}`,
+    ` * Tag: ${analysis.tag}`
+  ];
+  if (analysis.metadata["@aria"]) {
+    lines.push(` * ARIA: auto-injected dari semantic metadata`);
+  }
+  if (analysis.stateProperties.size > 0) {
+    const states = Array.from(analysis.stateProperties.entries()).map(([k, v]) => `${k} \u2192 ${v}`).join(", ");
+    lines.push(` * State mappings: ${states}`);
+  }
+  lines.push(" */");
+  return lines.join("\n");
+}
+function getBaseComponentType(analysis) {
+  const tag = analysis.tag.toLowerCase();
+  const tagMap = {
+    "button": "React.ButtonHTMLAttributes<HTMLButtonElement>",
+    "a": "React.AnchorHTMLAttributes<HTMLAnchorElement>",
+    "input": "React.InputHTMLAttributes<HTMLInputElement>",
+    "textarea": "React.TextareaHTMLAttributes<HTMLTextAreaElement>",
+    "select": "React.SelectHTMLAttributes<HTMLSelectElement>",
+    "form": "React.FormHTMLAttributes<HTMLFormElement>",
+    "div": "React.HTMLAttributes<HTMLDivElement>",
+    "span": "React.HTMLAttributes<HTMLSpanElement>",
+    "nav": "React.HTMLAttributes<HTMLElement>",
+    "dialog": "React.DialogHTMLAttributes<HTMLDialogElement>"
+  };
+  return tagMap[tag] ?? "React.HTMLAttributes<HTMLElement>";
+}
+function generateStateProperties(analysis) {
+  const props = /* @__PURE__ */ new Map();
+  for (const [stateName, ariaProp] of analysis.stateProperties) {
+    props.set(stateName, {
+      name: stateName,
+      type: "boolean | undefined",
+      description: `State mapped to ARIA property: ${ariaProp}`,
+      optional: true
+    });
+  }
+  return props;
+}
+function generateTypeDefinition(analysis, componentName) {
+  const interfaceName = `${componentName}Props`;
+  const baseType = getBaseComponentType(analysis);
+  const stateProps = generateStateProperties(analysis);
+  return {
+    interfaceName,
+    extendsFrom: baseType,
+    properties: stateProps,
+    jsDocComment: generateJsDocFromSemantic(analysis)
+  };
+}
+function renderTypeDefinition(def) {
+  const lines = [];
+  if (def.jsDocComment) {
+    lines.push(def.jsDocComment);
+  }
+  lines.push(`export interface ${def.interfaceName} extends ${def.extendsFrom} {`);
+  for (const prop of def.properties.values()) {
+    const optional = prop.optional ? "?" : "";
+    if (prop.description) {
+      lines.push(`  /** ${prop.description} */`);
+    }
+    lines.push(`  ${prop.name}${optional}: ${prop.type}`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function generateTypeStubFile(analyses, packageName = "tailwind-styled") {
+  const lines = [
+    "/**",
+    ` * Auto-generated type definitions dari semantic component metadata`,
+    ` * Generated at build-time dari @semantic, @aria, @state annotations`,
+    ` * Package: ${packageName}`,
+    ` */`,
+    "",
+    "import type * as React from 'react'",
+    ""
+  ];
+  const interfaces = [];
+  for (const [name, analysis] of analyses) {
+    const def = generateTypeDefinition(analysis, name);
+    interfaces.push(renderTypeDefinition(def));
+  }
+  lines.push(interfaces.join("\n\n"));
+  lines.push("");
+  lines.push("export namespace Components {");
+  for (const analysis of analyses.values()) {
+    lines.push(`  export type ${analysis.componentName}Props = ${analysis.componentName}Props`);
+  }
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateTypeStubOutputPaths(outputDir, packageName) {
+  return [
+    {
+      filePath: `${outputDir}/${packageName}.d.ts`,
+      content: "",
+      // Will be set by caller
+      format: "dts"
+    }
+  ];
+}
+function generateTypeDefinitionsBatch(analyses) {
+  const results = /* @__PURE__ */ new Map();
+  for (const [name, analysis] of analyses) {
+    const def = generateTypeDefinition(analysis, name);
+    const code = renderTypeDefinition(def);
+    results.set(name, code);
+  }
+  return results;
+}
+function combineTypeDefinitions(definitions, packageName = "tailwind-styled") {
+  const lines = [
+    "/**",
+    ` * Auto-generated type definitions dari semantic component metadata`,
+    ` * Generated at build-time dari @semantic, @aria, @state annotations`,
+    ` * Package: ${packageName}`,
+    " */",
+    "",
+    "import type * as React from 'react'",
+    ""
+  ];
+  const defs = Array.from(definitions.values());
+  lines.push(defs.join("\n\n"));
+  return lines.join("\n");
+}
+var init_typeGeneratorFromMetadata = __esm({
+  "packages/domain/compiler/src/typeGeneratorFromMetadata.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// packages/domain/compiler/src/typeGenerationPlugin.ts
+import fs3 from "fs";
+import path4 from "path";
+function createTypeGenerationPlugin(options = {}) {
+  const {
+    outputDir = "./dist/types",
+    packageName = "tailwind-styled",
+    verbose = false,
+    componentRegistryPath
+  } = options;
+  return {
+    name: "type-generation",
+    async setup(build) {
+      if (verbose) {
+        console.log("[type-generation] Plugin loaded");
+      }
+    }
+  };
+}
+async function generateTypesFromComponents(components, outputPath, packageName = "tailwind-styled") {
+  if (components.size === 0) {
+    console.warn("No components provided");
+    return;
+  }
+  const analyses = analyzeComponentBatch(components);
+  const typeContent = generateTypeStubFile(analyses, packageName);
+  const dir = path4.dirname(outputPath);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  fs3.writeFileSync(outputPath, typeContent, "utf8");
+  console.log(`Generated type stubs \u2192 ${outputPath} (${components.size} components)`);
+}
+var init_typeGenerationPlugin = __esm({
+  "packages/domain/compiler/src/typeGenerationPlugin.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_semanticComponentAnalyzer();
+    init_typeGeneratorFromMetadata();
+  }
+});
+
 // packages/domain/compiler/src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -2295,6 +2609,8 @@ __export(src_exports, {
   analyzeClassUsageNative: () => analyzeClassUsageNative,
   analyzeClasses: () => analyzeClasses,
   analyzeClassesNative: () => analyzeClassesNative,
+  analyzeComponentBatch: () => analyzeComponentBatch,
+  analyzeComponentSemantics: () => analyzeComponentSemantics,
   analyzeFile: () => analyzeFile,
   analyzeRscNative: () => analyzeRscNative,
   analyzeVariantUsage: () => analyzeVariantUsage,
@@ -2321,6 +2637,7 @@ __export(src_exports, {
   clearResolverPool: () => clearResolverPool,
   clearThemeCache: () => clearThemeCache,
   collectFiles: () => collectFiles,
+  combineTypeDefinitions: () => combineTypeDefinitions,
   compileAnimation: () => compileAnimation,
   compileClass: () => compileClass,
   compileClasses: () => compileClasses,
@@ -2334,6 +2651,7 @@ __export(src_exports, {
   compileVariantTableNative: () => compileVariantTableNative,
   computeIncrementalDiff: () => computeIncrementalDiff,
   createFingerprint: () => createFingerprint,
+  createTypeGenerationPlugin: () => createTypeGenerationPlugin,
   detectConflicts: () => detectConflicts,
   detectDeadCode: () => detectDeadCode,
   diffClassLists: () => diffClassLists,
@@ -2349,6 +2667,7 @@ __export(src_exports, {
   extractClassesFromSourceNative: () => extractClassesFromSourceNative,
   extractComponentUsage: () => extractComponentUsage,
   extractContainerCssFromSource: () => extractContainerCssFromSource,
+  extractSemanticMetadata: () => extractSemanticMetadata,
   extractTwContainerConfigs: () => extractTwContainerConfigs,
   extractTwStateConfigs: () => extractTwStateConfigs,
   extractTwStateConfigsNative: () => extractTwStateConfigsNative,
@@ -2363,8 +2682,14 @@ __export(src_exports, {
   generateStaticStateCss: () => generateStaticStateCss,
   generateStaticStateCssNative: () => generateStaticStateCssNative,
   generateSubComponentTypes: () => generateSubComponentTypes,
+  generateTypeDefinition: () => generateTypeDefinition,
+  generateTypeDefinitionsBatch: () => generateTypeDefinitionsBatch,
+  generateTypeStubFile: () => generateTypeStubFile,
+  generateTypeStubOutputPaths: () => generateTypeStubOutputPaths,
+  generateTypesFromComponents: () => generateTypesFromComponents,
   getAllRegisteredClasses: () => getAllRegisteredClasses,
   getAllRoutes: () => getAllRoutes,
+  getAriaRoleForSemantic: () => getAriaRoleForSemantic,
   getBucketEngine: () => getBucketEngine,
   getCacheOptimizationHints: () => getCacheOptimizationHints,
   getCacheStatistics: () => getCacheStatistics,
@@ -2460,6 +2785,7 @@ __export(src_exports, {
   registerPluginHook: () => registerPluginHook,
   registerPropertyName: () => registerPropertyName,
   registerValueName: () => registerValueName,
+  renderTypeDefinition: () => renderTypeDefinition,
   resetBucketEngine: () => resetBucketEngine,
   resetCacheStats: () => resetCacheStats,
   resetCompilationMetrics: () => resetCompilationMetrics,
@@ -2502,6 +2828,7 @@ __export(src_exports, {
   twMergeWithSeparator: () => twMergeWithSeparator,
   unregisterPluginHook: () => unregisterPluginHook,
   validateCssOutput: () => validateCssOutput,
+  validateSemanticMetadata: () => validateSemanticMetadata,
   validateThemeConfig: () => validateThemeConfig,
   valueIdToString: () => valueIdToString,
   walkAndPrefilterSourceFiles: () => walkAndPrefilterSourceFiles,
@@ -2513,8 +2840,8 @@ __export(src_exports, {
   watchRemovePattern: () => watchRemovePattern,
   watchResume: () => watchResume
 });
-import fs3 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path5 from "path";
 import { createRequire as createRequire4 } from "module";
 function _layoutClassesToCss(classes) {
   const native = getNativeBridge();
@@ -2563,6 +2890,9 @@ var init_src = __esm({
     init_redis();
     init_watch();
     init_routeGraph();
+    init_semanticComponentAnalyzer();
+    init_typeGeneratorFromMetadata();
+    init_typeGenerationPlugin();
     _require2 = createRequire4(
       typeof __require !== "undefined" ? typeof __filename !== "undefined" ? `file://${__filename}` : "file://unknown" : import.meta.url
     );
@@ -2657,7 +2987,7 @@ var init_src = __esm({
     };
     scanProjectUsage = (dirs, cwd) => {
       const { batchExtractClasses: batchExtractClasses2 } = _require2("./parser");
-      const files = dirs.map((dir) => path4.resolve(cwd, dir));
+      const files = dirs.map((dir) => path5.resolve(cwd, dir));
       const results = batchExtractClasses2(files) || [];
       const combined = {};
       for (const result of results) {
@@ -2674,13 +3004,13 @@ var init_src = __esm({
       const classes = scanProjectUsage(scanDirs, cwd || process.cwd());
       const allClasses = Object.keys(classes).sort();
       if (outputPath) {
-        fs3.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
+        fs4.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
       }
       return allClasses;
     };
     loadSafelist = (safelistPath) => {
       try {
-        const content = fs3.readFileSync(safelistPath, "utf-8");
+        const content = fs4.readFileSync(safelistPath, "utf-8");
         return JSON.parse(content);
       } catch {
         return [];
@@ -2694,8 +3024,8 @@ var init_src = __esm({
         "tailwind.config.cjs"
       ];
       for (const file of configFiles) {
-        const fullPath = path4.join(cwd, file);
-        if (fs3.existsSync(fullPath)) {
+        const fullPath = path5.join(cwd, file);
+        if (fs4.existsSync(fullPath)) {
           const mod = __require(fullPath);
           return mod.default || mod;
         }
@@ -2705,9 +3035,9 @@ var init_src = __esm({
     getContentPaths = (cwd = process.cwd()) => {
       return {
         content: [
-          path4.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
-          path4.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
-          path4.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
+          path5.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
+          path5.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
+          path5.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
         ]
       };
     };
@@ -3170,8 +3500,8 @@ var init_internal = __esm({
 });
 
 // packages/domain/shared/src/staticStateExtractor.ts
-import fs4 from "fs";
-import path5 from "path";
+import fs5 from "fs";
+import path6 from "path";
 function getNative() {
   if (_native) return _native;
   try {
@@ -3201,17 +3531,17 @@ function getNative() {
 function* walkSourceFiles(dir) {
   let entries;
   try {
-    entries = fs4.readdirSync(dir, { withFileTypes: true });
+    entries = fs5.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path5.join(dir, entry.name);
+    const fullPath = path6.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 = path5.extname(entry.name);
+      const ext = path6.extname(entry.name);
       if (SOURCE_EXTENSIONS.has(ext)) yield fullPath;
     }
   }
@@ -3275,7 +3605,7 @@ function extractStaticStateCss(srcDir, options = {}) {
         allConfigs.push(...configs);
         if (verbose) {
           process.stderr.write(
-            `[tw:static-state] ${path5.relative(srcDir, filePath)}: ${configs.length} komponen
+            `[tw:static-state] ${path6.relative(srcDir, filePath)}: ${configs.length} komponen
 `
           );
         }
@@ -3286,7 +3616,7 @@ function extractStaticStateCss(srcDir, options = {}) {
       if (filesScanned >= maxFiles) break;
       let source;
       try {
-        source = fs4.readFileSync(filePath, "utf-8");
+        source = fs5.readFileSync(filePath, "utf-8");
       } catch {
         continue;
       }
@@ -3299,7 +3629,7 @@ function extractStaticStateCss(srcDir, options = {}) {
         allConfigs.push(...configs);
         if (verbose) {
           process.stderr.write(
-            `[tw:static-state] ${path5.relative(srcDir, filePath)}: ${configs.length} komponen
+            `[tw:static-state] ${path6.relative(srcDir, filePath)}: ${configs.length} komponen
 `
           );
         }
@@ -3393,12 +3723,12 @@ function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
     resolvedCss: options.resolvedCss || ""
     // ← ensure always passed
   });
-  const twClassesDir = path5.join(path5.dirname(safelistPath), "tw-classes");
-  fs4.mkdirSync(twClassesDir, { recursive: true });
-  const stateFilePath = path5.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+  const twClassesDir = path6.join(path6.dirname(safelistPath), "tw-classes");
+  fs5.mkdirSync(twClassesDir, { recursive: true });
+  const stateFilePath = path6.join(twClassesDir, TW_STATE_STATIC_FILENAME);
   if (result.rulesGenerated === 0) {
     try {
-      fs4.writeFileSync(
+      fs5.writeFileSync(
         stateFilePath,
         "/* tw-state-static.css \u2014 tidak ada state rules yang di-generate */\n",
         "utf-8"
@@ -3408,7 +3738,7 @@ function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
     return `[tw:static-state] tidak ada state rules yang di-generate (${result.filesScanned} files di-scan)`;
   }
   try {
-    fs4.writeFileSync(stateFilePath, result.generatedCss, "utf-8");
+    fs5.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`,
@@ -3433,8 +3763,8 @@ var init_staticStateExtractor = __esm({
 });
 
 // packages/domain/shared/src/logger.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path7 from "path";
 function getEnvLevel() {
   const env = process.env.TWS_LOG_LEVEL?.toLowerCase();
   if (env && env in LEVELS) return env;
@@ -3444,8 +3774,8 @@ function setGlobalLogFile(filePath) {
   _globalLogFile = filePath;
   _logFileInitialized = false;
   try {
-    fs5.mkdirSync(path6.dirname(filePath), { recursive: true });
-    fs5.writeFileSync(
+    fs6.mkdirSync(path7.dirname(filePath), { recursive: true });
+    fs6.writeFileSync(
       filePath,
       `# tailwind-styled build log \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}
 `,
@@ -3458,7 +3788,7 @@ function setGlobalLogFile(filePath) {
 function writeToFile(line) {
   if (!_globalLogFile || !_logFileInitialized) return;
   try {
-    fs5.appendFileSync(_globalLogFile, line);
+    fs6.appendFileSync(_globalLogFile, line);
   } catch {
   }
 }
@@ -3499,8 +3829,8 @@ var init_logger = __esm({
 
 // packages/domain/shared/src/index.ts
 import { createHash } from "crypto";
-import fs6 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createRequire as createRequire5 } from "module";
 function createLogger2(namespace) {
@@ -3532,9 +3862,9 @@ function createDebugLogger(namespace, label) {
     }
   };
 }
-function formatIssuePath(path14) {
-  if (!path14 || path14.length === 0) return "(root)";
-  return path14.map(
+function formatIssuePath(path15) {
+  if (!path15 || path15.length === 0) return "(root)";
+  return path15.map(
     (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
   ).join(".");
 }
@@ -3542,9 +3872,9 @@ function loadNativeBinding(options) {
   const { runtimeDir, candidates, isValid } = options;
   const loadErrors = [];
   for (const candidate of candidates) {
-    const candidatePath = path7.resolve(runtimeDir, candidate);
+    const candidatePath = path8.resolve(runtimeDir, candidate);
     try {
-      if (!fs6.existsSync(candidatePath) && !fs6.existsSync(candidatePath + ".node")) {
+      if (!fs7.existsSync(candidatePath) && !fs7.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -3576,9 +3906,9 @@ function resolveNativeBindingCandidates(options) {
     }
   }
   if (!includeDefaultCandidates) return candidates;
-  if (fs6.existsSync(runtimeDir)) {
+  if (fs7.existsSync(runtimeDir)) {
     try {
-      for (const entry of fs6.readdirSync(runtimeDir)) {
+      for (const entry of fs7.readdirSync(runtimeDir)) {
         if (entry.endsWith(".node")) candidates.push(entry);
       }
     } catch {
@@ -3587,22 +3917,22 @@ 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(path7.resolve(runtimeDir, `${bin}.node`));
-    candidates.push(path7.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
-    candidates.push(path7.resolve(runtimeDir, "..", "native", `${bin}.node`));
-    candidates.push(path7.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path7.resolve(process.cwd(), "native", `${bin}.node`));
-    candidates.push(path7.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path7.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
-    candidates.push(path7.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path7.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path8.resolve(runtimeDir, `${bin}.node`));
+    candidates.push(path8.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
+    candidates.push(path8.resolve(runtimeDir, "..", "native", `${bin}.node`));
+    candidates.push(path8.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path8.resolve(process.cwd(), "native", `${bin}.node`));
+    candidates.push(path8.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path8.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path8.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path8.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
   }
   return Array.from(new Set(candidates));
 }
 function resolveRuntimeDir(dir, importMetaUrl) {
-  if (dir) return path7.resolve(dir);
+  if (dir) return path8.resolve(dir);
   try {
-    return path7.dirname(fileURLToPath2(importMetaUrl));
+    return path8.dirname(fileURLToPath2(importMetaUrl));
   } catch {
     return process.cwd();
   }
@@ -3649,8 +3979,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 path14 = formatIssuePath(first?.path);
-        const message = first ? `${path14}: ${first.message}` : "Schema validation failed";
+        const path15 = formatIssuePath(first?.path);
+        const message = first ? `${path15}: ${first.message}` : "Schema validation failed";
         return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
       }
       static wrap(source, code, err) {
@@ -3704,14 +4034,14 @@ __export(native_bridge_exports, {
   startWatchNative: () => startWatchNative,
   stopWatchNative: () => stopWatchNative
 });
-import path8 from "path";
+import path9 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function getDirname2() {
   if (typeof __dirname !== "undefined") {
     return __dirname;
   }
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    return path8.dirname(fileURLToPath3(import.meta.url));
+    return path9.dirname(fileURLToPath3(import.meta.url));
   }
   return process.cwd();
 }
@@ -4047,27 +4377,27 @@ var parseNextAdapterOptions = (options) => parseWithSchema(NextAdapterOptionsSch
 // packages/presentation/next/src/withTailwindStyled.ts
 init_esm_shims();
 init_src2();
-import fs11 from "fs";
+import fs12 from "fs";
 import { createRequire as createRequire7 } from "module";
-import path13 from "path";
+import path14 from "path";
 
 // packages/domain/scanner/src/index.ts
 init_esm_shims();
 init_src2();
-import fs8 from "fs";
+import fs9 from "fs";
 import { createRequire as createRequire6 } from "module";
-import path10 from "path";
+import path11 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { Worker } from "worker_threads";
 
 // packages/domain/scanner/src/cache-native.ts
 init_esm_shims();
 init_native_bridge();
-import fs7 from "fs";
-import path9 from "path";
+import fs8 from "fs";
+import path10 from "path";
 function defaultCachePath(rootDir, cacheDir) {
-  const dir = cacheDir ? path9.resolve(rootDir, cacheDir) : path9.join(process.cwd(), ".cache", "tailwind-styled");
-  return path9.join(dir, "scanner-cache.json");
+  const dir = cacheDir ? path10.resolve(rootDir, cacheDir) : path10.join(process.cwd(), ".cache", "tailwind-styled");
+  return path10.join(dir, "scanner-cache.json");
 }
 function metaPathFor(cachePath) {
   return cachePath.replace(/\.json$/, ".meta.json");
@@ -4081,7 +4411,7 @@ function getBinaryFingerprint() {
       _cachedFingerprint = null;
       return null;
     }
-    const stat = fs7.statSync(loadedPath);
+    const stat = fs8.statSync(loadedPath);
     _cachedFingerprint = `${stat.mtimeMs}:${stat.size}`;
   } catch {
     _cachedFingerprint = null;
@@ -4091,13 +4421,13 @@ function getBinaryFingerprint() {
 var STALE_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1e3;
 function readCache(rootDir, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs7.mkdirSync(path9.dirname(cachePath), { recursive: true });
+  fs8.mkdirSync(path10.dirname(cachePath), { recursive: true });
   const currentFingerprint = getBinaryFingerprint();
   if (currentFingerprint !== null) {
     const metaPath = metaPathFor(cachePath);
     let storedFingerprint = null;
     try {
-      storedFingerprint = JSON.parse(fs7.readFileSync(metaPath, "utf8")).binaryFingerprint ?? null;
+      storedFingerprint = JSON.parse(fs8.readFileSync(metaPath, "utf8")).binaryFingerprint ?? null;
     } catch {
     }
     if (storedFingerprint !== currentFingerprint) {
@@ -4121,7 +4451,7 @@ function readCache(rootDir, cacheDir) {
 }
 function writeCache(rootDir, entries, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs7.mkdirSync(path9.dirname(cachePath), { recursive: true });
+  fs8.mkdirSync(path10.dirname(cachePath), { recursive: true });
   const success = cacheWriteNative(cachePath, entries);
   if (!success) {
     throw new Error(
@@ -4131,7 +4461,7 @@ function writeCache(rootDir, entries, cacheDir) {
   const currentFingerprint = getBinaryFingerprint();
   if (currentFingerprint !== null) {
     try {
-      fs7.writeFileSync(
+      fs8.writeFileSync(
         metaPathFor(cachePath),
         JSON.stringify({ binaryFingerprint: currentFingerprint }),
         "utf8"
@@ -4159,12 +4489,12 @@ init_native_bridge();
 init_esm_shims();
 init_src2();
 import { z as z2 } from "zod";
-var formatIssuePath2 = (path14) => path14.length > 0 ? path14.map(
+var formatIssuePath2 = (path15) => path15.length > 0 ? path15.map(
   (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
 ).join(".") : "<root>";
 var formatIssues2 = (error) => error.issues.map((issue) => {
-  const path14 = formatIssuePath2(issue.path);
-  return `${path14}: ${issue.message}`;
+  const path15 = formatIssuePath2(issue.path);
+  return `${path15}: ${issue.message}`;
 }).join("; ");
 var parseWithSchema2 = (schema, data, label) => {
   const parsed = schema.safeParse(data);
@@ -4224,7 +4554,7 @@ function getRuntimeDir() {
     return __dirname;
   }
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    return path10.dirname(fileURLToPath4(import.meta.url));
+    return path11.dirname(fileURLToPath4(import.meta.url));
   }
   return process.cwd();
 }
@@ -4239,7 +4569,7 @@ var createNativeParserLoader = () => {
   const loadNativeParserBinding = () => {
     if (_state.binding !== void 0) return _state.binding;
     const runtimeDir = getRuntimeDir();
-    const req = createRequire6(path10.join(runtimeDir, "noop.cjs"));
+    const req = createRequire6(path11.join(runtimeDir, "noop.cjs"));
     const _platform = process.platform;
     const _arch = process.arch;
     const _platformArch = `${_platform}-${_arch}`;
@@ -4247,27 +4577,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.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
-      path10.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
-      path10.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path11.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
+      path11.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
+      path11.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.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
-      path10.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
-      path10.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path11.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
+      path11.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
+      path11.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // runtimeDir = dist/ → naik 4 level ke repo root (monorepo dev case)
-      path10.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
-      path10.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path11.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
+      path11.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // 3 level fallback (jika package di-nest lebih dangkal)
-      path10.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
-      path10.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path11.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
+      path11.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // ── binaryName lama: tailwind_styled_parser (backward compat) ──
-      path10.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
-      path10.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
-      path10.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
-      path10.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
-      path10.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
-      path10.resolve(
+      path11.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
+      path11.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
+      path11.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
+      path11.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
+      path11.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
+      path11.resolve(
         runtimeDir,
         "..",
         "..",
@@ -4279,7 +4609,7 @@ var createNativeParserLoader = () => {
       )
     ];
     for (const fullPath of candidates) {
-      if (!fs8.existsSync(fullPath)) continue;
+      if (!fs9.existsSync(fullPath)) continue;
       try {
         const required = req(fullPath);
         if (required && (typeof required.extractClassesFromSource === "function" || typeof required.parseClasses === "function" || typeof required.parse_classes === "function")) {
@@ -4320,19 +4650,19 @@ function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
     if (!currentDir) continue;
     const entries = (() => {
       try {
-        return fs8.readdirSync(currentDir, { withFileTypes: true });
+        return fs9.readdirSync(currentDir, { withFileTypes: true });
       } catch {
         return [];
       }
     })();
     for (const entry of entries) {
-      const fullPath = path10.join(currentDir, entry.name);
+      const fullPath = path11.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (!ignoreDirectories.has(entry.name)) directories.push(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      if (!extensionSet.has(path10.extname(entry.name))) continue;
+      if (!extensionSet.has(path11.extname(entry.name))) continue;
       candidates.push(fullPath);
     }
   }
@@ -4416,7 +4746,7 @@ function scanWorkspace2(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return fs8.statSync(filePath);
+          return fs9.statSync(filePath);
         } catch {
           return null;
         }
@@ -4442,7 +4772,7 @@ function scanWorkspace2(rootDir, options = {}) {
     for (const { filePath, stat, size, cached } of ranked) {
       const content = (() => {
         try {
-          return fs8.readFileSync(filePath, "utf8");
+          return fs9.readFileSync(filePath, "utf8");
         } catch {
           return null;
         }
@@ -4509,8 +4839,8 @@ init_src2();
 // packages/presentation/next/src/incrementalOrchestrator.ts
 init_esm_shims();
 init_src();
-import fs9 from "fs";
-import path11 from "path";
+import fs10 from "fs";
+import path12 from "path";
 var _fingerprintCache = /* @__PURE__ */ new Map();
 function getNative2() {
   try {
@@ -4521,10 +4851,10 @@ function getNative2() {
 }
 function fingerprintFile(filePath) {
   try {
-    const stat = fs9.statSync(filePath);
+    const stat = fs10.statSync(filePath);
     const native = getNative2();
     if (native?.create_fingerprint) {
-      const content = fs9.readFileSync(filePath, "utf-8");
+      const content = fs10.readFileSync(filePath, "utf-8");
       const hash = native.create_fingerprint(filePath, content);
       return { hash, mtime: stat.mtimeMs };
     }
@@ -4564,9 +4894,9 @@ function hasSourceChanged(sourceFiles) {
 }
 function isIncrementalEnabled(cwd) {
   try {
-    const configPath = path11.join(cwd, "tailwind-styled.config.json");
-    if (!fs9.existsSync(configPath)) return false;
-    const config = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
+    const configPath = path12.join(cwd, "tailwind-styled.config.json");
+    if (!fs10.existsSync(configPath)) return false;
+    const config = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
     return config.compiler?.incremental === true;
   } catch {
     return false;
@@ -4575,8 +4905,8 @@ function isIncrementalEnabled(cwd) {
 
 // packages/presentation/next/src/staticCssWebpackPlugin.ts
 init_esm_shims();
-import fs10 from "fs";
-import path12 from "path";
+import fs11 from "fs";
+import path13 from "path";
 var _fileStaticCssMap = /* @__PURE__ */ new Map();
 function setFileStaticCss(filepath, css) {
   if (css && css.trim()) {
@@ -4610,14 +4940,14 @@ var StaticCssWebpackPlugin = class _StaticCssWebpackPlugin {
   static PLUGIN_NAME = "TailwindStyledStaticCss";
   outPath;
   constructor(safelistPath) {
-    this.outPath = path12.join(path12.dirname(safelistPath), "_tw-state-static.css");
+    this.outPath = path13.join(path13.dirname(safelistPath), "_tw-state-static.css");
   }
   apply(compiler) {
     compiler.hooks.done.tap(_StaticCssWebpackPlugin.PLUGIN_NAME, () => {
       try {
         const content = buildContent(_fileStaticCssMap);
-        fs10.mkdirSync(path12.dirname(this.outPath), { recursive: true });
-        fs10.writeFileSync(
+        fs11.mkdirSync(path13.dirname(this.outPath), { recursive: true });
+        fs11.writeFileSync(
           this.outPath,
           HEADER + (content || "/* no static rules yet */") + "\n",
           "utf-8"
@@ -4654,12 +4984,12 @@ var resolveLoaderPath2 = (basename) => {
   } catch {
     const runtimeDir = resolveRuntimeDir2();
     const candidates = [
-      path13.resolve(runtimeDir, `${basename}.mjs`),
-      path13.resolve(runtimeDir, `${basename}.js`),
-      path13.resolve(runtimeDir, `${basename}.cjs`)
+      path14.resolve(runtimeDir, `${basename}.mjs`),
+      path14.resolve(runtimeDir, `${basename}.js`),
+      path14.resolve(runtimeDir, `${basename}.cjs`)
     ];
     for (const candidate of candidates) {
-      if (fs11.existsSync(candidate)) {
+      if (fs12.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -4697,7 +5027,7 @@ var createLoaderOptions = (options) => {
     preserveImports: true
   };
   if (options.verbose !== void 0) opts.verbose = options.verbose;
-  opts.safelistPath = options.safelistPath ?? path13.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
+  opts.safelistPath = options.safelistPath ?? path14.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
   return Object.freeze(opts);
 };
 var buildTurbopackRules = (loaderPath, loaderOptions) => {
@@ -4710,7 +5040,7 @@ var buildTurbopackRules = (loaderPath, loaderOptions) => {
     ])
   );
 };
-var normalizeLoaderPath = (loaderPath) => path13.resolve(loaderPath);
+var normalizeLoaderPath = (loaderPath) => path14.resolve(loaderPath);
 var applyWebpackRule = (config, options, loaderPath) => {
   const loaderOptions = createLoaderOptions(options);
   const rules = config.module?.rules ?? [];
@@ -4727,7 +5057,7 @@ var applyWebpackRule = (config, options, loaderPath) => {
     enforce: "pre",
     use: [{ loader: loaderPath, options: loaderOptions }]
   };
-  const safelistPath = loaderOptions.safelistPath ?? path13.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
+  const safelistPath = loaderOptions.safelistPath ?? path14.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
   const pluginAlreadyRegistered = (config.plugins ?? []).some(
     (p) => p?.constructor?.name === StaticCssWebpackPlugin.PLUGIN_NAME
   );
@@ -4827,17 +5157,17 @@ function withTailwindStyled(options = {}) {
           return fullCss.slice(startIdx, endIdx + 1);
         };
         var extractUtilitiesLayer = extractUtilitiesLayer2;
-        const twClassesDir = path13.join(path13.dirname(safelistPath), "tw-classes");
-        fs11.mkdirSync(twClassesDir, { recursive: true });
-        setGlobalLogFile(path13.join(twClassesDir, "_tw-build.log"));
-        fs11.writeFileSync(
-          path13.join(twClassesDir, "_start.txt"),
+        const twClassesDir = path14.join(path14.dirname(safelistPath), "tw-classes");
+        fs12.mkdirSync(twClassesDir, { recursive: true });
+        setGlobalLogFile(path14.join(twClassesDir, "_tw-build.log"));
+        fs12.writeFileSync(
+          path14.join(twClassesDir, "_start.txt"),
           String(Date.now()),
           "utf-8"
         );
-        const stateStaticPath = path13.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+        const stateStaticPath = path14.join(twClassesDir, TW_STATE_STATIC_FILENAME);
         try {
-          fs11.writeFileSync(
+          fs12.writeFileSync(
             stateStaticPath,
             "/* tw-state-static.css \u2014 placeholder, akan di-generate setelah scan */\n",
             "utf-8"
@@ -4853,14 +5183,14 @@ function withTailwindStyled(options = {}) {
             "src/index.css",
             "styles/globals.css"
           ];
-          const safelistDir = path13.dirname(safelistPath);
+          const safelistDir = path14.dirname(safelistPath);
           for (const candidate of CSS_CANDIDATES) {
-            const candidatePath = path13.join(process.cwd(), candidate);
-            if (!fs11.existsSync(candidatePath)) continue;
-            const content = fs11.readFileSync(candidatePath, "utf-8");
+            const candidatePath = path14.join(process.cwd(), candidate);
+            if (!fs12.existsSync(candidatePath)) continue;
+            const content = fs12.readFileSync(candidatePath, "utf-8");
             if (content.includes("_tw-state-static.css")) break;
-            const globalsDir = path13.dirname(candidatePath);
-            const rel = path13.relative(globalsDir, stateStaticPath).replace(/\\/g, "/");
+            const globalsDir = path14.dirname(candidatePath);
+            const rel = path14.relative(globalsDir, stateStaticPath).replace(/\\/g, "/");
             const importLine = `@import "./${rel}";`;
             const tailwindImportRe = /(@import\s+["']tailwindcss["']\s*;[^\n]*\n?)/;
             let updated;
@@ -4874,7 +5204,7 @@ function withTailwindStyled(options = {}) {
               updated = `${importLine}
 ${content}`;
             }
-            fs11.writeFileSync(candidatePath, updated, "utf-8");
+            fs12.writeFileSync(candidatePath, updated, "utf-8");
             if (options.verbose) {
               console.log(
                 `[tailwind-styled] Auto-injected "${importLine}" into ${candidate}`
@@ -4886,27 +5216,27 @@ ${content}`;
         }
         if (!process.env.TW_NATIVE_PATH) {
           const runtimeDir = resolveRuntimeDir2();
-          const nativePath = path13.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node");
-          if (fs11.existsSync(nativePath)) {
+          const nativePath = path14.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node");
+          if (fs12.existsSync(nativePath)) {
             process.env.TW_NATIVE_PATH = nativePath;
           }
         }
-        const srcDir = path13.join(process.cwd(), "src");
-        if (fs11.existsSync(srcDir)) {
+        const srcDir = path14.join(process.cwd(), "src");
+        if (fs12.existsSync(srcDir)) {
           try {
             const result = scanWorkspace2(srcDir);
             if (result.uniqueClasses.length > 0) {
               let atomicWriteFile2 = function(filePath, content) {
                 const tmpPath = `${filePath}.tmp`;
                 try {
-                  fs11.writeFileSync(tmpPath, content, "utf-8");
-                  fs11.renameSync(tmpPath, filePath);
+                  fs12.writeFileSync(tmpPath, content, "utf-8");
+                  fs12.renameSync(tmpPath, filePath);
                 } catch {
                   try {
-                    fs11.unlinkSync(tmpPath);
+                    fs12.unlinkSync(tmpPath);
                   } catch {
                   }
-                  fs11.writeFileSync(filePath, content, "utf-8");
+                  fs12.writeFileSync(filePath, content, "utf-8");
                 }
               };
               var atomicWriteFile = atomicWriteFile2;
@@ -4970,14 +5300,14 @@ ${content}`;
                 "styles/globals.css"
               ];
               try {
-                const twConfigPath = path13.join(process.cwd(), "tailwind-styled.config.json");
-                if (fs11.existsSync(twConfigPath)) {
-                  const twConfig = JSON.parse(fs11.readFileSync(twConfigPath, "utf-8"));
+                const twConfigPath = path14.join(process.cwd(), "tailwind-styled.config.json");
+                if (fs12.existsSync(twConfigPath)) {
+                  const twConfig = JSON.parse(fs12.readFileSync(twConfigPath, "utf-8"));
                   const cssEntry = twConfig.css?.entry;
                   if (cssEntry) {
-                    const cssEntryPath = path13.join(process.cwd(), cssEntry);
-                    if (fs11.existsSync(cssEntryPath)) {
-                      cssEntryContent = fs11.readFileSync(cssEntryPath, "utf-8");
+                    const cssEntryPath = path14.join(process.cwd(), cssEntry);
+                    if (fs12.existsSync(cssEntryPath)) {
+                      cssEntryContent = fs12.readFileSync(cssEntryPath, "utf-8");
                     }
                   }
                 }
@@ -4985,9 +5315,9 @@ ${content}`;
               }
               if (!cssEntryContent) {
                 for (const candidate of CSS_CANDIDATES) {
-                  const candidatePath = path13.join(process.cwd(), candidate);
-                  if (fs11.existsSync(candidatePath)) {
-                    cssEntryContent = fs11.readFileSync(candidatePath, "utf-8");
+                  const candidatePath = path14.join(process.cwd(), candidate);
+                  if (fs12.existsSync(candidatePath)) {
+                    cssEntryContent = fs12.readFileSync(candidatePath, "utf-8");
                     break;
                   }
                 }
@@ -4995,8 +5325,8 @@ ${content}`;
               if (cssEntryContent) {
                 cssEntryContent = cssEntryContent.replace(/@source\s+["'][^"']+["']\s*;?\s*/g, "").replace(/←[^\n]*/g, "").trim();
               }
-              const initialScanPath = path13.join(twClassesDir, "_initial-scan.css");
-              if (!fs11.existsSync(initialScanPath)) {
+              const initialScanPath = path14.join(twClassesDir, "_initial-scan.css");
+              if (!fs12.existsSync(initialScanPath)) {
                 atomicWriteFile2(
                   initialScanPath,
                   "/* tw-classes: initial scan \u2014 generating... */\n@layer utilities {}\n"
@@ -5004,7 +5334,7 @@ ${content}`;
               }
               const sourceFiles = result.files?.map((f) => f.file) ?? [];
               const incremental = isIncrementalEnabled(process.cwd());
-              if (incremental && fs11.existsSync(initialScanPath) && !hasSourceChanged(sourceFiles)) {
+              if (incremental && fs12.existsSync(initialScanPath) && !hasSourceChanged(sourceFiles)) {
                 if (options.verbose) console.log("[tailwind-styled] Incremental: tidak ada perubahan, skip regenerate CSS");
               } else {
                 void (async () => {
@@ -5045,8 +5375,8 @@ ${utilitiesOnly}`
                             classes: f.classes.filter(isValidTwClass)
                           }));
                           const buckets = buildRouteClassBuckets2(process.cwd(), srcDir, filesForGraph);
-                          const cssManifestDir = path13.join(process.cwd(), ".next", "static", "css", "tw");
-                          fs11.mkdirSync(cssManifestDir, { recursive: true });
+                          const cssManifestDir = path14.join(process.cwd(), ".next", "static", "css", "tw");
+                          fs12.mkdirSync(cssManifestDir, { recursive: true });
                           const manifestRoutes = {};
                           const usedFilenames = /* @__PURE__ */ new Set(["_global.css"]);
                           const minifyManifestCss = process.env.NODE_ENV === "production";
@@ -5061,7 +5391,7 @@ ${utilitiesOnly}`
                             const globalUtilities = extractUtilitiesLayer2(globalCss);
                             if (globalUtilities.trim()) {
                               const filename = "_global.css";
-                              atomicWriteFile2(path13.join(cssManifestDir, filename), globalUtilities);
+                              atomicWriteFile2(path14.join(cssManifestDir, filename), globalUtilities);
                               manifestRoutes.__global = filename;
                             }
                           }
@@ -5083,11 +5413,11 @@ ${utilitiesOnly}`
                               suffix++;
                             }
                             usedFilenames.add(filename);
-                            atomicWriteFile2(path13.join(cssManifestDir, filename), routeUtilities);
+                            atomicWriteFile2(path14.join(cssManifestDir, filename), routeUtilities);
                             manifestRoutes[route] = filename;
                           }
                           atomicWriteFile2(
-                            path13.join(cssManifestDir, "css-manifest.json"),
+                            path14.join(cssManifestDir, "css-manifest.json"),
                             JSON.stringify({ routes: manifestRoutes }, null, 2)
                           );
                           if (options.verbose) {