pasika 0.4.1 → 0.4.3

package/dist/eslint/pasika/index.js

@@ -66,11 +66,12 @@ function componentFromVariable(node) {
     smart: containsSmartCall(initializer)
   };
 }
-function parseComponentInfo(text, filename) {
+function parseComponentInfo(text, filename, options) {
   const sourceFile = ts.createSourceFile(path.resolve(filename), text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
   const components = [];
   for (const statement of sourceFile.statements) {
-    if (!isExported(statement)) continue;
+    const exported = isExported(statement);
+    if (!exported && !options?.includeNonExported) continue;
     if (ts.isFunctionDeclaration(statement)) {
       const component = componentFromFunction(statement);
       if (component) components.push(component);
@@ -350,59 +351,26 @@ var importBoundariesRule = {
 };
 
 // eslint/rules/no-mixed-concerns.ts
-function getExportName(declaration) {
-  if (declaration?.type === "FunctionDeclaration" && declaration.id) {
-    return declaration.id.name ?? null;
-  }
-  if (declaration?.type === "VariableDeclaration") {
-    const declarator = declaration.declarations?.[0];
-    if (declarator?.id?.type === "Identifier" && (declarator.init?.type === "ArrowFunctionExpression" || declarator.init?.type === "FunctionExpression")) {
-      return declarator.id.name ?? null;
-    }
-  }
-  if (declaration?.type === "ArrowFunctionExpression") {
-    return "default";
-  }
-  if (declaration?.type === "FunctionExpression" && declaration.id) {
-    return declaration.id.name ?? null;
-  }
-  return null;
-}
 var noMixedConcernsRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Enforce one exported React component per .tsx file."
+      description: "Enforce one React component per .tsx file, counting private components."
     }
   },
   create(context) {
     if (!context.filename.endsWith(".tsx")) return {};
-    let exportedComponentCount = 0;
-    const extraExports = [];
-    function registerExport(name) {
-      exportedComponentCount++;
-      if (exportedComponentCount > 1) {
-        extraExports.push({ name });
-      }
-    }
+    const sourceCode = context.sourceCode.text;
     return {
-      ExportNamedDeclaration(node) {
-        const name = getExportName(node.declaration);
-        if (name) registerExport(name);
-      },
-      ExportDefaultDeclaration(node) {
-        const name = getExportName(node.declaration);
-        if (name) registerExport(name);
-      },
       "Program:exit"() {
-        if (exportedComponentCount > 1) {
-          for (const extra of extraExports) {
-            context.report({
-              loc: { line: 1, column: 0 },
-              message: `File exports multiple components. "${extra.name}" is an extra component export. Move it to its own file. Each .tsx file MUST contain exactly one component. See docs/code-organization-guide/rules/no-mixed-concerns-rule.md`
-            });
-          }
+        const components = parseComponentInfo(sourceCode, context.filename, { includeNonExported: true });
+        if (components.length <= 1) return;
+        for (const extra of components.slice(1)) {
+          context.report({
+            loc: { line: 1, column: 0 },
+            message: `File defines multiple components. "${extra.name}" is an extra component. Move it to its own file. Each component file MUST define exactly one component. See docs/code-organization-guide/rules/no-mixed-concerns-rule.md`
+          });
         }
       }
     };
@@ -478,6 +446,397 @@ var noArbitraryTailwindRule = {
   }
 };
 
+// eslint/rules/unknown-utility.ts
+import { readdirSync, readFileSync, statSync } from "fs";
+import path4 from "path";
+var PREFIX_NAMESPACES = {
+  bg: ["color"],
+  text: ["color", "text"],
+  border: ["color"],
+  ring: ["color"],
+  fill: ["color"],
+  stroke: ["color"],
+  accent: ["color"],
+  caret: ["color"],
+  decoration: ["color"],
+  outline: ["color"],
+  divide: ["color"],
+  from: ["color"],
+  via: ["color"],
+  to: ["color"],
+  shadow: ["color", "shadow"],
+  rounded: ["radius"],
+  font: ["font"],
+  tracking: ["tracking"],
+  leading: ["leading"],
+  opacity: ["opacity"],
+  z: ["z"],
+  blur: ["blur"],
+  "backdrop-blur": ["blur"],
+  "ring-offset": ["color"]
+};
+var PREFIX_BUILTINS = {
+  bg: [
+    "none",
+    "cover",
+    "contain",
+    "auto",
+    "fixed",
+    "local",
+    "scroll",
+    "center",
+    "top",
+    "bottom",
+    "left",
+    "right",
+    "left-top",
+    "left-bottom",
+    "right-top",
+    "right-bottom",
+    "repeat",
+    "no-repeat",
+    "repeat-x",
+    "repeat-y",
+    "repeat-round",
+    "repeat-space",
+    "clip-border",
+    "clip-padding",
+    "clip-content",
+    "clip-text",
+    "origin-border",
+    "origin-padding",
+    "origin-content",
+    "gradient-to-t",
+    "gradient-to-tr",
+    "gradient-to-r",
+    "gradient-to-br",
+    "gradient-to-b",
+    "gradient-to-bl",
+    "gradient-to-l",
+    "gradient-to-tl",
+    "linear-to-t",
+    "linear-to-tr",
+    "linear-to-r",
+    "linear-to-br",
+    "linear-to-b",
+    "linear-to-bl",
+    "linear-to-l",
+    "linear-to-tl"
+  ],
+  text: [
+    "left",
+    "center",
+    "right",
+    "justify",
+    "start",
+    "end",
+    "wrap",
+    "nowrap",
+    "balance",
+    "pretty",
+    "ellipsis",
+    "clip",
+    "truncate",
+    "uppercase",
+    "lowercase",
+    "capitalize",
+    "normal-case",
+    "underline",
+    "overline",
+    "line-through",
+    "no-underline"
+  ],
+  border: [
+    "solid",
+    "dashed",
+    "dotted",
+    "double",
+    "hidden",
+    "none",
+    "collapse",
+    "separate",
+    "x",
+    "y",
+    "t",
+    "r",
+    "b",
+    "l",
+    "s",
+    "e"
+  ],
+  ring: ["inset"],
+  divide: ["x", "y", "reverse"],
+  from: ["t", "r", "b", "l", "tr", "tl", "br", "bl", "top", "right", "bottom", "left"],
+  via: ["t", "r", "b", "l", "tr", "tl", "br", "bl", "top", "right", "bottom", "left"],
+  to: ["t", "r", "b", "l", "tr", "tl", "br", "bl", "top", "right", "bottom", "left"],
+  fill: ["none"],
+  stroke: ["none"],
+  accent: ["auto"],
+  decoration: ["solid", "double", "dotted", "dashed", "wavy", "none"],
+  outline: ["none", "hidden", "dashed", "dotted", "double", "solid"],
+  font: ["thin", "extralight", "light", "normal", "medium", "semibold", "bold", "extrabold", "black"]
+};
+var DEFAULT_TOKENS = {
+  text: ["xs", "sm", "base", "lg", "xl", "2xl", "3xl", "4xl", "5xl", "6xl", "7xl", "8xl", "9xl"],
+  radius: ["none", "xs", "sm", "md", "lg", "xl", "2xl", "3xl", "4xl", "full"],
+  font: ["sans", "serif", "mono"],
+  shadow: ["2xs", "xs", "sm", "md", "lg", "xl", "2xl", "inner", "none"],
+  tracking: ["tighter", "tight", "normal", "wide", "wider", "widest"],
+  leading: ["none", "tight", "snug", "normal", "relaxed", "loose"],
+  opacity: [
+    "0",
+    "5",
+    "10",
+    "15",
+    "20",
+    "25",
+    "30",
+    "35",
+    "40",
+    "45",
+    "50",
+    "55",
+    "60",
+    "65",
+    "70",
+    "75",
+    "80",
+    "85",
+    "90",
+    "95",
+    "100"
+  ],
+  z: ["0", "10", "20", "30", "40", "50", "auto"],
+  blur: ["none", "xs", "sm", "md", "lg", "xl", "2xl", "3xl"],
+  animate: ["none", "spin", "ping", "pulse", "bounce"],
+  ease: ["linear", "in", "out", "in-out"],
+  aspect: ["auto", "video", "square"]
+};
+var DEFAULT_PALETTE_FAMILIES = /* @__PURE__ */ new Set([
+  "red",
+  "orange",
+  "amber",
+  "yellow",
+  "lime",
+  "green",
+  "emerald",
+  "teal",
+  "cyan",
+  "sky",
+  "blue",
+  "indigo",
+  "violet",
+  "purple",
+  "fuchsia",
+  "pink",
+  "rose",
+  "slate",
+  "gray",
+  "zinc",
+  "neutral",
+  "stone"
+]);
+var DEFAULT_PALETTE_SHADES = /* @__PURE__ */ new Set(["50", "100", "200", "300", "400", "500", "600", "700", "800", "900", "950"]);
+var DEFAULT_COLOR_SPECIALS = /* @__PURE__ */ new Set(["white", "black", "transparent", "current", "inherit"]);
+var NUMERIC_TOKEN_RE = /^-?(?:\d+\.?\d*|\.\d+)(?:%|px|rem|em)?$/;
+var SIDE_WIDTH_TOKEN_RE = /^(?:x|y|t|r|b|l|s|e)-(?:\d+\.?\d*|\.\d+)(?:%|px|rem|em)?$/;
+var OFFSET_TOKEN_RE = /^offset-(?:\d+\.?\d*|\.\d+)(?:%|px|rem|em)?$/;
+function stylesheetFiles(dir) {
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return entries.flatMap((entry) => {
+    if (entry.startsWith(".") || entry === "node_modules") return [];
+    const entryPath = path4.join(dir, entry);
+    let stats;
+    try {
+      stats = statSync(entryPath);
+    } catch {
+      return [];
+    }
+    if (stats.isDirectory()) return stylesheetFiles(entryPath);
+    return path4.extname(entry) === ".css" ? [entryPath] : [];
+  });
+}
+function themeBlocks(css2) {
+  const blocks = [];
+  let index = 0;
+  while (index < css2.length) {
+    const match = /@theme(?:\s+inline)?\s*\{/.exec(css2.slice(index));
+    if (!match) break;
+    const open = index + match.index + match[0].length - 1;
+    let depth = 1;
+    let cursor = open + 1;
+    for (; cursor < css2.length && depth > 0; cursor++) {
+      if (css2[cursor] === "{") depth++;
+      else if (css2[cursor] === "}") depth--;
+    }
+    blocks.push(css2.slice(open + 1, cursor - 1));
+    index = cursor;
+  }
+  return blocks;
+}
+function readInventory(files) {
+  const utilities = /* @__PURE__ */ new Set();
+  const utilityPrefixes = /* @__PURE__ */ new Set();
+  const themeTokensByNamespace = /* @__PURE__ */ new Map();
+  let defaultsReset = false;
+  for (const file of files) {
+    let css2;
+    try {
+      css2 = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    for (const name of css2.matchAll(/@utility\s+(?<utilityName>[a-zA-Z0-9_-]+)/g)) {
+      const utilityName = name.groups?.utilityName;
+      if (!utilityName) continue;
+      utilities.add(utilityName);
+      const dash = utilityName.indexOf("-");
+      if (dash > 0) utilityPrefixes.add(utilityName.slice(0, dash));
+    }
+    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;
+        if (!namespace || !token) continue;
+        let set = themeTokensByNamespace.get(namespace);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          themeTokensByNamespace.set(namespace, set);
+        }
+        set.add(token);
+      }
+    }
+  }
+  return { utilities, utilityPrefixes, themeTokens: themeTokensByNamespace, defaultsReset };
+}
+function isColorToken(token, inventory) {
+  if (inventory.themeTokens.get("color")?.has(token)) return true;
+  if (inventory.defaultsReset) return false;
+  if (DEFAULT_COLOR_SPECIALS.has(token)) return true;
+  const hyphen = token.lastIndexOf("-");
+  if (hyphen === -1) return false;
+  return DEFAULT_PALETTE_FAMILIES.has(token.slice(0, hyphen)) && DEFAULT_PALETTE_SHADES.has(token.slice(hyphen + 1));
+}
+function isKnown(className, inventory) {
+  if (className.includes("[") || className.includes("(")) return true;
+  const base = className.replace(/!+$/, "").split("/")[0] ?? "";
+  const segments = base.split(":");
+  const utility = segments[segments.length - 1] ?? "";
+  if (!utility.includes("-")) return true;
+  const dash = utility.indexOf("-");
+  const firstTwo = utility.split("-").slice(0, 2).join("-");
+  const compound = PREFIX_NAMESPACES[firstTwo] ? firstTwo : void 0;
+  const prefix = compound ?? utility.slice(0, dash);
+  const token = compound ? utility.slice(compound.length + 1) : utility.slice(dash + 1);
+  if (!token) return true;
+  if (inventory.utilities.has(utility)) return true;
+  const namespaces = PREFIX_NAMESPACES[prefix];
+  if (!namespaces) {
+    const projectTokens = inventory.themeTokens.get(prefix);
+    if (projectTokens) {
+      if (projectTokens.has(token)) return true;
+      if (!inventory.defaultsReset && DEFAULT_TOKENS[prefix]?.includes(token)) return true;
+      return false;
+    }
+    return !inventory.utilityPrefixes.has(prefix);
+  }
+  if (NUMERIC_TOKEN_RE.test(token) || SIDE_WIDTH_TOKEN_RE.test(token) || OFFSET_TOKEN_RE.test(token)) return true;
+  if (PREFIX_BUILTINS[prefix]?.includes(token)) return true;
+  for (const namespace of namespaces) {
+    if (namespace === "color") {
+      if (isColorToken(token, inventory)) return true;
+      continue;
+    }
+    if (inventory.themeTokens.get(namespace)?.has(token)) return true;
+    if (!inventory.defaultsReset && DEFAULT_TOKENS[namespace]?.includes(token)) return true;
+  }
+  return false;
+}
+var CLASS_HELPERS2 = /* @__PURE__ */ new Set(["cn", "clsx", "twMerge", "twJoin"]);
+var unknownUtilityRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require component class names to be a custom utility, theme-generated utility, or built-in."
+    }
+  },
+  create(context) {
+    const sourceRoot2 = path4.resolve("src");
+    let inventory;
+    try {
+      if (!statSync(sourceRoot2).isDirectory()) return {};
+      inventory = readInventory(stylesheetFiles(sourceRoot2));
+    } catch {
+      return {};
+    }
+    function reportUnknownClasses(node, value) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const candidate of value.split(/\s+/)) {
+        if (!candidate || seen.has(candidate)) continue;
+        seen.add(candidate);
+        if (!isKnown(candidate, inventory)) {
+          context.report({
+            node,
+            message: `Utility class "${candidate}" is not a custom @utility, a theme-generated utility, or a built-in Tailwind utility.`
+          });
+        }
+      }
+    }
+    function checkExpression(node, expression) {
+      if (!expression) return;
+      if (expression.type === "Literal") {
+        if (typeof expression.value === "string") reportUnknownClasses(node, expression.value);
+        return;
+      }
+      if (expression.type === "TemplateLiteral") {
+        for (const quasi of expression.quasis) reportUnknownClasses(node, quasi.value.raw);
+        return;
+      }
+      if (expression.type === "LogicalExpression") {
+        checkExpression(node, expression.left);
+        checkExpression(node, expression.right);
+        return;
+      }
+      if (expression.type === "ConditionalExpression") {
+        checkExpression(node, expression.consequent);
+        checkExpression(node, expression.alternate);
+        return;
+      }
+      if (expression.type === "ArrayExpression") {
+        for (const element of expression.elements) checkExpression(node, element);
+        return;
+      }
+      if (expression.type === "ObjectExpression") {
+        for (const property of expression.properties) {
+          if (property.type === "Property") checkExpression(node, property.key);
+        }
+      }
+    }
+    return {
+      JSXAttribute(node) {
+        const attributeName = node.name?.name;
+        if (attributeName !== "className" && attributeName !== "class") return;
+        const value = node.value;
+        if (!value) return;
+        checkExpression(node, value.type === "JSXExpressionContainer" ? value.expression : value);
+      },
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier" || !CLASS_HELPERS2.has(node.callee.name)) return;
+        for (const argument of node.arguments) {
+          checkExpression(node, argument);
+        }
+      }
+    };
+  }
+};
+
 // eslint/rules/enforce-cn-merge.ts
 function classCount(str) {
   return str.split(/\s+/).filter(Boolean).length;
@@ -494,7 +853,9 @@ function isOuterLayoutClass(className) {
 function stringArguments(node) {
   if (node?.type === "Literal" && typeof node.value === "string") return [node.value];
   if (node?.type === "TemplateLiteral") return node.quasis.map((quasi) => quasi.value.raw);
-  if (node?.type === "ConditionalExpression") return [...stringArguments(node.consequent), ...stringArguments(node.alternate)];
+  if (node?.type === "ConditionalExpression") {
+    return [...stringArguments(node.consequent), ...stringArguments(node.alternate)];
+  }
   if (node?.type === "LogicalExpression") return [...stringArguments(node.left), ...stringArguments(node.right)];
   if (node?.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "cn") {
     return node.arguments.flatMap((argument) => stringArguments(argument));
@@ -510,7 +871,10 @@ var enforceCnMergeRule = {
         const element = node.parent.parent;
         const isComponentProp = isComponentName(element.openingElement?.name);
         if (isComponentProp && attributeName !== "className" && attributeName.endsWith("ClassName")) {
-          context.report({ node, message: "Expose appearance through typed variant props instead of separate internal class-name props. See docs/styling-guide/rules/class-composition-rule.md" });
+          context.report({
+            node,
+            message: "Expose appearance through typed variant props instead of separate internal class-name props. See docs/styling-guide/rules/class-composition-rule.md"
+          });
           return;
         }
         if (attributeName !== "className" && attributeName !== "class") return;
@@ -519,31 +883,60 @@ var enforceCnMergeRule = {
         if (isComponentProp && attributeName === "className") {
           const expression = valueNode.type === "JSXExpressionContainer" ? valueNode.expression : valueNode;
           const invalidClass = stringArguments(expression).flatMap((value) => value.split(/\s+/).filter(Boolean)).find((className) => !isOuterLayoutClass(className));
-          if (invalidClass) context.report({ node, message: `Passed className contains non-layout utility "${invalidClass}". Expose appearance through typed variant props. See docs/styling-guide/rules/class-composition-rule.md` });
+          if (invalidClass) {
+            context.report({
+              node,
+              message: `Passed className contains non-layout utility "${invalidClass}". Expose appearance through typed variant props. See docs/styling-guide/rules/class-composition-rule.md`
+            });
+          }
           return;
         }
         if (valueNode.type === "Literal" && typeof valueNode.value === "string") {
-          if (classCount(valueNode.value) > 5) context.report({ node, message: "Static className with more than 5 classes must use cn() with grouped string literals. See docs/styling-guide/rules/class-composition-rule.md" });
+          if (classCount(valueNode.value) > 5) {
+            context.report({
+              node,
+              message: "Static className with more than 5 classes must use cn() with grouped string literals. See docs/styling-guide/rules/class-composition-rule.md"
+            });
+          }
           return;
         }
         if (valueNode.type !== "JSXExpressionContainer") return;
         const expr = valueNode.expression;
         if (expr.type === "BinaryExpression" && expr.operator === "+") {
-          context.report({ node, message: "Use cn() instead of + operator for className. See docs/styling-guide/rules/class-composition-rule.md" });
+          context.report({
+            node,
+            message: "Use cn() instead of + operator for className. See docs/styling-guide/rules/class-composition-rule.md"
+          });
           return;
         }
         if (expr.type === "TemplateLiteral" && expr.expressions.length > 0) {
-          context.report({ node, message: "Use cn() instead of template literals with conditionals for className. See docs/styling-guide/rules/class-composition-rule.md" });
+          context.report({
+            node,
+            message: "Use cn() instead of template literals with conditionals for className. See docs/styling-guide/rules/class-composition-rule.md"
+          });
+          return;
+        }
+        if (expr.type === "LogicalExpression" || expr.type === "ConditionalExpression") {
+          context.report({
+            node,
+            message: "Use cn() for conditional classes in className. See docs/styling-guide/rules/class-composition-rule.md"
+          });
           return;
         }
         if (expr.type === "Literal" && typeof expr.value === "string" && classCount(expr.value) > 5) {
-          context.report({ node, message: "Static className with more than 5 classes must use cn() with grouped string literals. See docs/styling-guide/rules/class-composition-rule.md" });
+          context.report({
+            node,
+            message: "Static className with more than 5 classes must use cn() with grouped string literals. See docs/styling-guide/rules/class-composition-rule.md"
+          });
           return;
         }
         if (expr.type === "CallExpression" && expr.callee.type === "Identifier" && expr.callee.name === "cn") {
           for (const arg of expr.arguments) {
             if (arg.type === "Literal" && typeof arg.value === "string" && classCount(arg.value) > 5) {
-              context.report({ node: arg, message: "Each cn() string argument must contain at most 5 class names. Group by styling concern. See docs/styling-guide/rules/class-composition-rule.md" });
+              context.report({
+                node: arg,
+                message: "Each cn() string argument must contain at most 5 class names. Group by styling concern. See docs/styling-guide/rules/class-composition-rule.md"
+              });
             }
           }
         }
@@ -653,7 +1046,7 @@ var enforceCvaVariantPropsRule = {
 };
 
 // eslint/rules/enforce-barrel-exports.ts
-import path4 from "path";
+import path5 from "path";
 import fs from "fs";
 function isPascalCase3(str) {
   return /^[A-Z][A-Za-z0-9]*$/.test(str);
@@ -673,14 +1066,14 @@ var enforceBarrelExportsRule = {
   create(context) {
     const filename = context.filename;
     if (!filename) return {};
-    const baseName = path4.basename(filename);
+    const baseName = path5.basename(filename);
     if (baseName !== "index.ts" && baseName !== "index.cts" && baseName !== "index.mts") return {};
-    const dirPath = path4.dirname(filename);
-    const folderName = path4.basename(dirPath);
-    const parentFolderName = path4.basename(path4.dirname(dirPath));
+    const dirPath = path5.dirname(filename);
+    const folderName = path5.basename(dirPath);
+    const parentFolderName = path5.basename(path5.dirname(dirPath));
     if (SUPPORT_FOLDERS.has(folderName)) return {};
     if (!isPascalCase3(folderName) && !isKebabCase2(folderName)) return {};
-    const matchingTsx = fs.existsSync(path4.join(dirPath, `${folderName}.tsx`)) ? folderName : null;
+    const matchingTsx = fs.existsSync(path5.join(dirPath, `${folderName}.tsx`)) ? folderName : null;
     if (!matchingTsx) return {};
     if (!isPascalCase3(parentFolderName) && !isKebabCase2(parentFolderName)) return {};
     const reExportedNames = /* @__PURE__ */ new Set();
@@ -715,15 +1108,15 @@ var enforceBarrelExportsRule = {
 };
 
 // eslint/rules/component-placement.ts
-import path8 from "path";
+import path9 from "path";
 
 // eslint/project/index.ts
-import { readdirSync, statSync } from "fs";
-import path6 from "path";
+import { readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import path7 from "path";
 
 // eslint/project/parse-module.ts
-import path5 from "path";
-import { readFileSync } from "fs";
+import path6 from "path";
+import { readFileSync as readFileSync2 } from "fs";
 import ts2 from "typescript";
 var isPascalCase4 = (name) => /^[A-Z][A-Za-z0-9]*$/.test(name);
 var isHookName = (name) => /^use[A-Z]/.test(name);
@@ -760,7 +1153,7 @@ function classifyValue(name, initializer, isTsx) {
   return "constant";
 }
 function parseModule(file) {
-  const text = readFileSync(file, "utf8");
+  const text = readFileSync2(file, "utf8");
   const isTsx = file.endsWith(".tsx") || file.endsWith(".jsx");
   const sourceFile = ts2.createSourceFile(file, text, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TSX);
   const imports = [];
@@ -823,7 +1216,7 @@ function parseModule(file) {
       exports.push({ name: statement.name.text, kind: "type", line: lineOf(sourceFile, statement) });
     }
   }
-  return { file: path5.resolve(file), imports, exports };
+  return { file: path6.resolve(file), imports, exports };
 }
 
 // eslint/project/index.ts
@@ -834,28 +1227,28 @@ var symbolKey = (file, name) => `${file}\0${name}`;
 function listSourceFiles(dir) {
   let entries;
   try {
-    entries = readdirSync(dir);
+    entries = readdirSync2(dir);
   } catch {
     return [];
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path6.join(dir, entry);
+    const entryPath = path7.join(dir, entry);
     let stats;
     try {
-      stats = statSync(entryPath);
+      stats = statSync2(entryPath);
     } catch {
       return [];
     }
     if (stats.isDirectory()) return listSourceFiles(entryPath);
-    return MODULE_EXTENSIONS.includes(path6.extname(entry)) ? [entryPath] : [];
+    return MODULE_EXTENSIONS.includes(path7.extname(entry)) ? [entryPath] : [];
   });
 }
 function fingerprint(files) {
   let total = 0;
   for (const file of files) {
     try {
-      total += statSync(file).mtimeMs;
+      total += statSync2(file).mtimeMs;
     } catch {
     }
   }
@@ -864,20 +1257,20 @@ function fingerprint(files) {
 function resolveSpecifier(fromFile, specifier, sourceRoot2) {
   let base;
   if (specifier.startsWith("@/")) {
-    base = path6.resolve(sourceRoot2, specifier.slice(2));
+    base = path7.resolve(sourceRoot2, specifier.slice(2));
   } else if (specifier.startsWith(".")) {
-    base = path6.resolve(path6.dirname(fromFile), specifier);
+    base = path7.resolve(path7.dirname(fromFile), specifier);
   } else {
     return void 0;
   }
   const candidates = [
     base,
     ...MODULE_EXTENSIONS.map((extension) => `${base}${extension}`),
-    ...INDEX_BASENAMES.map((name) => path6.join(base, name))
+    ...INDEX_BASENAMES.map((name) => path7.join(base, name))
   ];
   for (const candidate of candidates) {
     try {
-      if (statSync(candidate).isFile()) return candidate;
+      if (statSync2(candidate).isFile()) return candidate;
     } catch {
     }
   }
@@ -917,7 +1310,7 @@ function getProjectIndex(sourceRoot2) {
     return cache.index;
   }
   try {
-    if (!statSync(sourceRoot2).isDirectory()) return void 0;
+    if (!statSync2(sourceRoot2).isDirectory()) return void 0;
   } catch {
     return void 0;
   }
@@ -933,11 +1326,11 @@ function getProjectIndex(sourceRoot2) {
 }
 
 // eslint/project/ccf.ts
-import path7 from "path";
+import path8 from "path";
 var SUPPORT_FOLDERS2 = /* @__PURE__ */ new Set(["hooks", "types", "schemas", "constants", "utils"]);
 function segmentsOf(file, sourceRoot2) {
-  const relative = path7.relative(sourceRoot2, file);
-  return relative.startsWith("..") ? [] : relative.split(path7.sep);
+  const relative = path8.relative(sourceRoot2, file);
+  return relative.startsWith("..") ? [] : relative.split(path8.sep);
 }
 function folderSegmentsOf(file, sourceRoot2) {
   return segmentsOf(file, sourceRoot2).slice(0, -1);
@@ -1016,7 +1409,7 @@ function resolveSupportPlacement(supportFile, supportFolder, index) {
 }
 function describeConsumers(consumers, sourceRoot2) {
   const shown = 3;
-  const names = consumers.map((consumer) => path7.relative(path7.dirname(sourceRoot2), consumer).split(path7.sep).join("/")).sort((left, right) => left.localeCompare(right));
+  const names = consumers.map((consumer) => path8.relative(path8.dirname(sourceRoot2), consumer).split(path8.sep).join("/")).sort((left, right) => left.localeCompare(right));
   if (names.length <= shown) return names.join(", ");
   return `${names.slice(0, shown).join(", ")} and ${String(names.length - shown)} more`;
 }
@@ -1039,10 +1432,10 @@ var componentPlacementRule = {
   create(context) {
     const filename = context.filename;
     if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
-    const sourceRoot2 = path8.resolve("src");
+    const sourceRoot2 = path9.resolve("src");
     const index = getProjectIndex(sourceRoot2);
     if (!index) return {};
-    const componentFile = path8.resolve(filename);
+    const componentFile = path9.resolve(filename);
     const segments = segmentsOf(componentFile, sourceRoot2);
     if (segments.length === 0) return {};
     if (isUnderApp(segments) || isConfigModule(segments)) return {};
@@ -1075,7 +1468,7 @@ var componentPlacementRule = {
 };
 
 // eslint/rules/support-file-placement.ts
-import path9 from "path";
+import path10 from "path";
 var CONFIG_OWNED_FOLDERS = /* @__PURE__ */ new Set(["types", "constants"]);
 var REASON_TEXT2 = {
   "app-consumer": "a file under src/app/ imports it, so it belongs to the app-wide support folder",
@@ -1094,8 +1487,8 @@ var supportFilePlacementRule = {
     }
   },
   create(context) {
-    const sourceRoot2 = path9.resolve("src");
-    const supportFile = path9.resolve(context.filename);
+    const sourceRoot2 = path10.resolve("src");
+    const supportFile = path10.resolve(context.filename);
     const currentFolder = folderSegmentsOf(supportFile, sourceRoot2);
     const supportFolder = currentFolder[currentFolder.length - 1];
     if (supportFolder === void 0 || !SUPPORT_FOLDERS2.has(supportFolder)) return {};
@@ -1120,7 +1513,7 @@ var supportFilePlacementRule = {
 
 // eslint/rules/application-structure.ts
 import fs2 from "fs";
-import path10 from "path";
+import path11 from "path";
 var MODULE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
 var ROUTING_FILES = /* @__PURE__ */ new Set([
   "default",
@@ -1149,7 +1542,7 @@ function report2(context, message) {
   };
 }
 function isCodeFile(filename) {
-  return MODULE_EXTENSIONS2.has(path10.extname(filename));
+  return MODULE_EXTENSIONS2.has(path11.extname(filename));
 }
 function isRootSupportFolder(folder) {
   return SUPPORT_FOLDERS2.has(folder);
@@ -1170,7 +1563,7 @@ function expectedSupportFolder(kinds) {
 function configModuleRoot(filename, sourceRoot2) {
   const segments = segmentsOf(filename, sourceRoot2);
   if (segments[0] !== "config" || segments.length < 3) return void 0;
-  return path10.join(sourceRoot2, "config", segments[1] ?? "");
+  return path11.join(sourceRoot2, "config", segments[1] ?? "");
 }
 function componentFolderStart(segments) {
   if (segments[0] === "features") return 2;
@@ -1183,12 +1576,12 @@ function componentFolderViolation(segments, sourceRoot2) {
   for (let depth = segments.length - 2; depth >= start; depth -= 1) {
     const folder = segments[depth];
     if (!folder || SUPPORT_FOLDERS2.has(folder)) continue;
-    const folderPath = path10.join(sourceRoot2, ...segments.slice(0, depth + 1));
+    const folderPath = path11.join(sourceRoot2, ...segments.slice(0, depth + 1));
     const label = `src/${segments.slice(0, depth + 1).join("/")}/`;
-    if (!fs2.existsSync(path10.join(folderPath, `${folder}.tsx`))) {
+    if (!fs2.existsSync(path11.join(folderPath, `${folder}.tsx`))) {
       return `A folder that is not a support folder must be a component folder; add "${folder}.tsx" to ${label} or move its files into a support folder.`;
     }
-    if (!fs2.existsSync(path10.join(folderPath, "index.ts"))) {
+    if (!fs2.existsSync(path11.join(folderPath, "index.ts"))) {
       return `A component folder must have an index.ts that named-re-exports its component; add index.ts to ${label}.`;
     }
   }
@@ -1203,8 +1596,8 @@ var applicationStructureRule = {
     }
   },
   create(context) {
-    const filename = path10.resolve(context.filename);
-    const sourceRoot2 = path10.resolve("src");
+    const filename = path11.resolve(context.filename);
+    const sourceRoot2 = path11.resolve("src");
     const segments = segmentsOf(filename, sourceRoot2);
     if (segments.length === 0) return {};
     const [topLevel, secondLevel] = segments;
@@ -1234,42 +1627,42 @@ var applicationStructureRule = {
         );
       }
       const moduleRoot = configModuleRoot(filename, sourceRoot2);
-      if (moduleRoot && !fs2.existsSync(path10.join(moduleRoot, "index.ts"))) {
+      if (moduleRoot && !fs2.existsSync(path11.join(moduleRoot, "index.ts"))) {
         return report2(
           context,
-          `Add src/config/${path10.basename(moduleRoot)}/index.ts as the configuration module entry point.`
+          `Add src/config/${path11.basename(moduleRoot)}/index.ts as the configuration module entry point.`
         );
       }
-      if (moduleRoot && segments.length === 3 && path10.basename(filename) !== "index.ts") {
+      if (moduleRoot && segments.length === 3 && path11.basename(filename) !== "index.ts") {
         const kinds2 = exportedKinds(filename);
         const expected2 = expectedSupportFolder(kinds2);
         if (expected2 !== void 0) {
           return report2(
             context,
-            `Move this configuration support file into src/config/${path10.basename(moduleRoot)}/${expected2}/.`
+            `Move this configuration support file into src/config/${path11.basename(moduleRoot)}/${expected2}/.`
           );
         }
       }
     }
     if (topLevel === "app" && isCodeFile(filename)) {
-      const basename = path10.basename(filename, path10.extname(filename));
-      const currentFolder2 = path10.basename(path10.dirname(filename));
+      const basename = path11.basename(filename, path11.extname(filename));
+      const currentFolder2 = path11.basename(path11.dirname(filename));
       if (SUPPORT_FOLDERS2.has(currentFolder2)) {
         return report2(
           context,
           "src/app/ may contain routing files and framework assets, but ordinary components and support files must live outside src/app/."
         );
       }
-      if (!ROUTING_FILES.has(basename) && path10.extname(filename) !== ".css") {
+      if (!ROUTING_FILES.has(basename) && path11.extname(filename) !== ".css") {
         return report2(
           context,
           "src/app/ may contain routing files and framework assets, but ordinary components and support files must live outside src/app/."
         );
       }
     }
-    const currentFolder = path10.basename(path10.dirname(filename));
+    const currentFolder = path11.basename(path11.dirname(filename));
     const kinds = exportedKinds(filename);
-    const isConfigModuleRoot = topLevel === "config" && segments.length === 3 && path10.basename(filename) === "index.ts";
+    const isConfigModuleRoot = topLevel === "config" && segments.length === 3 && path11.basename(filename) === "index.ts";
     if (isConfigModuleRoot) return {};
     if (!SUPPORT_FOLDERS2.has(currentFolder)) {
       const expected2 = expectedSupportFolder(kinds);
@@ -1286,7 +1679,7 @@ var applicationStructureRule = {
     if (kinds.has("component")) {
       return report2(
         context,
-        `A support folder must not contain a component; move ${path10.basename(filename)} beside ${currentFolder}/.`
+        `A support folder must not contain a component; move ${path11.basename(filename)} beside ${currentFolder}/.`
       );
     }
     const expected = expectedSupportFolder(kinds);
@@ -1303,7 +1696,7 @@ var applicationStructureRule = {
 };
 
 // eslint/rules/named-exports.ts
-import path11 from "path";
+import path12 from "path";
 var FRAMEWORK_DEFAULT_EXPORT_FILES = /* @__PURE__ */ new Set([
   "default",
   "error",
@@ -1315,9 +1708,9 @@ var FRAMEWORK_DEFAULT_EXPORT_FILES = /* @__PURE__ */ new Set([
   "template"
 ]);
 function isFrameworkDefaultExportFile(filename) {
-  const normalized = filename.replaceAll(path11.sep, "/");
+  const normalized = filename.replaceAll(path12.sep, "/");
   if (!normalized.includes("/src/app/")) return false;
-  const basename = path11.basename(filename, path11.extname(filename));
+  const basename = path12.basename(filename, path12.extname(filename));
   return FRAMEWORK_DEFAULT_EXPORT_FILES.has(basename);
 }
 var namedExportsRule = {
@@ -1342,7 +1735,7 @@ var namedExportsRule = {
 };
 
 // eslint/rules/data-testid-case.ts
-import path12 from "path";
+import path13 from "path";
 var NEXT_ROUTING_FILES2 = /* @__PURE__ */ new Set([
   "page",
   "layout",
@@ -1366,9 +1759,9 @@ var dataTestIdCaseRule = {
     }
   },
   create(context) {
-    const filename = path12.resolve(context.filename);
+    const filename = path13.resolve(context.filename);
     if (!filename.endsWith(".tsx")) return {};
-    const base = path12.basename(filename, path12.extname(filename));
+    const base = path13.basename(filename, path13.extname(filename));
     if (NEXT_ROUTING_FILES2.has(base)) return {};
     const text = context.sourceCode.text;
     const components = parseComponentInfo(text, filename);
@@ -1410,7 +1803,7 @@ function toKebabCase(value) {
 
 // eslint/rules/support-folder-shape.ts
 import fs3 from "fs";
-import path13 from "path";
+import path14 from "path";
 var SUPPORT_FOLDERS3 = /* @__PURE__ */ new Set(["constants", "types", "schemas"]);
 var INDEX_NAMES = /* @__PURE__ */ new Set(["index.ts", "index.tsx", "index.mts", "index.cts"]);
 var supportFolderShapeRule = {
@@ -1422,12 +1815,12 @@ var supportFolderShapeRule = {
     }
   },
   create(context) {
-    const filename = path13.resolve(context.filename);
-    const baseName = path13.basename(filename);
+    const filename = path14.resolve(context.filename);
+    const baseName = path14.basename(filename);
     if (!INDEX_NAMES.has(baseName)) return {};
-    const folder = path13.basename(path13.dirname(filename));
+    const folder = path14.basename(path14.dirname(filename));
     if (!SUPPORT_FOLDERS3.has(folder)) return {};
-    const directory = path13.dirname(filename);
+    const directory = path14.dirname(filename);
     let entries;
     try {
       entries = fs3.readdirSync(directory);
@@ -1445,7 +1838,7 @@ var supportFolderShapeRule = {
         const exportPattern = /export\s+(?:\{[^}]*\}|\*[^;]*)\s+from\s+["'](?<specifier>\.[^"']+)["']/g;
         for (const match of source.matchAll(exportPattern)) {
           const specifier = match.groups?.specifier;
-          if (specifier) exportedFiles.add(path13.basename(specifier));
+          if (specifier) exportedFiles.add(path14.basename(specifier));
         }
         const missing = siblingModules.filter((entry) => {
           const stem = entry.replace(/\.(?:[cm]?tsx?|jsx?)$/, "");
@@ -1462,7 +1855,7 @@ var supportFolderShapeRule = {
 };
 
 // eslint/rules/import-through-index.ts
-import path14 from "path";
+import path15 from "path";
 var importThroughIndexRule = {
   meta: {
     schema: [],
@@ -1472,7 +1865,7 @@ var importThroughIndexRule = {
     }
   },
   create(context) {
-    const filename = path14.resolve(context.filename);
+    const filename = path15.resolve(context.filename);
     const sourceRoot2 = sourceRootOf(filename);
     return {
       Program(node) {
@@ -1484,7 +1877,7 @@ var importThroughIndexRule = {
             (segment) => ["constants", "types", "schemas"].includes(segment)
           );
           const supportFolder = supportFolderIndex >= 0 ? targetSegments[supportFolderIndex] : void 0;
-          if (!supportFolder || path14.basename(target).startsWith("index.")) continue;
+          if (!supportFolder || path15.basename(target).startsWith("index.")) continue;
           const folderIndex = targetSegments.slice(0, supportFolderIndex + 1);
           const expected = `@/${folderIndex.join("/")}`;
           context.report({
@@ -1506,13 +1899,13 @@ function importSpecifiers(source) {
   return specifiers;
 }
 function sourceRootOf(filename) {
-  const marker = `${path14.sep}src${path14.sep}`;
+  const marker = `${path15.sep}src${path15.sep}`;
   const srcIndex = filename.lastIndexOf(marker);
-  return srcIndex >= 0 ? filename.slice(0, srcIndex + marker.length - 1) : path14.resolve("src");
+  return srcIndex >= 0 ? filename.slice(0, srcIndex + marker.length - 1) : path15.resolve("src");
 }
 
 // eslint/rules/util-file-name.ts
-import path15 from "path";
+import path16 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();
 }
@@ -1525,7 +1918,7 @@ var utilFileNameRule = {
     }
   },
   create(context) {
-    const filename = path15.resolve(context.filename);
+    const filename = path16.resolve(context.filename);
     const segments = filename.replace(/\\/g, "/").split("/");
     if (!segments.includes("utils")) return {};
     let module;
@@ -1539,13 +1932,13 @@ var utilFileNameRule = {
     const functionName = functions[0]?.name;
     if (!functionName) return {};
     const expected = toKebabCase2(functionName);
-    const actual = path15.basename(filename, path15.extname(filename));
+    const actual = path16.basename(filename, path16.extname(filename));
     if (!expected || actual === expected) return {};
     return {
       Program(node) {
         context.report({
           node,
-          message: `A utility file exporting ${functionName} must be named ${expected}.${path15.extname(filename).slice(1)}.`
+          message: `A utility file exporting ${functionName} must be named ${expected}.${path16.extname(filename).slice(1)}.`
         });
       }
     };
@@ -1553,7 +1946,7 @@ var utilFileNameRule = {
 };
 
 // eslint/rules/no-util-barrel.ts
-import path16 from "path";
+import path17 from "path";
 var noUtilBarrelRule = {
   meta: {
     schema: [],
@@ -1563,7 +1956,7 @@ var noUtilBarrelRule = {
     }
   },
   create(context) {
-    const filename = path16.resolve(context.filename);
+    const filename = path17.resolve(context.filename);
     const sourceRoot2 = sourceRootOf2(filename);
     return {
       Program(node) {
@@ -1572,7 +1965,7 @@ var noUtilBarrelRule = {
           if (!target) continue;
           const segments = target.replace(/\\/g, "/").split("/");
           const utilsIndex = segments.lastIndexOf("utils");
-          if (utilsIndex < 0 || !path16.basename(target).startsWith("index.")) continue;
+          if (utilsIndex < 0 || !path17.basename(target).startsWith("index.")) continue;
           context.report({
             node,
             message: `Import utilities directly instead of through "${specifier}". See docs/code-organization-guide/rules/utilities-rule.md`
@@ -1592,9 +1985,9 @@ function importSpecifiers2(source) {
   return specifiers;
 }
 function sourceRootOf2(filename) {
-  const marker = `${path16.sep}src${path16.sep}`;
+  const marker = `${path17.sep}src${path17.sep}`;
   const srcIndex = filename.lastIndexOf(marker);
-  return srcIndex >= 0 ? filename.slice(0, srcIndex + marker.length - 1) : path16.resolve("src");
+  return srcIndex >= 0 ? filename.slice(0, srcIndex + marker.length - 1) : path17.resolve("src");
 }
 
 // eslint/rules/jsx-hygiene.ts
@@ -1970,12 +2363,12 @@ var cvaBooleanVariantsRule = {
 };
 
 // eslint/rules/cross-feature-import.ts
-import path17 from "path";
+import path18 from "path";
 var FEATURES_SEGMENT = "features";
 function featureNameOf(resolvedPath, sourceRoot2) {
-  const relative = path17.relative(sourceRoot2, resolvedPath);
+  const relative = path18.relative(sourceRoot2, resolvedPath);
   if (relative.startsWith("..")) return void 0;
-  const segments = relative.split(path17.sep);
+  const segments = relative.split(path18.sep);
   if (segments[0] !== FEATURES_SEGMENT || segments.length < 2) return void 0;
   return segments[1];
 }
@@ -1990,10 +2383,10 @@ var crossFeatureImportRule = {
   create(context) {
     const filename = context.filename;
     if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
-    const sourceRoot2 = path17.resolve("src");
-    const fileRelative = path17.relative(sourceRoot2, filename);
+    const sourceRoot2 = path18.resolve("src");
+    const fileRelative = path18.relative(sourceRoot2, filename);
     if (fileRelative.startsWith("..")) return {};
-    const fileSegments = fileRelative.split(path17.sep);
+    const fileSegments = fileRelative.split(path18.sep);
     const isInCompositions = fileSegments[0] === "compositions";
     const isInApp = fileSegments[0] === "app";
     const isConfig = fileSegments[0] === "config";
@@ -2007,9 +2400,9 @@ var crossFeatureImportRule = {
         if (typeof source.value !== "string") return;
         let resolved;
         if (source.value.startsWith("@/")) {
-          resolved = path17.resolve(sourceRoot2, source.value.slice(2));
+          resolved = path18.resolve(sourceRoot2, source.value.slice(2));
         } else if (source.value.startsWith(".")) {
-          resolved = path17.resolve(path17.dirname(filename), source.value);
+          resolved = path18.resolve(path18.dirname(filename), source.value);
         }
         if (!resolved) return;
         const feature = featureNameOf(resolved, sourceRoot2);
@@ -2028,7 +2421,7 @@ var crossFeatureImportRule = {
 };
 
 // eslint/rules/pure-function-extract.ts
-import path18 from "path";
+import path19 from "path";
 function isComponentLikeName(name) {
   return /^[A-Z]/.test(name);
 }
@@ -2056,10 +2449,10 @@ var pureFunctionExtractRule = {
   create(context) {
     const filename = context.filename;
     if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
-    const sourceRoot2 = path18.resolve("src");
-    const relative = path18.relative(sourceRoot2, filename);
+    const sourceRoot2 = path19.resolve("src");
+    const relative = path19.relative(sourceRoot2, filename);
     if (relative.startsWith("..")) return {};
-    const segments = relative.split(path18.sep);
+    const segments = relative.split(path19.sep);
     if (segments[0] === "utils") return {};
     if (segments[0] === "app") return {};
     const supportFolders = /* @__PURE__ */ new Set(["hooks", "types", "schemas", "constants", "utils"]);
@@ -2099,7 +2492,7 @@ var pureFunctionExtractRule = {
 };
 
 // eslint/rules/hook-complexity.ts
-import path19 from "path";
+import path20 from "path";
 import ts4 from "typescript";
 var REACT_HOOKS = /* @__PURE__ */ new Set([
   "useState",
@@ -2151,10 +2544,10 @@ var hookComplexityRule = {
   },
   create(context) {
     const filename = context.filename;
-    const sourceRoot2 = path19.resolve("src");
-    const relative = path19.relative(sourceRoot2, filename);
+    const sourceRoot2 = path20.resolve("src");
+    const relative = path20.relative(sourceRoot2, filename);
     if (relative.startsWith("..")) return {};
-    const segments = relative.split(path19.sep);
+    const segments = relative.split(path20.sep);
     const sourceText = context.sourceCode.text;
     function checkHook(node, name, body, exported) {
       if (!exported) return;
@@ -2196,9 +2589,9 @@ var hookComplexityRule = {
 };
 
 // eslint/rules/locale-dotted-path.ts
-import path20 from "path";
+import path21 from "path";
 function isInLocalesDir(filename) {
-  const segments = path20.resolve(filename).split(path20.sep);
+  const segments = path21.resolve(filename).split(path21.sep);
   const srcIdx = segments.lastIndexOf("src");
   return srcIdx !== -1 && segments[srcIdx + 1] === "locales";
 }
@@ -2247,9 +2640,9 @@ var localeDottedPathRule = {
 };
 
 // eslint/rules/locales-location.ts
-import path21 from "path";
+import path22 from "path";
 function isLocalesFile(filename) {
-  const segments = path21.resolve(filename).split(path21.sep);
+  const segments = path22.resolve(filename).split(path22.sep);
   const srcIdx = segments.lastIndexOf("src");
   return srcIdx !== -1 && segments[srcIdx + 1] === "locales";
 }
@@ -2268,7 +2661,7 @@ var localesLocationRule = {
   create(context) {
     if (isLocalesFile(context.filename)) return {};
     const filename = context.filename;
-    const segments = path21.resolve(filename).split(path21.sep);
+    const segments = path22.resolve(filename).split(path22.sep);
     const srcIdx = segments.lastIndexOf("src");
     if (srcIdx === -1) return {};
     const folder = segments[srcIdx + 1];
@@ -2290,7 +2683,7 @@ var localesLocationRule = {
 };
 
 // eslint/rules/hook-extraction.ts
-import path22 from "path";
+import path23 from "path";
 var hookExtractionRule = {
   meta: {
     schema: [],
@@ -2300,8 +2693,8 @@ var hookExtractionRule = {
     }
   },
   create(context) {
-    const sourceRoot2 = path22.resolve("src");
-    const file = path22.resolve(context.filename);
+    const sourceRoot2 = path23.resolve("src");
+    const file = path23.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot2);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot2);
@@ -2327,7 +2720,7 @@ var hookExtractionRule = {
 };
 
 // eslint/rules/value-extraction.ts
-import path23 from "path";
+import path24 from "path";
 var valueExtractionRule = {
   meta: {
     schema: [],
@@ -2337,8 +2730,8 @@ var valueExtractionRule = {
     }
   },
   create(context) {
-    const sourceRoot2 = path23.resolve("src");
-    const file = path23.resolve(context.filename);
+    const sourceRoot2 = path24.resolve("src");
+    const file = path24.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot2);
     if (segments.length === 0 || segments[0] !== "app") return {};
     const index = getProjectIndex(sourceRoot2);
@@ -2359,7 +2752,7 @@ var valueExtractionRule = {
 };
 
 // eslint/rules/config-extraction.ts
-import path24 from "path";
+import path25 from "path";
 var configExtractionRule = {
   meta: {
     schema: [],
@@ -2369,8 +2762,8 @@ var configExtractionRule = {
     }
   },
   create(context) {
-    const sourceRoot2 = path24.resolve("src");
-    const file = path24.resolve(context.filename);
+    const sourceRoot2 = path25.resolve("src");
+    const file = path25.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot2);
     if (segments.length < 3 || segments[0] !== "config") return {};
     if (SUPPORT_FOLDERS2.has(segments[2] ?? "")) return {};
@@ -2408,7 +2801,7 @@ var configExtractionRule = {
 };
 
 // eslint/rules/component-nesting.ts
-import path25 from "path";
+import path26 from "path";
 var componentNestingRule = {
   meta: {
     schema: [],
@@ -2418,8 +2811,8 @@ var componentNestingRule = {
     }
   },
   create(context) {
-    const sourceRoot2 = path25.resolve("src");
-    const file = path25.resolve(context.filename);
+    const sourceRoot2 = path26.resolve("src");
+    const file = path26.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot2);
     if (segments.length !== 4 || segments[0] !== "features") return {};
     const index = getProjectIndex(sourceRoot2);
@@ -2452,7 +2845,7 @@ var componentNestingRule = {
 };
 
 // eslint/rules/stay-flat.ts
-import path26 from "path";
+import path27 from "path";
 var stayFlatRule = {
   meta: {
     schema: [],
@@ -2462,8 +2855,8 @@ var stayFlatRule = {
     }
   },
   create(context) {
-    const sourceRoot2 = path26.resolve("src");
-    const file = path26.resolve(context.filename);
+    const sourceRoot2 = path27.resolve("src");
+    const file = path27.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot2);
     if (segments.length !== 3 || segments[0] !== "features") return {};
     const index = getProjectIndex(sourceRoot2);
@@ -2503,7 +2896,7 @@ var stayFlatRule = {
 };
 
 // eslint/rules/type-extraction.ts
-import path27 from "path";
+import path28 from "path";
 var typeExtractionRule = {
   meta: {
     schema: [],
@@ -2513,8 +2906,8 @@ var typeExtractionRule = {
     }
   },
   create(context) {
-    const sourceRoot2 = path27.resolve("src");
-    const file = path27.resolve(context.filename);
+    const sourceRoot2 = path28.resolve("src");
+    const file = path28.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot2);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot2);
@@ -2560,8 +2953,8 @@ var typeExtractionRule = {
 };
 
 // eslint/rules/locale-placement.ts
-import path28 from "path";
-import { readFileSync as readFileSync2 } from "fs";
+import path29 from "path";
+import { readFileSync as readFileSync3 } from "fs";
 import ts5 from "typescript";
 var LOCALE_ACCESS = /\blocales\.(?<key>[A-Za-z_$][\w$]*)/g;
 var camelCase = (name) => name.replace(/-[a-z]/g, (match) => match.slice(1).toUpperCase());
@@ -2607,8 +3000,8 @@ var localePlacementRule = {
     }
   },
   create(context) {
-    const sourceRoot2 = path28.resolve("src");
-    const file = path28.resolve(context.filename);
+    const sourceRoot2 = path29.resolve("src");
+    const file = path29.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot2);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot2);
@@ -2618,7 +3011,7 @@ var localePlacementRule = {
       return candidateSegments.length === 2 && candidateSegments[0] === "locales" && candidateSegments[1]?.startsWith("index.");
     });
     if (!localesFile || file !== localesFile) return {};
-    const placement = localePlacement(readFileSync2(localesFile, "utf8"));
+    const placement = localePlacement(readFileSync3(localesFile, "utf8"));
     if (!placement) return {};
     const keyReaders = /* @__PURE__ */ new Map();
     const keyFeatures = /* @__PURE__ */ new Map();
@@ -2630,7 +3023,7 @@ var localePlacementRule = {
       );
       if (!importsLocales) continue;
       const candidateSegments = segmentsOf(candidateFile, sourceRoot2);
-      for (const match of readFileSync2(candidateFile, "utf8").matchAll(LOCALE_ACCESS)) {
+      for (const match of readFileSync3(candidateFile, "utf8").matchAll(LOCALE_ACCESS)) {
         const key = match.groups?.key;
         if (key === void 0) continue;
         const readers = keyReaders.get(key) ?? /* @__PURE__ */ new Set();
@@ -2686,7 +3079,7 @@ var localePlacementRule = {
 };
 
 // eslint/rules/sole-state-owner.ts
-import path29 from "path";
+import path30 from "path";
 import ts6 from "typescript";
 function findStateHooks(node) {
   const hooks = [];
@@ -2766,7 +3159,7 @@ var soleStateOwnerRule = {
     }
   },
   create(context) {
-    const filename = path29.resolve(context.filename);
+    const filename = path30.resolve(context.filename);
     if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
     const text = context.sourceCode.text;
     const components = parseComponentInfo(text, filename);
@@ -2845,7 +3238,7 @@ function usesOutsideJsx(declaration, hook, children) {
 }
 
 // eslint/rules/locale-key-shape.ts
-import path30 from "path";
+import path31 from "path";
 var MAX_KEY_LENGTH = 30;
 var ROLE_POSTFIXES = /* @__PURE__ */ new Set([
   "Button",
@@ -2893,8 +3286,9 @@ var ROLE_POSTFIXES = /* @__PURE__ */ new Set([
   "ScrollBar"
 ]);
 var CAMEL_CASE = /^[a-z][a-zA-Z0-9]*$/;
+var ENGLISH = /^[A-Za-z0-9_]*$/;
 function isLocalesFile2(filename) {
-  const segments = path30.resolve(filename).split(path30.sep);
+  const segments = path31.resolve(filename).split(path31.sep);
   const srcIdx = segments.lastIndexOf("src");
   return srcIdx !== -1 && segments[srcIdx + 1] === "locales";
 }
@@ -2907,6 +3301,14 @@ function reportFor(context, node, message) {
   context.report({ node, message });
 }
 function checkKey(context, node, name) {
+  if (!ENGLISH.test(name)) {
+    reportFor(
+      context,
+      node,
+      `Locale key "${name}" must be English; write it in the Latin alphabet. See docs/code-organization-guide/rules/locales-rule.md`
+    );
+    return;
+  }
   if (!CAMEL_CASE.test(name)) {
     reportFor(
       context,
@@ -2957,8 +3359,8 @@ var localeKeyShapeRule = {
 };
 
 // eslint/rules/shared-style-dedup.ts
-import path31 from "path";
-import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import path32 from "path";
+import { readFileSync as readFileSync4, statSync as statSync3 } from "fs";
 var CLASS_NAME = /className="(?<classes>[^"]+)"/g;
 var comboCache;
 function combosFor(index) {
@@ -2966,7 +3368,7 @@ function combosFor(index) {
   let fingerprint2 = "";
   for (const file of files) {
     try {
-      fingerprint2 += String(statSync2(file).mtimeMs);
+      fingerprint2 += String(statSync3(file).mtimeMs);
     } catch {
       fingerprint2 += "0";
     }
@@ -2976,7 +3378,7 @@ function combosFor(index) {
   }
   const combos = /* @__PURE__ */ new Map();
   for (const file of files) {
-    const text = readFileSync3(file, "utf8");
+    const text = readFileSync4(file, "utf8");
     for (const match of text.matchAll(CLASS_NAME)) {
       const classes = (match.groups?.classes ?? "").split(/\s+/).filter(Boolean);
       if (classes.length < 2) continue;
@@ -2998,8 +3400,8 @@ var sharedStyleDedupRule = {
     }
   },
   create(context) {
-    const sourceRoot2 = path31.resolve("src");
-    const file = path31.resolve(context.filename);
+    const sourceRoot2 = path32.resolve("src");
+    const file = path32.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot2);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot2);
@@ -3203,7 +3605,7 @@ var zodSchemaValidationRule = {
 };
 
 // eslint/rules/source-under-src.ts
-import path32 from "path";
+import path33 from "path";
 var NON_SOURCE_ROOT_DIRS = /* @__PURE__ */ new Set([
   ".agents",
   ".cache",
@@ -3244,14 +3646,14 @@ var sourceUnderSrcRule = {
     }
   },
   create(context) {
-    const filename = path32.resolve(context.filename);
+    const filename = path33.resolve(context.filename);
     if (!MODULE_EXTENSION.test(filename)) return {};
-    const relative = path32.relative(process.cwd(), filename).replace(/\\/g, "/");
+    const relative = path33.relative(process.cwd(), filename).replace(/\\/g, "/");
     if (relative === "src" || relative.startsWith("src/")) return {};
     const topLevel = relative.split("/")[0] ?? "";
     if (NON_SOURCE_ROOT_DIRS.has(topLevel)) return {};
     if (!relative.includes("/")) {
-      const basename = path32.basename(filename);
+      const basename = path33.basename(filename);
       if (CONFIG_FILE.test(basename) || DECLARATION_FILE.test(basename) || basename.startsWith(".")) return {};
     }
     return {
@@ -3268,7 +3670,7 @@ var sourceUnderSrcRule = {
 
 // eslint/rules/zirka-baseline.ts
 import fs4 from "fs";
-import path33 from "path";
+import path34 from "path";
 var ESLINT_CONFIG = /^eslint\.config\.(?:ts|mts|cts|js|mjs|cjs)$/;
 var PRETTIER_CONFIGS = [
   "prettier.config.mjs",
@@ -3287,10 +3689,10 @@ var zirkaBaselineRule = {
     }
   },
   create(context) {
-    const filename = path33.resolve(context.filename);
-    const basename = path33.basename(filename);
+    const filename = path34.resolve(context.filename);
+    const basename = path34.basename(filename);
     if (!ESLINT_CONFIG.test(basename)) return {};
-    const projectRoot = path33.dirname(filename);
+    const projectRoot = path34.dirname(filename);
     const report3 = (message) => {
       context.report({
         node: context.sourceCode.ast,
@@ -3305,7 +3707,7 @@ var zirkaBaselineRule = {
             'ESLint config must take its configuration from zirka (import { styleguide } from "zirka") instead of restating rules locally.'
           );
         }
-        const tsconfigPath = path33.join(projectRoot, "tsconfig.json");
+        const tsconfigPath = path34.join(projectRoot, "tsconfig.json");
         if (!fs4.existsSync(tsconfigPath)) {
           report3('No tsconfig.json found. Create one extending the zirka TypeScript base config ("zirka/typescript").');
         } else {
@@ -3323,13 +3725,13 @@ var zirkaBaselineRule = {
             report3('tsconfig.json must extend the zirka TypeScript base config ("zirka/typescript").');
           }
         }
-        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs4.existsSync(path33.join(projectRoot, name)));
+        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs4.existsSync(path34.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 = fs4.readFileSync(path33.join(projectRoot, prettierConfigFile), "utf8");
+          const content = fs4.readFileSync(path34.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."
@@ -3399,7 +3801,7 @@ var docKindSuffixRule = {
 };
 
 // eslint/rules/documentation/title-matches-file-name.ts
-import path34 from "path";
+import path35 from "path";
 function toExpectedFileName(title) {
   return `${title.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")}.md`;
 }
@@ -3419,7 +3821,7 @@ var titleMatchesFileNameRule = {
         if (!filename.endsWith(".md")) return;
         const title = getTextContent(node).trim();
         const expectedFileName = toExpectedFileName(title);
-        const actualFileName = path34.basename(filename);
+        const actualFileName = path35.basename(filename);
         if (!title) {
           context.report({
             node,
@@ -3826,7 +4228,7 @@ var referenceBlockHeadingsRule = {
 };
 
 // eslint/rules/documentation/support-document-placement.ts
-import path35 from "path";
+import path36 from "path";
 var supportDocumentPlacementRule = {
   meta: {
     type: "problem",
@@ -3840,7 +4242,7 @@ var supportDocumentPlacementRule = {
       root(node) {
         const filename = getFilename(context);
         if (!filename.endsWith(".md")) return;
-        const parentFolder = path35.basename(path35.dirname(filename));
+        const parentFolder = path36.basename(path36.dirname(filename));
         if (filename.endsWith("-rule.md") && parentFolder !== "rules") {
           context.report({
             node,
@@ -3883,11 +4285,11 @@ var noTemplatePromptRule = {
 };
 
 // eslint/rules/documentation/guide-folder-entry-point.ts
-import path37 from "path";
+import path38 from "path";
 
 // eslint/rules/documentation/project-index.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
-import path36 from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
+import path37 from "path";
 var KIND_BY_SUFFIX = [
   ["-rule.md", "rule"],
   ["-guide.md", "guide"],
@@ -3895,16 +4297,16 @@ var KIND_BY_SUFFIX = [
   ["-policy.md", "policy"]
 ];
 function listMarkdownFiles(dir) {
-  return readdirSync2(dir).flatMap((entry) => {
-    const entryPath = path36.join(dir, entry);
-    if (statSync3(entryPath).isDirectory()) {
+  return readdirSync3(dir).flatMap((entry) => {
+    const entryPath = path37.join(dir, entry);
+    if (statSync4(entryPath).isDirectory()) {
       return entry.startsWith("_") ? [] : listMarkdownFiles(entryPath);
     }
     return entry.endsWith(".md") ? [entryPath] : [];
   });
 }
 function extractTitle(filePath) {
-  const content = readFileSync4(filePath, "utf8");
+  const content = readFileSync5(filePath, "utf8");
   const match = /^# (?<title>.+)$/m.exec(content);
   return match?.groups?.title?.trim() ?? "";
 }
@@ -3914,11 +4316,11 @@ function getProjectDocs(docsRoot) {
   if (cached) return cached;
   const files = listMarkdownFiles(docsRoot);
   const docs = files.sort((a, b) => a.localeCompare(b)).map((filePath) => {
-    const fileName = path36.basename(filePath);
+    const fileName = path37.basename(filePath);
     const kind = KIND_BY_SUFFIX.find(([suffix]) => fileName.endsWith(suffix))?.[1];
     return {
       filePath,
-      doc: path36.relative(docsRoot, filePath).split(path36.sep).join("/"),
+      doc: path37.relative(docsRoot, filePath).split(path37.sep).join("/"),
       fileName,
       kind,
       title: extractTitle(filePath)
@@ -3928,12 +4330,12 @@ function getProjectDocs(docsRoot) {
   return docs;
 }
 function findDocsRoot(filePath) {
-  let dir = path36.dirname(filePath);
+  let dir = path37.dirname(filePath);
   for (; ; ) {
-    if (path36.basename(dir) === "docs" && statSync3(dir).isDirectory()) {
+    if (path37.basename(dir) === "docs" && statSync4(dir).isDirectory()) {
       return dir;
     }
-    const parent = path36.dirname(dir);
+    const parent = path37.dirname(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -3957,13 +4359,13 @@ var guideFolderEntryPointRule = {
         if (!docsRoot) return;
         const docs = getProjectDocs(docsRoot);
         const guideFolders = new Set(
-          docs.filter((doc) => ["rules", "references"].includes(path37.basename(path37.dirname(doc.filePath)))).map((doc) => path37.dirname(path37.dirname(doc.filePath))).filter((folder) => path37.resolve(folder) !== path37.resolve(docsRoot))
+          docs.filter((doc) => ["rules", "references"].includes(path38.basename(path38.dirname(doc.filePath)))).map((doc) => path38.dirname(path38.dirname(doc.filePath))).filter((folder) => path38.resolve(folder) !== path38.resolve(docsRoot))
         );
-        const currentDir = path37.dirname(filename);
+        const currentDir = path38.dirname(filename);
         if (guideFolders.has(currentDir)) {
-          const expectedEntryPoint = `${path37.basename(currentDir)}.md`;
+          const expectedEntryPoint = `${path38.basename(currentDir)}.md`;
           const hasEntryPoint = docs.some(
-            (doc) => doc.kind === "guide" && path37.dirname(doc.filePath) === currentDir && doc.fileName === expectedEntryPoint
+            (doc) => doc.kind === "guide" && path38.dirname(doc.filePath) === currentDir && doc.fileName === expectedEntryPoint
           );
           if (!hasEntryPoint) {
             context.report({
@@ -4187,10 +4589,10 @@ var noNestedHowToRule = {
 };
 
 // eslint/rules/documentation/glossary-term-linking.ts
-import { readFileSync as readFileSync5 } from "fs";
-import path38 from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import path39 from "path";
 function extractGlossaryTerms(filePath) {
-  const content = readFileSync5(filePath, "utf8");
+  const content = readFileSync6(filePath, "utf8");
   const terms = [];
   const headingPattern = /^## (?<term>.+)$/gm;
   let match;
@@ -4242,9 +4644,9 @@ var glossaryTermLinkingRule = {
         const docsRoot = findDocsRoot(filename);
         if (!docsRoot) return;
         const docs = getProjectDocs(docsRoot);
-        const guideDir = path38.dirname(filename);
+        const guideDir = path39.dirname(filename);
         const guideReferences = docs.filter(
-          (doc) => doc.kind === "reference" && path38.dirname(doc.filePath) === guideDir
+          (doc) => doc.kind === "reference" && path39.dirname(doc.filePath) === guideDir
         );
         if (guideReferences.length === 0) return;
         const glossaryTerms = [];
@@ -4269,7 +4671,7 @@ var glossaryTermLinkingRule = {
 
 // eslint/rules/documentation/guide-mentions-documents.ts
 import { existsSync } from "fs";
-import path39 from "path";
+import path40 from "path";
 function visitSteps3(node, check) {
   if (node.type === "list" && node.ordered) {
     for (const child of node.children) check(child);
@@ -4302,12 +4704,12 @@ var guideMentionsDocumentsRule = {
         if (!filename.endsWith("-guide.md")) return;
         const docsRoot = findDocsRoot(filename);
         if (!docsRoot) return;
-        const guideDir = path39.dirname(filename);
-        if (path39.basename(filename, ".md") !== path39.basename(guideDir)) return;
+        const guideDir = path40.dirname(filename);
+        if (path40.basename(filename, ".md") !== path40.basename(guideDir)) return;
         const docs = getProjectDocs(docsRoot);
         const owned = docs.filter((doc) => {
-          const parent = path39.dirname(doc.filePath);
-          return parent === path39.join(guideDir, "rules") || parent === path39.join(guideDir, "references");
+          const parent = path40.dirname(doc.filePath);
+          return parent === path40.join(guideDir, "rules") || parent === path40.join(guideDir, "references");
         });
         const allLinks = [];
         collectMarkdownLinks(node, allLinks);
@@ -4334,7 +4736,7 @@ var guideMentionsDocumentsRule = {
         for (const link of allLinks) {
           const target = linkTarget(link.url);
           if (!target.endsWith(".md")) continue;
-          const resolved = path39.normalize(path39.join(guideDir, target));
+          const resolved = path40.normalize(path40.join(guideDir, target));
           if (!existsSync(resolved)) {
             context.report({
               node: link,
@@ -4839,6 +5241,83 @@ var globalStylesheetRule = {
   }
 };
 
+// eslint/rules/tailwind/unused-utility.ts
+import { readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync5 } from "fs";
+import path41 from "path";
+var SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".css"];
+function sourceFiles(dir) {
+  let entries;
+  try {
+    entries = readdirSync4(dir);
+  } catch {
+    return [];
+  }
+  return entries.flatMap((entry) => {
+    if (entry.startsWith(".") || entry === "node_modules") return [];
+    const entryPath = path41.join(dir, entry);
+    let stats;
+    try {
+      stats = statSync5(entryPath);
+    } catch {
+      return [];
+    }
+    if (stats.isDirectory()) return sourceFiles(entryPath);
+    return SOURCE_EXTENSIONS.includes(path41.extname(entry)) ? [entryPath] : [];
+  });
+}
+function usagePattern(name) {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`);
+}
+var unusedUtilityRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require every custom @utility to be referenced by the repository's source."
+    }
+  },
+  create(context) {
+    const sourceRoot2 = path41.resolve("src");
+    let files;
+    try {
+      if (!statSync5(sourceRoot2).isDirectory()) return {};
+      files = sourceFiles(sourceRoot2);
+    } catch {
+      return {};
+    }
+    const texts = /* @__PURE__ */ new Map();
+    const textOf = (file) => {
+      let text = texts.get(file);
+      if (text === void 0) {
+        try {
+          text = readFileSync7(file, "utf8");
+        } catch {
+          text = "";
+        }
+        texts.set(file, text);
+      }
+      return text;
+    };
+    return {
+      "StyleSheet:exit"(node) {
+        for (const utility of atrulesNamed(node, "utility")) {
+          const name = preludeIdentifiers(utility)[0];
+          if (!name) continue;
+          const pattern = usagePattern(name);
+          const definition = `@utility ${name}`;
+          const used = files.some((file) => pattern.test(textOf(file).replaceAll(definition, "")));
+          if (used) continue;
+          context.report({
+            node: utility,
+            message: `Custom utility "${name}" is never used by the repository's source; remove it or use it.`
+          });
+        }
+      }
+    };
+  }
+};
+
 // eslint/rules/tailwind/index.ts
 var tailwindRules = {
   "theme-reset": themeResetRule,
@@ -4851,7 +5330,8 @@ var tailwindRules = {
   "surface-utility": surfaceUtilityRule,
   "theme-variable-namespace": themeVariableNamespaceRule,
   "global-css-location": globalCssLocationRule,
-  "global-stylesheet": globalStylesheetRule
+  "global-stylesheet": globalStylesheetRule,
+  "unused-utility": unusedUtilityRule
 };
 
 // eslint/rules/package-json/exact-version.ts
@@ -4998,8 +5478,8 @@ var nextPackageJsonRules = {
 };
 
 // eslint/rules/husky/husky-hook.ts
-import { existsSync as existsSync2, readFileSync as readFileSync6 } from "fs";
-import path40 from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync8 } from "fs";
+import path42 from "path";
 function memberName4(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
@@ -5018,7 +5498,7 @@ var huskyHookRule = {
         if (root.type !== "Object") return;
         const scriptName = context.filename;
         if (!scriptName.endsWith("package.json")) return;
-        const hookPath = path40.join(process.cwd(), ".husky", "pre-commit");
+        const hookPath = path42.join(process.cwd(), ".husky", "pre-commit");
         if (!existsSync2(hookPath)) {
           context.report({
             node,
@@ -5026,7 +5506,7 @@ var huskyHookRule = {
           });
           return;
         }
-        const content = readFileSync6(hookPath, "utf8");
+        const content = readFileSync8(hookPath, "utf8");
         if (!content.includes("lint-staged")) {
           context.report({ node, message: ".husky/pre-commit must run lint-staged." });
         }
@@ -5057,8 +5537,8 @@ var huskyRules = {
 };
 
 // eslint/rules/vulyk/vulyk-docs.ts
-import { existsSync as existsSync3, readFileSync as readFileSync7 } from "fs";
-import path41 from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync9 } from "fs";
+import path43 from "path";
 var PASIKA_REPO = "Bredansky/pasika";
 var vulykDocsRule = {
   meta: {
@@ -5072,8 +5552,8 @@ var vulykDocsRule = {
     return {
       Document(node) {
         if (!context.filename.endsWith("package.json")) return;
-        const projectRoot = path41.dirname(path41.resolve(context.filename));
-        const configPath = path41.join(projectRoot, "vulyk.config.ts");
+        const projectRoot = path43.dirname(path43.resolve(context.filename));
+        const configPath = path43.join(projectRoot, "vulyk.config.ts");
         if (!existsSync3(configPath)) {
           context.report({
             node,
@@ -5081,14 +5561,14 @@ var vulykDocsRule = {
           });
           return;
         }
-        const config = readFileSync7(configPath, "utf8");
+        const config = readFileSync9(configPath, "utf8");
         if (!config.includes(PASIKA_REPO)) {
           context.report({
             node,
             message: "vulyk.config.ts must track the framework's docs from the pasika repository."
           });
         }
-        const agentsPath = path41.join(projectRoot, "AGENTS.md");
+        const agentsPath = path43.join(projectRoot, "AGENTS.md");
         if (!existsSync3(agentsPath)) {
           context.report({
             node,
@@ -5132,6 +5612,7 @@ var nextjsAppRules = {
   "ui-state": uiStateRule,
   "no-mixed-concerns": noMixedConcernsRule,
   "no-arbitrary-tailwind": noArbitraryTailwindRule,
+  "unknown-utility": unknownUtilityRule,
   "enforce-cn-merge": enforceCnMergeRule,
   "cn-helper": cnHelperRule,
   "enforce-cva-variant-props": enforceCvaVariantPropsRule,