pasika 0.10.133 → 0.10.135

package/dist/eslint/pasika/index.d.ts

@@ -124,6 +124,7 @@ declare const tailwindRules: {
     "theme-reset": _eslint_css.CSSRuleDefinition;
     "theme-mode": _eslint_css.CSSRuleDefinition;
     "color-role-usage": _eslint_css.CSSRuleDefinition;
+    "color-literal-usage": _eslint_css.CSSRuleDefinition;
     "root-variables": _eslint_css.CSSRuleDefinition;
     "apply-usage": _eslint_css.CSSRuleDefinition;
     "base-layer-pair": _eslint_css.CSSRuleDefinition;
@@ -166,6 +167,7 @@ declare const pasikaPlugin: {
         "theme-reset": _eslint_css.CSSRuleDefinition;
         "theme-mode": _eslint_css.CSSRuleDefinition;
         "color-role-usage": _eslint_css.CSSRuleDefinition;
+        "color-literal-usage": _eslint_css.CSSRuleDefinition;
         "root-variables": _eslint_css.CSSRuleDefinition;
         "apply-usage": _eslint_css.CSSRuleDefinition;
         "base-layer-pair": _eslint_css.CSSRuleDefinition;

package/dist/eslint/pasika/index.js

@@ -9909,6 +9909,96 @@ var baseLayerPairRule = {
   }
 };
 
+// eslint/rules/tailwind/color-literal-usage.ts
+var COLOR_FUNCTION = /\b(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch|color)\s*\(/giu;
+var HEX_COLOR = /#(?:[\da-f]{8}|[\da-f]{6}|[\da-f]{4}|[\da-f]{3})(?![\da-f])/giu;
+var NAMED_COLORS = new Set(
+  "aliceblue antiquewhite aqua aquamarine azure beige bisque black blanchedalmond blue blueviolet brown burlywood cadetblue chartreuse chocolate coral cornflowerblue cornsilk crimson cyan darkblue darkcyan darkgoldenrod darkgray darkgreen darkgrey darkkhaki darkmagenta darkolivegreen darkorange darkorchid darkred darksalmon darkseagreen darkslateblue darkslategray darkslategrey darkturquoise darkviolet deeppink deepskyblue dimgray dimgrey dodgerblue firebrick floralwhite forestgreen fuchsia gainsboro ghostwhite gold goldenrod gray green greenyellow grey honeydew hotpink indianred indigo ivory khaki lavender lavenderblush lawngreen lemonchiffon lightblue lightcoral lightcyan lightgoldenrodyellow lightgray lightgreen lightgrey lightpink lightsalmon lightseagreen lightskyblue lightslategray lightslategrey lightsteelblue lightyellow lime limegreen linen magenta maroon mediumaquamarine mediumblue mediumorchid mediumpurple mediumseagreen mediumslateblue mediumspringgreen mediumturquoise mediumvioletred midnightblue mintcream mistyrose moccasin navajowhite navy oldlace olive olivedrab orange orangered orchid palegoldenrod palegreen paleturquoise palevioletred papayawhip peachpuff peru pink plum powderblue purple rebeccapurple red rosybrown royalblue saddlebrown salmon sandybrown seagreen seashell sienna silver skyblue slateblue slategray slategrey snow springgreen steelblue tan teal thistle tomato turquoise violet wheat white whitesmoke yellow yellowgreen".split(" ")
+);
+var DECLARATION = /(?:^|[;{}\n])\s*(?<property>--[\w-]+|[a-z][\w-]*)\s*:\s*(?<value>[^;{}]*)/gmu;
+var APPLY = /@apply\s+(?<value>[^;{}]*);/gu;
+function maskNonColors(source) {
+  const spaces = (text) => text.replace(/[^\r\n]/gu, " ");
+  const masked = source.replace(/\/\*[\s\S]*?\*\/|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/gu, spaces);
+  return masked.replace(/\burl\s*\([^)]*\)/giu, spaces);
+}
+function matchingClose(text, open) {
+  let depth = 0;
+  for (let index = open; index < text.length; index++) {
+    if (text[index] === "(") depth++;
+    if (text[index] === ")" && --depth === 0) return index + 1;
+  }
+  return -1;
+}
+function colorLiterals(value) {
+  const matches = [];
+  const occupied = [];
+  for (const functionMatch of value.matchAll(COLOR_FUNCTION)) {
+    const start = functionMatch.index;
+    if (occupied.some((range) => start >= range.start && start < range.end)) continue;
+    const open = start + functionMatch[0].lastIndexOf("(");
+    const end = matchingClose(value, open);
+    if (end < 0) continue;
+    const text = value.slice(start, end);
+    occupied.push({ start, end });
+    if (!/\b(?:var|env|attr)\s*\(/iu.test(text)) matches.push({ text, offset: start });
+  }
+  for (const match of value.matchAll(HEX_COLOR)) {
+    if (occupied.some((range) => match.index >= range.start && match.index < range.end)) continue;
+    if (match.index > 0 && /[\w#-]/u.test(value[match.index - 1] ?? "")) continue;
+    matches.push({ text: match[0], offset: match.index });
+  }
+  for (const word of value.matchAll(/\b[a-z]+\b/giu)) {
+    if (!NAMED_COLORS.has(word[0].toLowerCase())) continue;
+    if (occupied.some((range) => word.index >= range.start && word.index < range.end)) continue;
+    if (word.index > 0 && /[-\w]/u.test(value[word.index - 1] ?? "")) continue;
+    if (/[-\w]/u.test(value[word.index + word[0].length] ?? "")) continue;
+    matches.push({ text: word[0], offset: word.index });
+  }
+  return matches.sort((a, b) => a.offset - b.offset);
+}
+var colorLiteralUsageRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require fixed CSS color literals to live only in --color-* token definitions."
+    }
+  },
+  create(context) {
+    return {
+      "StyleSheet:exit"(node) {
+        const masked = maskNonColors(context.sourceCode.text);
+        const reported = /* @__PURE__ */ new Set();
+        const reportValue = (value, start) => {
+          for (const color of colorLiterals(value)) {
+            const offset = start + color.offset;
+            if (reported.has(offset)) continue;
+            reported.add(offset);
+            const loc = context.sourceCode.getLocFromIndex(offset);
+            context.report({
+              node,
+              loc: { start: loc, end: context.sourceCode.getLocFromIndex(offset + color.text.length) },
+              message: `Move literal color "${color.text}" into a --color-* token and reference it with var().`
+            });
+          }
+        };
+        for (const match of masked.matchAll(DECLARATION)) {
+          const property = match.groups?.property;
+          const value = match.groups?.value;
+          if (!property || value === void 0 || property.startsWith("--color-")) continue;
+          reportValue(value, match.index + match[0].lastIndexOf(value));
+        }
+        for (const match of masked.matchAll(APPLY)) {
+          const value = match.groups?.value;
+          if (value === void 0) continue;
+          reportValue(value, match.index + match[0].indexOf(value));
+        }
+      }
+    };
+  }
+};
+
 // eslint/rules/color-role.ts
 function colorRoleUsageMessage(className) {
   const segments = className.replace(/!+$/u, "").split(":");
@@ -9933,14 +10023,14 @@ function colorRoleUsageMessage(className) {
 }
 
 // eslint/rules/tailwind/color-role-usage.ts
-var COLOR_TOKEN = /^--color-[a-z][a-z0-9-]*-(?:canvas|ink|edge)$/u;
+var COLOR_TOKEN = /^--color-[a-z][a-z0-9-]*(?:-(?:canvas|ink|edge))?$/u;
 var BACKGROUND_IMAGE_TOKEN = /^--background-image-[a-z][a-z0-9-]*-canvas$/u;
 var colorRoleUsageRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require semantic color and background-image token names and matching Tailwind color utilities."
+      description: "Allow shared color tokens while enforcing explicit semantic roles and background-image naming."
     }
   },
   create(context) {
@@ -9963,7 +10053,7 @@ var colorRoleUsageRule = {
             } else if (!COLOR_TOKEN.test(token)) {
               context.report({
                 node: theme,
-                message: `Color token "${token}" needs a semantic role ending in -canvas, -ink, or -edge.`
+                message: `Color token "${token}" must use a valid --color-* name, optionally ending in -canvas, -ink, or -edge.`
               });
             }
           }
@@ -10149,14 +10239,24 @@ function themeClasses(name) {
   if (name.includes("--", 2)) return [];
   if (name.startsWith("--color-")) {
     const stem = name.slice("--color-".length);
-    if (stem.endsWith("-canvas")) {
-      return ["bg", "fill", "from", "via", "to", "ring-offset"].map((prefix) => `${prefix}-${stem}`);
-    }
-    if (stem.endsWith("-ink")) return ["text", "caret", "decoration"].map((prefix) => `${prefix}-${stem}`);
-    if (stem.endsWith("-edge")) {
-      return ["border", "outline", "ring", "divide", "stroke"].map((prefix) => `${prefix}-${stem}`);
-    }
-    return ["bg", "text", "border", "fill", "stroke", "ring"].map((prefix) => `${prefix}-${stem}`);
+    return [
+      "bg",
+      "text",
+      "border",
+      "ring",
+      "fill",
+      "stroke",
+      "accent",
+      "caret",
+      "decoration",
+      "outline",
+      "divide",
+      "from",
+      "via",
+      "to",
+      "shadow",
+      "ring-offset"
+    ].map((prefix) => `${prefix}-${stem}`);
   }
   if (name.startsWith("--background-image-")) return [`bg-${name.slice("--background-image-".length)}`];
   if (name.startsWith("--spacing-")) {
@@ -10206,6 +10306,7 @@ function themeClasses(name) {
   if (name.startsWith("--aspect-")) return [`aspect-${name.slice("--aspect-".length)}`];
   if (name.startsWith("--leading-")) return [`leading-${name.slice("--leading-".length)}`];
   if (name.startsWith("--animate-")) return [`animate-${name.slice("--animate-".length)}`];
+  if (name.startsWith("--inset-shadow-")) return [`inset-shadow-${name.slice("--inset-shadow-".length)}`];
   if (name.startsWith("--radius-")) return [`rounded-${name.slice("--radius-".length)}`];
   if (name.startsWith("--text-") || name.startsWith("--tracking-") || name.startsWith("--font-")) {
     return [name.slice(2)];
@@ -10266,7 +10367,7 @@ function buildCssDependencyGraph(options) {
           } else if (node.name === "theme" && node.loc) {
             const source = file.content.slice(node.loc.start.offset, node.loc.end.offset).replace(/\/\*[\s\S]*?\*\//gu, (comment) => comment.replace(/[^\r\n]/gu, " "));
             for (const found of source.matchAll(
-              /(?:^|(?<=[{;\r\n]))\s*(?<name>--[a-z][\w-]*)\s*:\s*(?<value>[^;}\r\n]+)(?=;|[}])/gu
+              /(?:^|(?<=[{;\r\n]))\s*(?<name>--[a-z][\w-]*)\s*:\s*(?<value>[^;}]+)(?=;|[}])/gu
             )) {
               const name = found.groups?.name;
               const value = found.groups?.value;
@@ -10691,27 +10792,28 @@ var noUtilityAliasRule = {
 
 // eslint/rules/tailwind/root-variables.ts
 import path72 from "path";
-import { generate as generate3, parse as parse6, walk as walk3 } from "@eslint/css-tree";
-var INLINE_MESSAGE = "Define design tokens with direct values in @theme, not @theme inline.";
-var INDIRECT_MESSAGE = "Define design tokens that reference CSS variables via var() in @theme inline.";
-var MIXED_THEME_MESSAGE = "Use either @theme or @theme inline across the project; external font-loader mappings with valid fallbacks are the only exception.";
-var REDUNDANT_INLINE_MESSAGE = (name) => `Tailwind token "${name}" has no runtime overrides; define its value directly in @theme instead of using :root and @theme inline.`;
-var EXTERNAL_FONT_FALLBACK_MESSAGE = (name, variable) => `Tailwind font token "${name}" references external font "${variable}" without a fallback inside var(); use var(${variable}, Arial) or another font-family fallback.`;
-function hasVarFallback(source, variable) {
-  for (const match of source.matchAll(/\bvar\s*\(\s*(?<name>--[\w-]+)\s*,/gu)) {
-    if (match.groups?.name !== variable) continue;
-    const start = match.index + match[0].length;
-    const close = source.indexOf(")", start);
-    if (close !== -1 && /[^,\s]/u.test(source.slice(start, close))) return true;
-  }
-  return false;
+import { parse as parse6, walk as walk3 } from "@eslint/css-tree";
+
+// eslint/rules/tailwind/external-mapping.ts
+function externalMapping(value, token, authoredVariables) {
+  const match = /^var\s*\(\s*(?<source>--[a-z][\w-]*)\s*,\s*(?<fallback>[\s\S]+)\)$/u.exec(value.trim());
+  const source = match?.groups?.source;
+  const fallback = match?.groups?.fallback?.trim();
+  return Boolean(
+    source && source !== token && !authoredVariables.has(source) && fallback && !/\b(?:var|env|attr|calc|min|max|clamp|color-mix|light-dark)\s*\(/iu.test(fallback)
+  );
 }
+
+// eslint/rules/tailwind/root-variables.ts
+var INLINE_ONLY_MESSAGE = "Define all Tailwind theme tokens in @theme inline, including fixed values and resets.";
+var INLINE_MAPPING_MESSAGE = (name) => `Tailwind token "${name}" must use a fixed value, same-named var(${name}), or an external var() with fallback in @theme inline.`;
+var REDUNDANT_INLINE_MESSAGE = (name) => `Tailwind token "${name}" has no @variant override; define its fixed value directly in @theme inline.`;
 var rootVariablesRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require @theme for fixed tokens and fixed-token aliases, matching :root variables for @theme inline tokens, and no other token redeclarations."
+      description: "Require @theme inline for fixed tokens, variant-driven same-name mappings, and external variables with fallbacks."
     }
   },
   create(context) {
@@ -10734,7 +10836,11 @@ var rootVariablesRule = {
     const names = new Set(
       graph.definitions.filter((symbol) => symbol.kind === "theme-token").map((symbol) => symbol.name)
     );
-    function isFixedThemeExpression(name, value, visited = /* @__PURE__ */ new Set([name])) {
+    function isComposableThemeExpression(name, value, allowRuntimeReferences, visited = /* @__PURE__ */ new Set([name])) {
+      if (externalMapping(value, name, authoredVariables)) return true;
+      if (mirroredTokens.has(name) && new RegExp(`^\\s*var\\(\\s*${name}\\s*\\)\\s*$`, "u").test(value)) {
+        return allowRuntimeReferences && defaultRootNames.has(name) && variantNames.has(name);
+      }
       const references = [...value.matchAll(/\bvar\s*\(\s*(?<target>--[a-z][\w-]*)/giu)].map(
         (match) => match.groups?.target
       );
@@ -10743,41 +10849,15 @@ var rootVariablesRule = {
         if (!target || visited.has(target)) return false;
         const next = themeValues.get(target);
         if (!next) return false;
-        return isFixedThemeExpression(target, next, /* @__PURE__ */ new Set([...visited, target]));
+        return isComposableThemeExpression(target, next, allowRuntimeReferences, /* @__PURE__ */ new Set([...visited, target]));
       });
     }
     const mirroredTokens = /* @__PURE__ */ new Set();
-    let hasPlainThemeBlocks = false;
-    let hasInlineThemeBlocks = false;
-    let inlineBlocksAreExternalFonts = true;
     for (const file of [...stylesheets.filter((candidate) => path72.normalize(candidate) !== current), current]) {
       const source = (path72.normalize(file) === current ? context.sourceCode.text : textOf(file)).replace(
         /\/\*[\s\S]*?\*\//gu,
         " "
       );
-      for (const header of source.matchAll(/@theme(?<options>(?:\s+[\w-]+)*)\s*\{/gu)) {
-        if (/\binline\b/u.test(header.groups?.options ?? "")) hasInlineThemeBlocks = true;
-        else hasPlainThemeBlocks = true;
-      }
-      const inlineHeaders = [...source.matchAll(/@theme\s+inline\s*\{/gu)];
-      const inlineBlocks = [...source.matchAll(/@theme\s+inline\s*\{(?<body>[^{}]*)\}/gu)];
-      if (inlineHeaders.length !== inlineBlocks.length) inlineBlocksAreExternalFonts = false;
-      for (const block of inlineBlocks) {
-        const declarations = (block.groups?.body ?? "").split(";").map((part) => part.trim()).filter(Boolean);
-        if (declarations.length === 0) inlineBlocksAreExternalFonts = false;
-        for (const declaration of declarations) {
-          const match = /^(?<token>--font-[a-z][\w-]*)\s*:\s*(?<value>.+)$/u.exec(declaration);
-          const name = match?.groups?.token;
-          const value = match?.groups?.value ?? "";
-          const references = [...value.matchAll(/\bvar\s*\(\s*(?<name>--[\w-]+)/gu)].map(
-            (reference) => reference.groups?.name
-          );
-          const runtime = references[0];
-          if (!name || references.length !== 1 || !runtime?.startsWith("--font-") || runtime === name || names.has(runtime) || !hasVarFallback(value, runtime)) {
-            inlineBlocksAreExternalFonts = false;
-          }
-        }
-      }
       for (const theme of source.matchAll(/@theme(?<options>(?:\s+[\w-]+)*)\s*\{(?<body>[^{}]*)\}/gu)) {
         const inline = /\binline\b/u.test(theme.groups?.options ?? "");
         for (const declaration of (theme.groups?.body ?? "").matchAll(
@@ -10786,42 +10866,41 @@ var rootVariablesRule = {
           const { name, value } = declaration.groups ?? {};
           if (!name) continue;
           names.add(name);
-          if (inline && /\bvar\s*\(/u.test(value ?? "")) {
+          if (inline && new RegExp(`^\\s*var\\(\\s*${name}\\s*\\)\\s*$`, "u").test(value ?? "")) {
             mirroredTokens.add(name);
           }
         }
       }
     }
-    const overriddenNames = new Set(
-      graph.definitions.filter((symbol) => symbol.kind === "root-variable" && symbol.scope === "conditional").map((symbol) => symbol.name)
-    );
+    const authoredVariables = new Set(names);
+    const variantNames = /* @__PURE__ */ new Set();
     for (const file of [...stylesheets.filter((candidate) => path72.normalize(candidate) !== current), current]) {
       const css2 = path72.normalize(file) === current ? context.sourceCode.text : textOf(file);
       const tree = parse6(css2, { parseAtrulePrelude: false });
+      let variantDepth = 0;
       walk3(tree, {
         enter(node) {
+          if (node.type === "Atrule" && node.name === "variant") variantDepth += 1;
           if (node.type !== "Declaration" || !node.property.startsWith("--")) return;
-          if (this.rule?.type !== "Rule") return;
-          if (generate3(this.rule.prelude).trim() !== ":root") overriddenNames.add(node.property);
+          authoredVariables.add(node.property);
+          if (variantDepth > 0) variantNames.add(node.property);
+        },
+        leave(node) {
+          if (node.type === "Atrule" && node.name === "variant") variantDepth -= 1;
         }
       });
     }
-    for (const file of findFiles(sourceRoot, MODULE_EXTENSIONS4)) {
-      for (const found of textOf(file).matchAll(/\.setProperty\s*\(\s*["'\x60](?<name>--[\w-]+)["'\x60]/gu)) {
-        if (found.groups?.name) overriddenNames.add(found.groups.name);
-      }
-    }
     const defaultRootNames = new Set(
       graph.definitions.filter((symbol) => symbol.kind === "root-variable" && symbol.scope === "default").map((symbol) => symbol.name)
     );
     return {
       "StyleSheet:exit"(node) {
         const localThemes = atrulesNamed(node, "theme");
-        if (hasPlainThemeBlocks && hasInlineThemeBlocks && !inlineBlocksAreExternalFonts && localThemes[0]) {
-          context.report({ node: localThemes[0], message: MIXED_THEME_MESSAGE });
-        }
         for (const theme of localThemes) {
-          const inline = preludeIdentifiers(theme).includes("inline");
+          if (!preludeIdentifiers(theme).includes("inline")) {
+            context.report({ node: theme, message: INLINE_ONLY_MESSAGE });
+            continue;
+          }
           const source = context.sourceCode.getText(theme).replace(/\/\*[\s\S]*?\*\//gu, (comment) => comment.replace(/[^\r\n]/gu, " "));
           for (const match of source.matchAll(
             /(?:^|[{;\r\n])\s*(?<name>--[a-z][\w-]*)\s*:\s*(?<value>[^;{}]*)(?=;|[}])/gu
@@ -10830,60 +10909,48 @@ var rootVariablesRule = {
             if (!name || value === void 0) continue;
             const unquoted = value.replace(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/gu, "");
             const referencesVariable = /\bvar\s*\(/iu.test(unquoted);
-            if (inline && referencesVariable) {
-              for (const reference of unquoted.matchAll(/\bvar\(\s*(?<variable>--[\w-]+)/gu)) {
-                const runtime = reference.groups?.variable;
-                if (runtime && runtime !== name) {
-                  const externalFont = name.startsWith("--font-") && runtime.startsWith("--font-");
-                  if (externalFont && !hasVarFallback(value, runtime)) {
-                    context.report({ node: theme, message: EXTERNAL_FONT_FALLBACK_MESSAGE(name, runtime) });
-                  } else if (!externalFont) {
-                    context.report({
-                      node: theme,
-                      message: `Tailwind token "${name}" must reference its same-named CSS variable, not "${runtime}".`
-                    });
-                  }
-                } else if (runtime && !defaultRootNames.has(runtime)) {
-                  context.report({
-                    node: theme,
-                    message: `Tailwind token "${name}" references "${runtime}" without a default :root declaration.`
-                  });
-                }
-              }
-            }
-            if (inline && referencesVariable && defaultRootNames.has(name) && !overriddenNames.has(name)) {
-              const references = [...unquoted.matchAll(/\bvar\(\s*(?<variable>--[\w-]+)/gu)].map(
-                (reference) => reference.groups?.variable
-              );
-              if (references.length > 0 && references.every((variable) => variable === name)) {
+            const directReference = /^var\s*\(\s*(?<target>--[a-z][\w-]*)\s*\)$/u.exec(unquoted.trim())?.groups?.target;
+            if (directReference) {
+              if (directReference !== name) {
+                context.report({
+                  node: theme,
+                  message: `Tailwind token "${name}" must reference its same-named CSS variable, not "${directReference}".`
+                });
+              } else if (!defaultRootNames.has(name)) {
+                context.report({
+                  node: theme,
+                  message: `Tailwind token "${name}" references "${name}" without a default :root declaration.`
+                });
+              } else if (!variantNames.has(name)) {
                 context.report({ node: theme, message: REDUNDANT_INLINE_MESSAGE(name) });
               }
+              continue;
+            }
+            if (externalMapping(value, name, authoredVariables)) continue;
+            const fallbackTarget = /^var\s*\(\s*(?<target>--[a-z][\w-]*)\s*,/u.exec(unquoted.trim())?.groups?.target;
+            if (fallbackTarget && authoredVariables.has(fallbackTarget)) {
+              context.report({ node: theme, message: INLINE_MAPPING_MESSAGE(name) });
+              continue;
+            }
+            const runtimeEffect = /^--(?:shadow|inset-shadow|drop-shadow|text-shadow|background-image)-/u.test(name);
+            if (referencesVariable && !isComposableThemeExpression(name, unquoted, runtimeEffect)) {
+              context.report({ node: theme, message: INLINE_MAPPING_MESSAGE(name) });
             }
-            if (inline === referencesVariable || !inline && isFixedThemeExpression(name, unquoted)) continue;
-            const offset = (theme.loc?.start.offset ?? 0) + match.index + match[0].indexOf(name);
-            const preceding = context.sourceCode.text.slice(0, offset);
-            const line = preceding.split("\n").length;
-            const column = offset - preceding.lastIndexOf("\n");
-            context.report({
-              node: theme,
-              loc: {
-                start: { line, column },
-                end: { line, column: column + name.length }
-              },
-              message: inline ? INLINE_MESSAGE : INDIRECT_MESSAGE
-            });
           }
         }
-        function checkTokenRedeclarations(currentNode, conditional = false) {
+        function checkTokenRedeclarations(currentNode, conditional = false, inVariant = false) {
           if (currentNode.type === "Atrule" && ["theme", "utility", "keyframes"].includes(currentNode.name)) {
             return;
           }
           const isConditional = conditional || currentNode.type === "Atrule" && currentNode.name !== "layer";
+          const isVariant = inVariant || currentNode.type === "Atrule" && currentNode.name === "variant";
           const isDefaultRoot = currentNode.type === "Rule" && context.sourceCode.getText(currentNode.prelude).trim() === ":root" && !isConditional;
           if (currentNode.type === "Rule" && !isDefaultRoot || currentNode.type === "Atrule" && currentNode.name === "variant") {
             for (const declaration of blockChildren2(currentNode)) {
               if (declaration.type !== "Declaration") continue;
-              if (mirroredTokens.has(declaration.property)) continue;
+              if (mirroredTokens.has(declaration.property) && (isVariant || !variantNames.has(declaration.property))) {
+                continue;
+              }
               if (!names.has(declaration.property) && !declaration.property.startsWith("--color-")) continue;
               context.report({
                 node: declaration,
@@ -10893,7 +10960,9 @@ var rootVariablesRule = {
           }
           const children = currentNode.type === "StyleSheet" ? currentNode.children : blockChildren2(currentNode);
           for (const child of children) {
-            if (child.type === "Atrule" || child.type === "Rule") checkTokenRedeclarations(child, isConditional);
+            if (child.type === "Atrule" || child.type === "Rule") {
+              checkTokenRedeclarations(child, isConditional, isVariant);
+            }
           }
         }
         checkTokenRedeclarations(node);
@@ -10916,9 +10985,21 @@ var rootVariablesRule = {
 
 // eslint/rules/tailwind/stylesheet-ordering.ts
 import path73 from "path";
-import { generate as generate4 } from "@eslint/css-tree";
-var SECTION_ORDER = ["imports", "custom-variant", "root", "theme", "utility", "base styles", "keyframes"];
+import { generate as generate3 } from "@eslint/css-tree";
+var SECTION_ORDER = [
+  "Tailwind import",
+  "theme",
+  "feature imports",
+  "custom-variant",
+  "root",
+  "utility",
+  "base styles",
+  "keyframes"
+];
 var LATE_RESET_ERROR = "The global --*: initial theme reset must precede feature stylesheet imports, or it will erase their theme tokens.";
+var DUPLICATE_THEME_ERROR = "globals.css must use one @theme inline block for the reset and all global tokens; merge the theme blocks.";
+var RESET_FIRST_ERROR = "The --*: initial reset must be the first declaration in the globals.css @theme inline block.";
+var ORDER_ERROR = "Global stylesheet sections must be ordered: Tailwind import, one @theme inline block, feature imports, @custom-variant, :root/@variant, custom utilities, base styles, keyframes.";
 function themeBody(node, source) {
   if (node.type !== "Atrule" || node.name !== "theme" || !node.loc) return void 0;
   const raw = source.slice(node.loc.start.offset, node.loc.end.offset);
@@ -10930,12 +11011,9 @@ function themeBody(node, source) {
 function containsThemeReset(body) {
   return body !== void 0 && /(?:^|[;{])\s*--\*\s*:\s*initial\s*(?:;|$)/u.test(body);
 }
-function isStandaloneThemeReset(body) {
-  return body !== void 0 && /^--\*\s*:\s*initial\s*;?$/u.test(body);
-}
 function isTailwindImport(node) {
   if (node.type !== "Atrule" || node.name !== "import" || !node.prelude) return false;
-  return /^["']tailwindcss["'](?:\s|$)/u.test(generate4(node.prelude).trim());
+  return /^["']tailwindcss["'](?:\s|$)/u.test(generate3(node.prelude).trim());
 }
 function scopesCustomProperties(node) {
   if (node.type === "Declaration") return node.property.startsWith("--");
@@ -10957,80 +11035,68 @@ var stylesheetOrderingRule = {
     if (path73.normalize(path73.resolve(context.filename)) !== entryPoint) return {};
     return {
       "StyleSheet:exit"(node) {
+        const topLevel = [...node.children];
+        const first = topLevel[0];
+        const second = topLevel[1];
+        if (first && isTailwindImport(first) && second?.type === "Atrule" && second.name === "import" && !isTailwindImport(second) && topLevel.some((child) => containsThemeReset(themeBody(child, context.sourceCode.text)))) {
+          context.report({ node, message: LATE_RESET_ERROR });
+          return;
+        }
+        if (!first || !isTailwindImport(first) || second?.type !== "Atrule" || second.name !== "theme" || !preludeIdentifiers(second).includes("inline")) {
+          context.report({ node, message: ORDER_ERROR });
+          return;
+        }
         const sections = [];
-        let index = 0;
-        let sawTailwindImport = false;
         let sawFeatureImport = false;
-        let sawNonImport = false;
-        let sawEarlyReset = false;
+        let themeBlocks2 = 0;
         for (const child of node.children) {
           const body = themeBody(child, context.sourceCode.text);
-          let isEarlyReset = false;
+          if (containsThemeReset(body) && !/^--\*\s*:\s*initial\s*(?:;|$)/u.test(body ?? "")) {
+            context.report({ node: child, message: RESET_FIRST_ERROR });
+            return;
+          }
           if (containsThemeReset(body) && sawFeatureImport) {
             context.report({ node: child, message: LATE_RESET_ERROR });
             return;
           }
           if (child.type === "Atrule" && child.name === "import") {
-            sections.push({ name: "imports", at: index });
-            if (isTailwindImport(child)) sawTailwindImport = true;
-            else sawFeatureImport = true;
-          } else if (isStandaloneThemeReset(body) && sawTailwindImport && !sawFeatureImport && !sawNonImport && !sawEarlyReset) {
-            sawEarlyReset = true;
-            isEarlyReset = true;
-          } else if (child.type === "Atrule" && child.name === "custom-variant") {
-            sections.push({ name: "custom-variant", at: index });
+            if (isTailwindImport(child)) {
+              sections.push("Tailwind import");
+            } else {
+              sawFeatureImport = true;
+              sections.push("feature imports");
+            }
           } else if (child.type === "Atrule" && child.name === "theme") {
-            sections.push({ name: "theme", at: index });
+            themeBlocks2 += 1;
+            sections.push("theme");
+          } else if (child.type === "Atrule" && child.name === "custom-variant") {
+            sections.push("custom-variant");
           } else if (child.type === "Atrule" && child.name === "utility") {
-            sections.push({ name: "utility", at: index });
+            sections.push("utility");
           } else if (child.type === "Atrule" && child.name === "keyframes") {
-            sections.push({ name: "keyframes", at: index });
+            sections.push("keyframes");
           } else if (child.type === "Atrule" && child.name === "layer") {
             if (preludeIdentifiers(child).includes("base")) {
-              sections.push({ name: "base styles", at: index });
+              sections.push("base styles");
             }
           } else if (child.type === "Rule" && (selectorNames(child).includes("root") || scopesCustomProperties(child))) {
-            sections.push({ name: "root", at: index });
+            sections.push("root");
           } else if (child.type === "Atrule" && scopesCustomProperties(child)) {
-            sections.push({ name: "root", at: index });
-          }
-          if (child.type !== "Comment" && !(child.type === "Atrule" && child.name === "import") && !isEarlyReset) {
-            sawNonImport = true;
+            sections.push("root");
           }
-          index += 1;
         }
-        const firstAt = /* @__PURE__ */ new Map();
-        for (const section of sections) {
-          if (!firstAt.has(section.name)) firstAt.set(section.name, section.at ?? 0);
-        }
-        let lastSeen = -1;
-        for (const name of SECTION_ORDER) {
-          const at = firstAt.get(name);
-          if (at === void 0) continue;
-          if (at < lastSeen) {
-            context.report({
-              node,
-              message: `Global stylesheet sections must be ordered: imports, @custom-variant, :root, @theme, custom utilities, base styles, keyframes. Found "${name}" before an earlier section.`
-            });
-            return;
-          }
-          lastSeen = at;
+        if (themeBlocks2 > 1) {
+          context.report({ node, message: DUPLICATE_THEME_ERROR });
+          return;
         }
         let furthestSection = -1;
-        let furthestName;
         for (const section of sections) {
-          const order = SECTION_ORDER.findIndex((name) => name === section.name);
+          const order = SECTION_ORDER.findIndex((name) => name === section);
           if (order < furthestSection) {
-            context.report({
-              node,
-              message: `Global stylesheet section "${section.name}" cannot reappear after "${String(furthestName)}". Keep all section occurrences in the required order.`
-            });
+            context.report({ node, message: ORDER_ERROR });
             return;
           }
-          if (order > furthestSection) {
-            furthestSection = order;
-            furthestName = section.name;
-          }
+          furthestSection = order;
         }
       }
     };
@@ -11039,7 +11105,7 @@ var stylesheetOrderingRule = {
 
 // eslint/rules/tailwind/theme-mode.ts
 import path74 from "path";
-import { generate as generate5 } from "@eslint/css-tree";
+import { generate as generate4 } from "@eslint/css-tree";
 var MODE_NAME = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
 var MODE_REFERENCE = /(?:^|[^a-z0-9-])(?<name>[a-z][a-z0-9]*(?:-[a-z0-9]+)*):(?=[a-z[(])/gu;
 var MODE_ATTRIBUTE = /data-theme\s*=\s*["'](?<name>[a-z][a-z0-9]*(?:-[a-z0-9]+)*)["']/gu;
@@ -11086,7 +11152,7 @@ var themeModeRule = {
         const registered = /* @__PURE__ */ new Set();
         for (const variant of atrulesNamed(node, "custom-variant")) {
           if (variant.type !== "Atrule") continue;
-          const prelude = variant.prelude ? generate5(variant.prelude) : "";
+          const prelude = variant.prelude ? generate4(variant.prelude) : "";
           const name = variantName(prelude);
           if (!name) continue;
           if (!isModeVariant(name, prelude)) continue;
@@ -11115,14 +11181,14 @@ var themeModeRule = {
         const globalRegistrations = current === globalFile ? registered : registeredModes(read(globalFile));
         for (const variant of atrulesNamed(node, "variant")) {
           if (variant.type !== "Atrule" || !variant.prelude) continue;
-          const name = variantName(generate5(variant.prelude));
+          const name = variantName(generate4(variant.prelude));
           if (name && (name === "dark" || name.startsWith("theme-") || globalRegistrations.has(name) || modeHints.has(name)) && !globalRegistrations.has(name)) {
             context.report({ node: variant, message: MISSING_CSS_VARIANT(name) });
           }
         }
         for (const rule of rules(node)) {
           if (rule.type !== "Rule") continue;
-          const selector = generate5(rule.prelude);
+          const selector = generate4(rule.prelude);
           if (/\[\s*data-theme(?:\s*[~|^$*]?=|\s*\])/u.test(selector)) {
             context.report({ node: rule, message: SELECTOR_OVERRIDE });
           } else if (/\.dark(?![\w-])/u.test(selector)) {
@@ -11131,7 +11197,7 @@ var themeModeRule = {
         }
         walkNodes(node, (child) => {
           if (child.type !== "Atrule" || child.name !== "media" || !child.prelude) return;
-          if (/\bprefers-color-scheme\b/u.test(generate5(child.prelude))) {
+          if (/\bprefers-color-scheme\b/u.test(generate4(child.prelude))) {
             context.report({ node: child, message: SYSTEM_OVERRIDE });
           }
         });
@@ -11161,15 +11227,16 @@ var themeModeRule = {
 
 // eslint/rules/tailwind/theme-reset.ts
 import path75 from "path";
-import { generate as generate6 } from "@eslint/css-tree";
+import { generate as generate5 } from "@eslint/css-tree";
 function isThemeReset(node) {
   if (!node) return false;
-  if (node.type === "Declaration") return node.property === "--*" && generate6(node.value).trim() === "initial";
+  if (node.type === "Declaration") return node.property === "--*" && generate5(node.value).trim() === "initial";
   if (node.type === "Raw") return /(?:^|[;{])\s*--\*\s*:\s*initial\s*(?:;|$)/u.test(node.value);
   return false;
 }
-function hasThemeReset(node) {
+function hasThemeReset(node, inlineOnly = false) {
   return atrulesNamed(node, "theme").some((theme) => {
+    if (inlineOnly && !preludeIdentifiers(theme).includes("inline")) return false;
     if (blockChildren2(theme).some(isThemeReset)) return true;
     let nested = false;
     walkNodes(theme, (child) => {
@@ -11203,10 +11270,10 @@ var themeResetRule = {
           }
           return;
         }
-        if (!hasReset) {
+        if (!hasThemeReset(node, true)) {
           context.report({
             node,
-            message: "globals.css must reset Tailwind's default theme with --*: initial inside @theme or @theme inline."
+            message: "globals.css must reset Tailwind's default theme with --*: initial inside @theme inline."
           });
         }
       }
@@ -11295,13 +11362,226 @@ var uniqueCssDefinitionRule = {
 
 // eslint/rules/tailwind/unique-css-token-value.ts
 import path77 from "path";
+
+// eslint/rules/tailwind/css-named-colors.ts
+var CSS_NAMED_COLORS = {
+  aliceblue: [240, 248, 255],
+  antiquewhite: [250, 235, 215],
+  aqua: [0, 255, 255],
+  aquamarine: [127, 255, 212],
+  azure: [240, 255, 255],
+  beige: [245, 245, 220],
+  bisque: [255, 228, 196],
+  black: [0, 0, 0],
+  blanchedalmond: [255, 235, 205],
+  blue: [0, 0, 255],
+  blueviolet: [138, 43, 226],
+  brown: [165, 42, 42],
+  burlywood: [222, 184, 135],
+  cadetblue: [95, 158, 160],
+  chartreuse: [127, 255, 0],
+  chocolate: [210, 105, 30],
+  coral: [255, 127, 80],
+  cornflowerblue: [100, 149, 237],
+  cornsilk: [255, 248, 220],
+  crimson: [220, 20, 60],
+  cyan: [0, 255, 255],
+  darkblue: [0, 0, 139],
+  darkcyan: [0, 139, 139],
+  darkgoldenrod: [184, 134, 11],
+  darkgray: [169, 169, 169],
+  darkgreen: [0, 100, 0],
+  darkgrey: [169, 169, 169],
+  darkkhaki: [189, 183, 107],
+  darkmagenta: [139, 0, 139],
+  darkolivegreen: [85, 107, 47],
+  darkorange: [255, 140, 0],
+  darkorchid: [153, 50, 204],
+  darkred: [139, 0, 0],
+  darksalmon: [233, 150, 122],
+  darkseagreen: [143, 188, 143],
+  darkslateblue: [72, 61, 139],
+  darkslategray: [47, 79, 79],
+  darkslategrey: [47, 79, 79],
+  darkturquoise: [0, 206, 209],
+  darkviolet: [148, 0, 211],
+  deeppink: [255, 20, 147],
+  deepskyblue: [0, 191, 255],
+  dimgray: [105, 105, 105],
+  dimgrey: [105, 105, 105],
+  dodgerblue: [30, 144, 255],
+  firebrick: [178, 34, 34],
+  floralwhite: [255, 250, 240],
+  forestgreen: [34, 139, 34],
+  fuchsia: [255, 0, 255],
+  gainsboro: [220, 220, 220],
+  ghostwhite: [248, 248, 255],
+  gold: [255, 215, 0],
+  goldenrod: [218, 165, 32],
+  gray: [128, 128, 128],
+  green: [0, 128, 0],
+  greenyellow: [173, 255, 47],
+  grey: [128, 128, 128],
+  honeydew: [240, 255, 240],
+  hotpink: [255, 105, 180],
+  indianred: [205, 92, 92],
+  indigo: [75, 0, 130],
+  ivory: [255, 255, 240],
+  khaki: [240, 230, 140],
+  lavender: [230, 230, 250],
+  lavenderblush: [255, 240, 245],
+  lawngreen: [124, 252, 0],
+  lemonchiffon: [255, 250, 205],
+  lightblue: [173, 216, 230],
+  lightcoral: [240, 128, 128],
+  lightcyan: [224, 255, 255],
+  lightgoldenrodyellow: [250, 250, 210],
+  lightgray: [211, 211, 211],
+  lightgreen: [144, 238, 144],
+  lightgrey: [211, 211, 211],
+  lightpink: [255, 182, 193],
+  lightsalmon: [255, 160, 122],
+  lightseagreen: [32, 178, 170],
+  lightskyblue: [135, 206, 250],
+  lightslategray: [119, 136, 153],
+  lightslategrey: [119, 136, 153],
+  lightsteelblue: [176, 196, 222],
+  lightyellow: [255, 255, 224],
+  lime: [0, 255, 0],
+  limegreen: [50, 205, 50],
+  linen: [250, 240, 230],
+  magenta: [255, 0, 255],
+  maroon: [128, 0, 0],
+  mediumaquamarine: [102, 205, 170],
+  mediumblue: [0, 0, 205],
+  mediumorchid: [186, 85, 211],
+  mediumpurple: [147, 112, 219],
+  mediumseagreen: [60, 179, 113],
+  mediumslateblue: [123, 104, 238],
+  mediumspringgreen: [0, 250, 154],
+  mediumturquoise: [72, 209, 204],
+  mediumvioletred: [199, 21, 133],
+  midnightblue: [25, 25, 112],
+  mintcream: [245, 255, 250],
+  mistyrose: [255, 228, 225],
+  moccasin: [255, 228, 181],
+  navajowhite: [255, 222, 173],
+  navy: [0, 0, 128],
+  oldlace: [253, 245, 230],
+  olive: [128, 128, 0],
+  olivedrab: [107, 142, 35],
+  orange: [255, 165, 0],
+  orangered: [255, 69, 0],
+  orchid: [218, 112, 214],
+  palegoldenrod: [238, 232, 170],
+  palegreen: [152, 251, 152],
+  paleturquoise: [175, 238, 238],
+  palevioletred: [219, 112, 147],
+  papayawhip: [255, 239, 213],
+  peachpuff: [255, 218, 185],
+  peru: [205, 133, 63],
+  pink: [255, 192, 203],
+  plum: [221, 160, 221],
+  powderblue: [176, 224, 230],
+  purple: [128, 0, 128],
+  rebeccapurple: [102, 51, 153],
+  red: [255, 0, 0],
+  rosybrown: [188, 143, 143],
+  royalblue: [65, 105, 225],
+  saddlebrown: [139, 69, 19],
+  salmon: [250, 128, 114],
+  sandybrown: [244, 164, 96],
+  seagreen: [46, 139, 87],
+  seashell: [255, 245, 238],
+  sienna: [160, 82, 45],
+  silver: [192, 192, 192],
+  skyblue: [135, 206, 235],
+  slateblue: [106, 90, 205],
+  slategray: [112, 128, 144],
+  slategrey: [112, 128, 144],
+  snow: [255, 250, 250],
+  springgreen: [0, 255, 127],
+  steelblue: [70, 130, 180],
+  tan: [210, 180, 140],
+  teal: [0, 128, 128],
+  thistle: [216, 191, 216],
+  tomato: [255, 99, 71],
+  turquoise: [64, 224, 208],
+  violet: [238, 130, 238],
+  wheat: [245, 222, 179],
+  white: [255, 255, 255],
+  whitesmoke: [245, 245, 245],
+  yellow: [255, 255, 0],
+  yellowgreen: [154, 205, 50]
+};
+
+// eslint/rules/tailwind/unique-css-token-value.ts
+function normalizedColor(text) {
+  const hex = /^#(?<digits>[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/iu.exec(text)?.groups?.digits;
+  if (hex) {
+    const expanded = hex.length <= 4 ? Array.from(hex.matchAll(/./gu), (match) => match[0] + match[0]).join("") : hex;
+    const channels2 = [0, 2, 4].map((start) => Number.parseInt(expanded.slice(start, start + 2), 16));
+    const alpha2 = expanded.length === 8 ? Number.parseInt(expanded.slice(6, 8), 16) / 255 : 1;
+    return `srgb:${channels2.join(",")}/${String(alpha2)}`;
+  }
+  const named = CSS_NAMED_COLORS[text.toLowerCase()];
+  if (Array.isArray(named)) return `srgb:${named.join(",")}/1`;
+  const expression = /^(?<kind>rgba?|hsla?)\(\s*(?<body>[^()]*)\s*\)$/iu.exec(text);
+  if (!expression?.groups) return void 0;
+  const parts = (expression.groups.body ?? "").replace(/,/gu, " ").replace(/\//gu, " / ").trim().split(/\s+/u);
+  const alphaIndex = parts[3] === "/" ? 4 : 3;
+  if (parts.length !== 3 && !(parts.length === 4 && parts[3] !== "/") && !(parts.length === 5 && parts[3] === "/")) {
+    return void 0;
+  }
+  const alphaText = parts[alphaIndex];
+  const parseNumeric = (raw) => {
+    if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)%?$/u.test(raw)) return void 0;
+    const numeric = Number.parseFloat(raw);
+    return Number.isFinite(numeric) ? numeric : void 0;
+  };
+  const alpha = alphaText === void 0 ? 1 : parseNumeric(alphaText);
+  if (alpha === void 0 || alpha < 0 || (alphaText?.endsWith("%") ? alpha > 100 : alpha > 1)) return void 0;
+  const opacity = alphaText?.endsWith("%") ? alpha / 100 : alpha;
+  const kind = expression.groups.kind?.toLowerCase();
+  let channels;
+  if (kind === "rgb" || kind === "rgba") {
+    const rgb = parts.slice(0, 3).map((part) => {
+      const value = parseNumeric(part);
+      if (value === void 0) return Number.NaN;
+      if (part.endsWith("%")) return value * 255 / 100;
+      return value;
+    });
+    if (rgb.some((value) => !Number.isFinite(value) || value < 0 || value > 255)) return void 0;
+    channels = rgb;
+  } else {
+    const hue = parseNumeric(parts[0] ?? "");
+    const saturation = parseNumeric(parts[1] ?? "");
+    const lightness = parseNumeric(parts[2] ?? "");
+    if (hue === void 0 || saturation === void 0 || lightness === void 0) return void 0;
+    if (parts[0]?.endsWith("%") || !parts[1]?.endsWith("%") || !parts[2]?.endsWith("%")) return void 0;
+    if (saturation < 0 || saturation > 100 || lightness < 0 || lightness > 100) return void 0;
+    const h = (hue % 360 + 360) % 360;
+    const s = saturation / 100;
+    const l = lightness / 100;
+    const chroma = (1 - Math.abs(2 * l - 1)) * s;
+    const x = chroma * (1 - Math.abs(h / 60 % 2 - 1));
+    const m = l - chroma / 2;
+    let rgb;
+    if (h < 60) rgb = [chroma, x, 0];
+    else if (h < 120) rgb = [x, chroma, 0];
+    else if (h < 180) rgb = [0, chroma, x];
+    else if (h < 240) rgb = [0, x, chroma];
+    else if (h < 300) rgb = [x, 0, chroma];
+    else rgb = [chroma, 0, x];
+    const exact = rgb.map((channel) => (channel + m) * 255);
+    if (exact.some((channel) => Math.abs(channel - Math.round(channel)) > 1e-10)) return void 0;
+    channels = exact.map(Math.round);
+  }
+  return `srgb:${channels.join(",")}/${String(opacity)}`;
+}
 function valueIdentity(value) {
   const text = value.trim();
-  const hex = /^#(?<digits>[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/iu.exec(text)?.groups?.digits;
-  if (!hex) return text;
-  const lower = hex.toLowerCase();
-  const full = lower.length <= 4 ? Array.from(lower, (digit) => digit + digit).join("") : lower;
-  return `#${full.length === 8 && full.endsWith("ff") ? full.slice(0, -2) : full}`;
+  return normalizedColor(text) ?? text;
 }
 function isComparable(symbol) {
   if (symbol.value === void 0 || symbol.value.trim() === "") return false;
@@ -11345,10 +11625,11 @@ var uniqueCssTokenValueRule = {
     const redundant = /* @__PURE__ */ new Map();
     for (const group of byValue.values()) {
       group.sort(compareLocations);
-      const first = group[0];
-      if (!first) continue;
-      for (const definition of group.slice(1)) {
-        if (definition.name !== first.name) redundant.set(definition, first);
+      const seen = [];
+      for (const definition of group) {
+        const original = seen.find((prior) => prior.name !== definition.name);
+        if (original) redundant.set(definition, original);
+        seen.push(definition);
       }
     }
     return {
@@ -12042,7 +12323,7 @@ var utilityMappingRule = {
 import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync13 } from "fs";
 import path80 from "path";
-import { generate as generate7, parse as parse7, toPlainObject as toPlainObject2 } from "@eslint/css-tree";
+import { generate as generate6, parse as parse7, toPlainObject as toPlainObject2 } from "@eslint/css-tree";
 function numericPart(value) {
   const match = /^(?<negative>-?)(?<number>(?:\d+(?:\.\d+)?|\.\d+))(?<unit>%|px|rem|em|vw|vh|dvw|dvh|ch|fr|s|ms|deg|turn)?$/u.exec(
     value
@@ -12052,7 +12333,7 @@ function numericPart(value) {
   const sign = match.groups.negative === "-" ? "neg-" : "";
   return sign + number + (match.groups.unit === "%" ? "pct" : match.groups.unit ?? "");
 }
-function readableValue(value) {
+function simpleValueSlug(value) {
   const words = value.trim().replace(/,/gu, "_comma_").split(/[_\s]+/u).filter(Boolean);
   if (words.length === 0 || words.length > 8) return void 0;
   const parts = [];
@@ -12148,16 +12429,17 @@ function compiledOperation(compiled, index) {
       (child) => child.type === "Declaration" && child.property === "--tw-shadow"
     );
     if (shadow?.type === "Declaration") {
-      return { property: "box-shadow", value: generate7(shadow.value).trim() };
+      return { property: "box-shadow", value: generate6(shadow.value).trim() };
     }
   }
-  return { property: declaration.property, value: generate7(declaration.value).trim() };
+  return { property: declaration.property, value: generate6(declaration.value).trim() };
+}
+function propertyPrefix(property) {
+  return property.replace(/^-+/u, "").replace(/^background-/u, "bg-");
 }
 function expectedName(operation) {
-  const value = readableValue(operation.value);
-  if (!value) return void 0;
-  const property = operation.property.replace(/^-+/u, "").replace(/^background-/u, "bg-");
-  return `${property}-${value}`;
+  const value = simpleValueSlug(operation.value);
+  return value ? `${propertyPrefix(operation.property)}-${value}` : void 0;
 }
 function singleApply(utility, textOf) {
   const children = blockChildren2(utility);
@@ -12171,7 +12453,7 @@ var utilityNameParityRule = {
     schema: [],
     type: "problem",
     docs: {
-      description: "Use property/value-derived names for readable values and semantic names for complex values."
+      description: "Use property/value-derived names for simple values and property-prefixed semantic names for complex values."
     }
   },
   create(context) {
@@ -12205,8 +12487,16 @@ var utilityNameParityRule = {
             if (/-hash-[a-f0-9]{12}$/u.test(candidate.name)) {
               context.report({
                 node: candidate.utility,
-                message: `Custom utility "${candidate.name}" uses an opaque hash for a complex ${operation.property} value; use a semantic name, or prefer a theme-generated utility where supported.`
+                message: `Custom utility "${candidate.name}" uses an opaque hash for a complex ${operation.property} value; use a semantic name with a property prefix, or prefer a theme-generated utility where supported.`
               });
+            } else {
+              const prefix = `${propertyPrefix(operation.property)}-`;
+              if (!candidate.name.startsWith(prefix) || candidate.name.length === prefix.length) {
+                context.report({
+                  node: candidate.utility,
+                  message: `Custom utility "${candidate.name}" maps a complex ${operation.property} value; use a semantic name starting with "${prefix}" to preserve the CSS property.`
+                });
+              }
             }
             continue;
           }
@@ -12227,6 +12517,7 @@ var tailwindRules = {
   "theme-reset": themeResetRule,
   "theme-mode": themeModeRule,
   "color-role-usage": colorRoleUsageRule,
+  "color-literal-usage": colorLiteralUsageRule,
   "root-variables": rootVariablesRule,
   "apply-usage": applyUsageRule,
   "base-layer-pair": baseLayerPairRule,
@@ -12465,7 +12756,9 @@ var SPACING_UTILITY_PREFIXES = /* @__PURE__ */ new Set([
   "start",
   "end",
   "space-x",
-  "space-y"
+  "space-y",
+  "translate-x",
+  "translate-y"
 ]);
 var PREFIX_BUILTINS = {
   bg: [
@@ -12790,6 +13083,7 @@ function readInventory(files) {
   const themeTokensByNamespace = /* @__PURE__ */ new Map();
   const plainClasses = /* @__PURE__ */ new Set();
   let defaultsReset = false;
+  let baseSpacing = false;
   for (const file of files) {
     let css2;
     try {
@@ -12808,6 +13102,7 @@ function readInventory(files) {
     for (const plainClass of classSelectors(css2)) plainClasses.add(plainClass);
     for (const block of themeBlocks(css2)) {
       if (/--\*\s*:\s*initial\b/.test(block)) defaultsReset = true;
+      if (/(?:^|[;{])\s*--spacing\s*:/.test(block)) baseSpacing = true;
       for (const decl of block.matchAll(/--(?<namespace>[a-z][a-z0-9]*)-(?<token>[a-z0-9][a-z0-9_-]*)\s*:/g)) {
         let namespace = decl.groups?.namespace;
         let token = decl.groups?.token;
@@ -12843,6 +13138,7 @@ function readInventory(files) {
     utilityPrefixes,
     themeTokens: themeTokensByNamespace,
     defaultsReset,
+    baseSpacing,
     plainClasses
   };
 }
@@ -12871,7 +13167,13 @@ function isKnown(className, inventory) {
   const namespaces = PREFIX_NAMESPACES[prefix];
   if (!namespaces) {
     if (STATIC_VALUE_TOKENS[prefix]?.includes(token)) return true;
-    if (SPACING_UTILITY_PREFIXES.has(prefix) && inventory.themeTokens.get("spacing")?.has(token)) return true;
+    if (SPACING_UTILITY_PREFIXES.has(prefix)) {
+      const spacing = inventory.themeTokens.get("spacing");
+      if (/^(?:\d+(?:\.\d+)?|\.\d+)$/u.test(token) && inventory.defaultsReset && !inventory.baseSpacing) {
+        return false;
+      }
+      if (spacing?.has(token)) return true;
+    }
     const projectTokens = inventory.themeTokens.get(prefix);
     if (projectTokens) {
       if (projectTokens.has(token)) return true;
@@ -13620,7 +13922,7 @@ var tailwindStructureRules = {
   languageOptions: { tolerant: true },
   rules: Object.fromEntries(
     tailwindRuleIds.filter(
-      (id) => id !== "pasika/css-entry-point" && id !== "pasika/feature-css-placement" && id !== "pasika/unique-css-definition" && id !== "pasika/utility-mapping" && id !== "pasika/utility-name-parity" && id !== "pasika/no-utility-alias" && id !== "pasika/root-variables" && id !== "pasika/color-role-usage" && id !== "pasika/theme-mode"
+      (id) => id !== "pasika/css-entry-point" && id !== "pasika/feature-css-placement" && id !== "pasika/unique-css-definition" && id !== "pasika/utility-mapping" && id !== "pasika/utility-name-parity" && id !== "pasika/no-utility-alias" && id !== "pasika/root-variables" && id !== "pasika/color-role-usage" && id !== "pasika/color-literal-usage" && id !== "pasika/theme-mode"
     ).map((id) => [id, "error"])
   )
 };
@@ -13643,6 +13945,7 @@ var tailwindImportGraph = {
     "pasika/no-utility-alias": "error",
     "pasika/root-variables": "error",
     "pasika/color-role-usage": "error",
+    "pasika/color-literal-usage": "error",
     "pasika/theme-mode": "error"
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pasika",
-  "version": "0.10.133",
+  "version": "0.10.135",
   "description": "Reusable agent setup package",
   "repository": {
     "type": "git",