pasika 0.10.117 → 0.10.119

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

@@ -128,6 +128,7 @@ declare const tailwindRules: {
     "stylesheet-ordering": _eslint_css.CSSRuleDefinition;
     "custom-utility-apply": _eslint_css.CSSRuleDefinition;
     "utility-mapping": _eslint_css.CSSRuleDefinition;
+    "utility-name-parity": _eslint_css.CSSRuleDefinition;
     "css-entry-point": _eslint_css.CSSRuleDefinition;
     "feature-css-placement": _eslint_css.CSSRuleDefinition;
     "global-stylesheet": _eslint_css.CSSRuleDefinition;
@@ -168,6 +169,7 @@ declare const pasikaPlugin: {
         "stylesheet-ordering": _eslint_css.CSSRuleDefinition;
         "custom-utility-apply": _eslint_css.CSSRuleDefinition;
         "utility-mapping": _eslint_css.CSSRuleDefinition;
+        "utility-name-parity": _eslint_css.CSSRuleDefinition;
         "css-entry-point": _eslint_css.CSSRuleDefinition;
         "feature-css-placement": _eslint_css.CSSRuleDefinition;
         "global-stylesheet": _eslint_css.CSSRuleDefinition;

package/dist/eslint/pasika/index.js

@@ -10095,6 +10095,7 @@ function themeClasses(name) {
     }
     return ["bg", "text", "border", "fill", "stroke", "ring"].map((prefix) => `${prefix}-${stem}`);
   }
+  if (name.startsWith("--background-image-")) return [`bg-${name.slice("--background-image-".length)}`];
   if (name.startsWith("--spacing-")) {
     const stem = name.slice("--spacing-".length);
     return [
@@ -11160,6 +11161,7 @@ var themeOperations = [
   { property: "tab-size", prefix: "tab", namespace: "tab-size" },
   { property: "border-radius", prefix: "rounded", namespace: "radius" },
   { property: "background-color", prefix: "bg", namespace: "color" },
+  { property: "background-image", prefix: "bg", namespace: "background-image" },
   { property: "color", prefix: "text", namespace: "color" },
   { property: "border-color", prefix: "border", namespace: "color" },
   { property: "outline-color", prefix: "outline", namespace: "color" },
@@ -11194,9 +11196,9 @@ function themeCandidate(name, utilityText) {
   const typed = /^@utility\s+[\w-]+\s*\{\s*@apply\s+(?<kind>[a-z]+)-\((?<hint>[a-z-]+:)?(?<variable>--[a-z][a-z0-9-]*)\);?\s*\}$/u.exec(
     source
   );
-  const property = arbitrary?.groups?.property;
+  const direct = /^@utility\s+[\w-]+\s*\{\s*(?<property>[a-z-]+)\s*:\s*(?<value>[^;{}\r\n]+);?\s*\}$/u.exec(source);
+  const property = arbitrary?.groups?.property ?? direct?.groups?.property;
   const matched = themeOperations.find((operation) => {
-    if (!name.startsWith(`${operation.prefix}-`) || name.length <= operation.prefix.length + 1) return false;
     if (property) return property === operation.property;
     if (typed?.groups?.kind !== operation.prefix) return false;
     const hint = typed.groups.hint;
@@ -11204,23 +11206,23 @@ function themeCandidate(name, utilityText) {
     if (operation.prefix === "font") {
       return hint === (operation.property === "font-family" ? "family-name:" : "number:");
     }
+    if (operation.prefix === "bg") {
+      return hint === (operation.property === "background-image" ? "image:" : "color:");
+    }
+    if (["border", "outline", "decoration", "stroke"].includes(operation.prefix)) return hint === "color:";
     return hint === void 0;
   });
   if (!matched) return void 0;
-  const value = arbitrary?.groups?.value?.trim() ?? (typed?.groups?.variable ? `var(${typed.groups.variable})` : void 0);
+  const value = arbitrary?.groups?.value?.trim() ?? direct?.groups?.value?.trim() ?? (typed?.groups?.variable ? `var(${typed.groups.variable})` : void 0);
   if (!value) return void 0;
-  const simple = /^-?(?:\d+(?:\.\d+)?|\.\d+)(?:px|rem|em|%|vh|vw|ch|deg)?$/u.test(value);
-  const variable = /^var\(--[a-z][a-z0-9-]*\)$/u.test(value);
-  const color = /^#[\da-f]{3,8}$/iu.test(value);
-  const keyword = /^[a-z][a-z-]*$/u.test(value);
-  const ratio = /^\d+\/\d+$/u.test(value);
-  if (!simple && !variable && !color && !keyword && !ratio) return void 0;
-  if (matched.property === "font-size" && value.startsWith("-")) return void 0;
-  const stem = name.slice(matched.prefix.length + 1);
+  if (arbitrary && (/\\|["']|\burl\(/iu.test(value) || /var\(--[^)]*_/iu.test(value))) return void 0;
+  const cssValue = arbitrary ? value.replaceAll("_", " ") : value;
+  if (matched.property === "font-size" && cssValue.startsWith("-")) return void 0;
+  const stem = name.startsWith(`${matched.prefix}-`) ? name.slice(matched.prefix.length + 1) : void 0;
   return {
-    token: `--${matched.namespace}-${stem}`,
+    token: stem ? `--${matched.namespace}-${stem}` : "",
     property: matched.property,
-    value,
+    value: cssValue,
     prefix: matched.prefix,
     namespace: matched.namespace
   };
@@ -11282,6 +11284,37 @@ var utilityMappingRule = {
       includeReferences: false
     });
     const projectTokens = graph.definitions.filter((symbol) => symbol.kind === "theme-token");
+    const rootDefinitions = /* @__PURE__ */ new Map();
+    for (const symbol of graph.definitions) {
+      if (symbol.kind !== "root-variable" || !symbol.value) continue;
+      const values = rootDefinitions.get(symbol.name) ?? [];
+      values.push({ value: symbol.value, scope: symbol.scope ?? "default" });
+      rootDefinitions.set(symbol.name, values);
+    }
+    function comparableValue(value, visited = /* @__PURE__ */ new Set()) {
+      const text = value.trim();
+      const match = /^var\((?<name>--[a-z][a-z0-9-]*)\)$/u.exec(text);
+      const name = match?.groups?.name;
+      if (!name) {
+        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();
+        return lower.length <= 4 ? Array.from(lower, (digit) => digit + digit).join("") : lower;
+      }
+      if (visited.has(name)) return void 0;
+      const values = rootDefinitions.get(name);
+      if (!values) return text;
+      if (values.length !== 1 || values[0]?.scope !== "default") return void 0;
+      const next = values[0].value;
+      if (!next) return void 0;
+      visited.add(name);
+      return comparableValue(next, visited);
+    }
+    function equivalentValue(a, b) {
+      const left = comparableValue(a);
+      const right = comparableValue(b);
+      return left !== void 0 && right !== void 0 && left === right;
+    }
     return {
       "StyleSheet:exit"(node) {
         const utilities = atrulesNamed(node, "utility");
@@ -11307,6 +11340,16 @@ var utilityMappingRule = {
             themeDefinitions.set(child.property, definitions);
           }
         }
+        for (const cssRule of node.children) {
+          if (cssRule.type !== "Rule") continue;
+          if (context.sourceCode.getText(cssRule.prelude).trim() !== ":root") continue;
+          for (const child of blockChildren2(cssRule)) {
+            if (child.type !== "Declaration" || !child.property.startsWith("--")) continue;
+            if (rootDefinitions.has(child.property)) continue;
+            const value = declarationValue(context.sourceCode.getText(child));
+            if (value) rootDefinitions.set(child.property, [{ value, scope: "default" }]);
+          }
+        }
         const rootValues = /* @__PURE__ */ new Map();
         const overriddenVariables = /* @__PURE__ */ new Set();
         for (const cssRule of rules(node)) {
@@ -11358,8 +11401,55 @@ var utilityMappingRule = {
             break;
           }
         }
+        function matchingThemeToken(candidate) {
+          const namespacePrefix = `--${candidate.namespace}-`;
+          const available = [
+            ...projectTokens,
+            ...[...themeDefinitions].flatMap(
+              ([name, definitions]) => definitions.length === 1 && definitions[0] ? [{ name, value: definitions[0].value }] : []
+            )
+          ];
+          for (const token of available) {
+            if (!token.value || !token.name.startsWith(namespacePrefix) || token.name.includes("--", 2)) continue;
+            if (!equivalentValue(candidate.value, token.value)) continue;
+            if (candidate.namespace === "text" && ["--line-height", "--letter-spacing", "--font-weight"].some(
+              (suffix) => themeDefinitions.has(`${token.name}${suffix}`) || projectTokens.some((entry) => entry.name === `${token.name}${suffix}`)
+            )) {
+              continue;
+            }
+            const generatedClass = `${candidate.prefix}-${token.name.slice(namespacePrefix.length)}`;
+            if (candidate.namespace === "color" && !themeClasses(token.name).includes(generatedClass)) continue;
+            return generatedClass;
+          }
+          return void 0;
+        }
         for (const utility of utilities) {
           const name = preludeIdentifiers(utility)[0] ?? "unknown";
+          const source = context.sourceCode.getText(utility);
+          const zIndex = /^@utility\s+[\w-]+\s*\{\s*@apply\s+\[z-index:(?<value>-?\d+|auto)\];?\s*\}$/u.exec(source)?.groups?.value;
+          const numericZIndex = zIndex && zIndex !== "auto" ? Number(zIndex) : void 0;
+          let nativeClass;
+          if (zIndex === "auto") {
+            nativeClass = "z-auto";
+          } else if (numericZIndex !== void 0 && Number.isSafeInteger(numericZIndex)) {
+            nativeClass = numericZIndex < 0 ? `-z-${String(-numericZIndex)}` : `z-${String(numericZIndex)}`;
+          }
+          if (nativeClass && zIndex) {
+            context.report({
+              node: utility,
+              message: `Custom utility "${name}" duplicates built-in "${nativeClass}" (z-index: ${zIndex}); use "${nativeClass}" directly.`
+            });
+            continue;
+          }
+          const candidate = themeCandidate(name, source);
+          const equivalent = candidate ? matchingThemeToken(candidate) : void 0;
+          if (candidate && equivalent && nameCounts.get(name) === 1) {
+            context.report({
+              node: utility,
+              message: `Custom utility "${name}" duplicates theme-generated "${equivalent}" (${candidate.property}: ${candidate.value}); reuse "${equivalent}" instead.`
+            });
+            continue;
+          }
           const operationCount = applyOperationCount(utility);
           if (operationCount !== 1) {
             context.report({
@@ -11368,46 +11458,244 @@ var utilityMappingRule = {
             });
             continue;
           }
-          if (nameCounts.get(name) !== 1) continue;
-          const candidate = themeCandidate(name, context.sourceCode.getText(utility));
-          if (!candidate) continue;
-          const tokenAlreadyDefined = themeTokens.has(candidate.token) || projectTokens.some((token) => token.name === candidate.token);
-          const namespacePrefix = `--${candidate.namespace}-`;
-          const staticValue = !/\b(?:var|env|attr|calc|min|max|clamp|color-mix|light-dark)\s*\(/iu.test(
-            candidate.value
-          );
-          const valueKey = (value) => {
-            const input = value.trim();
-            const digits = /^#(?<hex>[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/iu.exec(input)?.groups?.hex;
-            if (digits) {
-              const lower = digits.toLowerCase();
-              return lower.length <= 4 ? Array.from(lower, (digit) => digit + digit).join("") : lower;
-            }
-            return input;
-          };
-          const sameOperation = (token, value) => token.startsWith(namespacePrefix) && !token.includes("--", 2) && valueKey(value) === valueKey(candidate.value) && (candidate.namespace !== "text" || !["--line-height", "--letter-spacing", "--font-weight"].some(
-            (suffix) => themeDefinitions.has(`${token}${suffix}`) || projectTokens.some((definition) => definition.name === `${token}${suffix}`)
-          ));
-          const equivalent = staticValue ? projectTokens.find((token) => token.value !== void 0 && sameOperation(token.name, token.value)) : void 0;
-          const localEquivalent = staticValue ? [...themeDefinitions].find(
-            ([token, definitions]) => definitions.length === 1 && definitions[0]?.value !== void 0 && sameOperation(token, definitions[0].value)
-          )?.[0] : void 0;
-          const existingToken = equivalent?.name ?? localEquivalent;
-          if (tokenAlreadyDefined && !existingToken) continue;
-          if (existingToken) {
-            const className = `${candidate.prefix}-${existingToken.slice(namespacePrefix.length)}`;
+          if (nameCounts.get(name) !== 1 || !candidate) continue;
+          if (!candidate.token) {
             context.report({
               node: utility,
-              message: `Custom utility "${name}" duplicates theme-generated "${className}" (${candidate.property}: ${candidate.value}); reuse "${className}" instead.`
+              message: `Custom utility "${name}" only maps ${candidate.property} (${candidate.value}); define an @theme token in the "--${candidate.namespace}-*" namespace and use its generated "${candidate.prefix}-*" class instead.`
             });
             continue;
           }
+          const tokenAlreadyDefined = themeTokens.has(candidate.token) || projectTokens.some((token) => token.name === candidate.token);
+          if (tokenAlreadyDefined) continue;
           if (candidate.property === "font-size" && themeTokens.has(`--color-${name.slice(5)}`)) continue;
           context.report({
             node: utility,
             message: `Custom utility "${name}" only maps ${candidate.property} (${candidate.value}); prefer @theme inline token "${candidate.token}" backed by a :root variable. Preserve the class name and compare compiled CSS before removing the utility.`
           });
         }
+        function checkClass(cssNode) {
+          if (cssNode.type === "Atrule") {
+            if (cssNode.name !== "layer" || !("prelude" in cssNode) || !cssNode.prelude) return;
+            if (context.sourceCode.getText(cssNode.prelude).trim() === "base") return;
+            for (const child of blockChildren2(cssNode)) checkClass(child);
+            return;
+          }
+          if (cssNode.type !== "Rule") return;
+          const selector = context.sourceCode.getText(cssNode.prelude).trim();
+          if (!/^\.[a-zA-Z_][\w-]*$/u.test(selector)) return;
+          const children = blockChildren2(cssNode);
+          if (children.length !== 1) return;
+          const only = children[0];
+          if (!only) return;
+          const declarationText = context.sourceCode.getText(only).trim();
+          if (only.type === "Atrule" && only.name === "apply") {
+            const alias = /^@apply\s+(?<name>[a-z][a-z0-9-]*)\s*;?$/u.exec(declarationText)?.groups?.name;
+            if (alias && [...projectTokens.map((token) => token.name), ...themeDefinitions.keys()].some(
+              (name) => themeClasses(name).includes(alias)
+            )) {
+              context.report({
+                node: cssNode,
+                message: `CSS class "${selector}" only aliases theme-generated "${alias}"; use "${alias}" instead.`
+              });
+              return;
+            }
+          }
+          const found = only.type === "Declaration" ? /^(?<property>[a-z-]+)\s*:\s*(?<value>[^;{}]+);?$/u.exec(declarationText) : /^@apply\s+\[(?<property>[a-z-]+):(?<value>[^\]\r\n;{}]+)\]\s*;?$/u.exec(declarationText);
+          const property = found?.groups?.property;
+          const value = found?.groups?.value?.trim();
+          if (!property || !value || value.endsWith("!important")) return;
+          const operation = themeOperations.find((item) => item.property === property);
+          if (!operation) return;
+          const candidate = {
+            token: "",
+            property,
+            value,
+            prefix: operation.prefix,
+            namespace: operation.namespace
+          };
+          const equivalent = matchingThemeToken(candidate);
+          if (!equivalent) return;
+          context.report({
+            node: cssNode,
+            message: `CSS class "${selector}" duplicates theme-generated "${equivalent}" (${property}: ${value}); use "${equivalent}" instead.`
+          });
+        }
+        for (const cssRule of node.children) checkClass(cssRule);
+      }
+    };
+  }
+};
+
+// eslint/rules/tailwind/utility-name-parity.ts
+import { spawnSync } from "child_process";
+import { createHash } from "crypto";
+import { existsSync as existsSync12 } from "fs";
+import path78 from "path";
+import { generate as generate4, parse as parse7, toPlainObject as toPlainObject3 } 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
+  );
+  if (!match?.groups?.number) return void 0;
+  const number = String(Number(match.groups.number)).replace(".", "p");
+  const sign = match.groups.negative === "-" ? "neg-" : "";
+  return sign + number + (match.groups.unit === "%" ? "pct" : match.groups.unit ?? "");
+}
+function readableValue(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 = [];
+  for (const word of words) {
+    const numeric = numericPart(word);
+    if (numeric) {
+      parts.push(numeric);
+      continue;
+    }
+    const hex = /^#(?<color>[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/iu.exec(word)?.groups?.color;
+    if (hex) {
+      parts.push("hex", hex.toLowerCase());
+      continue;
+    }
+    const variable = /^var\(--(?<name>[a-z][a-z0-9-]*)\)$/u.exec(word)?.groups?.name;
+    if (variable) {
+      parts.push("var", variable);
+      continue;
+    }
+    if (/^[a-z][a-z0-9-]*$/iu.test(word)) {
+      parts.push(word.toLowerCase());
+      continue;
+    }
+    return void 0;
+  }
+  const slug = parts.join("-");
+  return slug.length <= 70 ? slug : void 0;
+}
+function compoundValue(value) {
+  const readable = readableValue(value);
+  if (readable) return readable;
+  const candidate = /^(?<fn>[a-z][a-z0-9-]*)\(/iu.exec(value.trim())?.groups?.fn?.toLowerCase();
+  const hint = candidate?.endsWith("-") ? void 0 : candidate;
+  const digest = createHash("sha256").update(value.trim()).digest("hex").slice(0, 12);
+  return [hint, "hash", digest].filter(Boolean).join("-");
+}
+var TAILWIND_WORKER = String.raw`
+import { readFileSync } from "node:fs";
+import { compile } from "tailwindcss";
+const applies = JSON.parse(readFileSync(0, "utf8"));
+const results = [];
+for (const [index, apply] of applies.entries()) {
+  const name = "pasika-probe-" + index;
+  try {
+    const compiler = await compile("@tailwind utilities; @utility " + name + " { " + apply + " }");
+    results.push({ css: compiler.build([name]) });
+  } catch (error) {
+    results.push({ error: String(error instanceof Error ? error.message : error) });
+  }
+}
+process.stdout.write(JSON.stringify(results));
+`;
+var compilerCache = /* @__PURE__ */ new Map();
+function isCompiledResult(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return "css" in value && typeof value.css === "string" || "error" in value && typeof value.error === "string";
+}
+function compileApplies(applies, cwd) {
+  const key = `${cwd}\0${JSON.stringify(applies)}`;
+  const cached = compilerCache.get(key);
+  if (cached) return cached;
+  const child = spawnSync(process.execPath, ["--input-type=module", "--eval", TAILWIND_WORKER], {
+    cwd,
+    input: JSON.stringify(applies),
+    encoding: "utf8",
+    timeout: 3e4,
+    maxBuffer: 8 * 1024 * 1024,
+    windowsHide: true
+  });
+  let results;
+  if (child.error || child.status !== 0) {
+    const reason = child.error?.message ?? (child.stderr.trim() || "Tailwind compilation failed");
+    results = applies.map(() => ({ error: reason }));
+  } else {
+    try {
+      const parsed = JSON.parse(child.stdout);
+      if (!Array.isArray(parsed)) throw new Error("Unexpected Tailwind output");
+      const values = parsed;
+      results = values.filter(isCompiledResult);
+      if (results.length !== applies.length) throw new Error("Unexpected Tailwind output");
+    } catch {
+      results = applies.map(() => ({ error: "Invalid Tailwind compiler response" }));
+    }
+  }
+  compilerCache.set(key, results);
+  return results;
+}
+function compiledOperation(compiled, index) {
+  if (!compiled.css) return void 0;
+  const sheet = toPlainObject3(parse7(compiled.css, { parseValue: false }));
+  const probe = rules(sheet).find((candidate) => selectorNames(candidate).includes(`pasika-probe-${String(index)}`));
+  if (!probe) return void 0;
+  const declarations = blockChildren2(probe).filter(
+    (child) => child.type === "Declaration" && !child.property.startsWith("--tw-")
+  );
+  if (declarations.length !== 1) return void 0;
+  const declaration = declarations[0];
+  if (declaration?.type !== "Declaration") return void 0;
+  return { property: declaration.property, value: generate4(declaration.value).trim() };
+}
+function expectedName(operation) {
+  const value = compoundValue(operation.value);
+  const property = operation.property.replace(/^-+/u, "").replace(/^background-/u, "bg-");
+  return `${property}-${value}`;
+}
+function singleApply(utility, textOf) {
+  const children = blockChildren2(utility);
+  if (children.length !== 1) return void 0;
+  const child = children[0];
+  if (child?.type !== "Atrule" || child.name !== "apply") return void 0;
+  return textOf(child);
+}
+var utilityNameParityRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require single-operation custom utilities to have deterministic property/value-derived names."
+    }
+  },
+  create(context) {
+    return {
+      "StyleSheet:exit"(node) {
+        const candidates = atrulesNamed(node, "utility").flatMap((utility) => {
+          const name = preludeIdentifiers(utility)[0];
+          if (!name || name.endsWith("-*")) return [];
+          const apply = singleApply(utility, (child) => context.sourceCode.getText(child));
+          return apply ? [{ utility, name, apply }] : [];
+        });
+        if (candidates.length === 0) return;
+        const physicalDir = path78.dirname(context.physicalFilename);
+        const cwd = path78.isAbsolute(physicalDir) && existsSync12(physicalDir) ? physicalDir : context.cwd;
+        const compiled = compileApplies(
+          candidates.map((candidate) => candidate.apply),
+          cwd
+        );
+        for (const [index, candidate] of candidates.entries()) {
+          const result = compiled[index];
+          const operation = result ? compiledOperation(result, index) : void 0;
+          if (!operation) {
+            context.report({
+              node: candidate.utility,
+              message: `Custom utility "${candidate.name}" applies "${candidate.apply}", but Tailwind cannot resolve exactly one CSS property${result?.error ? `: ${result.error}` : ""}; use an explicit [property:value] @apply mapping instead.`
+            });
+            continue;
+          }
+          const expected = expectedName(operation);
+          if (candidate.name === expected) continue;
+          context.report({
+            node: candidate.utility,
+            message: `Custom utility "${candidate.name}" maps ${operation.property}: ${operation.value}; rename it "${expected}" to preserve property/value parity.`
+          });
+        }
       }
     };
   }
@@ -11423,6 +11711,7 @@ var tailwindRules = {
   "stylesheet-ordering": stylesheetOrderingRule,
   "custom-utility-apply": customUtilityApplyRule,
   "utility-mapping": utilityMappingRule,
+  "utility-name-parity": utilityNameParityRule,
   "css-entry-point": cssEntryPointRule,
   "feature-css-placement": featureCssPlacementRule,
   "global-stylesheet": globalStylesheetRule,
@@ -11434,7 +11723,7 @@ var tailwindRules = {
 };
 
 // eslint/rules/type-extraction.ts
-import path78 from "path";
+import path79 from "path";
 var typeExtractionRule = {
   meta: {
     schema: [],
@@ -11445,7 +11734,7 @@ var typeExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path78.resolve(context.filename);
+    const file = path79.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot);
@@ -11584,11 +11873,11 @@ var uiStateRule = {
 };
 
 // eslint/rules/unknown-utility.ts
-import { existsSync as existsSync12, readdirSync as readdirSync6, readFileSync as readFileSync15, statSync as statSync6 } from "fs";
+import { existsSync as existsSync13, readdirSync as readdirSync6, readFileSync as readFileSync15, statSync as statSync6 } from "fs";
 import { createRequire } from "module";
-import path79 from "path";
+import path80 from "path";
 var PREFIX_NAMESPACES = {
-  bg: ["color"],
+  bg: ["color", "background-image"],
   text: ["color", "text"],
   border: ["color"],
   ring: ["color"],
@@ -11867,7 +12156,7 @@ function stylesheetFiles(dir) {
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path79.join(dir, entry);
+    const entryPath = path80.join(dir, entry);
     let stats;
     try {
       stats = statSync6(entryPath);
@@ -11875,7 +12164,7 @@ function stylesheetFiles(dir) {
       return [];
     }
     if (stats.isDirectory()) return stylesheetFiles(entryPath);
-    return path79.extname(entry) === ".css" ? [entryPath] : [];
+    return path80.extname(entry) === ".css" ? [entryPath] : [];
   });
 }
 function packageNameOf(specifier) {
@@ -11886,24 +12175,24 @@ function packageNameOf(specifier) {
 function resolvePackageStylesheet(fromFile, specifier) {
   const packageName = packageNameOf(specifier);
   if (!packageName || packageName === "tailwindcss") return void 0;
-  let directory = path79.dirname(fromFile);
-  while (directory !== path79.dirname(directory)) {
-    const packageRoot = path79.join(directory, "node_modules", packageName);
-    const manifestPath = path79.join(packageRoot, "package.json");
-    if (existsSync12(manifestPath)) {
+  let directory = path80.dirname(fromFile);
+  while (directory !== path80.dirname(directory)) {
+    const packageRoot = path80.join(directory, "node_modules", packageName);
+    const manifestPath = path80.join(packageRoot, "package.json");
+    if (existsSync13(manifestPath)) {
       try {
         const manifest = readFileSync15(manifestPath, "utf8");
         const stylesheet = /"style"\s*:\s*"(?<file>[^"]+\.css)"/.exec(manifest)?.groups?.file;
         const main = /"main"\s*:\s*"(?<file>[^"]+\.css)"/.exec(manifest)?.groups?.file;
         const target = stylesheet ?? main;
         if (!target) return void 0;
-        const resolved = path79.resolve(packageRoot, target);
-        return existsSync12(resolved) ? resolved : void 0;
+        const resolved = path80.resolve(packageRoot, target);
+        return existsSync13(resolved) ? resolved : void 0;
       } catch {
         return void 0;
       }
     }
-    directory = path79.dirname(directory);
+    directory = path80.dirname(directory);
   }
   return void 0;
 }
@@ -11994,8 +12283,12 @@ function readInventory(files) {
     for (const block of themeBlocks(css2)) {
       if (/--\*\s*:\s*initial\b/.test(block)) defaultsReset = true;
       for (const decl of block.matchAll(/--(?<namespace>[a-z][a-z0-9]*)-(?<token>[a-z0-9][a-z0-9_-]*)\s*:/g)) {
-        const namespace = decl.groups?.namespace;
-        const token = decl.groups?.token;
+        let namespace = decl.groups?.namespace;
+        let token = decl.groups?.token;
+        if (namespace === "background" && token?.startsWith("image-")) {
+          namespace = "background-image";
+          token = token.slice("image-".length);
+        }
         if (!namespace || !token) continue;
         let set = themeTokensByNamespace.get(namespace);
         if (!set) {
@@ -12159,7 +12452,7 @@ var unknownUtilityRule = {
 };
 
 // eslint/rules/util-file-name.ts
-import path80 from "path";
+import path81 from "path";
 function toKebabCase2(value) {
   return value.replace(/(?<lower>[a-z0-9])(?<upper>[A-Z])/g, "$<lower>-$<upper>").replace(/(?<first>[A-Z])(?<rest>[A-Z][a-z])/g, "$<first>-$<rest>").toLowerCase();
 }
@@ -12172,7 +12465,7 @@ var utilFileNameRule = {
     }
   },
   create(context) {
-    const filename = path80.resolve(context.filename);
+    const filename = path81.resolve(context.filename);
     const segments = filename.replace(/\\/g, "/").split("/");
     if (!segments.includes("utils")) return {};
     let module;
@@ -12186,13 +12479,13 @@ var utilFileNameRule = {
     const functionName = functions[0]?.name;
     if (!functionName) return {};
     const expected = toKebabCase2(functionName);
-    const actual = path80.basename(filename, path80.extname(filename));
+    const actual = path81.basename(filename, path81.extname(filename));
     if (!expected || actual === expected) return {};
     return {
       Program(node) {
         context.report({
           node,
-          message: `A utility file exporting ${functionName} must be named ${expected}.${path80.extname(filename).slice(1)}.`
+          message: `A utility file exporting ${functionName} must be named ${expected}.${path81.extname(filename).slice(1)}.`
         });
       }
     };
@@ -12200,7 +12493,7 @@ var utilFileNameRule = {
 };
 
 // eslint/rules/value-extraction.ts
-import path81 from "path";
+import path82 from "path";
 var valueExtractionRule = {
   meta: {
     schema: [],
@@ -12211,7 +12504,7 @@ var valueExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path81.resolve(context.filename);
+    const file = path82.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0 || segments[0] !== "app") return {};
     const index = getProjectIndex(sourceRoot);
@@ -12232,8 +12525,8 @@ var valueExtractionRule = {
 };
 
 // eslint/rules/vulyk/tracked-docs.ts
-import { existsSync as existsSync13, readFileSync as readFileSync16 } from "fs";
-import path82 from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync16 } from "fs";
+import path83 from "path";
 var PASIKA_REPO = "Bredansky/pasika";
 var BASE_REQUIRED_TRACKED_DOCS = [
   { name: "documentation-guide", path: "docs/documentation-guide" },
@@ -12266,9 +12559,9 @@ var trackedDocsRule = {
         if (!context.filename.endsWith("package.json")) return;
         const root = node.body;
         if (root.type !== "Object") return;
-        const projectRoot = path82.dirname(path82.resolve(context.filename));
-        const configPath = path82.join(projectRoot, "vulyk.config.ts");
-        if (!existsSync13(configPath)) {
+        const projectRoot = path83.dirname(path83.resolve(context.filename));
+        const configPath = path83.join(projectRoot, "vulyk.config.ts");
+        if (!existsSync14(configPath)) {
           context.report({
             node,
             message: "No vulyk.config.ts found. Run npx vulyk init to create one that tracks the framework's required tracked docs."
@@ -12292,8 +12585,8 @@ var trackedDocsRule = {
             });
           }
         }
-        const agentsPath = path82.join(projectRoot, "AGENTS.md");
-        if (!existsSync13(agentsPath)) {
+        const agentsPath = path83.join(projectRoot, "AGENTS.md");
+        if (!existsSync14(agentsPath)) {
           context.report({
             node,
             message: "No AGENTS.md found. Run npx vulyk agents to generate the agent file that routes to the tracked docs."
@@ -12392,7 +12685,7 @@ var withResponseHelperRule = {
 
 // eslint/rules/zirka-baseline.ts
 import fs7 from "fs";
-import path83 from "path";
+import path84 from "path";
 var ESLINT_CONFIG = /^eslint\.config\.(?:ts|mts|cts|js|mjs|cjs)$/;
 var PRETTIER_CONFIGS = [
   "prettier.config.mjs",
@@ -12411,10 +12704,10 @@ var zirkaBaselineRule = {
     }
   },
   create(context) {
-    const filename = path83.resolve(context.filename);
-    const basename = path83.basename(filename);
+    const filename = path84.resolve(context.filename);
+    const basename = path84.basename(filename);
     if (!ESLINT_CONFIG.test(basename)) return {};
-    const projectRoot = path83.dirname(filename);
+    const projectRoot = path84.dirname(filename);
     const report3 = (message) => {
       context.report({
         node: context.sourceCode.ast,
@@ -12429,7 +12722,7 @@ var zirkaBaselineRule = {
             'ESLint config must take its configuration from zirka (import { styleguide } from "zirka") instead of restating rules locally.'
           );
         }
-        const tsconfigPath = path83.join(projectRoot, "tsconfig.json");
+        const tsconfigPath = path84.join(projectRoot, "tsconfig.json");
         if (!fs7.existsSync(tsconfigPath)) {
           report3('No tsconfig.json found. Create one extending the zirka TypeScript base config ("zirka/typescript").');
         } else {
@@ -12447,13 +12740,13 @@ var zirkaBaselineRule = {
             report3('tsconfig.json must extend the zirka TypeScript base config ("zirka/typescript").');
           }
         }
-        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path83.join(projectRoot, name)));
+        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path84.join(projectRoot, name)));
         if (!prettierConfigFile) {
           report3(
             "No prettier config found. Create one that takes its configuration from zirka (styleguide({ prettier: true }).prettierConfig)."
           );
         } else {
-          const content = fs7.readFileSync(path83.join(projectRoot, prettierConfigFile), "utf8");
+          const content = fs7.readFileSync(path84.join(projectRoot, prettierConfigFile), "utf8");
           if (!content.includes("zirka")) {
             report3(
               "The prettier config must take its configuration from zirka (styleguide({ prettier: true }).prettierConfig) instead of restating it locally."
@@ -12789,7 +13082,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/no-utility-alias" && id !== "pasika/root-variables" && id !== "pasika/color-role-usage"
+      (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"
     ).map((id) => [id, "error"])
   )
 };
@@ -12807,6 +13100,7 @@ var tailwindImportGraph = {
     "pasika/unique-css-definition": "error",
     "pasika/unique-css-token-value": "error",
     "pasika/utility-mapping": "error",
+    "pasika/utility-name-parity": "error",
     "pasika/no-utility-alias": "error",
     "pasika/root-variables": "error",
     "pasika/color-role-usage": "error"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pasika",
-  "version": "0.10.117",
+  "version": "0.10.119",
   "description": "Reusable agent setup package",
   "repository": {
     "type": "git",
@@ -90,6 +90,7 @@
     "next": "16.3.5",
     "prettier": "3.8.1",
     "tailwind-merge": "3.7.0",
+    "tailwindcss": "4.3.3",
     "tsup": "8.5.1",
     "tsx": "4.23.12",
     "typescript": "6.0.3",
@@ -105,6 +106,7 @@
     "clsx": ">=2.0.0",
     "next": ">=15.0.0",
     "tailwind-merge": ">=3.0.0",
+    "tailwindcss": "^4.0.0",
     "zod": ">=4.0.0"
   },
   "peerDependenciesMeta": {
@@ -117,6 +119,9 @@
     "tailwind-merge": {
       "optional": true
     },
+    "tailwindcss": {
+      "optional": true
+    },
     "zod": {
       "optional": true
     }