pasika 0.10.113 → 0.10.115

package/dist/eslint/pasika/index.js

@@ -7121,10 +7121,10 @@ var nextjsStackRule = {
       Document(node) {
         const root = node.body;
         if (root.type !== "Object") return;
-        const dependencies = sectionPackages(root, "dependencies");
+        const dependencies2 = sectionPackages(root, "dependencies");
         const devDependencies = sectionPackages(root, "devDependencies");
         for (const pkg of NEXTJS_STACK_DEPENDENCIES) {
-          if (dependencies.has(pkg)) continue;
+          if (dependencies2.has(pkg)) continue;
           context.report({
             node,
             message: `${pkg} must be listed in package.json as a dependency.`
@@ -9708,46 +9708,9 @@ var applyUsageRule = {
 };
 
 // eslint/rules/tailwind/base-layer-pair.ts
-var baseLayerPairRule = {
-  meta: {
-    schema: [],
-    type: "problem",
-    docs: {
-      description: "Require the base layer to apply base-canvas and base-ink to the body."
-    }
-  },
-  create(context) {
-    return {
-      "StyleSheet:exit"(node) {
-        const baseLayers = atrulesNamed(node, "layer").filter((layer) => preludeIdentifiers(layer).includes("base"));
-        if (baseLayers.length === 0) return;
-        const applied = [];
-        for (const layer of baseLayers) {
-          for (const child of blockChildren2(layer)) {
-            if (child.type !== "Rule") continue;
-            if (!selectorNames(child).includes("body")) continue;
-            for (const declaration of blockChildren2(child)) {
-              if (declaration.type !== "Atrule" || declaration.name !== "apply") continue;
-              applied.push(...preludeIdentifiers(declaration));
-            }
-          }
-        }
-        const hasCanvas = applied.some((name) => name.includes("canvas"));
-        const hasInk = applied.some((name) => name.includes("ink"));
-        if (!hasCanvas || !hasInk) {
-          context.report({
-            node,
-            message: "The global base layer must apply a canvas and an ink utility to the document body as the default page pair."
-          });
-        }
-      }
-    };
-  }
-};
-
-// eslint/rules/tailwind/css-entry-point.ts
-import { statSync as statSync4 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import path66 from "path";
+import { parse as parse3, toPlainObject } from "@eslint/css-tree";
 
 // eslint/rules/tailwind/source-files.ts
 import { readdirSync as readdirSync5, readFileSync as readFileSync14, statSync as statSync3 } from "fs";
@@ -9846,9 +9809,137 @@ function buildStylesheetGraph(options) {
   return { globals, reachable, directChildren };
 }
 
+// eslint/rules/tailwind/base-layer-pair.ts
+function collectBodyUtilities(node) {
+  const baseLayers = atrulesNamed(node, "layer").filter((layer) => preludeIdentifiers(layer).includes("base"));
+  const names = [];
+  for (const layer of baseLayers) {
+    for (const child of blockChildren2(layer)) {
+      if (child.type !== "Rule" || !selectorNames(child).includes("body")) continue;
+      for (const declaration of blockChildren2(child)) {
+        if (declaration.type === "Atrule" && declaration.name === "apply") {
+          names.push(...preludeIdentifiers(declaration));
+        }
+      }
+    }
+  }
+  return { hasBaseLayer: baseLayers.length > 0, names };
+}
+var baseLayerPairRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require the global CSS tree's base layer to apply canvas and ink utilities to body."
+    }
+  },
+  create(context) {
+    const sourceRoot = sourceRootOf(context);
+    const current = path66.normalize(path66.resolve(context.filename));
+    const entryPoint = path66.normalize(path66.join(sourceRoot, "app", "styles", "globals.css"));
+    if (current !== entryPoint) return {};
+    return {
+      "StyleSheet:exit"(node) {
+        const applied = collectBodyUtilities(node);
+        const seen = /* @__PURE__ */ new Set([current]);
+        const queue = [{ file: current, source: context.sourceCode.text }];
+        const textOf = cachedTextReader();
+        while (queue.length > 0) {
+          const from = queue.shift();
+          if (!from) continue;
+          for (const specifier of importedSpecifiers(from.source)) {
+            const target = resolveSpecifier2(from.file, specifier, sourceRoot);
+            if (!target || path66.extname(target) !== ".css") continue;
+            const filename = path66.normalize(target);
+            if (seen.has(filename) || !existsSync8(filename)) continue;
+            seen.add(filename);
+            const source = textOf(filename);
+            const parsed = toPlainObject(parse3(source, { parseAtrulePrelude: true }));
+            if (parsed.type !== "StyleSheet") continue;
+            const fragment = collectBodyUtilities(parsed);
+            applied.hasBaseLayer ||= fragment.hasBaseLayer;
+            applied.names.push(...fragment.names);
+            queue.push({ file: filename, source });
+          }
+        }
+        if (!applied.hasBaseLayer) return;
+        const hasCanvas = applied.names.some((name) => name.includes("canvas"));
+        const hasInk = applied.names.some((name) => name.includes("ink"));
+        if (!hasCanvas || !hasInk) {
+          context.report({
+            node,
+            message: "The global base layer must apply a canvas and an ink utility to the document body as the default page pair."
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/rules/color-role.ts
+function colorRoleUsageMessage(className) {
+  const segments = className.replace(/!+$/u, "").split(":");
+  const utility = ((segments[segments.length - 1] ?? "").split("/")[0] ?? "").replace(/^!/u, "");
+  if (utility.includes("[") || utility.includes("(")) return void 0;
+  const role = /-(?<role>canvas|ink|edge)$/u.exec(utility)?.groups?.role;
+  if (!role) return void 0;
+  let expected;
+  let purpose;
+  if (/^(?:bg|from|via|to|fill|ring-offset)-/u.test(utility)) {
+    expected = "canvas";
+    purpose = "backgrounds, fills, or gradients";
+  } else if (/^(?:text|caret|decoration)-/u.test(utility)) {
+    expected = "ink";
+    purpose = "text, carets, or text decoration";
+  } else if (/^(?:border|outline|ring|divide|stroke)-/u.test(utility)) {
+    expected = "edge";
+    purpose = "borders, outlines, rings, dividers, or strokes";
+  }
+  if (!expected || !purpose || role === expected) return void 0;
+  return `Color utility "${className}" uses a "${role}" token for ${purpose}; use a "${expected}" token instead.`;
+}
+
+// eslint/rules/tailwind/color-role-usage.ts
+var COLOR_TOKEN = /^--color-[a-z][a-z0-9-]*-(?:canvas|ink|edge)$/u;
+var colorRoleUsageRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: { description: "Require semantic color-token names and matching Tailwind color utilities." }
+  },
+  create(context) {
+    return {
+      "StyleSheet:exit"(node) {
+        for (const theme of atrulesNamed(node, "theme")) {
+          const source = context.sourceCode.getText(theme).replace(/\/\*[\s\S]*?\*\//gu, " ");
+          for (const match of source.matchAll(/(?:^|[{;\r\n])\s*(?<token>--color-[a-z][a-z0-9-]*)\s*:/gu)) {
+            const token = match.groups?.token;
+            if (token && !COLOR_TOKEN.test(token)) {
+              context.report({
+                node: theme,
+                message: `Color token "${token}" needs a semantic role ending in -canvas, -ink, or -edge.`
+              });
+            }
+          }
+        }
+        for (const apply of atrulesNamed(node, "apply")) {
+          const source = context.sourceCode.getText(apply);
+          const classes = source.replace(/^@apply\s+/u, "").replace(/;\s*$/u, "").trim().split(/\s+/u);
+          for (const className of classes) {
+            const message = colorRoleUsageMessage(className);
+            if (message) context.report({ node: apply, message });
+          }
+        }
+      }
+    };
+  }
+};
+
 // eslint/rules/tailwind/css-entry-point.ts
-var APP_STYLES_DIR = path66.join("app", "styles");
-var GLOBAL_STYLESHEET_PATH = path66.join(APP_STYLES_DIR, "globals.css");
+import { statSync as statSync4 } from "fs";
+import path67 from "path";
+var APP_STYLES_DIR = path67.join("app", "styles");
+var GLOBAL_STYLESHEET_PATH = path67.join(APP_STYLES_DIR, "globals.css");
 var cssEntryPointRule = {
   meta: {
     schema: [],
@@ -9874,8 +9965,8 @@ var cssEntryPointRule = {
     return {
       "StyleSheet:exit"(node) {
         if (globals.length === 0) return;
-        const current = path66.normalize(path66.resolve(context.filename));
-        const relative = path66.relative(sourceRoot, current);
+        const current = path67.normalize(path67.resolve(context.filename));
+        const relative = path67.relative(sourceRoot, current);
         if (globals.includes(current)) {
           if (globals.length > 1) {
             context.report({
@@ -9891,7 +9982,7 @@ var cssEntryPointRule = {
             });
             return;
           }
-          const basename = path66.basename(current);
+          const basename = path67.basename(current);
           const importCount = moduleFiles.filter((modulePath) => moduleImports(textOf(modulePath), basename)).length;
           if (importCount !== 1) {
             context.report({
@@ -9901,7 +9992,7 @@ var cssEntryPointRule = {
           }
           return;
         }
-        const isInAppStyles = relative === APP_STYLES_DIR || relative.startsWith(`${APP_STYLES_DIR}${path66.sep}`);
+        const isInAppStyles = relative === APP_STYLES_DIR || relative.startsWith(`${APP_STYLES_DIR}${path67.sep}`);
         if (!isInAppStyles) {
           context.report({
             node,
@@ -9932,106 +10023,6 @@ var cssEntryPointRule = {
   }
 };
 
-// eslint/project/semantic-color-role.ts
-var BOUNDARY_PROPERTY_WORDS = /* @__PURE__ */ new Set(["border", "outline", "ring", "stroke"]);
-function violatesBoundaryColorRole(token) {
-  return !token.endsWith("-edge") && token.split("-").some((word) => BOUNDARY_PROPERTY_WORDS.has(word));
-}
-var BACKGROUND_COLOR_UTILITIES = /* @__PURE__ */ new Set(["bg", "from", "via", "to"]);
-var TEXT_COLOR_UTILITIES = /* @__PURE__ */ new Set(["text"]);
-var BOUNDARY_COLOR_UTILITIES = /* @__PURE__ */ new Set(["border", "divide", "outline", "ring", "stroke"]);
-function incompatibleColorUtilityRole(prefix, token) {
-  let role;
-  if (token.endsWith("-canvas")) role = "canvas";
-  else if (token.endsWith("-ink")) role = "ink";
-  else if (token.endsWith("-edge")) role = "edge";
-  if (!role) return void 0;
-  if (BACKGROUND_COLOR_UTILITIES.has(prefix)) return role === "canvas" ? void 0 : role;
-  if (TEXT_COLOR_UTILITIES.has(prefix)) return role === "ink" ? void 0 : role;
-  if (BOUNDARY_COLOR_UTILITIES.has(prefix)) return role === "edge" ? void 0 : role;
-  return void 0;
-}
-
-// eslint/rules/tailwind/css-variable-naming.ts
-var EDGE_PROPERTY_WORDS = /* @__PURE__ */ new Set(["border", "outline", "ring", "stroke"]);
-var NON_COLOR_WORDS = /* @__PURE__ */ new Set(["height", "leading", "offset", "radius", "size", "spacing", "style", "width"]);
-var TAILWIND_THEME_NAMESPACES = /* @__PURE__ */ new Set([
-  "animate",
-  "aspect",
-  "blur",
-  "breakpoint",
-  "color",
-  "container",
-  "drop",
-  "ease",
-  "font",
-  "inset",
-  "leading",
-  "perspective",
-  "radius",
-  "shadow",
-  "spacing",
-  "text",
-  "tracking"
-]);
-function isTailwindThemeVariable(property) {
-  const namespace = property.slice(2).split("-")[0];
-  return namespace !== void 0 && TAILWIND_THEME_NAMESPACES.has(namespace);
-}
-function looksLikeEdgeColor(lower) {
-  const words = lower.slice(2).split("-");
-  return words.some((word) => EDGE_PROPERTY_WORDS.has(word)) && !words.some((word) => NON_COLOR_WORDS.has(word));
-}
-function looksLikeTextColor(lower) {
-  const words = lower.slice(2).split("-");
-  return words.includes("text") && !words.some((word) => NON_COLOR_WORDS.has(word));
-}
-var cssVariableNamingRule = {
-  meta: {
-    schema: [],
-    type: "problem",
-    docs: {
-      description: "Require property-specific color variables to use canvas, ink, and edge role suffixes."
-    }
-  },
-  create(context) {
-    return {
-      Declaration(node) {
-        const property = node.property;
-        if (!property.startsWith("--")) return;
-        if (isTailwindThemeVariable(property)) {
-          if (property.startsWith("--color-") && violatesBoundaryColorRole(property.slice("--color-".length))) {
-            context.report({
-              node,
-              message: `Theme color "${property}" names a boundary using a CSS property; use --color-<role>-edge and border-<role>-edge instead.`
-            });
-          }
-          return;
-        }
-        const lower = property.toLowerCase();
-        if ((lower.includes("bg") || lower.includes("background")) && !lower.endsWith("-canvas")) {
-          context.report({
-            node,
-            message: `CSS variable "${property}" looks like a background token; name it --<role>-canvas instead.`
-          });
-        }
-        if (looksLikeTextColor(lower) && !lower.endsWith("-ink")) {
-          context.report({
-            node,
-            message: `CSS variable "${property}" looks like a text token; name it --<role>-ink instead.`
-          });
-        }
-        if (looksLikeEdgeColor(lower) && !lower.endsWith("-edge")) {
-          context.report({
-            node,
-            message: `CSS variable "${property}" looks like a boundary token; name it --<role>-edge instead.`
-          });
-        }
-      }
-    };
-  }
-};
-
 // eslint/rules/tailwind/custom-utility-apply.ts
 function rawProperty(raw) {
   const match = /^\s*(?<property>[a-z][a-z-]*)\s*:/.exec(raw);
@@ -10074,6 +10065,440 @@ var customUtilityApplyRule = {
   }
 };
 
+// eslint/rules/tailwind/feature-css-placement.ts
+import { existsSync as existsSync9 } from "fs";
+import path70 from "path";
+
+// eslint/rules/tailwind/css-dependency-graph.ts
+import path68 from "path";
+import { generate, parse as parse4, walk } from "@eslint/css-tree";
+function lineAt(text, offset) {
+  return text.slice(0, offset).split("\n").length;
+}
+function tokenLines(content, token) {
+  const regex = new RegExp(`(?<![\\w-])${escapeRegExp(token)}(?![\\w-])`, "gu");
+  return [...content.matchAll(regex)].map((found) => lineAt(content, found.index));
+}
+function pushSymbol(symbols, kind, name, file, line, value) {
+  if (name) symbols.push({ kind, name, file, line, ...value === void 0 ? {} : { value } });
+}
+function themeClasses(name) {
+  if (name.includes("--", 2)) return [];
+  if (name.startsWith("--color-")) {
+    const stem = name.slice("--color-".length);
+    if (stem.endsWith("-canvas")) {
+      return ["bg", "fill", "from", "via", "to", "ring-offset"].map((prefix) => `${prefix}-${stem}`);
+    }
+    if (stem.endsWith("-ink")) return ["text", "caret", "decoration"].map((prefix) => `${prefix}-${stem}`);
+    if (stem.endsWith("-edge")) {
+      return ["border", "outline", "ring", "divide", "stroke"].map((prefix) => `${prefix}-${stem}`);
+    }
+    return ["bg", "text", "border", "fill", "stroke", "ring"].map((prefix) => `${prefix}-${stem}`);
+  }
+  if (name.startsWith("--animate-")) return [`animate-${name.slice("--animate-".length)}`];
+  if (name.startsWith("--radius-")) return [`rounded-${name.slice("--radius-".length)}`];
+  if (name.startsWith("--text-") || name.startsWith("--tracking-") || name.startsWith("--font-")) {
+    return [name.slice(2)];
+  }
+  return [];
+}
+function buildCssDependencyGraph(options) {
+  const definitions = [];
+  const references = [];
+  const imports = [];
+  for (const file of options.css) {
+    const filename = path68.normalize(file.path);
+    for (const spec of importedSpecifiers(file.content)) {
+      const target = resolveSpecifier2(filename, spec, options.sourceRoot);
+      if (target) imports.push({ from: filename, to: path68.normalize(target) });
+    }
+    const ast = parse4(file.content, { positions: true, parseAtrulePrelude: false });
+    const atRuleStack = [];
+    walk(ast, {
+      enter(node) {
+        if (node.type === "Atrule") {
+          atRuleStack.push({
+            name: node.name,
+            baseLayer: node.name === "layer" && node.prelude !== null && generate(node.prelude).trim() === "base"
+          });
+        }
+        const line = node.loc?.start.line ?? 1;
+        if (node.type === "Atrule") {
+          if (node.name === "utility" || node.name === "keyframes") {
+            pushSymbol(definitions, node.name, node.prelude ? generate(node.prelude).trim() : "", filename, line);
+          } else if (node.name === "font-face") {
+            const descriptors = /* @__PURE__ */ new Map();
+            for (const child of node.block?.children ?? []) {
+              if (child.type === "Declaration") descriptors.set(child.property, generate(child.value).trim());
+            }
+            const family = descriptors.get("font-family")?.replace(/^["']|["']$/gu, "").replace(/\s+/gu, " ").toLowerCase();
+            if (family) {
+              const descriptor = (name, fallback) => (descriptors.get(name) ?? fallback).toLowerCase().replace(/\s+/gu, " ").trim();
+              const weight = descriptor("font-weight", "400");
+              let normalizedWeight = weight;
+              if (weight === "normal") normalizedWeight = "400";
+              else if (weight === "bold") normalizedWeight = "700";
+              const stretch = descriptor("font-stretch", "normal");
+              definitions.push({
+                kind: "font-face",
+                name: family,
+                file: filename,
+                line,
+                identity: [
+                  family,
+                  descriptor("font-style", "normal"),
+                  normalizedWeight,
+                  stretch === "100%" ? "normal" : stretch,
+                  descriptor("unicode-range", "u+0-10ffff")
+                ].join("|")
+              });
+            }
+          } else if (node.name === "theme" && node.loc) {
+            const source = file.content.slice(node.loc.start.offset, node.loc.end.offset).replace(/\/\*[\s\S]*?\*\//gu, (comment) => comment.replace(/[^\r\n]/gu, " "));
+            for (const found of source.matchAll(
+              /(?:^|[{;\r\n])\s*(?<name>--[a-z][\w-]*)\s*:\s*(?<value>[^;\r\n]+);/gu
+            )) {
+              const name = found.groups?.name;
+              const value = found.groups?.value;
+              if (!name || !value) continue;
+              pushSymbol(
+                definitions,
+                "theme-token",
+                name,
+                filename,
+                lineAt(file.content, node.loc.start.offset + found.index + found[0].indexOf(name)),
+                value.trim()
+              );
+            }
+          }
+        }
+        if (node.type === "Rule" && !atRuleStack.some((entry) => entry.name === "keyframes" || entry.baseLayer)) {
+          const selector = generate(node.prelude).trim();
+          const match = /^\.(?<name>[a-zA-Z_][\w-]*)(?:::{0,1}[a-zA-Z-]+(?:\([^)]*\))?)*$/u.exec(selector);
+          if (match?.groups?.name) pushSymbol(definitions, "selector", match.groups.name, filename, line);
+        }
+        if (node.type !== "Declaration" || !node.property.startsWith("--") || node.property === "--*") return;
+        const inRoot = this.rule?.type === "Rule" && generate(this.rule.prelude).trim() === ":root";
+        if (inRoot) {
+          const scope = atRuleStack.every((entry) => entry.name === "layer") ? "default" : "conditional";
+          definitions.push({
+            kind: "root-variable",
+            name: node.property,
+            file: filename,
+            line,
+            value: generate(node.value),
+            scope
+          });
+        }
+      },
+      leave(node) {
+        if (node.type === "Atrule") atRuleStack.pop();
+      }
+    });
+    if (options.includeReferences === false) continue;
+    for (const found of file.content.matchAll(/var\(\s*(?<name>--[\w-]+)/gu)) {
+      if (!found.groups?.name) continue;
+      references.push({
+        kind: "variable",
+        name: found.groups.name,
+        file: filename,
+        line: lineAt(file.content, found.index),
+        source: "css"
+      });
+    }
+  }
+  if (options.includeReferences === false) return { definitions, references, imports };
+  const utilities = new Set(definitions.filter((item) => item.kind === "utility").map((item) => item.name));
+  const selectors = new Set(definitions.filter((item) => item.kind === "selector").map((item) => item.name));
+  const keyframes = new Set(definitions.filter((item) => item.kind === "keyframes").map((item) => item.name));
+  const generatedClasses = /* @__PURE__ */ new Map();
+  for (const symbol of definitions) {
+    if (symbol.kind !== "theme-token") continue;
+    for (const className of themeClasses(symbol.name)) generatedClasses.set(className, symbol.name);
+  }
+  for (const file of options.css) {
+    const filename = path68.normalize(file.path);
+    const ast = parse4(file.content, { positions: true, parseAtrulePrelude: false });
+    walk(ast, {
+      enter(node) {
+        let kind;
+        let text;
+        let names;
+        if (node.type === "Atrule" && node.name === "apply" && node.prelude) {
+          kind = "utility";
+          text = generate(node.prelude);
+          names = utilities;
+        } else if (node.type === "Declaration" && (node.property === "animation" || node.property === "animation-name")) {
+          kind = "keyframes";
+          text = generate(node.value);
+          names = keyframes;
+        } else return;
+        for (const name of names) {
+          if (tokenLines(text, name).length > 0) {
+            references.push({ kind, name, file: filename, line: node.loc?.start.line ?? 1, source: "css" });
+          }
+        }
+        if (kind === "utility") {
+          for (const match of text.matchAll(/\[(?:animation|animation-name):(?<value>[^\]]+)\]/gu)) {
+            const normalized = (match.groups?.value ?? "").replace(/_/gu, " ");
+            for (const name of keyframes) {
+              if (tokenLines(normalized, name).length > 0) {
+                references.push({
+                  kind: "keyframes",
+                  name,
+                  file: filename,
+                  line: node.loc?.start.line ?? 1,
+                  source: "css"
+                });
+              }
+            }
+          }
+          for (const [name, token] of generatedClasses) {
+            if (tokenLines(text, name).length > 0) {
+              references.push({
+                kind: "theme-class",
+                name,
+                token,
+                file: filename,
+                line: node.loc?.start.line ?? 1,
+                source: "css"
+              });
+            }
+          }
+        }
+      }
+    });
+  }
+  for (const file of options.modules) {
+    const filename = path68.normalize(file.path);
+    for (const [kind, names] of [
+      ["utility", utilities],
+      ["keyframes", keyframes],
+      ["selector", selectors]
+    ]) {
+      for (const name of names) {
+        for (const line of tokenLines(file.content, name)) {
+          references.push({ kind, name, file: filename, line, source: "module" });
+        }
+      }
+    }
+    for (const [name, token] of generatedClasses) {
+      for (const line of tokenLines(file.content, name)) {
+        references.push({ kind: "theme-class", name, token, file: filename, line, source: "module" });
+      }
+    }
+  }
+  return { definitions, references, imports };
+}
+function cssSymbolUsages(graph, kind, name) {
+  return graph.references.filter((item) => item.kind === kind && item.name === name);
+}
+
+// eslint/rules/tailwind/css-ownership.ts
+import path69 from "path";
+import { generate as generate2, parse as parse5, walk as walk2 } from "@eslint/css-tree";
+var GLOBAL = "globals.css";
+function symbolId(def) {
+  return [def.file, def.kind, def.name, def.line].join("|");
+}
+function consumerFeature(file, sourceRoot) {
+  const parts = path69.relative(sourceRoot, file).split(path69.sep);
+  return parts[0] === "features" && parts.length > 2 ? parts[1] ?? GLOBAL : GLOBAL;
+}
+function contains(text, name) {
+  return new RegExp(`(?<![\\w-])${escapeRegExp(name)}(?![\\w-])`, "u").test(text);
+}
+function dependencies(text, defs) {
+  const result = /* @__PURE__ */ new Set();
+  const variables = new Set([...text.matchAll(/var\(\s*(?<name>--[\w-]+)/gu)].map((m) => m.groups?.name));
+  const applied = [...text.matchAll(/@apply\s+(?<value>[^;}]+)/gu)].map((m) => m.groups?.value ?? "");
+  const animations = [...text.matchAll(/(?:animation|animation-name)\s*:\s*(?<value>[^;}\]]+)/gu)].map(
+    (m) => (m.groups?.value ?? "").replaceAll("_", " ")
+  );
+  const families = [...text.matchAll(/font-family\s*:\s*(?<value>[^;}\]]+)/gu)].map(
+    (m) => (m.groups?.value ?? "").replaceAll("_", " ").toLowerCase()
+  );
+  for (const def of defs) {
+    const match = (def.kind === "theme-token" || def.kind === "root-variable") && variables.has(def.name) || (def.kind === "utility" || def.kind === "selector") && applied.some((part) => contains(part, def.name)) || def.kind === "keyframes" && animations.some((part) => contains(part, def.name)) || def.kind === "font-face" && (families.some((part) => contains(part, def.name)) || new RegExp(`^\\s*["']?${escapeRegExp(def.name)}["']?\\s*(?:,|$)`, "iu").test(text)) || def.kind === "theme-token" && applied.some((part) => themeClasses(def.name).some((name) => contains(part, name)));
+    if (match) result.add(symbolId(def));
+  }
+  return result;
+}
+function bodiesOf(css2, defs) {
+  const bodies = /* @__PURE__ */ new Map();
+  for (const src of css2) {
+    const file = path69.normalize(src.path);
+    const ast = parse5(src.content, { positions: true, parseAtrulePrelude: false });
+    walk2(ast, {
+      enter(node) {
+        if (!node.loc) return;
+        let kind;
+        if (node.type === "Atrule" && ["utility", "keyframes", "font-face"].includes(node.name)) {
+          kind = node.name;
+        } else if (node.type === "Rule") {
+          kind = "selector";
+        }
+        if (!kind) return;
+        const found = defs.filter((def) => def.file === file && def.kind === kind && def.line === node.loc?.start.line);
+        if (found.length !== 1 || !found[0]) return;
+        bodies.set(symbolId(found[0]), src.content.slice(node.loc.start.offset, node.loc.end.offset));
+      }
+    });
+  }
+  for (const def of defs) {
+    if ((def.kind === "theme-token" || def.kind === "root-variable") && def.value !== void 0) {
+      bodies.set(symbolId(def), def.value);
+    }
+  }
+  return bodies;
+}
+function inferCssOwners(options) {
+  const { graph, css: css2, modules, sourceRoot } = options;
+  const defs = graph.definitions;
+  const owners = new Map(defs.map((def) => [symbolId(def), /* @__PURE__ */ new Set()]));
+  const counts = /* @__PURE__ */ new Map();
+  for (const def of defs) {
+    if (def.kind === "root-variable" && def.scope === "conditional") continue;
+    const key = `${def.kind}:${def.identity ?? def.name}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  const duplicates = new Set(
+    defs.filter((d) => (counts.get(`${d.kind}:${d.identity ?? d.name}`) ?? 0) > 1).map(symbolId)
+  );
+  for (const def of defs) {
+    const key = symbolId(def);
+    if (duplicates.has(key) || def.kind === "root-variable" && def.scope === "conditional") continue;
+    for (const ref of graph.references) {
+      if (ref.source !== "module") continue;
+      if (def.kind === "utility" && ref.kind === "utility" && ref.name === def.name || def.kind === "selector" && ref.kind === "selector" && ref.name === def.name || def.kind === "theme-token" && ref.kind === "theme-class" && ref.token === def.name) {
+        owners.get(key)?.add(consumerFeature(ref.file, sourceRoot));
+      }
+    }
+    for (const mod of modules) {
+      const name = escapeRegExp(def.name);
+      const explicit = (def.kind === "theme-token" || def.kind === "root-variable") && new RegExp(`var\\(\\s*${name}(?![\\w-])`, "u").test(mod.content) || def.kind === "keyframes" && new RegExp(`(?:animationName|animation-name|animation)\\s*[:=]\\s*["'][^"']*${name}`, "u").test(
+        mod.content
+      ) || def.kind === "font-face" && new RegExp(`(?:fontFamily|font-family)\\s*[:=]\\s*["'][^"']*${name}`, "iu").test(mod.content);
+      if (explicit) owners.get(key)?.add(consumerFeature(mod.path, sourceRoot));
+    }
+    if (def.kind === "theme-token" && (def.name === "--spacing" || def.name.startsWith("--color-base-")) || def.kind === "root-variable" && def.name.startsWith("--color-base-")) {
+      owners.get(key)?.add(GLOBAL);
+    }
+  }
+  const links = /* @__PURE__ */ new Map();
+  for (const [key, content] of bodiesOf(css2, defs)) {
+    const targets = dependencies(content, defs);
+    const def = defs.find((candidate) => symbolId(candidate) === key);
+    if (def?.kind === "theme-token" && def.name.startsWith("--animate-")) {
+      for (const frame of defs) {
+        if (frame.kind === "keyframes" && contains(content, frame.name)) {
+          targets.add(symbolId(frame));
+        }
+      }
+    }
+    targets.delete(key);
+    links.set(key, targets);
+  }
+  for (const src of css2) {
+    if (path69.basename(src.path) !== GLOBAL) continue;
+    const ast = parse5(src.content, { positions: true, parseAtrulePrelude: false });
+    if (ast.type !== "StyleSheet") continue;
+    for (const node of ast.children) {
+      if (node.type !== "Atrule" || node.name !== "layer" || !node.loc || !node.prelude || generate2(node.prelude).trim() !== "base") {
+        continue;
+      }
+      const body = src.content.slice(node.loc.start.offset, node.loc.end.offset);
+      for (const key of dependencies(body, defs)) owners.get(key)?.add(GLOBAL);
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [from, targets] of links) {
+      for (const feature of owners.get(from) ?? []) {
+        for (const to of targets) {
+          if (duplicates.has(to)) continue;
+          const set = owners.get(to);
+          if (set && !set.has(feature)) {
+            set.add(feature);
+            changed = true;
+          }
+        }
+      }
+    }
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const def of defs) {
+    const key = symbolId(def);
+    const set = owners.get(key);
+    let owner;
+    if (!duplicates.has(key) && set && set.size > 0 && !(def.kind === "root-variable" && def.scope === "conditional")) {
+      owner = set.size === 1 ? [...set][0] : GLOBAL;
+    }
+    result.set(key, owner);
+  }
+  return result;
+}
+
+// eslint/rules/tailwind/feature-css-placement.ts
+var STYLES_DIR = path70.join("app", "styles");
+var GLOBALS = "globals.css";
+var FEATURE_CSS = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*\.css$/u;
+var LABELS = {
+  utility: "utility",
+  "theme-token": "theme token",
+  "root-variable": "root variable",
+  keyframes: "keyframes",
+  "font-face": "font face",
+  selector: "selector"
+};
+var featureCssPlacementRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Enforce ownership of CSS definitions and their transitive dependencies across feature scopes."
+    }
+  },
+  create(context) {
+    const sourceRoot = sourceRootOf(context);
+    const current = path70.normalize(path70.resolve(context.filename));
+    const relative = path70.relative(sourceRoot, current);
+    const styles = path70.join(sourceRoot, STYLES_DIR);
+    if (!relative.startsWith(`${STYLES_DIR}${path70.sep}`)) return {};
+    const basename = path70.basename(current);
+    const featureName = basename.slice(0, -".css".length);
+    const isFeatureFile = path70.dirname(current) === styles && FEATURE_CSS.test(basename) && existsSync9(path70.join(sourceRoot, "features", featureName));
+    if (basename !== GLOBALS && !isFeatureFile) return {};
+    const read = cachedTextReader();
+    const css2 = findFiles(sourceRoot, CSS_EXTENSIONS).map((file) => ({ path: file, content: read(file) }));
+    const modules = findFiles(sourceRoot, MODULE_EXTENSIONS4).map((file) => ({ path: file, content: read(file) }));
+    const graph = buildCssDependencyGraph({ sourceRoot, css: css2, modules });
+    const owners = inferCssOwners({ graph, css: css2, modules, sourceRoot });
+    return {
+      "StyleSheet:exit"(node) {
+        for (const definition of graph.definitions) {
+          if (definition.file !== current) continue;
+          const owner = owners.get(symbolId(definition));
+          if (!owner) continue;
+          const expected = owner === GLOBALS ? GLOBALS : `${owner}.css`;
+          if (basename === GLOBALS && expected !== GLOBALS && !existsSync9(path70.join(styles, expected))) continue;
+          if (basename === expected) continue;
+          const kind = LABELS[definition.kind] ?? definition.kind;
+          context.report({
+            node,
+            loc: {
+              start: { line: definition.line, column: 1 },
+              end: { line: definition.line, column: 2 }
+            },
+            message: `CSS ${kind} "${definition.name}" is consumed ${owner === GLOBALS ? "across feature scopes" : `only by feature "${owner}"`}; define it in ${expected}.`
+          });
+        }
+      }
+    };
+  }
+};
+
 // eslint/rules/tailwind/global-selector-styling.ts
 function hasStyling(node) {
   for (const child of blockChildren2(node)) {
@@ -10107,74 +10532,215 @@ var globalSelectorStylingRule = {
 };
 
 // eslint/rules/tailwind/global-stylesheet.ts
+import { existsSync as existsSync10 } from "fs";
+import path71 from "path";
+var MISSING_REGISTRATION = 'Global stylesheet must register Tailwind with @import "tailwindcss".';
+var MISSING_ENTRYPOINT = "Project CSS must have a canonical global stylesheet at src/app/styles/globals.css.";
 var globalStylesheetRule = {
   meta: {
     schema: [],
     type: "problem",
+    fixable: "code",
     docs: {
-      description: "Require a global stylesheet entry point that registers Tailwind."
+      description: "Require the canonical global CSS entry point to register Tailwind, not every imported partial."
     }
   },
   create(context) {
+    const sourceRoot = sourceRootOf(context);
+    const entryPoint = path71.normalize(path71.join(sourceRoot, "app", "styles", "globals.css"));
+    const current = path71.normalize(path71.resolve(context.filename));
+    const isEntryPoint = current === entryPoint;
+    const hasEntryPoint = existsSync10(entryPoint);
+    const isFirstStylesheet = !hasEntryPoint && [current, ...findFiles(sourceRoot, CSS_EXTENSIONS).map((file) => path71.normalize(file))].sort()[0] === current;
+    if (!isEntryPoint && !isFirstStylesheet) return {};
     return {
       "StyleSheet:exit"(node) {
+        if (!isEntryPoint) {
+          context.report({ node, message: MISSING_ENTRYPOINT });
+          return;
+        }
         const registersTailwind2 = node.children.some(
           (child) => child.type === "Atrule" && child.name === "import" && JSON.stringify(child.prelude).includes("tailwindcss")
         );
         if (!registersTailwind2) {
-          const hasProjectCss = node.children.some((child) => {
-            if (child.type === "Atrule" && child.name === "import") return false;
-            if (child.type === "Comment") return false;
-            return true;
+          context.report({
+            node,
+            message: MISSING_REGISTRATION,
+            fix(fixer) {
+              return fixer.insertTextBeforeRange([0, 0], '@import "tailwindcss";\n');
+            }
           });
-          if (hasProjectCss) {
-            context.report({
-              node,
-              message: 'Global stylesheet must register Tailwind with @import "tailwindcss".'
-            });
-          }
         }
       }
     };
   }
 };
 
-// eslint/rules/tailwind/root-variables.ts
-var rootVariablesRule = {
+// eslint/rules/tailwind/no-utility-alias.ts
+function plainUtilityAlias(utility, textOf) {
+  const children = blockChildren2(utility);
+  if (children.length !== 1) return void 0;
+  const apply = children[0];
+  if (apply?.type !== "Atrule" || apply.name !== "apply") return void 0;
+  const source = textOf(apply).trim();
+  return /^@apply\s+(?<name>-?[a-z][a-z0-9]*(?:-[a-z0-9]+)*(?:\/[a-z0-9.%-]+)?)\s*;?$/u.exec(source)?.groups?.name;
+}
+var noUtilityAliasRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require styling values to be CSS variables in :root referenced through @theme inline."
+      description: "Disallow custom @utility definitions that only rename one plain Tailwind class."
     }
   },
   create(context) {
     return {
       "StyleSheet:exit"(node) {
-        const hasRootVars = rules(node).some((rule) => {
-          if (!selectorNames(rule).includes("root")) return false;
-          return blockChildren2(rule).some((child) => child.type === "Declaration");
-        });
-        if (!hasRootVars) {
+        for (const utility of atrulesNamed(node, "utility")) {
+          const alias = plainUtilityAlias(utility, (child) => context.sourceCode.getText(child));
+          if (!alias) continue;
+          const name = preludeIdentifiers(utility)[0] ?? "unknown";
           context.report({
-            node,
-            message: "Styling values must be defined as CSS variables in a :root block."
+            node: utility,
+            message: `Custom utility "${name}" only renames "${alias}"; use the class directly instead of defining an @utility alias.`
           });
         }
-        const referencingThemes = atrulesNamed(node, "theme").filter(
-          (theme) => blockChildren2(theme).some((child) => {
-            if (child.type === "Raw") return child.value.includes("var(");
-            if (child.type === "Declaration") return JSON.stringify(child.value).includes("var(");
-            return false;
-          })
-        );
-        const inlineThemes = atrulesNamed(node, "theme").filter(
-          (theme) => preludeIdentifiers(theme).includes("inline")
-        );
-        if (referencingThemes.length > 0 && inlineThemes.length === 0) {
+      }
+    };
+  }
+};
+
+// eslint/rules/tailwind/root-variables.ts
+import path72 from "path";
+var INLINE_MESSAGE = "Define design tokens with direct values in @theme, not @theme inline.";
+var INDIRECT_MESSAGE = "Define design tokens that reference CSS variables via var() in @theme inline.";
+var rootVariablesRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require @theme for fixed tokens, matching :root variables for @theme inline tokens, and no other token redeclarations."
+    }
+  },
+  create(context) {
+    const sourceRoot = sourceRootOf(context);
+    const current = path72.normalize(path72.resolve(context.filename));
+    const textOf = cachedTextReader();
+    const stylesheets = findFiles(sourceRoot, CSS_EXTENSIONS);
+    const graph = buildCssDependencyGraph({
+      sourceRoot,
+      css: [
+        ...stylesheets.filter((file) => path72.normalize(file) !== current).map((file) => ({ path: file, content: textOf(file) })),
+        { path: current, content: context.sourceCode.text }
+      ],
+      modules: [],
+      includeReferences: false
+    });
+    const names = new Set(
+      graph.definitions.filter((symbol) => symbol.kind === "theme-token").map((symbol) => symbol.name)
+    );
+    const mirroredTokens = /* @__PURE__ */ new Set();
+    for (const file of [...stylesheets.filter((candidate) => path72.normalize(candidate) !== current), current]) {
+      const source = (path72.normalize(file) === current ? context.sourceCode.text : textOf(file)).replace(
+        /\/\*[\s\S]*?\*\//gu,
+        " "
+      );
+      for (const theme of source.matchAll(/@theme(?<options>(?:\s+[\w-]+)*)\s*\{(?<body>[^{}]*)\}/gu)) {
+        const inline = /\binline\b/u.test(theme.groups?.options ?? "");
+        for (const declaration of (theme.groups?.body ?? "").matchAll(
+          /(?:^|;)\s*(?<name>--[a-z][\w-]*)\s*:\s*(?<value>[^;]*)/gu
+        )) {
+          const { name, value } = declaration.groups ?? {};
+          if (!name) continue;
+          names.add(name);
+          if (inline && /\bvar\s*\(/u.test(value ?? "")) {
+            mirroredTokens.add(name);
+          }
+        }
+      }
+    }
+    const defaultRootNames = new Set(
+      graph.definitions.filter((symbol) => symbol.kind === "root-variable" && symbol.scope === "default").map((symbol) => symbol.name)
+    );
+    return {
+      "StyleSheet:exit"(node) {
+        for (const theme of atrulesNamed(node, "theme")) {
+          const inline = preludeIdentifiers(theme).includes("inline");
+          const source = context.sourceCode.getText(theme).replace(/\/\*[\s\S]*?\*\//gu, (comment) => comment.replace(/[^\r\n]/gu, " "));
+          for (const match of source.matchAll(
+            /(?:^|[{;\r\n])\s*(?<name>--[a-z][\w-]*)\s*:\s*(?<value>[^;{}]*)(?=;|[}])/gu
+          )) {
+            const { name, value } = match.groups ?? {};
+            if (!name || value === void 0) continue;
+            const unquoted = value.replace(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/gu, "");
+            const referencesVariable = /\bvar\s*\(/iu.test(unquoted);
+            if (inline && referencesVariable) {
+              for (const reference of unquoted.matchAll(/\bvar\(\s*(?<variable>--[\w-]+)/gu)) {
+                const runtime = reference.groups?.variable;
+                if (runtime && runtime !== name) {
+                  context.report({
+                    node: theme,
+                    message: `Tailwind token "${name}" must reference its same-named CSS variable, not "${runtime}".`
+                  });
+                } else if (runtime && !defaultRootNames.has(runtime)) {
+                  context.report({
+                    node: theme,
+                    message: `Tailwind token "${name}" references "${runtime}" without a default :root declaration.`
+                  });
+                }
+              }
+            }
+            if (inline === referencesVariable) continue;
+            const offset = (theme.loc?.start.offset ?? 0) + match.index + match[0].indexOf(name);
+            const preceding = context.sourceCode.text.slice(0, offset);
+            const line = preceding.split("\n").length;
+            const column = offset - preceding.lastIndexOf("\n");
+            context.report({
+              node: theme,
+              loc: {
+                start: { line, column },
+                end: { line, column: column + name.length }
+              },
+              message: inline ? INLINE_MESSAGE : INDIRECT_MESSAGE
+            });
+          }
+        }
+        function checkTokenRedeclarations(currentNode, conditional = false) {
+          if (currentNode.type === "Atrule" && ["theme", "utility", "keyframes"].includes(currentNode.name)) {
+            return;
+          }
+          const isConditional = conditional || currentNode.type === "Atrule" && currentNode.name !== "layer";
+          if (currentNode.type === "Rule") {
+            const selector = context.sourceCode.getText(currentNode.prelude).trim();
+            const isDefaultRoot = selector === ":root" && !isConditional;
+            if (!isDefaultRoot) {
+              for (const declaration of blockChildren2(currentNode)) {
+                if (declaration.type !== "Declaration") continue;
+                if (mirroredTokens.has(declaration.property)) continue;
+                if (!names.has(declaration.property) && !declaration.property.startsWith("--color-")) continue;
+                context.report({
+                  node: declaration,
+                  message: `Tailwind token "${declaration.property}" must not be redeclared outside @theme; map it through @theme inline to its same-named runtime variable instead.`
+                });
+              }
+            }
+          }
+          const children = currentNode.type === "StyleSheet" ? currentNode.children : blockChildren2(currentNode);
+          for (const child of children) {
+            if (child.type === "Atrule" || child.type === "Rule") checkTokenRedeclarations(child, isConditional);
+          }
+        }
+        checkTokenRedeclarations(node);
+        for (const symbol of graph.definitions) {
+          if (symbol.kind !== "root-variable" || symbol.scope !== "default") continue;
+          if (symbol.file !== current || !names.has(symbol.name) || mirroredTokens.has(symbol.name)) continue;
           context.report({
             node,
-            message: "Tailwind theme variables that reference CSS variables must use @theme inline."
+            loc: {
+              start: { line: symbol.line, column: 1 },
+              end: { line: symbol.line, column: 2 }
+            },
+            message: `Token "${symbol.name}" is already defined in @theme; remove its duplicate default :root declaration.`
           });
         }
       }
@@ -10234,83 +10800,161 @@ var stylesheetOrderingRule = {
           }
           lastSeen = at;
         }
+        let furthestSection = -1;
+        let furthestName;
+        for (const section of sections) {
+          const order = SECTION_ORDER.findIndex((name) => name === section.name);
+          if (order < furthestSection) {
+            context.report({
+              node,
+              message: `Global stylesheet section "${section.name}" cannot reappear after "${String(furthestName)}". Keep all section occurrences in the required order.`
+            });
+            return;
+          }
+          if (order > furthestSection) {
+            furthestSection = order;
+            furthestName = section.name;
+          }
+        }
       }
     };
   }
 };
 
 // eslint/rules/tailwind/theme-reset.ts
+import { existsSync as existsSync11 } from "fs";
+import path73 from "path";
+import { generate as generate3, parse as parse6, toPlainObject as toPlainObject2 } from "@eslint/css-tree";
 function isThemeReset(node) {
   if (!node) return false;
-  if (node.type === "Declaration") return node.property.startsWith("--*");
-  if (node.type === "Raw") return node.value.includes("--*: initial");
+  if (node.type === "Declaration") return node.property === "--*" && generate3(node.value).trim() === "initial";
+  if (node.type === "Raw") return /--\*\s*:\s*initial\s*;/u.test(node.value);
   return false;
 }
+function hasThemeReset(node) {
+  return atrulesNamed(node, "theme").some((theme) => {
+    if (blockChildren2(theme).some(isThemeReset)) return true;
+    let nested = false;
+    walkNodes(theme, (child) => {
+      if (isThemeReset(child)) nested = true;
+    });
+    return nested;
+  });
+}
 var themeResetRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require Tailwind's default theme reset --*: initial."
+      description: "Require the CSS tree to reset Tailwind's default theme with --*: initial."
     }
   },
   create(context) {
+    const sourceRoot = sourceRootOf(context);
+    const current = path73.normalize(path73.resolve(context.filename));
+    const entryPoint = path73.normalize(path73.join(sourceRoot, "app", "styles", "globals.css"));
+    if (current !== entryPoint) return {};
     return {
       "StyleSheet:exit"(node) {
-        const resetFound = atrulesNamed(node, "theme").some((theme) => {
-          const direct = blockChildren2(theme).some(isThemeReset);
-          if (direct) return true;
-          let nested = false;
-          walkNodes(theme, (current) => {
-            if (nested) return;
-            if (isThemeReset(current)) nested = true;
-          });
-          return nested;
-        });
-        if (!resetFound) {
-          context.report({
-            node,
-            message: "The global stylesheet must reset Tailwind's default theme with --*: initial inside an @theme block."
-          });
+        if (hasThemeReset(node)) return;
+        const textOf = cachedTextReader();
+        const seen = /* @__PURE__ */ new Set([current]);
+        const queue = [{ file: current, source: context.sourceCode.text }];
+        while (queue.length > 0) {
+          const from = queue.shift();
+          if (!from) continue;
+          for (const specifier of importedSpecifiers(from.source)) {
+            const target = resolveSpecifier2(from.file, specifier, sourceRoot);
+            if (!target || path73.extname(target) !== ".css") continue;
+            const filename = path73.normalize(target);
+            if (seen.has(filename) || !existsSync11(filename)) continue;
+            seen.add(filename);
+            const source = textOf(filename);
+            const parsed = toPlainObject2(parse6(source, { parseAtrulePrelude: false }));
+            if (parsed.type === "StyleSheet" && hasThemeReset(parsed)) return;
+            queue.push({ file: filename, source });
+          }
         }
+        context.report({
+          node,
+          message: "The global stylesheet must reset Tailwind's default theme with --*: initial inside an @theme block."
+        });
       }
     };
   }
 };
 
-// eslint/rules/tailwind/theme-variable-namespace.ts
-var themeVariableNamespaceRule = {
+// eslint/rules/tailwind/unique-css-definition.ts
+import path74 from "path";
+function ownershipKey(symbol) {
+  if (symbol.kind === "selector") return void 0;
+  if (symbol.kind === "root-variable" && symbol.scope !== "default") return void 0;
+  return [symbol.kind, symbol.identity ?? symbol.name].join("|");
+}
+function symbolLabel(symbol) {
+  switch (symbol.kind) {
+    case "utility":
+      return "Custom utility";
+    case "theme-token":
+      return "Theme token";
+    case "root-variable":
+      return "Default :root variable";
+    case "keyframes":
+      return "@keyframes";
+    case "font-face":
+      return "@font-face with matching descriptors for";
+    case "selector":
+      return "CSS selector";
+  }
+}
+var uniqueCssDefinitionRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require utility classes from the same theme namespace to share a prefix."
+      description: "Reject duplicate project-level CSS definitions across stylesheets while preserving scoped overrides."
     }
   },
   create(context) {
+    const sourceRoot = sourceRootOf(context);
+    const cssFiles = findFiles(sourceRoot, CSS_EXTENSIONS);
+    if (cssFiles.length === 0) return {};
+    const textOf = cachedTextReader();
+    const graph = buildCssDependencyGraph({
+      sourceRoot,
+      css: cssFiles.map((file) => ({ path: file, content: textOf(file) })),
+      modules: [],
+      includeReferences: false
+    });
+    const owners = /* @__PURE__ */ new Map();
+    for (const symbol of graph.definitions) {
+      const key = ownershipKey(symbol);
+      if (!key) continue;
+      const files = owners.get(key) ?? /* @__PURE__ */ new Set();
+      files.add(symbol.file);
+      owners.set(key, files);
+    }
     return {
       "StyleSheet:exit"(node) {
-        const namespaces = /* @__PURE__ */ new Set();
-        for (const theme of atrulesNamed(node, "theme")) {
-          for (const child of blockChildren2(theme)) {
-            if (child.type !== "Declaration") continue;
-            const segments = child.property.replace(/^--/, "").split("-");
-            if (segments[0]) namespaces.add(segments[0]);
-          }
-        }
-        for (const apply of atrulesNamed(node, "apply")) {
-          const classes = preludeIdentifiers(apply);
-          for (const ns of namespaces) {
-            const matching = classes.filter((name) => name.startsWith(`${ns}-`) || name === ns);
-            if (matching.length < 2) continue;
-            const prefixes = matching.map((name) => name.split("-").slice(0, 2).join("-"));
-            if (new Set(prefixes).size > 1) {
-              context.report({
-                node: apply,
-                message: `Utility classes ${matching.join(", ")} use namespace "${ns}" but lack a shared prefix; use the theme-variable namespace prefix.`
-              });
-            }
-          }
+        const current = path74.normalize(path74.resolve(context.filename));
+        const checked = /* @__PURE__ */ new Set();
+        for (const symbol of graph.definitions) {
+          if (symbol.file !== current) continue;
+          const key = ownershipKey(symbol);
+          if (!key || checked.has(key)) continue;
+          checked.add(key);
+          const files = owners.get(key);
+          if (!files || files.size < 2) continue;
+          const canonical = [...files].sort()[0];
+          if (!canonical || canonical === current) continue;
+          context.report({
+            node,
+            loc: {
+              start: { line: symbol.line, column: 1 },
+              end: { line: symbol.line, column: 2 }
+            },
+            message: `${symbolLabel(symbol)} "${symbol.name}" is also defined in ${path74.relative(sourceRoot, canonical)}; define it in only one CSS file.`
+          });
         }
       }
     };
@@ -10319,9 +10963,7 @@ var themeVariableNamespaceRule = {
 
 // eslint/rules/tailwind/unused-utility.ts
 import { statSync as statSync5 } from "fs";
-function usagePattern(name) {
-  return new RegExp(`(?<![\\w-])${escapeRegExp(name)}(?![\\w-])`);
-}
+import path75 from "path";
 var unusedUtilityRule = {
   meta: {
     schema: [],
@@ -10332,23 +10974,29 @@ var unusedUtilityRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    let files;
     try {
       if (!statSync5(sourceRoot).isDirectory()) return {};
-      files = findFiles(sourceRoot, SOURCE_EXTENSIONS);
     } catch {
       return {};
     }
+    const current = path75.normalize(path75.resolve(context.filename));
     const textOf = cachedTextReader();
+    const cssFiles = findFiles(sourceRoot, CSS_EXTENSIONS);
+    const moduleFiles = findFiles(sourceRoot, MODULE_EXTENSIONS4);
+    const graph = buildCssDependencyGraph({
+      sourceRoot,
+      css: cssFiles.map((file) => ({
+        path: file,
+        content: path75.normalize(file) === current ? context.sourceCode.text : textOf(file)
+      })),
+      modules: moduleFiles.map((file) => ({ path: file, content: textOf(file) }))
+    });
     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;
+          if (cssSymbolUsages(graph, "utility", name).length > 0) continue;
           context.report({
             node: utility,
             message: `Custom utility "${name}" is never used by the repository's source; remove it or use it.`
@@ -10547,22 +11195,24 @@ var utilityMappingRule = {
 // eslint/rules/tailwind/index.ts
 var tailwindRules = {
   "theme-reset": themeResetRule,
+  "color-role-usage": colorRoleUsageRule,
   "root-variables": rootVariablesRule,
   "apply-usage": applyUsageRule,
   "base-layer-pair": baseLayerPairRule,
   "stylesheet-ordering": stylesheetOrderingRule,
-  "css-variable-naming": cssVariableNamingRule,
   "custom-utility-apply": customUtilityApplyRule,
   "utility-mapping": utilityMappingRule,
-  "theme-variable-namespace": themeVariableNamespaceRule,
   "css-entry-point": cssEntryPointRule,
+  "feature-css-placement": featureCssPlacementRule,
   "global-stylesheet": globalStylesheetRule,
   "unused-utility": unusedUtilityRule,
+  "unique-css-definition": uniqueCssDefinitionRule,
+  "no-utility-alias": noUtilityAliasRule,
   "global-selector-styling": globalSelectorStylingRule
 };
 
 // eslint/rules/type-extraction.ts
-import path67 from "path";
+import path76 from "path";
 var typeExtractionRule = {
   meta: {
     schema: [],
@@ -10573,7 +11223,7 @@ var typeExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path67.resolve(context.filename);
+    const file = path76.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot);
@@ -10712,9 +11362,9 @@ var uiStateRule = {
 };
 
 // eslint/rules/unknown-utility.ts
-import { existsSync as existsSync8, readdirSync as readdirSync6, readFileSync as readFileSync15, statSync as statSync6 } from "fs";
+import { existsSync as existsSync12, readdirSync as readdirSync6, readFileSync as readFileSync15, statSync as statSync6 } from "fs";
 import { createRequire } from "module";
-import path68 from "path";
+import path77 from "path";
 var PREFIX_NAMESPACES = {
   bg: ["color"],
   text: ["color", "text"],
@@ -10954,7 +11604,7 @@ function stylesheetFiles(dir) {
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path68.join(dir, entry);
+    const entryPath = path77.join(dir, entry);
     let stats;
     try {
       stats = statSync6(entryPath);
@@ -10962,7 +11612,7 @@ function stylesheetFiles(dir) {
       return [];
     }
     if (stats.isDirectory()) return stylesheetFiles(entryPath);
-    return path68.extname(entry) === ".css" ? [entryPath] : [];
+    return path77.extname(entry) === ".css" ? [entryPath] : [];
   });
 }
 function packageNameOf(specifier) {
@@ -10973,24 +11623,24 @@ function packageNameOf(specifier) {
 function resolvePackageStylesheet(fromFile, specifier) {
   const packageName = packageNameOf(specifier);
   if (!packageName || packageName === "tailwindcss") return void 0;
-  let directory = path68.dirname(fromFile);
-  while (directory !== path68.dirname(directory)) {
-    const packageRoot = path68.join(directory, "node_modules", packageName);
-    const manifestPath = path68.join(packageRoot, "package.json");
-    if (existsSync8(manifestPath)) {
+  let directory = path77.dirname(fromFile);
+  while (directory !== path77.dirname(directory)) {
+    const packageRoot = path77.join(directory, "node_modules", packageName);
+    const manifestPath = path77.join(packageRoot, "package.json");
+    if (existsSync12(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 = path68.resolve(packageRoot, target);
-        return existsSync8(resolved) ? resolved : void 0;
+        const resolved = path77.resolve(packageRoot, target);
+        return existsSync12(resolved) ? resolved : void 0;
       } catch {
         return void 0;
       }
     }
-    directory = path68.dirname(directory);
+    directory = path77.dirname(directory);
   }
   return void 0;
 }
@@ -11111,24 +11761,6 @@ function isColorToken(token, inventory) {
   if (hyphen === -1) return false;
   return DEFAULT_PALETTE_FAMILIES.has(token.slice(0, hyphen)) && DEFAULT_PALETTE_SHADES.has(token.slice(hyphen + 1));
 }
-function definedThemeColorClass(className, inventory) {
-  if (className.includes("[") || className.includes("(")) return void 0;
-  const utility = (className.replace(/!+$/, "").split(":").pop() ?? "").split("/")[0] ?? "";
-  const compound = Object.keys(PREFIX_NAMESPACES).find(
-    (prefix2) => prefix2.includes("-") && utility.startsWith(`${prefix2}-`)
-  );
-  const dash = utility.indexOf("-");
-  if (dash === -1) return void 0;
-  const prefix = compound ?? utility.slice(0, dash);
-  const token = utility.slice(prefix.length + 1);
-  if (!(PREFIX_NAMESPACES[prefix]?.includes("color") ?? false)) return void 0;
-  if (!(inventory.themeTokens.get("color")?.has(token) ?? false)) return void 0;
-  return { prefix, token };
-}
-function isInvalidBoundaryColorClass(className, inventory) {
-  const themeColor = definedThemeColorClass(className, inventory);
-  return themeColor !== void 0 && violatesBoundaryColorRole(themeColor.token);
-}
 function isKnown(className, inventory) {
   if (className.includes("[") || className.includes("(")) return true;
   const segments = className.replace(/!+$/, "").split(":");
@@ -11189,28 +11821,11 @@ var unknownUtilityRule = {
       for (const candidate of value.split(/\s+/)) {
         if (!candidate || seen.has(candidate)) continue;
         seen.add(candidate);
-        if (isInvalidBoundaryColorClass(candidate, inventory)) {
-          context.report({
-            node,
-            message: `Utility class "${candidate}" uses a boundary color token named after a CSS property; use a semantic -edge color token instead (for example, border-control-edge).`
-          });
+        if (isKnown(candidate, inventory)) {
+          const roleError = colorRoleUsageMessage(candidate);
+          if (roleError) context.report({ node, message: roleError });
           continue;
         }
-        const themeColor = definedThemeColorClass(candidate, inventory);
-        const incompatibleRole = themeColor ? incompatibleColorUtilityRole(themeColor.prefix, themeColor.token) : void 0;
-        if (incompatibleRole) {
-          const expected = {
-            canvas: "bg-<role>-canvas",
-            ink: "text-<role>-ink",
-            edge: "border-<role>-edge"
-          }[incompatibleRole];
-          context.report({
-            node,
-            message: `Utility class "${candidate}" applies a -${incompatibleRole} color token to an incompatible property; use ${expected} for that role or define a token for the intended property.`
-          });
-          continue;
-        }
-        if (isKnown(candidate, inventory)) continue;
         const plainBase = candidate.replace(/!+$/, "").split(":").pop() ?? "";
         if (inventory.plainClasses.has(plainBase)) {
           context.report({
@@ -11280,7 +11895,7 @@ var unknownUtilityRule = {
 };
 
 // eslint/rules/util-file-name.ts
-import path69 from "path";
+import path78 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();
 }
@@ -11293,7 +11908,7 @@ var utilFileNameRule = {
     }
   },
   create(context) {
-    const filename = path69.resolve(context.filename);
+    const filename = path78.resolve(context.filename);
     const segments = filename.replace(/\\/g, "/").split("/");
     if (!segments.includes("utils")) return {};
     let module;
@@ -11307,13 +11922,13 @@ var utilFileNameRule = {
     const functionName = functions[0]?.name;
     if (!functionName) return {};
     const expected = toKebabCase2(functionName);
-    const actual = path69.basename(filename, path69.extname(filename));
+    const actual = path78.basename(filename, path78.extname(filename));
     if (!expected || actual === expected) return {};
     return {
       Program(node) {
         context.report({
           node,
-          message: `A utility file exporting ${functionName} must be named ${expected}.${path69.extname(filename).slice(1)}.`
+          message: `A utility file exporting ${functionName} must be named ${expected}.${path78.extname(filename).slice(1)}.`
         });
       }
     };
@@ -11321,7 +11936,7 @@ var utilFileNameRule = {
 };
 
 // eslint/rules/value-extraction.ts
-import path70 from "path";
+import path79 from "path";
 var valueExtractionRule = {
   meta: {
     schema: [],
@@ -11332,7 +11947,7 @@ var valueExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path70.resolve(context.filename);
+    const file = path79.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0 || segments[0] !== "app") return {};
     const index = getProjectIndex(sourceRoot);
@@ -11353,8 +11968,8 @@ var valueExtractionRule = {
 };
 
 // eslint/rules/vulyk/tracked-docs.ts
-import { existsSync as existsSync9, readFileSync as readFileSync16 } from "fs";
-import path71 from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync16 } from "fs";
+import path80 from "path";
 var PASIKA_REPO = "Bredansky/pasika";
 var BASE_REQUIRED_TRACKED_DOCS = [
   { name: "documentation-guide", path: "docs/documentation-guide" },
@@ -11387,9 +12002,9 @@ var trackedDocsRule = {
         if (!context.filename.endsWith("package.json")) return;
         const root = node.body;
         if (root.type !== "Object") return;
-        const projectRoot = path71.dirname(path71.resolve(context.filename));
-        const configPath = path71.join(projectRoot, "vulyk.config.ts");
-        if (!existsSync9(configPath)) {
+        const projectRoot = path80.dirname(path80.resolve(context.filename));
+        const configPath = path80.join(projectRoot, "vulyk.config.ts");
+        if (!existsSync13(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."
@@ -11413,8 +12028,8 @@ var trackedDocsRule = {
             });
           }
         }
-        const agentsPath = path71.join(projectRoot, "AGENTS.md");
-        if (!existsSync9(agentsPath)) {
+        const agentsPath = path80.join(projectRoot, "AGENTS.md");
+        if (!existsSync13(agentsPath)) {
           context.report({
             node,
             message: "No AGENTS.md found. Run npx vulyk agents to generate the agent file that routes to the tracked docs."
@@ -11513,7 +12128,7 @@ var withResponseHelperRule = {
 
 // eslint/rules/zirka-baseline.ts
 import fs7 from "fs";
-import path72 from "path";
+import path81 from "path";
 var ESLINT_CONFIG = /^eslint\.config\.(?:ts|mts|cts|js|mjs|cjs)$/;
 var PRETTIER_CONFIGS = [
   "prettier.config.mjs",
@@ -11532,10 +12147,10 @@ var zirkaBaselineRule = {
     }
   },
   create(context) {
-    const filename = path72.resolve(context.filename);
-    const basename = path72.basename(filename);
+    const filename = path81.resolve(context.filename);
+    const basename = path81.basename(filename);
     if (!ESLINT_CONFIG.test(basename)) return {};
-    const projectRoot = path72.dirname(filename);
+    const projectRoot = path81.dirname(filename);
     const report3 = (message) => {
       context.report({
         node: context.sourceCode.ast,
@@ -11550,7 +12165,7 @@ var zirkaBaselineRule = {
             'ESLint config must take its configuration from zirka (import { styleguide } from "zirka") instead of restating rules locally.'
           );
         }
-        const tsconfigPath = path72.join(projectRoot, "tsconfig.json");
+        const tsconfigPath = path81.join(projectRoot, "tsconfig.json");
         if (!fs7.existsSync(tsconfigPath)) {
           report3('No tsconfig.json found. Create one extending the zirka TypeScript base config ("zirka/typescript").');
         } else {
@@ -11568,13 +12183,13 @@ var zirkaBaselineRule = {
             report3('tsconfig.json must extend the zirka TypeScript base config ("zirka/typescript").');
           }
         }
-        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path72.join(projectRoot, name)));
+        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path81.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(path72.join(projectRoot, prettierConfigFile), "utf8");
+          const content = fs7.readFileSync(path81.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."
@@ -11908,7 +12523,11 @@ var tailwindStructureRules = {
   },
   language: "css/css",
   languageOptions: { tolerant: true },
-  rules: Object.fromEntries(tailwindRuleIds.filter((id) => id !== "pasika/css-entry-point").map((id) => [id, "error"]))
+  rules: Object.fromEntries(
+    tailwindRuleIds.filter(
+      (id) => id !== "pasika/css-entry-point" && id !== "pasika/feature-css-placement" && id !== "pasika/unique-css-definition" && id !== "pasika/no-utility-alias" && id !== "pasika/root-variables" && id !== "pasika/color-role-usage"
+    ).map((id) => [id, "error"])
+  )
 };
 var tailwindImportGraph = {
   files: ["src/**/*.css"],
@@ -11918,7 +12537,14 @@ var tailwindImportGraph = {
   },
   language: "css/css",
   languageOptions: { tolerant: true },
-  rules: { "pasika/css-entry-point": "error" }
+  rules: {
+    "pasika/css-entry-point": "error",
+    "pasika/feature-css-placement": "error",
+    "pasika/unique-css-definition": "error",
+    "pasika/no-utility-alias": "error",
+    "pasika/root-variables": "error",
+    "pasika/color-role-usage": "error"
+  }
 };
 var pasikaAppPackageJsonConfig = {
   files: ["package.json"],