tailwind-styled-v4 5.1.22 → 5.1.23

package/dist/next.js

@@ -66,11 +66,11 @@ function resolvePath(...segments) {
     return segments.join("/").replace(/\/+/g, "/");
   }
 }
-function existsSync(path13) {
+function existsSync(path14) {
   if (isBrowser) return false;
   try {
     const nodeFs = require(NODE_FS);
-    return nodeFs.existsSync(path13);
+    return nodeFs.existsSync(path14);
   } catch {
     return false;
   }
@@ -252,7 +252,7 @@ var init_nativeBridge = __esm({
     "use strict";
     init_cjs_shims();
     init_src2();
-    _loadNative = (path13) => require(path13);
+    _loadNative = (path14) => require(path14);
     log = (...args) => {
       if (process.env.DEBUG?.includes("compiler:native")) {
         console.log("[compiler:native]", ...args);
@@ -2290,6 +2290,321 @@ 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_cjs_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_cjs_shims();
+  }
+});
+
+// packages/domain/compiler/src/typeGenerationPlugin.ts
+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 = import_node_path2.default.dirname(outputPath);
+  if (!import_node_fs2.default.existsSync(dir)) {
+    import_node_fs2.default.mkdirSync(dir, { recursive: true });
+  }
+  import_node_fs2.default.writeFileSync(outputPath, typeContent, "utf8");
+  console.log(`Generated type stubs \u2192 ${outputPath} (${components.size} components)`);
+}
+var import_node_fs2, import_node_path2;
+var init_typeGenerationPlugin = __esm({
+  "packages/domain/compiler/src/typeGenerationPlugin.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_fs2 = __toESM(require("fs"), 1);
+    import_node_path2 = __toESM(require("path"), 1);
+    init_semanticComponentAnalyzer();
+    init_typeGeneratorFromMetadata();
+  }
+});
+
 // packages/domain/compiler/src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -2299,6 +2614,8 @@ __export(src_exports, {
   analyzeClassUsageNative: () => analyzeClassUsageNative,
   analyzeClasses: () => analyzeClasses,
   analyzeClassesNative: () => analyzeClassesNative,
+  analyzeComponentBatch: () => analyzeComponentBatch,
+  analyzeComponentSemantics: () => analyzeComponentSemantics,
   analyzeFile: () => analyzeFile,
   analyzeRscNative: () => analyzeRscNative,
   analyzeVariantUsage: () => analyzeVariantUsage,
@@ -2325,6 +2642,7 @@ __export(src_exports, {
   clearResolverPool: () => clearResolverPool,
   clearThemeCache: () => clearThemeCache,
   collectFiles: () => collectFiles,
+  combineTypeDefinitions: () => combineTypeDefinitions,
   compileAnimation: () => compileAnimation,
   compileClass: () => compileClass,
   compileClasses: () => compileClasses,
@@ -2338,6 +2656,7 @@ __export(src_exports, {
   compileVariantTableNative: () => compileVariantTableNative,
   computeIncrementalDiff: () => computeIncrementalDiff,
   createFingerprint: () => createFingerprint,
+  createTypeGenerationPlugin: () => createTypeGenerationPlugin,
   detectConflicts: () => detectConflicts,
   detectDeadCode: () => detectDeadCode,
   diffClassLists: () => diffClassLists,
@@ -2353,6 +2672,7 @@ __export(src_exports, {
   extractClassesFromSourceNative: () => extractClassesFromSourceNative,
   extractComponentUsage: () => extractComponentUsage,
   extractContainerCssFromSource: () => extractContainerCssFromSource,
+  extractSemanticMetadata: () => extractSemanticMetadata,
   extractTwContainerConfigs: () => extractTwContainerConfigs,
   extractTwStateConfigs: () => extractTwStateConfigs,
   extractTwStateConfigsNative: () => extractTwStateConfigsNative,
@@ -2367,8 +2687,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,
@@ -2464,6 +2790,7 @@ __export(src_exports, {
   registerPluginHook: () => registerPluginHook,
   registerPropertyName: () => registerPropertyName,
   registerValueName: () => registerValueName,
+  renderTypeDefinition: () => renderTypeDefinition,
   resetBucketEngine: () => resetBucketEngine,
   resetCacheStats: () => resetCacheStats,
   resetCompilationMetrics: () => resetCompilationMetrics,
@@ -2506,6 +2833,7 @@ __export(src_exports, {
   twMergeWithSeparator: () => twMergeWithSeparator,
   unregisterPluginHook: () => unregisterPluginHook,
   validateCssOutput: () => validateCssOutput,
+  validateSemanticMetadata: () => validateSemanticMetadata,
   validateThemeConfig: () => validateThemeConfig,
   valueIdToString: () => valueIdToString,
   walkAndPrefilterSourceFiles: () => walkAndPrefilterSourceFiles,
@@ -2551,13 +2879,13 @@ function extractContainerCssFromSource(source) {
   }
   return rules.join("\n");
 }
-var import_node_fs2, import_node_path2, import_node_module4, _require2, transformSource, hasTwUsage, isAlreadyTransformed, shouldProcess, compileCssFromClasses, buildStyleTag, generateCssForClasses, eliminateDeadCss, findDeadVariants, runElimination, scanProjectUsage, generateSafelist, loadSafelist, loadTailwindConfig, getContentPaths, _CONTAINER_BREAKPOINTS, runLoaderTransform, shouldSkipFile, fileToRoute, getAllRoutes, _fileClassesMap, _globalClasses, getRouteClasses, getAllRegisteredClasses, registerFileClasses, registerGlobalClasses, resetRouteClassRegistry, _incrementalEngineInstance, getIncrementalEngine, resetIncrementalEngine, IncrementalEngine, getBucketEngine, resetBucketEngine, BucketEngine, classifyNode, detectConflicts, bucketSort, analyzeFile, analyzeVariantUsage, injectClientDirective, injectServerOnlyComment, analyzeClasses, extractTwStateConfigs, generateStaticStateCss, extractAndGenerateStateCss;
+var import_node_fs3, import_node_path3, import_node_module4, _require2, transformSource, hasTwUsage, isAlreadyTransformed, shouldProcess, compileCssFromClasses, buildStyleTag, generateCssForClasses, eliminateDeadCss, findDeadVariants, runElimination, scanProjectUsage, generateSafelist, loadSafelist, loadTailwindConfig, getContentPaths, _CONTAINER_BREAKPOINTS, runLoaderTransform, shouldSkipFile, fileToRoute, getAllRoutes, _fileClassesMap, _globalClasses, getRouteClasses, getAllRegisteredClasses, registerFileClasses, registerGlobalClasses, resetRouteClassRegistry, _incrementalEngineInstance, getIncrementalEngine, resetIncrementalEngine, IncrementalEngine, getBucketEngine, resetBucketEngine, BucketEngine, classifyNode, detectConflicts, bucketSort, analyzeFile, analyzeVariantUsage, injectClientDirective, injectServerOnlyComment, analyzeClasses, extractTwStateConfigs, generateStaticStateCss, extractAndGenerateStateCss;
 var init_src = __esm({
   "packages/domain/compiler/src/index.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs2 = __toESM(require("fs"), 1);
-    import_node_path2 = __toESM(require("path"), 1);
+    import_node_fs3 = __toESM(require("fs"), 1);
+    import_node_path3 = __toESM(require("path"), 1);
     import_node_module4 = require("module");
     init_nativeBridge();
     init_compiler();
@@ -2567,6 +2895,9 @@ var init_src = __esm({
     init_redis();
     init_watch();
     init_routeGraph();
+    init_semanticComponentAnalyzer();
+    init_typeGeneratorFromMetadata();
+    init_typeGenerationPlugin();
     _require2 = (0, import_node_module4.createRequire)(
       typeof require !== "undefined" ? typeof __filename !== "undefined" ? `file://${__filename}` : "file://unknown" : importMetaUrl
     );
@@ -2661,7 +2992,7 @@ var init_src = __esm({
     };
     scanProjectUsage = (dirs, cwd) => {
       const { batchExtractClasses: batchExtractClasses2 } = _require2("./parser");
-      const files = dirs.map((dir) => import_node_path2.default.resolve(cwd, dir));
+      const files = dirs.map((dir) => import_node_path3.default.resolve(cwd, dir));
       const results = batchExtractClasses2(files) || [];
       const combined = {};
       for (const result of results) {
@@ -2678,13 +3009,13 @@ var init_src = __esm({
       const classes = scanProjectUsage(scanDirs, cwd || process.cwd());
       const allClasses = Object.keys(classes).sort();
       if (outputPath) {
-        import_node_fs2.default.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
+        import_node_fs3.default.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
       }
       return allClasses;
     };
     loadSafelist = (safelistPath) => {
       try {
-        const content = import_node_fs2.default.readFileSync(safelistPath, "utf-8");
+        const content = import_node_fs3.default.readFileSync(safelistPath, "utf-8");
         return JSON.parse(content);
       } catch {
         return [];
@@ -2698,8 +3029,8 @@ var init_src = __esm({
         "tailwind.config.cjs"
       ];
       for (const file of configFiles) {
-        const fullPath = import_node_path2.default.join(cwd, file);
-        if (import_node_fs2.default.existsSync(fullPath)) {
+        const fullPath = import_node_path3.default.join(cwd, file);
+        if (import_node_fs3.default.existsSync(fullPath)) {
           const mod = require(fullPath);
           return mod.default || mod;
         }
@@ -2709,9 +3040,9 @@ var init_src = __esm({
     getContentPaths = (cwd = process.cwd()) => {
       return {
         content: [
-          import_node_path2.default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
-          import_node_path2.default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
-          import_node_path2.default.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
+          import_node_path3.default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
+          import_node_path3.default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
+          import_node_path3.default.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
         ]
       };
     };
@@ -3203,17 +3534,17 @@ function getNative() {
 function* walkSourceFiles(dir) {
   let entries;
   try {
-    entries = import_node_fs3.default.readdirSync(dir, { withFileTypes: true });
+    entries = import_node_fs4.default.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = import_node_path3.default.join(dir, entry.name);
+    const fullPath = import_node_path4.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 = import_node_path3.default.extname(entry.name);
+      const ext = import_node_path4.default.extname(entry.name);
       if (SOURCE_EXTENSIONS.has(ext)) yield fullPath;
     }
   }
@@ -3277,7 +3608,7 @@ function extractStaticStateCss(srcDir, options = {}) {
         allConfigs.push(...configs);
         if (verbose) {
           process.stderr.write(
-            `[tw:static-state] ${import_node_path3.default.relative(srcDir, filePath)}: ${configs.length} komponen
+            `[tw:static-state] ${import_node_path4.default.relative(srcDir, filePath)}: ${configs.length} komponen
 `
           );
         }
@@ -3288,7 +3619,7 @@ function extractStaticStateCss(srcDir, options = {}) {
       if (filesScanned >= maxFiles) break;
       let source;
       try {
-        source = import_node_fs3.default.readFileSync(filePath, "utf-8");
+        source = import_node_fs4.default.readFileSync(filePath, "utf-8");
       } catch {
         continue;
       }
@@ -3301,7 +3632,7 @@ function extractStaticStateCss(srcDir, options = {}) {
         allConfigs.push(...configs);
         if (verbose) {
           process.stderr.write(
-            `[tw:static-state] ${import_node_path3.default.relative(srcDir, filePath)}: ${configs.length} komponen
+            `[tw:static-state] ${import_node_path4.default.relative(srcDir, filePath)}: ${configs.length} komponen
 `
           );
         }
@@ -3395,12 +3726,12 @@ function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
     resolvedCss: options.resolvedCss || ""
     // ← ensure always passed
   });
-  const twClassesDir = import_node_path3.default.join(import_node_path3.default.dirname(safelistPath), "tw-classes");
-  import_node_fs3.default.mkdirSync(twClassesDir, { recursive: true });
-  const stateFilePath = import_node_path3.default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+  const twClassesDir = import_node_path4.default.join(import_node_path4.default.dirname(safelistPath), "tw-classes");
+  import_node_fs4.default.mkdirSync(twClassesDir, { recursive: true });
+  const stateFilePath = import_node_path4.default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
   if (result.rulesGenerated === 0) {
     try {
-      import_node_fs3.default.writeFileSync(
+      import_node_fs4.default.writeFileSync(
         stateFilePath,
         "/* tw-state-static.css \u2014 tidak ada state rules yang di-generate */\n",
         "utf-8"
@@ -3410,7 +3741,7 @@ function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
     return `[tw:static-state] tidak ada state rules yang di-generate (${result.filesScanned} files di-scan)`;
   }
   try {
-    import_node_fs3.default.writeFileSync(stateFilePath, result.generatedCss, "utf-8");
+    import_node_fs4.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`,
@@ -3422,13 +3753,13 @@ function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
     return `[tw:static-state] gagal tulis state CSS: ${msg}`;
   }
 }
-var import_node_fs3, import_node_path3, SOURCE_EXTENSIONS, IGNORE_PATTERNS, _native, TW_STATE_STATIC_FILENAME;
+var import_node_fs4, import_node_path4, SOURCE_EXTENSIONS, IGNORE_PATTERNS, _native, TW_STATE_STATIC_FILENAME;
 var init_staticStateExtractor = __esm({
   "packages/domain/shared/src/staticStateExtractor.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs3 = __toESM(require("fs"));
-    import_node_path3 = __toESM(require("path"));
+    import_node_fs4 = __toESM(require("fs"));
+    import_node_path4 = __toESM(require("path"));
     SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"]);
     IGNORE_PATTERNS = ["node_modules", ".next", "dist", "build", ".git", "coverage", "__tests__"];
     _native = null;
@@ -3446,8 +3777,8 @@ function setGlobalLogFile(filePath) {
   _globalLogFile = filePath;
   _logFileInitialized = false;
   try {
-    import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(filePath), { recursive: true });
-    import_node_fs4.default.writeFileSync(
+    import_node_fs5.default.mkdirSync(import_node_path5.default.dirname(filePath), { recursive: true });
+    import_node_fs5.default.writeFileSync(
       filePath,
       `# tailwind-styled build log \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}
 `,
@@ -3460,7 +3791,7 @@ function setGlobalLogFile(filePath) {
 function writeToFile(line) {
   if (!_globalLogFile || !_logFileInitialized) return;
   try {
-    import_node_fs4.default.appendFileSync(_globalLogFile, line);
+    import_node_fs5.default.appendFileSync(_globalLogFile, line);
   } catch {
   }
 }
@@ -3487,13 +3818,13 @@ function createLogger(prefix, level) {
     setLogFile: (filePath) => setGlobalLogFile(filePath)
   };
 }
-var import_node_fs4, import_node_path4, LEVELS, _globalLogFile, _logFileInitialized, logger;
+var import_node_fs5, import_node_path5, LEVELS, _globalLogFile, _logFileInitialized, logger;
 var init_logger = __esm({
   "packages/domain/shared/src/logger.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs4 = __toESM(require("fs"));
-    import_node_path4 = __toESM(require("path"));
+    import_node_fs5 = __toESM(require("fs"));
+    import_node_path5 = __toESM(require("path"));
     LEVELS = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
     _globalLogFile = null;
     _logFileInitialized = false;
@@ -3531,9 +3862,9 @@ function createDebugLogger(namespace, label) {
     }
   };
 }
-function formatIssuePath(path13) {
-  if (!path13 || path13.length === 0) return "(root)";
-  return path13.map(
+function formatIssuePath(path14) {
+  if (!path14 || path14.length === 0) return "(root)";
+  return path14.map(
     (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
   ).join(".");
 }
@@ -3541,9 +3872,9 @@ function loadNativeBinding(options) {
   const { runtimeDir, candidates, isValid } = options;
   const loadErrors = [];
   for (const candidate of candidates) {
-    const candidatePath = import_node_path5.default.resolve(runtimeDir, candidate);
+    const candidatePath = import_node_path6.default.resolve(runtimeDir, candidate);
     try {
-      if (!import_node_fs5.default.existsSync(candidatePath) && !import_node_fs5.default.existsSync(candidatePath + ".node")) {
+      if (!import_node_fs6.default.existsSync(candidatePath) && !import_node_fs6.default.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -3575,9 +3906,9 @@ function resolveNativeBindingCandidates(options) {
     }
   }
   if (!includeDefaultCandidates) return candidates;
-  if (import_node_fs5.default.existsSync(runtimeDir)) {
+  if (import_node_fs6.default.existsSync(runtimeDir)) {
     try {
-      for (const entry of import_node_fs5.default.readdirSync(runtimeDir)) {
+      for (const entry of import_node_fs6.default.readdirSync(runtimeDir)) {
         if (entry.endsWith(".node")) candidates.push(entry);
       }
     } catch {
@@ -3586,34 +3917,34 @@ 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(import_node_path5.default.resolve(runtimeDir, `${bin}.node`));
-    candidates.push(import_node_path5.default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
-    candidates.push(import_node_path5.default.resolve(runtimeDir, "..", "native", `${bin}.node`));
-    candidates.push(import_node_path5.default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(import_node_path5.default.resolve(process.cwd(), "native", `${bin}.node`));
-    candidates.push(import_node_path5.default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(import_node_path5.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
-    candidates.push(import_node_path5.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(import_node_path5.default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(import_node_path6.default.resolve(runtimeDir, `${bin}.node`));
+    candidates.push(import_node_path6.default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
+    candidates.push(import_node_path6.default.resolve(runtimeDir, "..", "native", `${bin}.node`));
+    candidates.push(import_node_path6.default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(import_node_path6.default.resolve(process.cwd(), "native", `${bin}.node`));
+    candidates.push(import_node_path6.default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(import_node_path6.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(import_node_path6.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(import_node_path6.default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
   }
   return Array.from(new Set(candidates));
 }
 function resolveRuntimeDir(dir, importMetaUrl2) {
-  if (dir) return import_node_path5.default.resolve(dir);
+  if (dir) return import_node_path6.default.resolve(dir);
   try {
-    return import_node_path5.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl2));
+    return import_node_path6.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl2));
   } catch {
     return process.cwd();
   }
 }
-var import_node_crypto, import_node_fs5, import_node_path5, import_node_url, import_node_module5, TwError, _require3;
+var import_node_crypto, import_node_fs6, import_node_path6, import_node_url, import_node_module5, TwError, _require3;
 var init_src2 = __esm({
   "packages/domain/shared/src/index.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_crypto = require("crypto");
-    import_node_fs5 = __toESM(require("fs"));
-    import_node_path5 = __toESM(require("path"));
+    import_node_fs6 = __toESM(require("fs"));
+    import_node_path6 = __toESM(require("path"));
     import_node_url = require("url");
     import_node_module5 = require("module");
     init_workerResolver();
@@ -3653,8 +3984,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 path13 = formatIssuePath(first?.path);
-        const message = first ? `${path13}: ${first.message}` : "Schema validation failed";
+        const path14 = formatIssuePath(first?.path);
+        const message = first ? `${path14}: ${first.message}` : "Schema validation failed";
         return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
       }
       static wrap(source, code, err) {
@@ -3713,7 +4044,7 @@ function getDirname() {
     return __dirname;
   }
   if (typeof import_meta4 !== "undefined" && importMetaUrl) {
-    return import_node_path6.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
+    return import_node_path7.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
   }
   return process.cwd();
 }
@@ -3925,12 +4256,12 @@ function hasNativeWatchBinding() {
     return false;
   }
 }
-var import_node_path6, import_node_url2, import_meta4, log2, isValidScannerBinding, createScannerBridgeLoader, scannerBridgeLoader, scannerGetBinding, resetScannerBridgeCache;
+var import_node_path7, import_node_url2, import_meta4, log2, isValidScannerBinding, createScannerBridgeLoader, scannerBridgeLoader, scannerGetBinding, resetScannerBridgeCache;
 var init_native_bridge = __esm({
   "packages/domain/scanner/src/native-bridge.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_path6 = __toESM(require("path"), 1);
+    import_node_path7 = __toESM(require("path"), 1);
     import_node_url2 = require("url");
     init_src2();
     import_meta4 = {};
@@ -4060,28 +4391,28 @@ var parseNextAdapterOptions = (options) => parseWithSchema(NextAdapterOptionsSch
 
 // packages/presentation/next/src/withTailwindStyled.ts
 init_cjs_shims();
-var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_fs11 = __toESM(require("fs"), 1);
 var import_node_module7 = require("module");
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 init_src2();
 
 // packages/domain/scanner/src/index.ts
 init_cjs_shims();
-var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_fs8 = __toESM(require("fs"), 1);
 var import_node_module6 = require("module");
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 var import_node_url3 = require("url");
 var import_node_worker_threads = require("worker_threads");
 init_src2();
 
 // packages/domain/scanner/src/cache-native.ts
 init_cjs_shims();
-var import_node_fs6 = __toESM(require("fs"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 init_native_bridge();
 function defaultCachePath(rootDir, cacheDir) {
-  const dir = cacheDir ? import_node_path7.default.resolve(rootDir, cacheDir) : import_node_path7.default.join(process.cwd(), ".cache", "tailwind-styled");
-  return import_node_path7.default.join(dir, "scanner-cache.json");
+  const dir = cacheDir ? import_node_path8.default.resolve(rootDir, cacheDir) : import_node_path8.default.join(process.cwd(), ".cache", "tailwind-styled");
+  return import_node_path8.default.join(dir, "scanner-cache.json");
 }
 function metaPathFor(cachePath) {
   return cachePath.replace(/\.json$/, ".meta.json");
@@ -4095,7 +4426,7 @@ function getBinaryFingerprint() {
       _cachedFingerprint = null;
       return null;
     }
-    const stat = import_node_fs6.default.statSync(loadedPath);
+    const stat = import_node_fs7.default.statSync(loadedPath);
     _cachedFingerprint = `${stat.mtimeMs}:${stat.size}`;
   } catch {
     _cachedFingerprint = null;
@@ -4105,13 +4436,13 @@ function getBinaryFingerprint() {
 var STALE_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1e3;
 function readCache(rootDir, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  import_node_fs6.default.mkdirSync(import_node_path7.default.dirname(cachePath), { recursive: true });
+  import_node_fs7.default.mkdirSync(import_node_path8.default.dirname(cachePath), { recursive: true });
   const currentFingerprint = getBinaryFingerprint();
   if (currentFingerprint !== null) {
     const metaPath = metaPathFor(cachePath);
     let storedFingerprint = null;
     try {
-      storedFingerprint = JSON.parse(import_node_fs6.default.readFileSync(metaPath, "utf8")).binaryFingerprint ?? null;
+      storedFingerprint = JSON.parse(import_node_fs7.default.readFileSync(metaPath, "utf8")).binaryFingerprint ?? null;
     } catch {
     }
     if (storedFingerprint !== currentFingerprint) {
@@ -4135,7 +4466,7 @@ function readCache(rootDir, cacheDir) {
 }
 function writeCache(rootDir, entries, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  import_node_fs6.default.mkdirSync(import_node_path7.default.dirname(cachePath), { recursive: true });
+  import_node_fs7.default.mkdirSync(import_node_path8.default.dirname(cachePath), { recursive: true });
   const success = cacheWriteNative(cachePath, entries);
   if (!success) {
     throw new Error(
@@ -4145,7 +4476,7 @@ function writeCache(rootDir, entries, cacheDir) {
   const currentFingerprint = getBinaryFingerprint();
   if (currentFingerprint !== null) {
     try {
-      import_node_fs6.default.writeFileSync(
+      import_node_fs7.default.writeFileSync(
         metaPathFor(cachePath),
         JSON.stringify({ binaryFingerprint: currentFingerprint }),
         "utf8"
@@ -4173,12 +4504,12 @@ init_native_bridge();
 init_cjs_shims();
 var import_zod2 = require("zod");
 init_src2();
-var formatIssuePath2 = (path13) => path13.length > 0 ? path13.map(
+var formatIssuePath2 = (path14) => path14.length > 0 ? path14.map(
   (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
 ).join(".") : "<root>";
 var formatIssues2 = (error) => error.issues.map((issue) => {
-  const path13 = formatIssuePath2(issue.path);
-  return `${path13}: ${issue.message}`;
+  const path14 = formatIssuePath2(issue.path);
+  return `${path14}: ${issue.message}`;
 }).join("; ");
 var parseWithSchema2 = (schema, data, label) => {
   const parsed = schema.safeParse(data);
@@ -4239,7 +4570,7 @@ function getRuntimeDir() {
     return __dirname;
   }
   if (typeof import_meta5 !== "undefined" && importMetaUrl) {
-    return import_node_path8.default.dirname((0, import_node_url3.fileURLToPath)(importMetaUrl));
+    return import_node_path9.default.dirname((0, import_node_url3.fileURLToPath)(importMetaUrl));
   }
   return process.cwd();
 }
@@ -4254,7 +4585,7 @@ var createNativeParserLoader = () => {
   const loadNativeParserBinding = () => {
     if (_state.binding !== void 0) return _state.binding;
     const runtimeDir = getRuntimeDir();
-    const req = (0, import_node_module6.createRequire)(import_node_path8.default.join(runtimeDir, "noop.cjs"));
+    const req = (0, import_node_module6.createRequire)(import_node_path9.default.join(runtimeDir, "noop.cjs"));
     const _platform = process.platform;
     const _arch = process.arch;
     const _platformArch = `${_platform}-${_arch}`;
@@ -4262,27 +4593,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
-      import_node_path8.default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
-      import_node_path8.default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
-      import_node_path8.default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      import_node_path9.default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
+      import_node_path9.default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
+      import_node_path9.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/
-      import_node_path8.default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
-      import_node_path8.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
-      import_node_path8.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      import_node_path9.default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
+      import_node_path9.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
+      import_node_path9.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // runtimeDir = dist/ → naik 4 level ke repo root (monorepo dev case)
-      import_node_path8.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
-      import_node_path8.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      import_node_path9.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
+      import_node_path9.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // 3 level fallback (jika package di-nest lebih dangkal)
-      import_node_path8.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
-      import_node_path8.default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      import_node_path9.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
+      import_node_path9.default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // ── binaryName lama: tailwind_styled_parser (backward compat) ──
-      import_node_path8.default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
-      import_node_path8.default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
-      import_node_path8.default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
-      import_node_path8.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
-      import_node_path8.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
-      import_node_path8.default.resolve(
+      import_node_path9.default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
+      import_node_path9.default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
+      import_node_path9.default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
+      import_node_path9.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
+      import_node_path9.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
+      import_node_path9.default.resolve(
         runtimeDir,
         "..",
         "..",
@@ -4294,7 +4625,7 @@ var createNativeParserLoader = () => {
       )
     ];
     for (const fullPath of candidates) {
-      if (!import_node_fs7.default.existsSync(fullPath)) continue;
+      if (!import_node_fs8.default.existsSync(fullPath)) continue;
       try {
         const required = req(fullPath);
         if (required && (typeof required.extractClassesFromSource === "function" || typeof required.parseClasses === "function" || typeof required.parse_classes === "function")) {
@@ -4335,19 +4666,19 @@ function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
     if (!currentDir) continue;
     const entries = (() => {
       try {
-        return import_node_fs7.default.readdirSync(currentDir, { withFileTypes: true });
+        return import_node_fs8.default.readdirSync(currentDir, { withFileTypes: true });
       } catch {
         return [];
       }
     })();
     for (const entry of entries) {
-      const fullPath = import_node_path8.default.join(currentDir, entry.name);
+      const fullPath = import_node_path9.default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (!ignoreDirectories.has(entry.name)) directories.push(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      if (!extensionSet.has(import_node_path8.default.extname(entry.name))) continue;
+      if (!extensionSet.has(import_node_path9.default.extname(entry.name))) continue;
       candidates.push(fullPath);
     }
   }
@@ -4431,7 +4762,7 @@ function scanWorkspace2(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return import_node_fs7.default.statSync(filePath);
+          return import_node_fs8.default.statSync(filePath);
         } catch {
           return null;
         }
@@ -4457,7 +4788,7 @@ function scanWorkspace2(rootDir, options = {}) {
     for (const { filePath, stat, size, cached } of ranked) {
       const content = (() => {
         try {
-          return import_node_fs7.default.readFileSync(filePath, "utf8");
+          return import_node_fs8.default.readFileSync(filePath, "utf8");
         } catch {
           return null;
         }
@@ -4523,8 +4854,8 @@ init_src2();
 
 // packages/presentation/next/src/incrementalOrchestrator.ts
 init_cjs_shims();
-var import_node_fs8 = __toESM(require("fs"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_fs9 = __toESM(require("fs"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 init_src();
 var _fingerprintCache = /* @__PURE__ */ new Map();
 function getNative2() {
@@ -4536,10 +4867,10 @@ function getNative2() {
 }
 function fingerprintFile(filePath) {
   try {
-    const stat = import_node_fs8.default.statSync(filePath);
+    const stat = import_node_fs9.default.statSync(filePath);
     const native = getNative2();
     if (native?.create_fingerprint) {
-      const content = import_node_fs8.default.readFileSync(filePath, "utf-8");
+      const content = import_node_fs9.default.readFileSync(filePath, "utf-8");
       const hash = native.create_fingerprint(filePath, content);
       return { hash, mtime: stat.mtimeMs };
     }
@@ -4579,9 +4910,9 @@ function hasSourceChanged(sourceFiles) {
 }
 function isIncrementalEnabled(cwd) {
   try {
-    const configPath = import_node_path9.default.join(cwd, "tailwind-styled.config.json");
-    if (!import_node_fs8.default.existsSync(configPath)) return false;
-    const config = JSON.parse(import_node_fs8.default.readFileSync(configPath, "utf-8"));
+    const configPath = import_node_path10.default.join(cwd, "tailwind-styled.config.json");
+    if (!import_node_fs9.default.existsSync(configPath)) return false;
+    const config = JSON.parse(import_node_fs9.default.readFileSync(configPath, "utf-8"));
     return config.compiler?.incremental === true;
   } catch {
     return false;
@@ -4590,8 +4921,8 @@ function isIncrementalEnabled(cwd) {
 
 // packages/presentation/next/src/staticCssWebpackPlugin.ts
 init_cjs_shims();
-var import_node_fs9 = __toESM(require("fs"), 1);
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 var _fileStaticCssMap = /* @__PURE__ */ new Map();
 function setFileStaticCss(filepath, css) {
   if (css && css.trim()) {
@@ -4625,14 +4956,14 @@ var StaticCssWebpackPlugin = class _StaticCssWebpackPlugin {
   static PLUGIN_NAME = "TailwindStyledStaticCss";
   outPath;
   constructor(safelistPath) {
-    this.outPath = import_node_path10.default.join(import_node_path10.default.dirname(safelistPath), "_tw-state-static.css");
+    this.outPath = import_node_path11.default.join(import_node_path11.default.dirname(safelistPath), "_tw-state-static.css");
   }
   apply(compiler) {
     compiler.hooks.done.tap(_StaticCssWebpackPlugin.PLUGIN_NAME, () => {
       try {
         const content = buildContent(_fileStaticCssMap);
-        import_node_fs9.default.mkdirSync(import_node_path10.default.dirname(this.outPath), { recursive: true });
-        import_node_fs9.default.writeFileSync(
+        import_node_fs10.default.mkdirSync(import_node_path11.default.dirname(this.outPath), { recursive: true });
+        import_node_fs10.default.writeFileSync(
           this.outPath,
           HEADER + (content || "/* no static rules yet */") + "\n",
           "utf-8"
@@ -4670,12 +5001,12 @@ var resolveLoaderPath2 = (basename) => {
   } catch {
     const runtimeDir = resolveRuntimeDir2();
     const candidates = [
-      import_node_path11.default.resolve(runtimeDir, `${basename}.mjs`),
-      import_node_path11.default.resolve(runtimeDir, `${basename}.js`),
-      import_node_path11.default.resolve(runtimeDir, `${basename}.cjs`)
+      import_node_path12.default.resolve(runtimeDir, `${basename}.mjs`),
+      import_node_path12.default.resolve(runtimeDir, `${basename}.js`),
+      import_node_path12.default.resolve(runtimeDir, `${basename}.cjs`)
     ];
     for (const candidate of candidates) {
-      if (import_node_fs10.default.existsSync(candidate)) {
+      if (import_node_fs11.default.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -4713,7 +5044,7 @@ var createLoaderOptions = (options) => {
     preserveImports: true
   };
   if (options.verbose !== void 0) opts.verbose = options.verbose;
-  opts.safelistPath = options.safelistPath ?? import_node_path11.default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
+  opts.safelistPath = options.safelistPath ?? import_node_path12.default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
   return Object.freeze(opts);
 };
 var buildTurbopackRules = (loaderPath, loaderOptions) => {
@@ -4726,7 +5057,7 @@ var buildTurbopackRules = (loaderPath, loaderOptions) => {
     ])
   );
 };
-var normalizeLoaderPath = (loaderPath) => import_node_path11.default.resolve(loaderPath);
+var normalizeLoaderPath = (loaderPath) => import_node_path12.default.resolve(loaderPath);
 var applyWebpackRule = (config, options, loaderPath) => {
   const loaderOptions = createLoaderOptions(options);
   const rules = config.module?.rules ?? [];
@@ -4743,7 +5074,7 @@ var applyWebpackRule = (config, options, loaderPath) => {
     enforce: "pre",
     use: [{ loader: loaderPath, options: loaderOptions }]
   };
-  const safelistPath = loaderOptions.safelistPath ?? import_node_path11.default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
+  const safelistPath = loaderOptions.safelistPath ?? import_node_path12.default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
   const pluginAlreadyRegistered = (config.plugins ?? []).some(
     (p) => p?.constructor?.name === StaticCssWebpackPlugin.PLUGIN_NAME
   );
@@ -4843,17 +5174,17 @@ function withTailwindStyled(options = {}) {
           return fullCss.slice(startIdx, endIdx + 1);
         };
         var extractUtilitiesLayer = extractUtilitiesLayer2;
-        const twClassesDir = import_node_path11.default.join(import_node_path11.default.dirname(safelistPath), "tw-classes");
-        import_node_fs10.default.mkdirSync(twClassesDir, { recursive: true });
-        setGlobalLogFile(import_node_path11.default.join(twClassesDir, "_tw-build.log"));
-        import_node_fs10.default.writeFileSync(
-          import_node_path11.default.join(twClassesDir, "_start.txt"),
+        const twClassesDir = import_node_path12.default.join(import_node_path12.default.dirname(safelistPath), "tw-classes");
+        import_node_fs11.default.mkdirSync(twClassesDir, { recursive: true });
+        setGlobalLogFile(import_node_path12.default.join(twClassesDir, "_tw-build.log"));
+        import_node_fs11.default.writeFileSync(
+          import_node_path12.default.join(twClassesDir, "_start.txt"),
           String(Date.now()),
           "utf-8"
         );
-        const stateStaticPath = import_node_path11.default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+        const stateStaticPath = import_node_path12.default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
         try {
-          import_node_fs10.default.writeFileSync(
+          import_node_fs11.default.writeFileSync(
             stateStaticPath,
             "/* tw-state-static.css \u2014 placeholder, akan di-generate setelah scan */\n",
             "utf-8"
@@ -4869,14 +5200,14 @@ function withTailwindStyled(options = {}) {
             "src/index.css",
             "styles/globals.css"
           ];
-          const safelistDir = import_node_path11.default.dirname(safelistPath);
+          const safelistDir = import_node_path12.default.dirname(safelistPath);
           for (const candidate of CSS_CANDIDATES) {
-            const candidatePath = import_node_path11.default.join(process.cwd(), candidate);
-            if (!import_node_fs10.default.existsSync(candidatePath)) continue;
-            const content = import_node_fs10.default.readFileSync(candidatePath, "utf-8");
+            const candidatePath = import_node_path12.default.join(process.cwd(), candidate);
+            if (!import_node_fs11.default.existsSync(candidatePath)) continue;
+            const content = import_node_fs11.default.readFileSync(candidatePath, "utf-8");
             if (content.includes("_tw-state-static.css")) break;
-            const globalsDir = import_node_path11.default.dirname(candidatePath);
-            const rel = import_node_path11.default.relative(globalsDir, stateStaticPath).replace(/\\/g, "/");
+            const globalsDir = import_node_path12.default.dirname(candidatePath);
+            const rel = import_node_path12.default.relative(globalsDir, stateStaticPath).replace(/\\/g, "/");
             const importLine = `@import "./${rel}";`;
             const tailwindImportRe = /(@import\s+["']tailwindcss["']\s*;[^\n]*\n?)/;
             let updated;
@@ -4890,7 +5221,7 @@ function withTailwindStyled(options = {}) {
               updated = `${importLine}
 ${content}`;
             }
-            import_node_fs10.default.writeFileSync(candidatePath, updated, "utf-8");
+            import_node_fs11.default.writeFileSync(candidatePath, updated, "utf-8");
             if (options.verbose) {
               console.log(
                 `[tailwind-styled] Auto-injected "${importLine}" into ${candidate}`
@@ -4902,27 +5233,27 @@ ${content}`;
         }
         if (!process.env.TW_NATIVE_PATH) {
           const runtimeDir = resolveRuntimeDir2();
-          const nativePath = import_node_path11.default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node");
-          if (import_node_fs10.default.existsSync(nativePath)) {
+          const nativePath = import_node_path12.default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node");
+          if (import_node_fs11.default.existsSync(nativePath)) {
             process.env.TW_NATIVE_PATH = nativePath;
           }
         }
-        const srcDir = import_node_path11.default.join(process.cwd(), "src");
-        if (import_node_fs10.default.existsSync(srcDir)) {
+        const srcDir = import_node_path12.default.join(process.cwd(), "src");
+        if (import_node_fs11.default.existsSync(srcDir)) {
           try {
             const result = scanWorkspace2(srcDir);
             if (result.uniqueClasses.length > 0) {
               let atomicWriteFile2 = function(filePath, content) {
                 const tmpPath = `${filePath}.tmp`;
                 try {
-                  import_node_fs10.default.writeFileSync(tmpPath, content, "utf-8");
-                  import_node_fs10.default.renameSync(tmpPath, filePath);
+                  import_node_fs11.default.writeFileSync(tmpPath, content, "utf-8");
+                  import_node_fs11.default.renameSync(tmpPath, filePath);
                 } catch {
                   try {
-                    import_node_fs10.default.unlinkSync(tmpPath);
+                    import_node_fs11.default.unlinkSync(tmpPath);
                   } catch {
                   }
-                  import_node_fs10.default.writeFileSync(filePath, content, "utf-8");
+                  import_node_fs11.default.writeFileSync(filePath, content, "utf-8");
                 }
               };
               var atomicWriteFile = atomicWriteFile2;
@@ -4986,14 +5317,14 @@ ${content}`;
                 "styles/globals.css"
               ];
               try {
-                const twConfigPath = import_node_path11.default.join(process.cwd(), "tailwind-styled.config.json");
-                if (import_node_fs10.default.existsSync(twConfigPath)) {
-                  const twConfig = JSON.parse(import_node_fs10.default.readFileSync(twConfigPath, "utf-8"));
+                const twConfigPath = import_node_path12.default.join(process.cwd(), "tailwind-styled.config.json");
+                if (import_node_fs11.default.existsSync(twConfigPath)) {
+                  const twConfig = JSON.parse(import_node_fs11.default.readFileSync(twConfigPath, "utf-8"));
                   const cssEntry = twConfig.css?.entry;
                   if (cssEntry) {
-                    const cssEntryPath = import_node_path11.default.join(process.cwd(), cssEntry);
-                    if (import_node_fs10.default.existsSync(cssEntryPath)) {
-                      cssEntryContent = import_node_fs10.default.readFileSync(cssEntryPath, "utf-8");
+                    const cssEntryPath = import_node_path12.default.join(process.cwd(), cssEntry);
+                    if (import_node_fs11.default.existsSync(cssEntryPath)) {
+                      cssEntryContent = import_node_fs11.default.readFileSync(cssEntryPath, "utf-8");
                     }
                   }
                 }
@@ -5001,9 +5332,9 @@ ${content}`;
               }
               if (!cssEntryContent) {
                 for (const candidate of CSS_CANDIDATES) {
-                  const candidatePath = import_node_path11.default.join(process.cwd(), candidate);
-                  if (import_node_fs10.default.existsSync(candidatePath)) {
-                    cssEntryContent = import_node_fs10.default.readFileSync(candidatePath, "utf-8");
+                  const candidatePath = import_node_path12.default.join(process.cwd(), candidate);
+                  if (import_node_fs11.default.existsSync(candidatePath)) {
+                    cssEntryContent = import_node_fs11.default.readFileSync(candidatePath, "utf-8");
                     break;
                   }
                 }
@@ -5011,8 +5342,8 @@ ${content}`;
               if (cssEntryContent) {
                 cssEntryContent = cssEntryContent.replace(/@source\s+["'][^"']+["']\s*;?\s*/g, "").replace(/←[^\n]*/g, "").trim();
               }
-              const initialScanPath = import_node_path11.default.join(twClassesDir, "_initial-scan.css");
-              if (!import_node_fs10.default.existsSync(initialScanPath)) {
+              const initialScanPath = import_node_path12.default.join(twClassesDir, "_initial-scan.css");
+              if (!import_node_fs11.default.existsSync(initialScanPath)) {
                 atomicWriteFile2(
                   initialScanPath,
                   "/* tw-classes: initial scan \u2014 generating... */\n@layer utilities {}\n"
@@ -5020,7 +5351,7 @@ ${content}`;
               }
               const sourceFiles = result.files?.map((f) => f.file) ?? [];
               const incremental = isIncrementalEnabled(process.cwd());
-              if (incremental && import_node_fs10.default.existsSync(initialScanPath) && !hasSourceChanged(sourceFiles)) {
+              if (incremental && import_node_fs11.default.existsSync(initialScanPath) && !hasSourceChanged(sourceFiles)) {
                 if (options.verbose) console.log("[tailwind-styled] Incremental: tidak ada perubahan, skip regenerate CSS");
               } else {
                 void (async () => {
@@ -5061,8 +5392,8 @@ ${utilitiesOnly}`
                             classes: f.classes.filter(isValidTwClass)
                           }));
                           const buckets = buildRouteClassBuckets2(process.cwd(), srcDir, filesForGraph);
-                          const cssManifestDir = import_node_path11.default.join(process.cwd(), ".next", "static", "css", "tw");
-                          import_node_fs10.default.mkdirSync(cssManifestDir, { recursive: true });
+                          const cssManifestDir = import_node_path12.default.join(process.cwd(), ".next", "static", "css", "tw");
+                          import_node_fs11.default.mkdirSync(cssManifestDir, { recursive: true });
                           const manifestRoutes = {};
                           const usedFilenames = /* @__PURE__ */ new Set(["_global.css"]);
                           const minifyManifestCss = process.env.NODE_ENV === "production";
@@ -5077,7 +5408,7 @@ ${utilitiesOnly}`
                             const globalUtilities = extractUtilitiesLayer2(globalCss);
                             if (globalUtilities.trim()) {
                               const filename = "_global.css";
-                              atomicWriteFile2(import_node_path11.default.join(cssManifestDir, filename), globalUtilities);
+                              atomicWriteFile2(import_node_path12.default.join(cssManifestDir, filename), globalUtilities);
                               manifestRoutes.__global = filename;
                             }
                           }
@@ -5099,11 +5430,11 @@ ${utilitiesOnly}`
                               suffix++;
                             }
                             usedFilenames.add(filename);
-                            atomicWriteFile2(import_node_path11.default.join(cssManifestDir, filename), routeUtilities);
+                            atomicWriteFile2(import_node_path12.default.join(cssManifestDir, filename), routeUtilities);
                             manifestRoutes[route] = filename;
                           }
                           atomicWriteFile2(
-                            import_node_path11.default.join(cssManifestDir, "css-manifest.json"),
+                            import_node_path12.default.join(cssManifestDir, "css-manifest.json"),
                             JSON.stringify({ routes: manifestRoutes }, null, 2)
                           );
                           if (options.verbose) {