pasika 0.3.2 → 0.3.4

package/dist/eslint/pasika/index.js

@@ -1,90 +1,4425 @@
-import { filenameCaseRule } from "./rules/filename-case.js";
-import { importBoundariesRule } from "./rules/import-boundaries.js";
-import { noMixedConcernsRule } from "./rules/no-mixed-concerns.js";
-import { noArbitraryTailwindRule } from "./rules/no-arbitrary-tailwind.js";
-import { enforceCnMergeRule } from "./rules/enforce-cn-merge.js";
-import { enforceCvaVariantPropsRule } from "./rules/enforce-cva-variant-props.js";
-import { enforceBarrelExportsRule } from "./rules/enforce-barrel-exports.js";
-import { componentPlacementRule } from "./rules/component-placement.js";
-import { supportFilePlacementRule } from "./rules/support-file-placement.js";
-import { applicationStructureRule } from "./rules/application-structure.js";
-import { namedExportsRule } from "./rules/named-exports.js";
-import { dataTestIdCaseRule } from "./rules/data-testid-case.js";
-import { supportFolderShapeRule } from "./rules/support-folder-shape.js";
-import { importThroughIndexRule } from "./rules/import-through-index.js";
-import { utilFileNameRule } from "./rules/util-file-name.js";
-import { noUtilBarrelRule } from "./rules/no-util-barrel.js";
-import { jsxHygieneRule } from "./rules/jsx-hygiene.js";
-import { interactiveComponentRule } from "./rules/interactive-component.js";
-import { uiStateRule } from "./rules/ui-state.js";
-import { cvaAppearancePropsRule } from "./rules/cva-appearance-props.js";
-import { cvaBooleanVariantsRule } from "./rules/cva-boolean-variants.js";
-import { crossFeatureImportRule } from "./rules/cross-feature-import.js";
-import { pureFunctionExtractRule } from "./rules/pure-function-extract.js";
-import { hookComplexityRule } from "./rules/hook-complexity.js";
-import { localeDottedPathRule } from "./rules/locale-dotted-path.js";
-import { localesLocationRule } from "./rules/locales-location.js";
-import { hookExtractionRule } from "./rules/hook-extraction.js";
-import { valueExtractionRule } from "./rules/value-extraction.js";
-import { configExtractionRule } from "./rules/config-extraction.js";
-import { componentNestingRule } from "./rules/component-nesting.js";
-import { stayFlatRule } from "./rules/stay-flat.js";
-import { typeExtractionRule } from "./rules/type-extraction.js";
-import { localePlacementRule } from "./rules/locale-placement.js";
-import { sharedStyleDedupRule } from "./rules/shared-style-dedup.js";
-import { noEslintDisableRule } from "./rules/no-eslint-disable.js";
-import { mdRules } from "./rules/md/index.js";
-import { cssRules } from "./rules/css/index.js";
-import { jsonRules } from "./rules/json/index.js";
-export const pasikaRules = {
-    "component-placement": componentPlacementRule,
-    "support-file-placement": supportFilePlacementRule,
-    "application-structure": applicationStructureRule,
-    "named-exports": namedExportsRule,
-    "data-testid-case": dataTestIdCaseRule,
-    "support-folder-shape": supportFolderShapeRule,
-    "import-through-index": importThroughIndexRule,
-    "util-file-name": utilFileNameRule,
-    "no-util-barrel": noUtilBarrelRule,
-    "jsx-hygiene": jsxHygieneRule,
-    "interactive-component": interactiveComponentRule,
-    "ui-state": uiStateRule,
-    "filename-case": filenameCaseRule,
-    "import-boundaries": importBoundariesRule,
-    "no-mixed-concerns": noMixedConcernsRule,
-    "no-arbitrary-tailwind": noArbitraryTailwindRule,
-    "enforce-cn-merge": enforceCnMergeRule,
-    "enforce-cva-variant-props": enforceCvaVariantPropsRule,
-    "cva-appearance-props": cvaAppearancePropsRule,
-    "cva-boolean-variants": cvaBooleanVariantsRule,
-    "enforce-barrel-exports": enforceBarrelExportsRule,
-    "cross-feature-import": crossFeatureImportRule,
-    "pure-function-extract": pureFunctionExtractRule,
-    "hook-complexity": hookComplexityRule,
-    "locale-dotted-path": localeDottedPathRule,
-    "locales-location": localesLocationRule,
-    "hook-extraction": hookExtractionRule,
-    "value-extraction": valueExtractionRule,
-    "config-extraction": configExtractionRule,
-    "component-nesting": componentNestingRule,
-    "stay-flat": stayFlatRule,
-    "type-extraction": typeExtractionRule,
-    "locale-placement": localePlacementRule,
-    "shared-style-dedup": sharedStyleDedupRule,
-    "no-eslint-disable": noEslintDisableRule,
-};
-export { mdRules, cssRules, jsonRules };
-/** Rule ids as they appear in configuration and in lint output. */
-export const pasikaRuleIds = Object.keys(pasikaRules).map((name) => `pasika/${name}`);
-export const pasikaMdRuleIds = Object.keys(mdRules).map((name) => `pasika/${name}`);
-export const pasikaCssRuleIds = Object.keys(cssRules).map((name) => `pasika/${name}`);
-export const pasikaJsonRuleIds = Object.keys(jsonRules).map((name) => `pasika/${name}`);
-/** Every rule id, as they appear in configuration and in lint output. */
-export const allPasikaRuleIds = [...pasikaRuleIds, ...pasikaMdRuleIds, ...pasikaCssRuleIds, ...pasikaJsonRuleIds];
-export const pasikaConfig = {
-    files: ["src/**/*.{cjs,cts,js,jsx,mjs,mts,ts,tsx}"],
-    plugins: {
-        pasika: { rules: pasikaRules },
-    },
-    rules: Object.fromEntries(pasikaRuleIds.map((id) => [id, "error"])),
+// eslint/pasika/rules/filename-case.ts
+import path2 from "path";
+
+// eslint/pasika/rules/component-conventions.ts
+import path from "path";
+import ts from "typescript";
+var isPascalCase = (name) => /^[A-Z][A-Za-z0-9]*$/.test(name);
+var isHookCallName = (name) => /^use[A-Z]/.test(name);
+function isExported(node) {
+  if (!ts.canHaveModifiers(node)) return false;
+  return (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+}
+function containsJsx(node) {
+  let found = false;
+  const visit = (child) => {
+    if (found) return;
+    if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child) || ts.isJsxFragment(child)) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(child, visit);
+  };
+  ts.forEachChild(node, visit);
+  return found;
+}
+function containsSmartCall(node) {
+  let found = false;
+  const visit = (child) => {
+    if (found) return;
+    if (ts.isCallExpression(child)) {
+      const expression = child.expression;
+      let name = "";
+      if (ts.isIdentifier(expression)) {
+        name = expression.text;
+      } else if (ts.isPropertyAccessExpression(expression)) {
+        name = expression.name.text;
+      }
+      if (isHookCallName(name)) {
+        found = true;
+        return;
+      }
+    }
+    ts.forEachChild(child, visit);
+  };
+  ts.forEachChild(node, visit);
+  return found;
+}
+function componentFromFunction(node) {
+  const name = node.name?.text;
+  if (!name || !isPascalCase(name) || !containsJsx(node)) return void 0;
+  return { name, declaration: node, smart: containsSmartCall(node) };
+}
+function componentFromVariable(node) {
+  if (!ts.isIdentifier(node.name) || !isPascalCase(node.name.text)) return void 0;
+  const initializer = node.initializer;
+  if (!initializer || !ts.isArrowFunction(initializer) && !ts.isFunctionExpression(initializer)) return void 0;
+  if (!containsJsx(initializer)) return void 0;
+  return {
+    name: node.name.text,
+    declaration: node,
+    smart: containsSmartCall(initializer)
+  };
+}
+function parseComponentInfo(text, filename) {
+  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;
+    if (ts.isFunctionDeclaration(statement)) {
+      const component = componentFromFunction(statement);
+      if (component) components.push(component);
+      continue;
+    }
+    if (ts.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        const component = componentFromVariable(declaration);
+        if (component) components.push(component);
+      }
+    }
+  }
+  return components;
+}
+function jsxTagName(element) {
+  const tagName2 = ts.isJsxElement(element) ? element.openingElement.tagName : element.tagName;
+  return ts.isIdentifier(tagName2) ? tagName2.text : void 0;
+}
+function rootFromExpression(expression) {
+  if (ts.isJsxSelfClosingElement(expression)) {
+    const tagName2 = jsxTagName(expression);
+    if (!tagName2?.startsWith(tagName2[0]?.toLowerCase() ?? "")) return void 0;
+    return { tagName: tagName2, attributes: [...expression.attributes.properties] };
+  }
+  if (ts.isJsxElement(expression)) {
+    const tagName2 = jsxTagName(expression);
+    if (!tagName2?.startsWith(tagName2[0]?.toLowerCase() ?? "")) return void 0;
+    return { tagName: tagName2, attributes: [...expression.openingElement.attributes.properties] };
+  }
+  return void 0;
+}
+function findSimpleRoot(component, _text, _filename) {
+  const declaration = component.declaration;
+  let body;
+  if (ts.isFunctionDeclaration(declaration)) body = declaration.body;
+  else if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) body = declaration.initializer.body;
+  else if (declaration.initializer && ts.isFunctionExpression(declaration.initializer)) {
+    body = declaration.initializer.body;
+  }
+  if (!body) return void 0;
+  if (!ts.isBlock(body)) return rootFromExpression(body);
+  const returns = [];
+  const visit = (node) => {
+    if (node !== body && (ts.isFunctionLike(node) || ts.isClassLike(node))) return;
+    if (ts.isReturnStatement(node)) returns.push(node);
+    ts.forEachChild(node, visit);
+  };
+  visit(body);
+  if (returns.length !== 1) return void 0;
+  const expression = returns[0]?.expression;
+  return expression && ts.isExpression(expression) ? rootFromExpression(expression) : void 0;
+}
+function getTestId(root) {
+  const attribute = root.attributes.find(
+    (candidate) => ts.isJsxAttribute(candidate) && ts.isIdentifier(candidate.name) && candidate.name.text === "data-testid"
+  );
+  if (!attribute) return {};
+  const value = attribute.initializer;
+  if (!value || !ts.isStringLiteral(value)) return { attribute };
+  return { value: value.text, attribute };
+}
+
+// eslint/pasika/rules/filename-case.ts
+var NEXT_ROUTING_FILES = /* @__PURE__ */ new Set([
+  "page",
+  "layout",
+  "loading",
+  "error",
+  "not-found",
+  "route",
+  "template",
+  "default",
+  "middleware",
+  "instrumentation"
+]);
+var COMPOUND_SUFFIXES = /* @__PURE__ */ new Set(["example", "test", "spec", "stories"]);
+function isKebabCase(str) {
+  return /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(str);
+}
+function isPascalCase2(str) {
+  return /^[A-Z][A-Za-z0-9]*$/.test(str);
+}
+var filenameCaseRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Enforce pasika filename conventions: kebab-case by default, PascalCase for smart .tsx components."
+    }
+  },
+  create(context) {
+    const filename = context.filename;
+    if (!filename) {
+      return {};
+    }
+    const normalized = filename.replace(/\\/g, "/");
+    if (!normalized.includes("/src/")) {
+      return {};
+    }
+    const ext = path2.extname(filename);
+    let base = path2.basename(filename, ext);
+    const baseExt = path2.extname(base);
+    if (baseExt && COMPOUND_SUFFIXES.has(baseExt.slice(1))) {
+      base = path2.basename(base, baseExt);
+    }
+    if (NEXT_ROUTING_FILES.has(base)) {
+      return {};
+    }
+    if (ext === ".tsx") {
+      return {
+        Program(node) {
+          const components = parseComponentInfo(context.sourceCode.text, filename);
+          const component = components[0];
+          if (component?.smart && !isPascalCase2(base)) {
+            context.report({
+              node,
+              message: `Smart component files must use PascalCase.tsx. Filename "${path2.basename(filename)}" is not PascalCase.`
+            });
+            return;
+          }
+          if (component && !component.smart && !isKebabCase(base)) {
+            context.report({
+              node,
+              message: `Dumb component files must use kebab-case.tsx. Filename "${path2.basename(filename)}" is not kebab-case.`
+            });
+            return;
+          }
+          if (!component && !(isPascalCase2(base) || isKebabCase(base))) {
+            context.report({
+              node,
+              message: `Filename "${path2.basename(filename)}" does not match pasika conventions. Component files must be PascalCase.tsx (smart) or kebab-case.tsx (dumb).`
+            });
+          }
+        }
+      };
+    }
+    if (!isKebabCase(base)) {
+      return report(context, filename, ext);
+    }
+    return {};
+  }
+};
+function report(context, filename, ext) {
+  return {
+    Program(node) {
+      const convention = ext === ".tsx" ? "Component files must be PascalCase.tsx (smart) or kebab-case.tsx (dumb)." : "Non-component files must use kebab-case.";
+      context.report({
+        node,
+        loc: { line: 1, column: 0 },
+        message: `Filename "${path2.basename(filename)}" does not match pasika conventions. ${convention}`
+      });
+    }
+  };
+}
+
+// eslint/pasika/rules/import-boundaries.ts
+import path3 from "path";
+var sourceRoot = path3.resolve("src");
+var rootSupportFolders = /* @__PURE__ */ new Set(["config", "constants", "hooks", "locales", "schemas", "types", "utils"]);
+var moduleExtensions = /* @__PURE__ */ new Set([".cjs", ".cts", ".js", ".jsx", ".mjs", ".mts", ".ts", ".tsx"]);
+var styleExtensions = /* @__PURE__ */ new Set([".css", ".less", ".sass", ".scss"]);
+function resolveSourceImport(filename, importPath) {
+  if (importPath.startsWith("@/")) {
+    return path3.resolve(sourceRoot, importPath.slice(2));
+  }
+  if (importPath.startsWith(".")) {
+    return path3.resolve(path3.dirname(filename), importPath);
+  }
+  return void 0;
+}
+function sourceSegments(absolutePath) {
+  const relativePath = path3.relative(sourceRoot, absolutePath);
+  if (relativePath.startsWith("..") || path3.isAbsolute(relativePath)) {
+    return void 0;
+  }
+  return relativePath.split(path3.sep);
+}
+function relativeSpecifier(filename, resolvedPath) {
+  const relativePath = path3.relative(path3.dirname(filename), resolvedPath).split(path3.sep).join("/");
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+function aliasSpecifier(resolvedPath) {
+  return `@/${(sourceSegments(resolvedPath) ?? []).join("/")}`;
+}
+function segmentCount(specifier) {
+  return specifier.replace(/^@\//, "").split("/").filter((segment) => segment !== "." && segment !== "").length;
+}
+function describeSegments(count) {
+  return `${String(count)} segment${count === 1 ? "" : "s"}`;
+}
+function prefersRelative(filename, resolvedPath) {
+  return segmentCount(relativeSpecifier(filename, resolvedPath)) <= segmentCount(aliasSpecifier(resolvedPath));
+}
+var importBoundariesRule = {
+  meta: {
+    schema: [],
+    type: "problem"
+  },
+  create(context) {
+    const filename = context.filename;
+    if (!filename) {
+      return {};
+    }
+    function reportImport(source) {
+      if (typeof source.value !== "string") {
+        return;
+      }
+      const importPath = source.value;
+      const resolvedPath = resolveSourceImport(filename, importPath);
+      if (!resolvedPath) {
+        return;
+      }
+      const importer = sourceSegments(filename);
+      const imported = sourceSegments(resolvedPath);
+      if (!importer || !imported || importer.length === 0 || imported.length === 0) {
+        return;
+      }
+      const [importerLayer = "", importerFeature] = importer;
+      const [importedLayer = "", importedFeature] = imported;
+      const extension = path3.extname(importPath);
+      const isCodeModule = !extension || moduleExtensions.has(extension);
+      const isAppLocalStyleImport = importerLayer === "app" && importedLayer === "app" && styleExtensions.has(extension);
+      const importedIsRootSupport = rootSupportFolders.has(importedLayer);
+      const importedIsSameConfig = importerLayer === "config" && importedLayer === "config" && importer[1] === imported[1];
+      const isAllowed = !isCodeModule && importerLayer === "app" && isAppLocalStyleImport || isCodeModule && importerLayer === "app" && (importedLayer === "compositions" || importedLayer === "features" || importedLayer === "shared" || importedIsRootSupport) || isCodeModule && importerLayer === "compositions" && (importedLayer === "compositions" || importedLayer === "features" || importedLayer === "shared" || importedIsRootSupport) || isCodeModule && importerLayer === "features" && (importedLayer === "features" && importerFeature === importedFeature || importedLayer === "shared" || importedIsRootSupport) || isCodeModule && importerLayer === "shared" && (importedLayer === "shared" || importedIsRootSupport) || isCodeModule && rootSupportFolders.has(importerLayer) && importedIsRootSupport && (importerLayer !== "config" || importedLayer !== "config" || importedIsSameConfig);
+      if (!isAllowed) {
+        context.report({
+          node: source,
+          message: "This import violates the src layer boundary."
+        });
+        return;
+      }
+      const relativeForm = relativeSpecifier(filename, resolvedPath);
+      const aliasForm = aliasSpecifier(resolvedPath);
+      const relativeSegments = segmentCount(relativeForm);
+      const aliasSegments = segmentCount(aliasForm);
+      function describeChoice(preferred, preferredSegments, other, otherSegments) {
+        const tie = preferredSegments === otherSegments ? ", and a tie goes to the relative path" : "";
+        return `Use "${preferred}" (${describeSegments(preferredSegments)}) instead of "${other}" (${describeSegments(otherSegments)})${tie}.`;
+      }
+      if (prefersRelative(filename, resolvedPath) && importPath.startsWith("@/")) {
+        context.report({
+          node: source,
+          message: describeChoice(relativeForm, relativeSegments, aliasForm, aliasSegments)
+        });
+        return;
+      }
+      if (!prefersRelative(filename, resolvedPath) && importPath.startsWith(".")) {
+        context.report({
+          node: source,
+          message: describeChoice(aliasForm, aliasSegments, relativeForm, relativeSegments)
+        });
+      }
+    }
+    return {
+      ImportDeclaration(node) {
+        reportImport(node.source);
+      },
+      ExportAllDeclaration(node) {
+        reportImport(node.source);
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source) {
+          reportImport(node.source);
+        }
+      },
+      ImportExpression(node) {
+        reportImport(node.source);
+      },
+      CallExpression(node) {
+        if (node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments[0]) {
+          reportImport(node.arguments[0]);
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/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."
+    }
+  },
+  create(context) {
+    if (!context.filename.endsWith(".tsx")) return {};
+    let exportedComponentCount = 0;
+    const extraExports = [];
+    function registerExport(name) {
+      exportedComponentCount++;
+      if (exportedComponentCount > 1) {
+        extraExports.push({ name });
+      }
+    }
+    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`
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/no-arbitrary-tailwind.ts
+var ARBITRARY_VALUE_RE = /(?:^|(?<=\s))(?:[a-z]+(?:-[a-z]+)*)-\[[^\]]+\](?![-\w]*:)/g;
+var CLASS_HELPERS = /* @__PURE__ */ new Set(["cn", "clsx", "twMerge", "twJoin"]);
+var noArbitraryTailwindRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Disallow Tailwind arbitrary-value classes like rounded-[13px]."
+    }
+  },
+  create(context) {
+    function reportClassString(node, value) {
+      ARBITRARY_VALUE_RE.lastIndex = 0;
+      const match = ARBITRARY_VALUE_RE.exec(value);
+      if (!match) return;
+      context.report({
+        node,
+        message: `Tailwind arbitrary-value class "${match[0]}" is not allowed. Use a named token or custom utility. See docs/styling-guide/rules/arbitrary-value-rule.md`
+      });
+    }
+    function checkExpression(node, expression) {
+      if (!expression) return;
+      if (expression.type === "Literal") {
+        if (typeof expression.value === "string") reportClassString(node, expression.value);
+        return;
+      }
+      if (expression.type === "TemplateLiteral") {
+        for (const quasi of expression.quasis) reportClassString(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_HELPERS.has(node.callee.name)) return;
+        for (const argument of node.arguments) {
+          checkExpression(node, argument);
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/enforce-cn-merge.ts
+function classCount(str) {
+  return str.split(/\s+/).filter(Boolean).length;
+}
+function isComponentName(name) {
+  return name?.type === "JSXIdentifier" && /^[A-Z]/.test(name.name);
+}
+function isOuterLayoutClass(className) {
+  const utility = className.split(":").pop() ?? className;
+  return /^(?:-?m[trblsexy]?-.+|(?:min-|max-)?[wh]-.+|size-.+|(?:flex-(?:1|auto|initial|none|grow|shrink|basis-.+)|grow(?:-.+)?|shrink(?:-.+)?|basis-.+|order-.+|(?:col|row)-(?:auto|span-.+|start-.+|end-.+)|(?:self|place-self|justify-self)-.+|z-.+|gap-.+|space-[xy]-.+))$/.test(
+    utility
+  );
+}
+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 === "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));
+  }
+  return [];
+}
+var enforceCnMergeRule = {
+  meta: { schema: [], type: "problem", docs: { description: "Enforce cn() for conditional class merging." } },
+  create(context) {
+    return {
+      JSXAttribute(node) {
+        const attributeName = node.name?.name ?? "";
+        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" });
+          return;
+        }
+        if (attributeName !== "className" && attributeName !== "class") return;
+        const valueNode = node.value;
+        if (!valueNode) return;
+        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` });
+          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" });
+          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" });
+          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" });
+          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" });
+          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" });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/enforce-cva-variant-props.ts
+var enforceCvaVariantPropsRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Enforce VariantProps from CVA instead of manual variant union types."
+    }
+  },
+  create(context) {
+    const cvaDefinitions = /* @__PURE__ */ new Map();
+    return {
+      VariableDeclarator(node) {
+        const init = node.init;
+        if (init?.type !== "CallExpression" || init.callee.type !== "Identifier" || init.callee.name !== "cva" || node.id.type !== "Identifier") {
+          return;
+        }
+        const args = init.arguments;
+        if (args.length < 2) return;
+        const options = args[1];
+        if (options?.type !== "ObjectExpression") return;
+        for (const prop of options.properties) {
+          if (prop.type !== "Property" || prop.key.type !== "Identifier" || prop.key.name !== "variants" || prop.value.type !== "ObjectExpression") {
+            continue;
+          }
+          const variantNames = prop.value.properties.filter(
+            (p) => p.type === "Property" && p.key.type === "Identifier"
+          ).map((p) => p.key.name);
+          if (variantNames.length > 0) {
+            cvaDefinitions.set(node.id.name, variantNames);
+          }
+        }
+      },
+      TSTypeAliasDeclaration(node) {
+        const aliasName = node.id?.name;
+        if (!aliasName?.endsWith("Props")) return;
+        if (node.typeAnnotation?.type !== "TSTypeLiteral") return;
+        for (const member of node.typeAnnotation.members ?? []) {
+          if (member.type !== "TSPropertySignature") continue;
+          const keyName = member.key?.type === "Identifier" ? member.key.name : void 0;
+          if (!keyName) continue;
+          const typeAnn = member.typeAnnotation?.typeAnnotation;
+          if (typeAnn?.type !== "TSUnionType") continue;
+          const allStringLiterals = (typeAnn.types ?? []).every(
+            (t) => t.type === "TSLiteralType" && (t.literal?.type === "StringLiteral" || t.literal?.type === "Literal" && typeof t.literal.value === "string")
+          );
+          if (allStringLiterals && (typeAnn.types?.length ?? 0) >= 2) {
+            for (const variantNames of cvaDefinitions.values()) {
+              if (variantNames.includes(keyName)) {
+                context.report({
+                  node,
+                  message: `Variant prop "${keyName}" duplicates CVA variant values. Use VariantProps<typeof variants> instead of manually writing union types. See docs/styling-guide/rules/component-variant-rule.md`
+                });
+                return;
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/enforce-barrel-exports.ts
+import path4 from "path";
+import fs from "fs";
+function isPascalCase3(str) {
+  return /^[A-Z][A-Za-z0-9]*$/.test(str);
+}
+function isKebabCase2(str) {
+  return /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(str);
+}
+var SUPPORT_FOLDERS = /* @__PURE__ */ new Set(["types", "schemas", "hooks", "constants", "utils", "config", "locales"]);
+var enforceBarrelExportsRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Enforce index.ts barrels only re-export the parent component."
+    }
+  },
+  create(context) {
+    const filename = context.filename;
+    if (!filename) return {};
+    const baseName = path4.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));
+    if (SUPPORT_FOLDERS.has(folderName)) return {};
+    if (!isPascalCase3(folderName) && !isKebabCase2(folderName)) return {};
+    const matchingTsx = fs.existsSync(path4.join(dirPath, `${folderName}.tsx`)) ? folderName : null;
+    if (!matchingTsx) return {};
+    if (!isPascalCase3(parentFolderName) && !isKebabCase2(parentFolderName)) return {};
+    const reExportedNames = /* @__PURE__ */ new Set();
+    return {
+      ExportNamedDeclaration(node) {
+        if (!node.source) return;
+        for (const spec of node.specifiers) {
+          if (spec.exported.type === "Identifier") {
+            reExportedNames.add(spec.exported.name);
+          }
+        }
+      },
+      "Program:exit"() {
+        if (reExportedNames.size === 0) return;
+        if (!reExportedNames.has(matchingTsx)) {
+          context.report({
+            loc: { line: 1, column: 0 },
+            message: `index.ts in "${folderName}/" must re-export "${matchingTsx}". See docs/code-organization-guide/rules/folder-nesting-rule.md`
+          });
+          return;
+        }
+        const nonParentExports = [...reExportedNames].filter((n) => n !== matchingTsx);
+        if (nonParentExports.length > 0) {
+          context.report({
+            loc: { line: 1, column: 0 },
+            message: `index.ts must not re-export exclusive children: ${nonParentExports.join(", ")}. Only "${matchingTsx}" may be re-exported. See docs/code-organization-guide/rules/folder-nesting-rule.md`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/component-placement.ts
+import path8 from "path";
+
+// eslint/pasika/project/index.ts
+import { readdirSync, statSync } from "fs";
+import path6 from "path";
+
+// eslint/pasika/project/parse-module.ts
+import path5 from "path";
+import { readFileSync } 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);
+var isSchemaName = (name) => /[Ss]chema$/.test(name);
+function lineOf(sourceFile, node) {
+  return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+function returnsJsx(node) {
+  let found = false;
+  const visit = (child) => {
+    if (found) return;
+    if (ts2.isJsxElement(child) || ts2.isJsxSelfClosingElement(child) || ts2.isJsxFragment(child) || ts2.isJsxOpeningFragment(child)) {
+      found = true;
+      return;
+    }
+    ts2.forEachChild(child, visit);
+  };
+  ts2.forEachChild(node, visit);
+  return found;
+}
+function classifyFunction(name, isTsx, hasJsx) {
+  if (isHookName(name)) return "hook";
+  if (isTsx && isPascalCase4(name) && hasJsx) return "component";
+  return "function";
+}
+function classifyValue(name, initializer, isTsx) {
+  const isFunctionLike = initializer !== void 0 && (ts2.isArrowFunction(initializer) || ts2.isFunctionExpression(initializer) || ts2.isFunctionDeclaration(initializer));
+  if (isHookName(name)) return "hook";
+  if (isSchemaName(name)) return "schema";
+  if (isTsx && isPascalCase4(name) && (initializer === void 0 || returnsJsx(initializer) || isFunctionLike)) {
+    return "component";
+  }
+  if (isFunctionLike) return "function";
+  return "constant";
+}
+function parseModule(file) {
+  const text = readFileSync(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 = [];
+  const exports = [];
+  const addImport = (specifierNode, names, node) => {
+    if (!ts2.isStringLiteral(specifierNode)) return;
+    imports.push({ specifier: specifierNode.text, names, line: lineOf(sourceFile, node) });
+  };
+  for (const statement of sourceFile.statements) {
+    if (ts2.isImportDeclaration(statement)) {
+      const names = [];
+      const bindings = statement.importClause?.namedBindings;
+      if (statement.importClause?.name) names.push(statement.importClause.name.text);
+      if (bindings && ts2.isNamedImports(bindings)) {
+        for (const element of bindings.elements) names.push(element.propertyName?.text ?? element.name.text);
+      }
+      addImport(statement.moduleSpecifier, names, statement);
+      continue;
+    }
+    if (ts2.isExportDeclaration(statement)) {
+      if (statement.moduleSpecifier) {
+        const names = [];
+        if (statement.exportClause && ts2.isNamedExports(statement.exportClause)) {
+          for (const element of statement.exportClause.elements) {
+            names.push(element.propertyName?.text ?? element.name.text);
+          }
+        }
+        addImport(statement.moduleSpecifier, names, statement);
+      }
+      if (statement.exportClause && ts2.isNamedExports(statement.exportClause)) {
+        for (const element of statement.exportClause.elements) {
+          exports.push({ name: element.name.text, kind: "other", line: lineOf(sourceFile, element) });
+        }
+      }
+      continue;
+    }
+    const isExported2 = ts2.canHaveModifiers(statement) ? (ts2.getModifiers(statement) ?? []).some((modifier) => modifier.kind === ts2.SyntaxKind.ExportKeyword) : false;
+    if (!isExported2) continue;
+    if (ts2.isFunctionDeclaration(statement) && statement.name) {
+      const name = statement.name.text;
+      exports.push({
+        name,
+        kind: classifyFunction(name, isTsx, returnsJsx(statement)),
+        line: lineOf(sourceFile, statement)
+      });
+      continue;
+    }
+    if (ts2.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (!ts2.isIdentifier(declaration.name)) continue;
+        exports.push({
+          name: declaration.name.text,
+          kind: classifyValue(declaration.name.text, declaration.initializer, isTsx),
+          line: lineOf(sourceFile, declaration)
+        });
+      }
+      continue;
+    }
+    if (ts2.isTypeAliasDeclaration(statement) || ts2.isInterfaceDeclaration(statement)) {
+      exports.push({ name: statement.name.text, kind: "type", line: lineOf(sourceFile, statement) });
+    }
+  }
+  return { file: path5.resolve(file), imports, exports };
+}
+
+// eslint/pasika/project/index.ts
+var MODULE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var INDEX_BASENAMES = ["index.ts", "index.tsx", "index.mts", "index.cts", "index.js", "index.jsx"];
+var REVALIDATE_AFTER_MS = 2e3;
+var symbolKey = (file, name) => `${file}\0${name}`;
+function listSourceFiles(dir) {
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return entries.flatMap((entry) => {
+    if (entry.startsWith(".") || entry === "node_modules") return [];
+    const entryPath = path6.join(dir, entry);
+    let stats;
+    try {
+      stats = statSync(entryPath);
+    } catch {
+      return [];
+    }
+    if (stats.isDirectory()) return listSourceFiles(entryPath);
+    return MODULE_EXTENSIONS.includes(path6.extname(entry)) ? [entryPath] : [];
+  });
+}
+function fingerprint(files) {
+  let total = 0;
+  for (const file of files) {
+    try {
+      total += statSync(file).mtimeMs;
+    } catch {
+    }
+  }
+  return `${String(files.length)}:${String(total)}`;
+}
+function resolveSpecifier(fromFile, specifier, sourceRoot2) {
+  let base;
+  if (specifier.startsWith("@/")) {
+    base = path6.resolve(sourceRoot2, specifier.slice(2));
+  } else if (specifier.startsWith(".")) {
+    base = path6.resolve(path6.dirname(fromFile), specifier);
+  } else {
+    return void 0;
+  }
+  const candidates = [
+    base,
+    ...MODULE_EXTENSIONS.map((extension) => `${base}${extension}`),
+    ...INDEX_BASENAMES.map((name) => path6.join(base, name))
+  ];
+  for (const candidate of candidates) {
+    try {
+      if (statSync(candidate).isFile()) return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function build(sourceRoot2, files) {
+  const modules = /* @__PURE__ */ new Map();
+  const consumers = /* @__PURE__ */ new Map();
+  const symbolConsumers = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    try {
+      modules.set(file, parseModule(file));
+    } catch {
+    }
+  }
+  for (const [file, module] of modules) {
+    for (const moduleImport of module.imports) {
+      const target = resolveSpecifier(file, moduleImport.specifier, sourceRoot2);
+      if (!target || !modules.has(target)) continue;
+      const fileConsumers = consumers.get(target) ?? /* @__PURE__ */ new Set();
+      fileConsumers.add(file);
+      consumers.set(target, fileConsumers);
+      for (const name of moduleImport.names) {
+        const key = symbolKey(target, name);
+        const nameConsumers = symbolConsumers.get(key) ?? /* @__PURE__ */ new Set();
+        nameConsumers.add(file);
+        symbolConsumers.set(key, nameConsumers);
+      }
+    }
+  }
+  return { sourceRoot: sourceRoot2, modules, consumers, symbolConsumers };
+}
+var cache;
+function getProjectIndex(sourceRoot2) {
+  const now = Date.now();
+  if (cache?.index.sourceRoot === sourceRoot2 && now - cache.checkedAt < REVALIDATE_AFTER_MS) {
+    return cache.index;
+  }
+  try {
+    if (!statSync(sourceRoot2).isDirectory()) return void 0;
+  } catch {
+    return void 0;
+  }
+  const files = listSourceFiles(sourceRoot2).sort((left, right) => left.localeCompare(right));
+  const currentFingerprint = fingerprint(files);
+  if (cache?.index.sourceRoot === sourceRoot2 && cache.fingerprint === currentFingerprint) {
+    cache.checkedAt = now;
+    return cache.index;
+  }
+  const index = build(sourceRoot2, files);
+  cache = { index, checkedAt: now, fingerprint: currentFingerprint };
+  return index;
+}
+
+// eslint/pasika/project/ccf.ts
+import path7 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);
+}
+function folderSegmentsOf(file, sourceRoot2) {
+  return segmentsOf(file, sourceRoot2).slice(0, -1);
+}
+var isUnderApp = (segments) => segments[0] === "app";
+var isConfigModule = (segments) => segments[0] === "config";
+var isUnderCompositions = (segments) => segments[0] === "compositions";
+function commonPrefix(folders) {
+  if (folders.length === 0) return [];
+  const [first = []] = folders;
+  const shared = [];
+  for (const [depth, segment] of first.entries()) {
+    if (!folders.every((folder) => folder[depth] === segment)) break;
+    shared.push(segment);
+  }
+  return shared;
+}
+function outOfSupportFolders(folder) {
+  const result = [...folder];
+  while (result.length > 0 && SUPPORT_FOLDERS2.has(result[result.length - 1] ?? "")) result.pop();
+  return result;
+}
+function resolveComponentPlacement(componentFile, index) {
+  const consumers = [...index.consumers.get(componentFile) ?? []];
+  const relevant = consumers.filter((consumer) => {
+    const segments = segmentsOf(consumer, index.sourceRoot);
+    return segments.length > 0 && !isUnderApp(segments) && !isConfigModule(segments);
+  });
+  if (relevant.length === 0) return void 0;
+  const outsideCompositions = relevant.filter(
+    (consumer) => !isUnderCompositions(segmentsOf(consumer, index.sourceRoot))
+  );
+  const counted = outsideCompositions.length > 0 ? outsideCompositions : relevant;
+  const shared = outOfSupportFolders(
+    commonPrefix(counted.map((consumer) => folderSegmentsOf(consumer, index.sourceRoot)))
+  );
+  if (shared.length === 1 && shared[0] === "features") {
+    return { countedConsumers: counted, expectedFolder: ["shared"], reason: "across-features" };
+  }
+  if (shared.length === 0) {
+    return { countedConsumers: counted, expectedFolder: ["shared"], reason: "across-layers" };
+  }
+  return { countedConsumers: counted, expectedFolder: shared, reason: "ccf" };
+}
+var formatFolder = (folder) => `src/${folder.join("/")}/`;
+function owningFolderOf(consumer, sourceRoot2) {
+  return outOfSupportFolders(folderSegmentsOf(consumer, sourceRoot2));
+}
+var configModuleOf = (segments) => isConfigModule(segments) && segments.length >= 3 ? segments[1] : void 0;
+function resolveSupportPlacement(supportFile, supportFolder, index) {
+  const consumers = [...index.consumers.get(supportFile) ?? []].filter(
+    (consumer) => segmentsOf(consumer, index.sourceRoot).length > 0
+  );
+  if (consumers.length === 0) return void 0;
+  const consumerSegments = consumers.map((consumer) => segmentsOf(consumer, index.sourceRoot));
+  if (consumerSegments.some((segments) => isUnderApp(segments))) {
+    return { countedConsumers: consumers, expectedFolder: [supportFolder], reason: "app-consumer" };
+  }
+  const configModules = new Set(consumerSegments.map((segments) => configModuleOf(segments)));
+  const [onlyConfigModule] = [...configModules];
+  if (configModules.size === 1 && onlyConfigModule !== void 0) {
+    return {
+      countedConsumers: consumers,
+      expectedFolder: ["config", onlyConfigModule, supportFolder],
+      reason: "config-module"
+    };
+  }
+  const shared = commonPrefix(consumers.map((consumer) => owningFolderOf(consumer, index.sourceRoot)));
+  if (shared.length === 1 && shared[0] === "features") {
+    return { countedConsumers: consumers, expectedFolder: [supportFolder], reason: "across-features" };
+  }
+  if (shared.length === 0) {
+    return { countedConsumers: consumers, expectedFolder: [supportFolder], reason: "across-layers" };
+  }
+  return { countedConsumers: consumers, expectedFolder: [...shared, supportFolder], reason: "ccf" };
+}
+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));
+  if (names.length <= shown) return names.join(", ");
+  return `${names.slice(0, shown).join(", ")} and ${String(names.length - shown)} more`;
+}
+
+// eslint/pasika/rules/component-placement.ts
+var REASON_TEXT = {
+  ccf: "that is the closest folder its consumers share",
+  "across-features": "its consumers span more than one feature, and no feature may import from another",
+  "across-layers": "its consumers span more than one layer, so no feature can own it"
+};
+var sameFolder = (left, right) => left.length === right.length && left.every((segment, depth) => segment === right[depth]);
+var componentPlacementRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Enforce that a component lives in the folder its consumers imply."
+    }
+  },
+  create(context) {
+    const filename = context.filename;
+    if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
+    const sourceRoot2 = path8.resolve("src");
+    const index = getProjectIndex(sourceRoot2);
+    if (!index) return {};
+    const componentFile = path8.resolve(filename);
+    const segments = segmentsOf(componentFile, sourceRoot2);
+    if (segments.length === 0) return {};
+    if (isUnderApp(segments) || isConfigModule(segments)) return {};
+    const module = index.modules.get(componentFile);
+    if (!module?.exports.some((moduleExport) => moduleExport.kind === "component")) return {};
+    const currentFolder = folderSegmentsOf(componentFile, sourceRoot2);
+    const placement = resolveComponentPlacement(componentFile, index);
+    return {
+      Program(node) {
+        if (!placement) {
+          if (segments[0] !== "features" || segments.length < 3) {
+            context.report({
+              node,
+              loc: { line: 1, column: 0 },
+              message: `This component has no consumer outside src/app/ or a configuration module, so it belongs in the feature folder it represents, not in ${formatFolder(currentFolder)}. See docs/code-organization-guide/rules/component-placement-rule.md`
+            });
+          }
+          return;
+        }
+        if (sameFolder(currentFolder, placement.expectedFolder)) return;
+        const explanation = REASON_TEXT[placement.reason] ?? "that is where its consumers place it";
+        context.report({
+          node,
+          loc: { line: 1, column: 0 },
+          message: `Move this component to ${formatFolder(placement.expectedFolder)} \u2014 ${explanation}. Imported by ${describeConsumers(placement.countedConsumers, sourceRoot2)}. See docs/code-organization-guide/rules/component-placement-rule.md`
+        });
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/support-file-placement.ts
+import path9 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",
+  "config-module": "every file that imports it belongs to that configuration module",
+  ccf: "that is the closest folder its consumers share",
+  "across-features": "its consumers span more than one feature, so no feature can own it",
+  "across-layers": "its consumers span more than one layer, so no layer can own it"
+};
+var sameFolder2 = (left, right) => left.length === right.length && left.every((segment, depth) => segment === right[depth]);
+var supportFilePlacementRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Enforce that a support file lives in the folder its consumers imply."
+    }
+  },
+  create(context) {
+    const sourceRoot2 = path9.resolve("src");
+    const supportFile = path9.resolve(context.filename);
+    const currentFolder = folderSegmentsOf(supportFile, sourceRoot2);
+    const supportFolder = currentFolder[currentFolder.length - 1];
+    if (supportFolder === void 0 || !SUPPORT_FOLDERS2.has(supportFolder)) return {};
+    const index = getProjectIndex(sourceRoot2);
+    if (!index) return {};
+    const placement = resolveSupportPlacement(supportFile, supportFolder, index);
+    if (!placement || sameFolder2(currentFolder, placement.expectedFolder)) return {};
+    if (isConfigModule(segmentsOf(supportFile, sourceRoot2)) && CONFIG_OWNED_FOLDERS.has(supportFolder)) {
+      if (placement.reason !== "config-module") return {};
+    }
+    return {
+      Program(node) {
+        context.report({
+          node,
+          loc: { line: 1, column: 0 },
+          message: `Move this file to ${formatFolder(placement.expectedFolder)} \u2014 ${REASON_TEXT2[placement.reason] ?? "that is where its consumers place it"}. Imported by ${describeConsumers(placement.countedConsumers, sourceRoot2)}.`
+        });
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/application-structure.ts
+import fs2 from "fs";
+import path10 from "path";
+var MODULE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
+var ROUTING_FILES = /* @__PURE__ */ new Set([
+  "default",
+  "error",
+  "instrumentation",
+  "layout",
+  "loading",
+  "middleware",
+  "not-found",
+  "page",
+  "route",
+  "template"
+]);
+var EXPECTED_SUPPORT_FOLDER = {
+  hook: "hooks",
+  type: "types",
+  schema: "schemas",
+  constant: "constants",
+  function: "utils"
+};
+function report2(context, message) {
+  return {
+    Program(node) {
+      context.report({ node, loc: { line: 1, column: 0 }, message });
+    }
+  };
+}
+function isCodeFile(filename) {
+  return MODULE_EXTENSIONS2.has(path10.extname(filename));
+}
+function isRootSupportFolder(folder) {
+  return SUPPORT_FOLDERS2.has(folder);
+}
+function exportedKinds(filename) {
+  try {
+    return new Set(parseModule(filename).exports.map((moduleExport) => moduleExport.kind));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function expectedSupportFolder(kinds) {
+  for (const kind of ["component", "hook", "type", "schema", "constant", "function"]) {
+    if (kinds.has(kind)) return EXPECTED_SUPPORT_FOLDER[kind];
+  }
+  return void 0;
+}
+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] ?? "");
+}
+function componentFolderStart(segments) {
+  if (segments[0] === "features") return 2;
+  if (segments[0] === "compositions" || segments[0] === "shared") return 1;
+  return -1;
+}
+function componentFolderViolation(segments, sourceRoot2) {
+  const start = componentFolderStart(segments);
+  if (start < 0) return void 0;
+  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 label = `src/${segments.slice(0, depth + 1).join("/")}/`;
+    if (!fs2.existsSync(path10.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"))) {
+      return `A component folder must have an index.ts that named-re-exports its component; add index.ts to ${label}.`;
+    }
+  }
+  return void 0;
+}
+var applicationStructureRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Enforce the repository's application, configuration, and support-folder structure."
+    }
+  },
+  create(context) {
+    const filename = path10.resolve(context.filename);
+    const sourceRoot2 = path10.resolve("src");
+    const segments = segmentsOf(filename, sourceRoot2);
+    if (segments.length === 0) return {};
+    const [topLevel, secondLevel] = segments;
+    if (topLevel === void 0) return {};
+    if (segments.length > 1 && topLevel !== "app" && topLevel !== "compositions" && topLevel !== "features" && topLevel !== "shared" && topLevel !== "config" && topLevel !== "locales" && !isRootSupportFolder(topLevel)) {
+      return report2(
+        context,
+        `Move this source file under an allowed src/ folder; "src/${topLevel}/" is not part of the application structure.`
+      );
+    }
+    if (topLevel === "features" && segments.length >= 2 && secondLevel !== void 0) {
+      if (SUPPORT_FOLDERS2.has(secondLevel)) {
+        return report2(
+          context,
+          `Move this support folder inside a feature folder; "src/features/${secondLevel}/" does not belong to a feature.`
+        );
+      }
+      if (segments.length === 2) {
+        return report2(context, "src/features/ must contain only feature folders, not source files.");
+      }
+    }
+    if (topLevel === "config") {
+      if (segments.length === 2) {
+        return report2(
+          context,
+          "A configuration module must be a src/config/<config-name>/ folder with index.ts as its entry point."
+        );
+      }
+      const moduleRoot = configModuleRoot(filename, sourceRoot2);
+      if (moduleRoot && !fs2.existsSync(path10.join(moduleRoot, "index.ts"))) {
+        return report2(
+          context,
+          `Add src/config/${path10.basename(moduleRoot)}/index.ts as the configuration module entry point.`
+        );
+      }
+      if (moduleRoot && segments.length === 3 && path10.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}/.`
+          );
+        }
+      }
+    }
+    if (topLevel === "app" && isCodeFile(filename)) {
+      const basename = path10.basename(filename, path10.extname(filename));
+      const currentFolder2 = path10.basename(path10.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") {
+        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 kinds = exportedKinds(filename);
+    const isConfigModuleRoot = topLevel === "config" && segments.length === 3 && path10.basename(filename) === "index.ts";
+    if (isConfigModuleRoot) return {};
+    if (!SUPPORT_FOLDERS2.has(currentFolder)) {
+      const expected2 = expectedSupportFolder(kinds);
+      if (expected2 !== void 0 && segments.length > 2) {
+        return report2(
+          context,
+          `Move this file to a ${expected2}/ folder; ${currentFolder}/ is not a recognized support folder.`
+        );
+      }
+      const violation2 = componentFolderViolation(segments, sourceRoot2);
+      if (violation2 !== void 0) return report2(context, violation2);
+      return {};
+    }
+    if (kinds.has("component")) {
+      return report2(
+        context,
+        `A support folder must not contain a component; move ${path10.basename(filename)} beside ${currentFolder}/.`
+      );
+    }
+    const expected = expectedSupportFolder(kinds);
+    if (expected !== void 0 && expected !== currentFolder) {
+      return report2(
+        context,
+        `Move this file to a ${expected}/ folder; ${currentFolder}/ is reserved for ${expected === "utils" ? "utilities" : expected}.`
+      );
+    }
+    const violation = componentFolderViolation(segments, sourceRoot2);
+    if (violation !== void 0) return report2(context, violation);
+    return {};
+  }
+};
+
+// eslint/pasika/rules/named-exports.ts
+import path11 from "path";
+var FRAMEWORK_DEFAULT_EXPORT_FILES = /* @__PURE__ */ new Set([
+  "default",
+  "error",
+  "layout",
+  "loading",
+  "not-found",
+  "page",
+  "route",
+  "template"
+]);
+function isFrameworkDefaultExportFile(filename) {
+  const normalized = filename.replaceAll(path11.sep, "/");
+  if (!normalized.includes("/src/app/")) return false;
+  const basename = path11.basename(filename, path11.extname(filename));
+  return FRAMEWORK_DEFAULT_EXPORT_FILES.has(basename);
+}
+var namedExportsRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require named exports except where a framework requires a default export."
+    }
+  },
+  create(context) {
+    if (isFrameworkDefaultExportFile(context.filename)) return {};
+    return {
+      ExportDefaultDeclaration(node) {
+        context.report({
+          node,
+          message: "Files that export values must use named exports unless a framework or third-party package requires a different export style for that file. See docs/code-organization-guide/rules/exports-and-imports-rule.md"
+        });
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/data-testid-case.ts
+import path12 from "path";
+var NEXT_ROUTING_FILES2 = /* @__PURE__ */ new Set([
+  "page",
+  "layout",
+  "loading",
+  "error",
+  "not-found",
+  "route",
+  "template",
+  "default",
+  "middleware",
+  "instrumentation"
+]);
+var isPascalCase5 = (value) => /^[A-Z][A-Za-z0-9]*$/.test(value);
+var isKebabCase3 = (value) => /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(value);
+var dataTestIdCaseRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Enforce data-testid casing for smart and dumb components with a single intrinsic root."
+    }
+  },
+  create(context) {
+    const filename = path12.resolve(context.filename);
+    if (!filename.endsWith(".tsx")) return {};
+    const base = path12.basename(filename, path12.extname(filename));
+    if (NEXT_ROUTING_FILES2.has(base)) return {};
+    const text = context.sourceCode.text;
+    const components = parseComponentInfo(text, filename);
+    return {
+      Program(node) {
+        for (const component of components) {
+          const root = findSimpleRoot(component, text, filename);
+          if (!root) continue;
+          const { value } = getTestId(root);
+          const expected = component.smart ? component.name : toKebabCase(component.name);
+          if (component.smart && value === void 0) {
+            context.report({
+              node,
+              message: `Smart component "${component.name}" with one outer DOM element must set data-testid="${expected}".`
+            });
+            continue;
+          }
+          if (value === void 0 || value === expected) continue;
+          if (component.smart ? !isPascalCase5(value) || value !== expected : !isKebabCase3(value)) {
+            context.report({
+              node,
+              message: `data-testid for ${component.smart ? "smart" : "dumb"} component "${component.name}" must be ${component.smart ? "PascalCase" : "kebab-case"}: expected "${expected}".`
+            });
+          }
+        }
+      }
+    };
+  }
+};
+function toKebabCase(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();
+}
+
+// eslint/pasika/rules/support-folder-shape.ts
+import fs3 from "fs";
+import path13 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 = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require support-folder exports to be defined in index.ts or named-re-exported by it."
+    }
+  },
+  create(context) {
+    const filename = path13.resolve(context.filename);
+    const baseName = path13.basename(filename);
+    if (!INDEX_NAMES.has(baseName)) return {};
+    const folder = path13.basename(path13.dirname(filename));
+    if (!SUPPORT_FOLDERS3.has(folder)) return {};
+    const directory = path13.dirname(filename);
+    let entries;
+    try {
+      entries = fs3.readdirSync(directory);
+    } catch {
+      return {};
+    }
+    const siblingModules = entries.filter((entry) => entry !== baseName && /\.(?:[cm]?tsx?|jsx?)$/.test(entry));
+    if (siblingModules.length === 0) return {};
+    return {
+      Program(node) {
+        const source = context.sourceCode.text;
+        const hasDirectExport = /export\s+(?:const|let|var|function|class|type|interface|enum)\b/.test(source);
+        if (hasDirectExport) return;
+        const exportedFiles = /* @__PURE__ */ new Set();
+        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));
+        }
+        const missing = siblingModules.filter((entry) => {
+          const stem = entry.replace(/\.(?:[cm]?tsx?|jsx?)$/, "");
+          return !exportedFiles.has(stem);
+        });
+        if (missing.length === 0) return;
+        context.report({
+          node,
+          message: `${folder}/index.ts must named-re-export every support file: ${missing.join(", ")}. See docs/code-organization-guide/rules/${folder === "constants" ? "constants" : "types-and-schemas"}-rule.md`
+        });
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/import-through-index.ts
+import path14 from "path";
+var importThroughIndexRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require imports of support files to use their support-folder index."
+    }
+  },
+  create(context) {
+    const filename = path14.resolve(context.filename);
+    const sourceRoot2 = sourceRootOf(filename);
+    return {
+      Program(node) {
+        for (const specifier of importSpecifiers(context.sourceCode.text)) {
+          const target = resolveSpecifier(filename, specifier, sourceRoot2);
+          if (!target) continue;
+          const targetSegments = segmentsOf(target, sourceRoot2);
+          const supportFolderIndex = targetSegments.findIndex(
+            (segment) => ["constants", "types", "schemas"].includes(segment)
+          );
+          const supportFolder = supportFolderIndex >= 0 ? targetSegments[supportFolderIndex] : void 0;
+          if (!supportFolder || path14.basename(target).startsWith("index.")) continue;
+          const folderIndex = targetSegments.slice(0, supportFolderIndex + 1);
+          const expected = `@/${folderIndex.join("/")}`;
+          context.report({
+            node,
+            message: `Import support files through ${expected} instead of "${specifier}". See the code-organization-guide exports and imports rules.`
+          });
+        }
+      }
+    };
+  }
+};
+function importSpecifiers(source) {
+  const specifiers = [];
+  const pattern = /\bimport\s+(?:(?:type\s+)?[\s\S]*?\sfrom\s+)?["'](?<specifier>[^"']+)["']/g;
+  for (const match of source.matchAll(pattern)) {
+    const specifier = match.groups?.specifier;
+    if (specifier) specifiers.push(specifier);
+  }
+  return specifiers;
+}
+function sourceRootOf(filename) {
+  const marker = `${path14.sep}src${path14.sep}`;
+  const srcIndex = filename.lastIndexOf(marker);
+  return srcIndex >= 0 ? filename.slice(0, srcIndex + marker.length - 1) : path14.resolve("src");
+}
+
+// eslint/pasika/rules/util-file-name.ts
+import path15 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();
+}
+var utilFileNameRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require single-function utility files to use the function's kebab-case name."
+    }
+  },
+  create(context) {
+    const filename = path15.resolve(context.filename);
+    const segments = filename.replace(/\\/g, "/").split("/");
+    if (!segments.includes("utils")) return {};
+    let module;
+    try {
+      module = parseModule(filename);
+    } catch {
+      return {};
+    }
+    const functions = module.exports.filter((entry) => entry.kind === "function");
+    if (functions.length !== 1 || module.exports.length !== 1) return {};
+    const functionName = functions[0]?.name;
+    if (!functionName) return {};
+    const expected = toKebabCase2(functionName);
+    const actual = path15.basename(filename, path15.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)}.`
+        });
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/no-util-barrel.ts
+import path16 from "path";
+var noUtilBarrelRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require utilities to be imported directly without a barrel."
+    }
+  },
+  create(context) {
+    const filename = path16.resolve(context.filename);
+    const sourceRoot2 = sourceRootOf2(filename);
+    return {
+      Program(node) {
+        for (const specifier of importSpecifiers2(context.sourceCode.text)) {
+          const target = resolveSpecifier(filename, specifier, sourceRoot2);
+          if (!target) continue;
+          const segments = target.replace(/\\/g, "/").split("/");
+          const utilsIndex = segments.lastIndexOf("utils");
+          if (utilsIndex < 0 || !path16.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`
+          });
+        }
+      }
+    };
+  }
+};
+function importSpecifiers2(source) {
+  const specifiers = [];
+  const pattern = /\bimport\s+(?:(?:type\s+)?[\s\S]*?\sfrom\s+)?["'](?<specifier>[^"']+)["']/g;
+  for (const match of source.matchAll(pattern)) {
+    const specifier = match.groups?.specifier;
+    if (specifier) specifiers.push(specifier);
+  }
+  return specifiers;
+}
+function sourceRootOf2(filename) {
+  const marker = `${path16.sep}src${path16.sep}`;
+  const srcIndex = filename.lastIndexOf(marker);
+  return srcIndex >= 0 ? filename.slice(0, srcIndex + marker.length - 1) : path16.resolve("src");
+}
+
+// eslint/pasika/rules/jsx-hygiene.ts
+import ts3 from "typescript";
+var ARITHMETIC_OPERATORS = /* @__PURE__ */ new Set(["+", "-", "*", "/", "%"]);
+function isCallExpression(node) {
+  return node.type === "CallExpression";
+}
+function isMemberExpression(node) {
+  return ["MemberExpression", "OptionalMemberExpression"].includes(node.type);
+}
+function logicalOperatorCount(node) {
+  if (node.type !== "LogicalExpression") return 0;
+  return 1 + logicalOperatorCount(node.left) + logicalOperatorCount(node.right);
+}
+function containsConditionalIn(node, sourceText) {
+  const start = node.range?.[0] ?? 0;
+  const end = node.range?.[1] ?? sourceText.length;
+  const sourceFile = ts3.createSourceFile(
+    "fragment.tsx",
+    sourceText.slice(start, end),
+    ts3.ScriptTarget.Latest,
+    true,
+    ts3.ScriptKind.TSX
+  );
+  let found = false;
+  const visit = (child) => {
+    if (found) return;
+    if (ts3.isConditionalExpression(child)) {
+      found = true;
+      return;
+    }
+    ts3.forEachChild(child, visit);
+  };
+  visit(sourceFile);
+  return found;
+}
+function hasNestedTernary(node, sourceText) {
+  if (node.type !== "ConditionalExpression") return false;
+  return containsConditionalIn(node.consequent, sourceText) || containsConditionalIn(node.alternate, sourceText);
+}
+function hasChainedCall(node) {
+  if (!isCallExpression(node) || !isMemberExpression(node.callee)) return false;
+  return isCallExpression(node.callee.object) || isMemberExpression(node.callee.object);
+}
+function hasExternalCall(node) {
+  if (!isCallExpression(node)) return false;
+  const callee = node.callee;
+  if (callee.type === "Identifier" && callee.name === "cn") return false;
+  if (isMemberExpression(callee)) return false;
+  return callee.type === "Identifier";
+}
+function findViolation(node, sourceText) {
+  if (node.type === "BinaryExpression" && ARITHMETIC_OPERATORS.has(node.operator)) {
+    return "arithmetic";
+  }
+  if (hasChainedCall(node)) return "chained built-in method calls";
+  if (hasExternalCall(node)) return "calls to functions declared outside the component";
+  if (hasNestedTernary(node, sourceText)) return "nested ternaries";
+  if (logicalOperatorCount(node) >= 2) return "conditions containing two or more logical operators";
+  return void 0;
+}
+var jsxHygieneRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require complex JSX expressions to be extracted before return."
+    }
+  },
+  create(context) {
+    if (!context.filename.endsWith(".tsx") && !context.filename.endsWith(".jsx")) return {};
+    const sourceText = context.sourceCode.text;
+    function checkExpression(node) {
+      const violation = findViolation(node, sourceText);
+      if (!violation) return;
+      context.report({
+        node,
+        message: `Extract ${violation} from JSX before return. See docs/code-organization-guide/rules/jsx-hygiene-rule.md`
+      });
+    }
+    return {
+      JSXExpressionContainer(node) {
+        const expression = node.expression;
+        if (!expression || expression.type === "JSXEmptyExpression") return;
+        checkExpression(expression);
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/interactive-component.ts
+var INTERACTIVE_TAGS = /* @__PURE__ */ new Set([
+  "a",
+  "button",
+  "details",
+  "embed",
+  "iframe",
+  "input",
+  "label",
+  "select",
+  "textarea",
+  "video"
+]);
+function tagName(node) {
+  const name = node.openingElement?.name;
+  if (name?.type !== "JSXIdentifier") return void 0;
+  return name.name;
+}
+function isInteractive(node) {
+  const name = tagName(node);
+  return name !== void 0 && INTERACTIVE_TAGS.has(name);
+}
+function isComponentElement(node) {
+  const name = tagName(node);
+  return name !== void 0 && /^[A-Z]/.test(name);
+}
+function isComponentReturn(node) {
+  const parent = node.parent;
+  if (parent.type === "ReturnStatement") return true;
+  return parent.type === "ArrowFunctionExpression" && parent.body === node;
+}
+var interactiveComponentRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require interactive HTML elements mixed with other content to be extracted into components."
+    }
+  },
+  create(context) {
+    if (!context.filename.endsWith(".tsx") && !context.filename.endsWith(".jsx")) return {};
+    return {
+      JSXElement(node) {
+        if (!isInteractive(node)) return;
+        if (isComponentElement(node.parent)) {
+          return;
+        }
+        if (isInteractive(node.parent)) {
+          return;
+        }
+        if (isComponentReturn(node)) {
+          return;
+        }
+        const name = tagName(node);
+        if (name === void 0) return;
+        context.report({
+          node,
+          message: `Extract the interactive <${name}> into a descriptive component. See docs/code-organization-guide/rules/interactive-component-rule.md`
+        });
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/ui-state.ts
+var STATE_PROPS = /* @__PURE__ */ new Set([
+  "disabled",
+  "loading",
+  "selected",
+  "expanded",
+  "pressed",
+  "checked",
+  "busy",
+  "invalid",
+  "open"
+]);
+var STATE_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "disabled",
+  "aria-busy",
+  "aria-selected",
+  "aria-expanded",
+  "aria-pressed",
+  "aria-checked",
+  "aria-invalid",
+  "open"
+]);
+var STATE_CLASS_RE = /^(?:disabled|aria-(?:busy|selected|expanded|pressed|checked|invalid)|data-\[state)/;
+function isComponentElement2(node) {
+  const name = node.openingElement?.name;
+  return name?.type === "JSXIdentifier" && /^[A-Z]/.test(name.name);
+}
+function expressionName(node) {
+  if (node?.type !== "JSXExpressionContainer") return void 0;
+  if (node.expression?.type === "Identifier") return node.expression.name;
+  return void 0;
+}
+var uiStateRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require semantic UI states and Tailwind state variants."
+    }
+  },
+  create(context) {
+    return {
+      JSXElement(node) {
+        if (!isComponentElement2(node)) return;
+        const attributes = node.openingElement?.attributes ?? [];
+        const names = /* @__PURE__ */ new Set();
+        for (const attribute of attributes) {
+          names.add(String(attribute.name?.name));
+        }
+        for (const attribute of attributes) {
+          const name = String(attribute.name?.name);
+          const stateName = expressionName(attribute.value);
+          if (!stateName || !STATE_PROPS.has(stateName)) continue;
+          const hasNativeState = [...STATE_ATTRIBUTES].some((nativeName) => names.has(nativeName));
+          if (!hasNativeState) {
+            context.report({
+              node: attribute,
+              message: `UI state prop "${name}" should be expressed with a native or ARIA state attribute. See docs/styling-guide/rules/component-ui-state-rule.md`
+            });
+          }
+        }
+        for (const attribute of attributes) {
+          if (String(attribute.name?.name) !== "className") continue;
+          const value = attribute.value;
+          const text = value?.type === "Literal" ? String(value.value) : "";
+          if (value?.type === "JSXExpressionContainer" && value.expression.type === "ConditionalExpression") {
+            const consequent = value.expression.consequent;
+            const alternate = value.expression.alternate;
+            const classes = [consequent, alternate].filter(
+              (branch) => branch.type === "Literal" && typeof branch.value === "string"
+            ).flatMap((branch) => String(branch.value).split(/\s+/));
+            if (classes.length > 0 && !classes.some((className) => STATE_CLASS_RE.test(className))) {
+              context.report({
+                node: attribute,
+                message: "Use a Tailwind state variant for a UI state instead of conditional replacement classes. See docs/styling-guide/rules/component-ui-state-rule.md"
+              });
+            }
+          }
+          if (text.split(/\s+/).some((className) => className.includes("state-"))) {
+            return;
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/cva-appearance-props.ts
+var VISUAL_OPTION_NAMES = /* @__PURE__ */ new Set([
+  "size",
+  "variant",
+  "tone",
+  "color",
+  "appearance",
+  "intent",
+  "style",
+  "scheme",
+  "theme"
+]);
+function hasCvaCall(body) {
+  for (const stmt of body) {
+    if (stmt.type !== "VariableDeclaration") continue;
+    for (const decl of stmt.declarations) {
+      const init = decl.init;
+      if (init?.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "cva") {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var cvaAppearancePropsRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Components with visual option props must define them using cva."
+    }
+  },
+  create(context) {
+    const program = context.sourceCode.ast;
+    const hasCva = hasCvaCall(program.body);
+    if (hasCva) return {};
+    return {
+      TSTypeAliasDeclaration(node) {
+        if (node.id?.type !== "Identifier" || !node.id.name?.endsWith("Props")) return;
+        if (node.typeAnnotation?.type !== "TSTypeLiteral") return;
+        for (const member of node.typeAnnotation.members ?? []) {
+          if (member.type !== "TSPropertySignature") continue;
+          const keyName = member.key?.type === "Identifier" ? member.key.name : void 0;
+          if (!keyName || !VISUAL_OPTION_NAMES.has(keyName)) continue;
+          const typeAnnotation = member.typeAnnotation?.typeAnnotation ?? member.typeAnnotation;
+          if (!typeAnnotation) continue;
+          if (typeAnnotation.type === "TSUnionType" || typeAnnotation.type === "TSTypeLiteral") {
+            context.report({
+              node,
+              message: `Visual option prop "${keyName}" must be defined through a cva() call rather than a manual union type. See docs/styling-guide/rules/component-variant-rule.md`
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/cva-boolean-variants.ts
+function extractCvaInfo(node) {
+  if (node.callee.type !== "Identifier" || node.callee.name !== "cva") {
+    return void 0;
+  }
+  const variantNames = /* @__PURE__ */ new Set();
+  const compoundVariants = /* @__PURE__ */ new Set();
+  const options = node.arguments[1];
+  if (options?.type !== "ObjectExpression") return { variantNames, compoundVariants };
+  for (const prop of options.properties) {
+    if (prop.type !== "Property") continue;
+    const keyName = prop.key.type === "Identifier" ? prop.key.name : void 0;
+    if (keyName === "variants" && prop.value.type === "ObjectExpression") {
+      for (const vProp of prop.value.properties) {
+        if (vProp.type !== "Property") continue;
+        const vName = vProp.key.type === "Identifier" ? vProp.key.name : void 0;
+        if (vName) variantNames.add(vName);
+      }
+    }
+    if (keyName === "compoundVariants" && prop.value.type === "ArrayExpression") {
+      for (const entry of prop.value.elements) {
+        if (entry?.type !== "ObjectExpression") continue;
+        for (const cvProp of entry.properties) {
+          if (cvProp.type !== "Property") continue;
+          const cvName = cvProp.key.type === "Identifier" ? cvProp.key.name : void 0;
+          if (cvName && variantNames.has(cvName)) {
+            compoundVariants.add(cvName);
+          }
+        }
+      }
+    }
+  }
+  return { variantNames, compoundVariants };
+}
+var cvaBooleanVariantsRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Enforce correct boolean variant placement between CVA and cn()."
+    }
+  },
+  create(context) {
+    const cvaInfos = [];
+    return {
+      // Collect all cva() calls in the file
+      CallExpression(node) {
+        const info = extractCvaInfo(node);
+        if (info) cvaInfos.push(info);
+      },
+      // Detect boolean && "class" patterns anywhere inside a className attribute
+      "JSXAttribute[name.name='className'] LogicalExpression[operator='&&']"(node) {
+        if (cvaInfos.length === 0) return;
+        if (node.type !== "LogicalExpression") return;
+        const left = node.left;
+        const right = node.right;
+        if (right.type !== "Literal" || typeof right.value !== "string") {
+          return;
+        }
+        if (left.type !== "Identifier") return;
+        const propName = left.name;
+        for (const info of cvaInfos) {
+          if (info.variantNames.has(propName)) {
+            context.report({
+              node,
+              message: `Boolean prop "${propName}" is used as a standalone conditional in cn() but is also defined as a CVA variant. Move it to one place: either CVA (with both true/false treatments) or cn() (standalone). See docs/styling-guide/rules/component-variant-rule.md`
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/cross-feature-import.ts
+import path17 from "path";
+var FEATURES_SEGMENT = "features";
+function featureNameOf(resolvedPath, sourceRoot2) {
+  const relative = path17.relative(sourceRoot2, resolvedPath);
+  if (relative.startsWith("..")) return void 0;
+  const segments = relative.split(path17.sep);
+  if (segments[0] !== FEATURES_SEGMENT || segments.length < 2) return void 0;
+  return segments[1];
+}
+var crossFeatureImportRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require non-composition files that import from two or more feature folders to live in src/compositions/."
+    }
+  },
+  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);
+    if (fileRelative.startsWith("..")) return {};
+    const fileSegments = fileRelative.split(path17.sep);
+    const isInCompositions = fileSegments[0] === "compositions";
+    const isInApp = fileSegments[0] === "app";
+    const isConfig = fileSegments[0] === "config";
+    if (isInCompositions || isInApp || isConfig) return {};
+    const importedFeatures = /* @__PURE__ */ new Set();
+    let alreadyReported = false;
+    return {
+      ImportDeclaration(node) {
+        if (alreadyReported) return;
+        const source = node.source;
+        if (typeof source.value !== "string") return;
+        let resolved;
+        if (source.value.startsWith("@/")) {
+          resolved = path17.resolve(sourceRoot2, source.value.slice(2));
+        } else if (source.value.startsWith(".")) {
+          resolved = path17.resolve(path17.dirname(filename), source.value);
+        }
+        if (!resolved) return;
+        const feature = featureNameOf(resolved, sourceRoot2);
+        if (feature) importedFeatures.add(feature);
+        if (importedFeatures.size >= 2) {
+          alreadyReported = true;
+          const names = [...importedFeatures].sort().join(", ");
+          context.report({
+            node,
+            message: `This component imports from two or more feature folders (${names}) and must live in src/compositions/. See docs/code-organization-guide/rules/component-placement-rule.md`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/pure-function-extract.ts
+import path18 from "path";
+function isComponentLikeName(name) {
+  return /^[A-Z]/.test(name);
+}
+function isHookName2(name) {
+  return /^use[A-Z]/.test(name);
+}
+function hasHookUsage(body) {
+  for (const stmt of body.body) {
+    if (stmt.type !== "ExpressionStatement") continue;
+    const expr = stmt.expression;
+    if (expr.type === "CallExpression" && expr.callee.type === "Identifier" && isHookName2(expr.callee.name)) {
+      return true;
+    }
+  }
+  return false;
+}
+var pureFunctionExtractRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require pure functions declared in component files to be extracted to utils/."
+    }
+  },
+  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);
+    if (relative.startsWith("..")) return {};
+    const segments = relative.split(path18.sep);
+    if (segments[0] === "utils") return {};
+    if (segments[0] === "app") return {};
+    const supportFolders = /* @__PURE__ */ new Set(["hooks", "types", "schemas", "constants", "utils"]);
+    if (segments.length >= 2 && supportFolders.has(segments[segments.length - 1] ?? "")) return {};
+    function report3(node, name) {
+      context.report({
+        node,
+        message: `Extract pure function "${name}" to utils/. See docs/code-organization-guide/rules/utilities-rule.md`
+      });
+    }
+    return {
+      FunctionDeclaration(node) {
+        const exported = node.parent?.type === "ExportNamedDeclaration";
+        if (!exported) return;
+        const name = node.id?.name;
+        if (!name) return;
+        if (isComponentLikeName(name) || isHookName2(name)) return;
+        if (!node.body || hasHookUsage(node.body)) return;
+        report3(node, name);
+      },
+      VariableDeclarator(node) {
+        if (node.id.type !== "Identifier") return;
+        const name = node.id.name;
+        if (!name) return;
+        const exported = node.parent.parent?.type === "ExportNamedDeclaration";
+        if (!exported) return;
+        if (isComponentLikeName(name) || isHookName2(name)) return;
+        const init = node.init;
+        if (!init || init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression") {
+          return;
+        }
+        if (init.body.type === "BlockStatement" && hasHookUsage(init.body)) return;
+        report3(node, name);
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/hook-complexity.ts
+import path19 from "path";
+import ts4 from "typescript";
+var REACT_HOOKS = /* @__PURE__ */ new Set([
+  "useState",
+  "useEffect",
+  "useContext",
+  "useReducer",
+  "useCallback",
+  "useMemo",
+  "useRef",
+  "useLayoutEffect",
+  "useImperativeHandle",
+  "useDebugValue",
+  "useDeferredValue",
+  "useTransition",
+  "useId",
+  "useSyncExternalStore",
+  "useInsertionEffect"
+]);
+function isHookName3(name) {
+  return /^use[A-Z]/.test(name);
+}
+function countImperativeCategories(body, sourceText) {
+  const start = body.range?.[0] ?? 0;
+  const end = body.range?.[1] ?? sourceText.length;
+  const sourceFile = ts4.createSourceFile(
+    "hook.ts",
+    sourceText.slice(start, end),
+    ts4.ScriptTarget.Latest,
+    true,
+    ts4.ScriptKind.TS
+  );
+  const categories = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (ts4.isCallExpression(node) && ts4.isIdentifier(node.expression) && REACT_HOOKS.has(node.expression.text)) {
+      categories.add(node.expression.text);
+    }
+    ts4.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return categories.size;
+}
+var hookComplexityRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require extraction of complex single-consumer hooks and inline of simple ones."
+    }
+  },
+  create(context) {
+    const filename = context.filename;
+    const sourceRoot2 = path19.resolve("src");
+    const relative = path19.relative(sourceRoot2, filename);
+    if (relative.startsWith("..")) return {};
+    const segments = relative.split(path19.sep);
+    const sourceText = context.sourceCode.text;
+    function checkHook(node, name, body, exported) {
+      if (!exported) return;
+      if (!name || !isHookName3(name)) return;
+      if (!body) return;
+      const imperativeCount = countImperativeCategories(body, sourceText);
+      const parentFolder = segments.length >= 2 ? segments[segments.length - 2] : void 0;
+      const inSupportFolder = parentFolder === "hooks";
+      if (imperativeCount >= 2 && !inSupportFolder) {
+        context.report({
+          node,
+          message: `Hook "${name}" has ${String(imperativeCount)} imperative categories and must be extracted to a hooks/ folder. See docs/code-organization-guide/rules/hook-extraction-rule.md`
+        });
+      } else if (imperativeCount < 2 && inSupportFolder) {
+        context.report({
+          node,
+          message: `Hook "${name}" has fewer than two imperative categories and must stay inline in its consumer file. See docs/code-organization-guide/rules/hook-extraction-rule.md`
+        });
+      }
+    }
+    return {
+      FunctionDeclaration(node) {
+        const exported = node.parent?.type === "ExportNamedDeclaration";
+        checkHook(node, node.id?.name, node.body, exported);
+      },
+      VariableDeclarator(node) {
+        if (node.id.type !== "Identifier") return;
+        const exported = node.parent.parent?.type === "ExportNamedDeclaration";
+        if (!exported) return;
+        const init = node.init;
+        if (!init || init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression") {
+          return;
+        }
+        if (init.body.type !== "BlockStatement") return;
+        checkHook(node, node.id.name, init.body, true);
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/locale-dotted-path.ts
+import path20 from "path";
+function isInLocalesDir(filename) {
+  const segments = path20.resolve(filename).split(path20.sep);
+  const srcIdx = segments.lastIndexOf("src");
+  return srcIdx !== -1 && segments[srcIdx + 1] === "locales";
+}
+function isLocalesAccess(node) {
+  if (node.type === "Identifier" && node.name === "locales") {
+    return true;
+  }
+  if (node.type === "MemberExpression" && node.object.type === "Identifier" && node.object.name === "locales" && node.property.type === "Identifier") {
+    return true;
+  }
+  return false;
+}
+var localeDottedPathRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require reading namespaced locales through their full dotted path."
+    }
+  },
+  create(context) {
+    if (isInLocalesDir(context.filename)) return {};
+    return {
+      VariableDeclarator(node) {
+        if (node.id.type !== "ObjectPattern") return;
+        const init = node.init;
+        if (!init || !isLocalesAccess(init)) return;
+        for (const prop of node.id.properties) {
+          if (prop.type !== "Property") continue;
+          let valueName;
+          if (prop.value.type === "Identifier") {
+            valueName = prop.value.name;
+          } else if (prop.key.type === "Identifier") {
+            valueName = prop.key.name;
+          }
+          if (valueName) {
+            context.report({
+              node,
+              message: `Destructuring locales.${valueName} loses the namespace; read through the full dotted path instead.`
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/locales-location.ts
+import path21 from "path";
+function isLocalesFile(filename) {
+  const segments = path21.resolve(filename).split(path21.sep);
+  const srcIdx = segments.lastIndexOf("src");
+  return srcIdx !== -1 && segments[srcIdx + 1] === "locales";
+}
+var LOCALE_NAME_RE = /^[a-z][a-zA-Z0-9]*$/;
+function looksLikeLocaleKey(name) {
+  return LOCALE_NAME_RE.test(name);
+}
+var localesLocationRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require all locales to live in the named locales object."
+    }
+  },
+  create(context) {
+    if (isLocalesFile(context.filename)) return {};
+    const filename = context.filename;
+    const segments = path21.resolve(filename).split(path21.sep);
+    const srcIdx = segments.lastIndexOf("src");
+    if (srcIdx === -1) return {};
+    const folder = segments[srcIdx + 1];
+    if (folder === "app" || folder === "config") return {};
+    return {
+      VariableDeclarator(node) {
+        if (node.id.type === "Identifier" && node.init?.type === "ObjectExpression" && node.init.properties.length > 0 && looksLikeLocaleKey(node.id.name)) {
+          const hasStringValues = node.init.properties.some((p) => p.type === "Property" && p.value.type === "Literal");
+          if (hasStringValues) {
+            context.report({
+              node,
+              message: "User-facing strings must live in src/locales/, not inline in component files."
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/hook-extraction.ts
+import path22 from "path";
+var hookExtractionRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require a custom hook with two or more consumers to live in its own hooks/ file."
+    }
+  },
+  create(context) {
+    const sourceRoot2 = path22.resolve("src");
+    const file = path22.resolve(context.filename);
+    const segments = segmentsOf(file, sourceRoot2);
+    if (segments.length === 0) return {};
+    const index = getProjectIndex(sourceRoot2);
+    if (!index) return {};
+    const module = index.modules.get(file);
+    if (!module) return {};
+    const folder = folderSegmentsOf(file, sourceRoot2);
+    const alreadyInHooksFolder = folder.length > 0 && folder[folder.length - 1] === "hooks";
+    const reusedHooks = module.exports.filter((exp) => exp.kind === "hook" && !alreadyInHooksFolder).map((exp) => ({ exp, consumers: index.symbolConsumers.get(symbolKey(file, exp.name)) })).filter(({ consumers }) => (consumers?.size ?? 0) >= 2);
+    if (reusedHooks.length === 0) return {};
+    return {
+      Program(node) {
+        for (const { exp, consumers } of reusedHooks) {
+          context.report({
+            node,
+            loc: { line: exp.line, column: 0 },
+            message: `Hook "${exp.name}" has ${String(consumers?.size ?? 0)} consumers; extract it to its own file in a hooks/ folder. See docs/code-organization-guide/rules/hook-extraction-rule.md`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/value-extraction.ts
+import path23 from "path";
+var valueExtractionRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require a value imported independently to be extracted as a constant."
+    }
+  },
+  create(context) {
+    const sourceRoot2 = path23.resolve("src");
+    const file = path23.resolve(context.filename);
+    const segments = segmentsOf(file, sourceRoot2);
+    if (segments.length === 0 || segments[0] !== "app") return {};
+    const index = getProjectIndex(sourceRoot2);
+    if (!index) return {};
+    const consumers = [...index.consumers.get(file) ?? []];
+    const outsideApp = consumers.filter((consumer) => segmentsOf(consumer, sourceRoot2)[0] !== "app");
+    if (outsideApp.length === 0) return {};
+    return {
+      Program(node) {
+        context.report({
+          node,
+          loc: { line: 1, column: 0 },
+          message: `This file in src/app/ is imported by ${describeConsumers(outsideApp, sourceRoot2)} outside src/app/. Extract the value to a shared or feature folder so it can be imported independently. See docs/code-organization-guide/rules/constants-rule.md`
+        });
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/config-extraction.ts
+import path24 from "path";
+var configExtractionRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require config-only types and schemas to be extracted into the module's support folder."
+    }
+  },
+  create(context) {
+    const sourceRoot2 = path24.resolve("src");
+    const file = path24.resolve(context.filename);
+    const segments = segmentsOf(file, sourceRoot2);
+    if (segments.length < 3 || segments[0] !== "config") return {};
+    if (SUPPORT_FOLDERS2.has(segments[2] ?? "")) return {};
+    const index = getProjectIndex(sourceRoot2);
+    if (!index) return {};
+    const module = index.modules.get(file);
+    if (!module) return {};
+    const suspects = module.exports.filter((exp) => exp.kind === "type" || exp.kind === "schema");
+    if (suspects.length === 0) return {};
+    const findings = [];
+    for (const exp of suspects) {
+      const consumers = [...index.symbolConsumers.get(symbolKey(file, exp.name)) ?? []];
+      const outsideConfig = consumers.filter((consumer) => segmentsOf(consumer, sourceRoot2)[0] !== "config");
+      if (outsideConfig.length > 0) {
+        findings.push({
+          line: exp.line,
+          message: `${exp.kind} "${exp.name}" in a configuration module is imported by ${describeConsumers(outsideConfig, sourceRoot2)} outside src/config/. Move it to the matching root support folder. See docs/code-organization-guide/rules/configuration-rule.md`
+        });
+      } else if (consumers.length > 0) {
+        findings.push({
+          line: exp.line,
+          message: `${exp.kind} "${exp.name}" is used only to implement this configuration module; extract it to the module's ${exp.kind === "schema" ? "schemas/" : "types/"} folder even with one consumer. See docs/code-organization-guide/rules/configuration-rule.md`
+        });
+      }
+    }
+    if (findings.length === 0) return {};
+    return {
+      Program(node) {
+        for (const finding of findings) {
+          context.report({ node, loc: { line: finding.line, column: 0 }, message: finding.message });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/component-nesting.ts
+import path25 from "path";
+var componentNestingRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require a nested component to have exclusive child components, not only support files."
+    }
+  },
+  create(context) {
+    const sourceRoot2 = path25.resolve("src");
+    const file = path25.resolve(context.filename);
+    const segments = segmentsOf(file, sourceRoot2);
+    if (segments.length !== 4 || segments[0] !== "features") return {};
+    const index = getProjectIndex(sourceRoot2);
+    if (!index) return {};
+    const module = index.modules.get(file);
+    if (!module?.exports.some((exp) => exp.kind === "component")) return {};
+    const folder = segments.slice(0, 3);
+    const hasChildComponent = [...index.modules.values()].some((candidate) => {
+      if (candidate.file === file) return false;
+      const candidateSegments = segmentsOf(candidate.file, sourceRoot2);
+      if (candidateSegments.length !== 4) return false;
+      if (candidateSegments[0] !== folder[0] || candidateSegments[1] !== folder[1] || candidateSegments[2] !== folder[2]) {
+        return false;
+      }
+      if (candidateSegments[3]?.startsWith("index.")) return false;
+      return candidate.exports.some((exp) => exp.kind === "component");
+    });
+    if (hasChildComponent) return {};
+    const flatFolder = segments.slice(0, 2).join("/");
+    return {
+      Program(node) {
+        context.report({
+          node,
+          loc: { line: 1, column: 0 },
+          message: `This component is nested in src/${folder.join("/")}/ but its folder has no exclusive child components \u2014 only support files. Flatten it back into src/${flatFolder}/. See docs/code-organization-guide/rules/folder-nesting-rule.md`
+        });
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/stay-flat.ts
+import path26 from "path";
+var stayFlatRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require a component with exclusive children to be nested in a folder with the same name."
+    }
+  },
+  create(context) {
+    const sourceRoot2 = path26.resolve("src");
+    const file = path26.resolve(context.filename);
+    const segments = segmentsOf(file, sourceRoot2);
+    if (segments.length !== 3 || segments[0] !== "features") return {};
+    const index = getProjectIndex(sourceRoot2);
+    if (!index) return {};
+    const module = index.modules.get(file);
+    if (!module?.exports.some((exp) => exp.kind === "component")) return {};
+    const featureName = segments[1];
+    if (!featureName) return {};
+    const exclusiveChildren = [...index.modules.values()].filter((candidate) => {
+      if (candidate.file === file) return false;
+      const candidateSegments = segmentsOf(candidate.file, sourceRoot2);
+      if (candidateSegments.length !== 3) return false;
+      if (candidateSegments[0] !== "features" || candidateSegments[1] !== featureName) return false;
+      if (candidateSegments[2]?.startsWith("index.")) return false;
+      if (!candidate.exports.some((exp) => exp.kind === "component")) return false;
+      const consumers = index.consumers.get(candidate.file) ?? /* @__PURE__ */ new Set();
+      if (consumers.size === 0) return false;
+      return [...consumers].every((consumer) => {
+        if (consumer === file) return true;
+        const consumerSegments = segmentsOf(consumer, sourceRoot2);
+        if (consumerSegments[0] !== "features" || consumerSegments[1] !== featureName) return false;
+        return !(index.modules.get(consumer)?.exports.some((exp) => exp.kind === "component") ?? false);
+      });
+    });
+    if (exclusiveChildren.length === 0) return {};
+    const childNames = exclusiveChildren.map((child) => child.exports.find((exp) => exp.kind === "component")?.name).filter((name) => name !== void 0);
+    return {
+      Program(node) {
+        context.report({
+          node,
+          loc: { line: 1, column: 0 },
+          message: `This component has exclusive child component(s) ${childNames.join(", ")}; nest it in a folder named after it inside src/features/${featureName}/. See docs/code-organization-guide/rules/folder-nesting-rule.md`
+        });
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/type-extraction.ts
+import path27 from "path";
+var typeExtractionRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require a type or schema imported without its defining code to be extracted."
+    }
+  },
+  create(context) {
+    const sourceRoot2 = path27.resolve("src");
+    const file = path27.resolve(context.filename);
+    const segments = segmentsOf(file, sourceRoot2);
+    if (segments.length === 0) return {};
+    const index = getProjectIndex(sourceRoot2);
+    if (!index) return {};
+    const module = index.modules.get(file);
+    if (!module) return {};
+    const componentExport = module.exports.find((exp) => exp.kind === "component");
+    const codeExports = module.exports.filter((exp) => exp.kind !== "type" && exp.kind !== "other");
+    const findings = [];
+    for (const exp of module.exports) {
+      if (exp.kind !== "type" && exp.kind !== "schema") continue;
+      const consumers = [...index.symbolConsumers.get(symbolKey(file, exp.name)) ?? []];
+      if (consumers.length === 0) continue;
+      if (componentExport) {
+        const componentConsumers = index.symbolConsumers.get(symbolKey(file, componentExport.name)) ?? /* @__PURE__ */ new Set();
+        const independent2 = consumers.filter((consumer) => !componentConsumers.has(consumer));
+        if (independent2.length === 0) continue;
+        findings.push({
+          line: exp.line,
+          message: `${exp.kind} "${exp.name}" is imported by ${describeConsumers(independent2, sourceRoot2)} without the component "${componentExport.name}" that defines it. Extract it to a types/ or schemas/ folder. See docs/code-organization-guide/rules/types-and-schemas-rule.md`
+        });
+        continue;
+      }
+      if (codeExports.length === 0) continue;
+      const independent = consumers.filter(
+        (consumer) => !codeExports.some((other) => index.symbolConsumers.get(symbolKey(file, other.name))?.has(consumer))
+      );
+      if (independent.length === 0) continue;
+      findings.push({
+        line: exp.line,
+        message: `${exp.kind} "${exp.name}" is imported by ${describeConsumers(independent, sourceRoot2)} without using the code in this file. Extract it to a types/ or schemas/ folder. See docs/code-organization-guide/rules/types-and-schemas-rule.md`
+      });
+    }
+    if (findings.length === 0) return {};
+    return {
+      Program(node) {
+        for (const finding of findings) {
+          context.report({ node, loc: { line: finding.line, column: 0 }, message: finding.message });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/locale-placement.ts
+import path28 from "path";
+import { readFileSync as readFileSync2 } 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());
+var FORCED_TOP_LEVEL = /* @__PURE__ */ new Set(["app", "shared", "compositions", "config"]);
+function forcesTopLevel(segments) {
+  return FORCED_TOP_LEVEL.has(segments[0] ?? "") || SUPPORT_FOLDERS2.has(segments[0] ?? "");
+}
+function localePlacement(text) {
+  const sourceFile = ts5.createSourceFile("locales.ts", text, ts5.ScriptTarget.Latest, true, ts5.ScriptKind.TS);
+  for (const statement of sourceFile.statements) {
+    if (!ts5.isVariableStatement(statement)) continue;
+    const isExported2 = (ts5.getModifiers(statement) ?? []).some(
+      (modifier) => modifier.kind === ts5.SyntaxKind.ExportKeyword
+    );
+    if (!isExported2) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts5.isIdentifier(declaration.name) || declaration.name.text !== "locales") continue;
+      if (!declaration.initializer || !ts5.isObjectLiteralExpression(declaration.initializer)) continue;
+      const placement = /* @__PURE__ */ new Map();
+      for (const property of declaration.initializer.properties) {
+        if (!ts5.isPropertyAssignment(property)) continue;
+        let name;
+        if (ts5.isIdentifier(property.name)) name = property.name.text;
+        else if (ts5.isStringLiteral(property.name)) name = property.name.text;
+        if (name === void 0) continue;
+        const line = sourceFile.getLineAndCharacterOfPosition(property.getStart(sourceFile)).line + 1;
+        placement.set(name, {
+          kind: ts5.isObjectLiteralExpression(property.initializer) ? "nested" : "top",
+          line
+        });
+      }
+      return placement;
+    }
+  }
+  return void 0;
+}
+var localePlacementRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require shared locales at the top level and single-feature locales in a namespaced object."
+    }
+  },
+  create(context) {
+    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);
+    if (!index) return {};
+    const localesFile = [...index.modules.keys()].find((candidate) => {
+      const candidateSegments = segmentsOf(candidate, sourceRoot2);
+      return candidateSegments.length === 2 && candidateSegments[0] === "locales" && candidateSegments[1]?.startsWith("index.");
+    });
+    if (!localesFile || file !== localesFile) return {};
+    const placement = localePlacement(readFileSync2(localesFile, "utf8"));
+    if (!placement) return {};
+    const keyReaders = /* @__PURE__ */ new Map();
+    const keyFeatures = /* @__PURE__ */ new Map();
+    const keyForcedTopLevel = /* @__PURE__ */ new Set();
+    for (const [candidateFile, module] of index.modules) {
+      if (candidateFile === localesFile) continue;
+      const importsLocales = module.imports.some(
+        (moduleImport) => resolveSpecifier(candidateFile, moduleImport.specifier, sourceRoot2) === localesFile
+      );
+      if (!importsLocales) continue;
+      const candidateSegments = segmentsOf(candidateFile, sourceRoot2);
+      for (const match of readFileSync2(candidateFile, "utf8").matchAll(LOCALE_ACCESS)) {
+        const key = match.groups?.key;
+        if (key === void 0) continue;
+        const readers = keyReaders.get(key) ?? /* @__PURE__ */ new Set();
+        readers.add(candidateFile);
+        keyReaders.set(key, readers);
+        if (candidateSegments[0] === "features" && candidateSegments.length >= 2) {
+          const features = keyFeatures.get(key) ?? /* @__PURE__ */ new Set();
+          features.add(candidateSegments[1] ?? "");
+          keyFeatures.set(key, features);
+        } else if (forcesTopLevel(candidateSegments)) {
+          keyForcedTopLevel.add(key);
+        }
+      }
+    }
+    const findings = [];
+    for (const [key, readers] of keyReaders) {
+      const features = keyFeatures.get(key) ?? /* @__PURE__ */ new Set();
+      const shared = features.size > 1 || keyForcedTopLevel.has(key);
+      const current = placement.get(key);
+      if (shared) {
+        if (current?.kind === "nested") {
+          findings.push({
+            line: current.line,
+            message: `Locale "${key}" is read by ${describeConsumers([...readers], sourceRoot2)} and must live at the top level of locales. See docs/code-organization-guide/rules/locales-rule.md`
+          });
+        }
+        continue;
+      }
+      if (features.size !== 1) continue;
+      const featureName = [...features][0] ?? "";
+      const expected = camelCase(featureName);
+      if (current?.kind === "top") {
+        findings.push({
+          line: current.line,
+          message: `Locale "${key}" is read only by the ${featureName} feature; it must live in an object named "${expected}". See docs/code-organization-guide/rules/locales-rule.md`
+        });
+      } else if (current?.kind === "nested" && key !== expected) {
+        findings.push({
+          line: current.line,
+          message: `Locale "${key}" is read only by the ${featureName} feature; it must live in an object named "${expected}", not "${key}". See docs/code-organization-guide/rules/locales-rule.md`
+        });
+      }
+    }
+    if (findings.length === 0) return {};
+    return {
+      Program(node) {
+        for (const finding of findings) {
+          context.report({ node, loc: { line: finding.line, column: 0 }, message: finding.message });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/shared-style-dedup.ts
+import path29 from "path";
+import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+var CLASS_NAME = /className="(?<classes>[^"]+)"/g;
+var comboCache;
+function combosFor(index) {
+  const files = [...index.modules.keys()].filter((file) => file.endsWith(".tsx") || file.endsWith(".jsx")).sort((left, right) => left.localeCompare(right));
+  let fingerprint2 = "";
+  for (const file of files) {
+    try {
+      fingerprint2 += String(statSync2(file).mtimeMs);
+    } catch {
+      fingerprint2 += "0";
+    }
+  }
+  if (comboCache?.sourceRoot === index.sourceRoot && comboCache.fingerprint === fingerprint2) {
+    return comboCache.combos;
+  }
+  const combos = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const text = readFileSync3(file, "utf8");
+    for (const match of text.matchAll(CLASS_NAME)) {
+      const classes = (match.groups?.classes ?? "").split(/\s+/).filter(Boolean);
+      if (classes.length < 2) continue;
+      const key = [...classes].sort().join(" ");
+      const users = combos.get(key) ?? /* @__PURE__ */ new Set();
+      users.add(file);
+      combos.set(key, users);
+    }
+  }
+  comboCache = { sourceRoot: index.sourceRoot, fingerprint: fingerprint2, combos };
+  return combos;
+}
+var sharedStyleDedupRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require a className combination used by two or more components to become a named custom utility."
+    }
+  },
+  create(context) {
+    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);
+    if (!index) return {};
+    const combos = combosFor(index);
+    const sharedHere = [...combos.entries()].filter(([, users]) => users.size >= 2 && users.has(file)).filter(([, users]) => [...users].sort((left, right) => left.localeCompare(right))[0] === file);
+    if (sharedHere.length === 0) return {};
+    return {
+      Program(node) {
+        for (const [combo, users] of sharedHere) {
+          context.report({
+            node,
+            loc: { line: 1, column: 0 },
+            message: `Class combination "${combo}" is used by ${String(users.size)} components and should change together; create a named custom Tailwind utility for it. See docs/styling-guide/rules/theme-and-utility-definition-rule.md`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/no-eslint-disable.ts
+var noEslintDisableRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Forbid eslint-disable directives."
+    }
+  },
+  create(context) {
+    return {
+      Program() {
+        for (const comment of context.sourceCode.getAllComments()) {
+          if (!comment.value.includes("eslint-disable")) continue;
+          if (!comment.loc) continue;
+          context.report({
+            loc: comment.loc,
+            message: "Do not use eslint-disable directives; fix the reported violation instead."
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/zod-schema-validation.ts
+var NON_SCHEMA_OBJECTS = /* @__PURE__ */ new Set(["JSON", "Date", "Number"]);
+var SCHEMA_METHODS = /* @__PURE__ */ new Set(["safeParse", "parse", "assert"]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isTypePredicate(node) {
+  return node.returnType?.typeAnnotation?.type === "TSTypePredicate";
+}
+function guardsUnknown(node) {
+  return (node.params ?? []).some((param) => {
+    if (!isRecord(param)) return false;
+    const typeAnnotation = param.typeAnnotation;
+    if (!isRecord(typeAnnotation)) return false;
+    const annotation = typeAnnotation.typeAnnotation;
+    if (!isRecord(annotation)) return false;
+    return annotation.type === "TSUnknownKeyword" || annotation.type === "TSAnyKeyword";
+  });
+}
+function delegatesToSchema(node) {
+  if (Array.isArray(node)) return node.some(delegatesToSchema);
+  if (!isRecord(node)) return false;
+  if (node.type === "CallExpression") {
+    const callee = node.callee;
+    if (isRecord(callee) && callee.type === "MemberExpression") {
+      const property = callee.property;
+      const object = callee.object;
+      if (isRecord(property) && property.type === "Identifier" && typeof property.name === "string" && SCHEMA_METHODS.has(property.name) && // A named object is only a schema if it is not a known non-schema
+      // object (JSON.parse, Date.parse, ...); any other callee (a call, a
+      // member chain) is a delegation to whatever returns it.
+      !(isRecord(object) && object.type === "Identifier" && typeof object.name === "string" && NON_SCHEMA_OBJECTS.has(object.name))) {
+        return true;
+      }
+    }
+  }
+  for (const key of Object.keys(node)) {
+    if (key === "callee" || key === "parent") continue;
+    if (delegatesToSchema(node[key])) return true;
+  }
+  return false;
+}
+var zodSchemaValidationRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require Zod schemas for runtime validation instead of hand-written type guards."
+    }
+  },
+  create(context) {
+    function checkFunction(node) {
+      if (!isTypePredicate(node)) return;
+      if (!guardsUnknown(node)) return;
+      if (delegatesToSchema(node.body)) return;
+      context.report({
+        loc: node.loc ?? { line: 1, column: 0 },
+        message: "This hand-written type guard validates an unknown value ad hoc. Use a Zod schema instead: schema.safeParse(value) returns a discriminated result whose .success narrows the type. See docs/agent-policy.md"
+      });
+    }
+    return {
+      FunctionDeclaration(node) {
+        checkFunction(node);
+      },
+      FunctionExpression(node) {
+        checkFunction(node);
+      },
+      ArrowFunctionExpression(node) {
+        checkFunction(node);
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/source-under-src.ts
+import path30 from "path";
+var NON_SOURCE_ROOT_DIRS = /* @__PURE__ */ new Set([
+  ".agents",
+  ".cache",
+  ".github",
+  ".husky",
+  ".next",
+  ".tmp",
+  ".turbo",
+  ".vercel",
+  ".vulyk",
+  "__tests__",
+  "assets",
+  "bin",
+  "build",
+  "cli",
+  "coverage",
+  "dist",
+  "docs",
+  "enforcement",
+  "eslint",
+  "node_modules",
+  "public",
+  "static",
+  "test",
+  "tests",
+  "tmp",
+  "vendor"
+]);
+var MODULE_EXTENSION = /\.(?:cjs|cts|js|jsx|mjs|mts|ts|tsx)$/;
+var CONFIG_FILE = /^[\w.-]+\.config\.(?:cjs|cts|js|jsx|mjs|mts|ts|tsx)$/;
+var DECLARATION_FILE = /\.d\.(?:cjs|cts|mts|ts)$/;
+var sourceUnderSrcRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Report application source files that live outside src/."
+    }
+  },
+  create(context) {
+    const filename = path30.resolve(context.filename);
+    if (!MODULE_EXTENSION.test(filename)) return {};
+    const relative = path30.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 = path30.basename(filename);
+      if (CONFIG_FILE.test(basename) || DECLARATION_FILE.test(basename) || basename.startsWith(".")) return {};
+    }
+    return {
+      Program(node) {
+        context.report({
+          node,
+          loc: { line: 1, column: 0 },
+          message: `Application source must live under src/. Move "${relative}" under src/.`
+        });
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/helpers.ts
+var RFC_PATTERN = /\b(?<keyword>MUST NOT|MUST|SHALL NOT|SHALL|SHOULD NOT|SHOULD|MAY|RECOMMENDED|NOT RECOMMENDED|OPTIONAL|REQUIRED)\b/;
+function containsRfcKeyword(text) {
+  const match = RFC_PATTERN.exec(text);
+  return match?.groups?.keyword ?? null;
+}
+function getFilename(context) {
+  return context.filename;
+}
+function getTextContent(node) {
+  if ("value" in node && typeof node.value === "string") return node.value;
+  if ("children" in node) {
+    return node.children.map(getTextContent).join("");
+  }
+  return "";
+}
+function getLine(node) {
+  return node.position?.start.line ?? 0;
+}
+
+// eslint/pasika/rules/md/doc-kind-suffix.ts
+var docKindSuffixRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Documentation files must have a -guide, -rule, -reference, or -policy suffix.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith(".md")) return;
+        if (filename.endsWith("-guide.md") || filename.endsWith("-rule.md") || filename.endsWith("-reference.md") || filename.endsWith("-policy.md")) {
+          return;
+        }
+        context.report({
+          node,
+          message: "file name carries no -guide, -rule, -reference, or -policy suffix"
+        });
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/title-matches-file-name.ts
+import path31 from "path";
+function toExpectedFileName(title) {
+  return `${title.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")}.md`;
+}
+var titleMatchesFileNameRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Document title must match the file name in kebab-case.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      heading(node) {
+        if (node.depth !== 1) return;
+        const filename = getFilename(context);
+        if (!filename.endsWith(".md")) return;
+        const title = getTextContent(node).trim();
+        const expectedFileName = toExpectedFileName(title);
+        const actualFileName = path31.basename(filename);
+        if (!title) {
+          context.report({
+            node,
+            message: "document has no `# Title` heading"
+          });
+        } else if (expectedFileName !== actualFileName) {
+          context.report({
+            node,
+            message: `title "${title}" expects file name ${expectedFileName}`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/overview-present.ts
+var overviewPresentRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Overview must follow the title in a documentation file.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith(".md")) return;
+        let titleLine = 0;
+        for (const child of node.children) {
+          if (child.type === "heading" && child.depth === 1) {
+            titleLine = getLine(child);
+            break;
+          }
+        }
+        if (!titleLine) return;
+        let hasOverview = false;
+        for (const child of node.children) {
+          if (child.type === "paragraph" && getLine(child) > titleLine && getTextContent(child).trim()) {
+            hasOverview = true;
+            break;
+          }
+        }
+        if (!hasOverview) {
+          context.report({
+            node,
+            message: "no overview follows the title"
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/overview-length.ts
+function countSentences(text) {
+  return text.split(/[.!?](?:\s+|$)/).filter((part) => part.trim() !== "").length;
+}
+var overviewLengthRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Overview must contain at most two sentences.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith(".md")) return;
+        let titleLine = 0;
+        for (const child of node.children) {
+          if (child.type === "heading" && child.depth === 1) {
+            titleLine = getLine(child);
+            break;
+          }
+        }
+        if (!titleLine) return;
+        for (const child of node.children) {
+          if (child.type !== "paragraph" || getLine(child) <= titleLine) continue;
+          const text = getTextContent(child).trim();
+          if (!text || text.startsWith("#")) continue;
+          const sentenceCount = countSentences(text);
+          if (sentenceCount > 2) {
+            context.report({
+              node: child,
+              message: `overview uses ${String(sentenceCount)} sentences, at most two are allowed`
+            });
+          }
+          break;
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/guide-overview-no-links.ts
+function containsLink(node) {
+  if (node.type === "link") return true;
+  if ("children" in node) {
+    return node.children.some(containsLink);
+  }
+  return false;
+}
+var guideOverviewNoLinksRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Guide overview must not link to other documents.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-guide.md")) return;
+        let titleLine = 0;
+        for (const child of node.children) {
+          if (child.type === "heading" && child.depth === 1) {
+            titleLine = getLine(child);
+            break;
+          }
+        }
+        if (!titleLine) return;
+        for (const child of node.children) {
+          if (child.type !== "paragraph" || getLine(child) <= titleLine) continue;
+          const text = getTextContent(child).trim();
+          if (!text || text.startsWith("#")) continue;
+          if (containsLink(child)) {
+            context.report({
+              node: child,
+              message: "guide overview links another document"
+            });
+          }
+          break;
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/guide-step-single-sentence.ts
+function countSentences2(text) {
+  return text.split(/[.!?](?:\s+|$)/).filter((part) => part.trim() !== "").length;
+}
+var guideStepSingleSentenceRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Each guide step must be concise and use one sentence.",
+      recommended: true
+    }
+  },
+  create(context) {
+    const listsOnPath = [];
+    return {
+      list(node) {
+        listsOnPath.push(node);
+      },
+      "list:exit"() {
+        listsOnPath.pop();
+      },
+      listItem(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-guide.md")) return;
+        if (!listsOnPath.at(-1)?.ordered) return;
+        const text = getTextContent(node).trim();
+        const sentenceCount = countSentences2(text);
+        if (sentenceCount > 1) {
+          context.report({
+            node,
+            message: `step uses ${String(sentenceCount)} sentences`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/guide-step-single-link.ts
+function countDocLinks(node) {
+  if (node.type === "link" && node.url.endsWith(".md")) return 1;
+  if ("children" in node) {
+    return node.children.reduce((sum, child) => sum + countDocLinks(child), 0);
+  }
+  return 0;
+}
+function visitSteps(node, check) {
+  if (node.type === "list" && node.ordered) {
+    for (const child of node.children) check(child);
+  }
+  if ("children" in node) {
+    for (const child of node.children) visitSteps(child, check);
+  }
+}
+var guideStepSingleLinkRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Each guide step must link at most one document total.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-guide.md")) return;
+        visitSteps(node, (item) => {
+          const links = countDocLinks(item);
+          if (links > 1) {
+            context.report({
+              node: item,
+              message: `step links ${String(links)} documents`
+            });
+          }
+        });
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/guide-states-no-requirement.ts
+var guideStatesNoRequirementRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Guide must not state requirements with RFC 2119 vocabulary.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      listItem(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-guide.md")) return;
+        const text = getTextContent(node);
+        if (containsRfcKeyword(text)) {
+          context.report({
+            node,
+            message: "guide states a requirement with RFC 2119 vocabulary"
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/requirement-present.ts
+function hasRequirement(node) {
+  if (node.type === "listItem") {
+    if (containsRfcKeyword(getTextContent(node))) return true;
+  }
+  if ("children" in node) {
+    for (const child of node.children) {
+      if (hasRequirement(child)) return true;
+    }
+  }
+  return false;
+}
+var requirementPresentRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Rule and policy documents must state at least one requirement.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-rule.md") && !filename.endsWith("-policy.md")) {
+          return;
+        }
+        if (!hasRequirement(node)) {
+          const kind = filename.endsWith("-rule.md") ? "rule" : "policy";
+          context.report({
+            node,
+            message: `${kind} document states no requirement`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/rule-paired-examples.ts
+var rulePairedExamplesRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Rule must have paired Incorrect/Correct examples.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-rule.md")) return;
+        const exampleHeadings = [];
+        for (const child of node.children) {
+          if (child.type === "heading" && child.depth === 2) {
+            const text = getTextContent(child).trim();
+            if (/^(?:Incorrect|Correct)\b/.test(text)) {
+              exampleHeadings.push({ line: getLine(child), text });
+            }
+          }
+        }
+        const incorrect = exampleHeadings.filter((h) => h.text.startsWith("Incorrect"));
+        const correct = exampleHeadings.filter((h) => h.text.startsWith("Correct"));
+        if (incorrect.length === 0 || incorrect.length !== correct.length) {
+          context.report({
+            node,
+            message: `${String(incorrect.length)} Incorrect and ${String(correct.length)} Correct examples`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/example-heading-description.ts
+var exampleHeadingDescriptionRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Example headings must have an em-dash description.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      heading(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-rule.md")) return;
+        if (node.depth !== 2) return;
+        const text = getTextContent(node).trim();
+        if (!/^(?:Incorrect|Correct)\b/.test(text)) return;
+        if (!/^(?:Incorrect|Correct) — .+/.test(text)) {
+          context.report({
+            node,
+            message: `example heading has no em-dash description: ${text}`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/policy-no-examples.ts
+var policyNoExamplesRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Policy document must not contain Incorrect/Correct examples.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      heading(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-policy.md")) return;
+        if (node.depth !== 2) return;
+        const text = getTextContent(node).trim();
+        if (/^(?:Incorrect|Correct)\b/.test(text)) {
+          context.report({
+            node,
+            message: `policy document contains an example: ${text}`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/no-cross-document-link.ts
+function linkedKind(filename) {
+  if (filename.endsWith("-rule.md")) return "rule";
+  if (filename.endsWith("-reference.md")) return "reference";
+  if (filename.endsWith("-policy.md")) return "policy";
+  return void 0;
+}
+var noCrossDocumentLinkRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Rules, references, and policy must not link to other documents.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      link(node) {
+        const filename = getFilename(context);
+        const kind = linkedKind(filename);
+        if (!kind) return;
+        if (node.url.endsWith(".md")) {
+          context.report({
+            node,
+            message: `${kind} links another document: ${node.url}`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/reference-no-rfc-vocabulary.ts
+var referenceNoRfcVocabularyRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Reference documents must not use RFC 2119 vocabulary (MUST, MUST NOT, SHOULD, SHOULD NOT, MAY) in prose.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      text(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-reference.md")) return;
+        const keyword = containsRfcKeyword(node.value);
+        if (keyword) {
+          context.report({
+            node,
+            message: `reference uses RFC 2119 vocabulary: ${keyword}`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/reference-block-headings.ts
+var referenceBlockHeadingsRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Reference block headings rule.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-reference.md")) return;
+        const sectionHeadings = [];
+        for (const child of node.children) {
+          if (child.type === "heading" && child.depth >= 2) {
+            sectionHeadings.push(child);
+          }
+        }
+        if (sectionHeadings.length === 1) {
+          context.report({
+            node: node.children[0] ?? node,
+            message: "reference has exactly one section heading, so either a single block is headed or a first block is not"
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/support-document-placement.ts
+import path32 from "path";
+var supportDocumentPlacementRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Rules must live in rules/, references must live in references/.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith(".md")) return;
+        const parentFolder = path32.basename(path32.dirname(filename));
+        if (filename.endsWith("-rule.md") && parentFolder !== "rules") {
+          context.report({
+            node,
+            message: `rule lives in "${parentFolder}/" instead of "rules/"`
+          });
+        }
+        if (filename.endsWith("-reference.md") && parentFolder !== "references") {
+          context.report({
+            node,
+            message: `reference lives in "${parentFolder}/" instead of "references/"`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/no-template-prompt.ts
+var TEMPLATE_PROMPT = /^\s*\[[A-Z0-9].*\]\s*$/;
+var noTemplatePromptRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "No leftover bracketed template prompts.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      text(node) {
+        if (TEMPLATE_PROMPT.test(node.value)) {
+          context.report({
+            node,
+            message: "leftover bracketed template prompt"
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/guide-folder-entry-point.ts
+import path34 from "path";
+
+// eslint/pasika/rules/md/project-index.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
+import path33 from "path";
+var KIND_BY_SUFFIX = [
+  ["-rule.md", "rule"],
+  ["-guide.md", "guide"],
+  ["-reference.md", "reference"],
+  ["-policy.md", "policy"]
+];
+function listMarkdownFiles(dir) {
+  return readdirSync2(dir).flatMap((entry) => {
+    const entryPath = path33.join(dir, entry);
+    if (statSync3(entryPath).isDirectory()) {
+      return entry.startsWith("_") ? [] : listMarkdownFiles(entryPath);
+    }
+    return entry.endsWith(".md") ? [entryPath] : [];
+  });
+}
+function extractTitle(filePath) {
+  const content = readFileSync4(filePath, "utf8");
+  const match = /^# (?<title>.+)$/m.exec(content);
+  return match?.groups?.title?.trim() ?? "";
+}
+var cache2 = /* @__PURE__ */ new Map();
+function getProjectDocs(docsRoot) {
+  const cached = cache2.get(docsRoot);
+  if (cached) return cached;
+  const files = listMarkdownFiles(docsRoot);
+  const docs = files.sort((a, b) => a.localeCompare(b)).map((filePath) => {
+    const fileName = path33.basename(filePath);
+    const kind = KIND_BY_SUFFIX.find(([suffix]) => fileName.endsWith(suffix))?.[1];
+    return {
+      filePath,
+      doc: path33.relative(docsRoot, filePath).split(path33.sep).join("/"),
+      fileName,
+      kind,
+      title: extractTitle(filePath)
+    };
+  });
+  cache2.set(docsRoot, docs);
+  return docs;
+}
+function findDocsRoot(filePath) {
+  let dir = path33.dirname(filePath);
+  for (; ; ) {
+    if (path33.basename(dir) === "docs" && statSync3(dir).isDirectory()) {
+      return dir;
+    }
+    const parent = path33.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+
+// eslint/pasika/rules/md/guide-folder-entry-point.ts
+var guideFolderEntryPointRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Guide folders must have an entry point.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith(".md")) return;
+        const docsRoot = findDocsRoot(filename);
+        if (!docsRoot) return;
+        const docs = getProjectDocs(docsRoot);
+        const guideFolders = new Set(
+          docs.filter((doc) => ["rules", "references"].includes(path34.basename(path34.dirname(doc.filePath)))).map((doc) => path34.dirname(path34.dirname(doc.filePath))).filter((folder) => path34.resolve(folder) !== path34.resolve(docsRoot))
+        );
+        const currentDir = path34.dirname(filename);
+        if (guideFolders.has(currentDir)) {
+          const expectedEntryPoint = `${path34.basename(currentDir)}.md`;
+          const hasEntryPoint = docs.some(
+            (doc) => doc.kind === "guide" && path34.dirname(doc.filePath) === currentDir && doc.fileName === expectedEntryPoint
+          );
+          if (!hasEntryPoint) {
+            context.report({
+              node,
+              message: `folder holds support documents but has no ${expectedEntryPoint} entry point`
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/rfc-only-in-bullets.ts
+function checkOutsideBullets(node, context, insideBullet) {
+  if (node.type === "listItem") {
+    for (const child of node.children) {
+      checkOutsideBullets(child, context, true);
+    }
+    return;
+  }
+  if (node.type === "text") {
+    const keyword = containsRfcKeyword(node.value);
+    if (keyword && !insideBullet) {
+      context.report({
+        node,
+        message: `RFC 2119 vocabulary "${keyword}" appears outside a bullet point`
+      });
+    }
+    return;
+  }
+  if ("children" in node) {
+    for (const child of node.children) {
+      checkOutsideBullets(child, context, insideBullet);
+    }
+  }
+}
+var rfcOnlyInBulletsRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "RFC 2119 vocabulary must appear only in bullet points.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-rule.md")) return;
+        checkOutsideBullets(node, context, false);
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/policy-subject-headings.ts
+var policySubjectHeadingsRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Policy document must group its bullets under a heading per subject.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-policy.md")) return;
+        let titleLine = 0;
+        let firstSubjectLine = 0;
+        let overviewLine = 0;
+        let foundTitle = false;
+        let foundOverview = false;
+        for (const child of node.children) {
+          const line = getLine(child);
+          if (!foundTitle && child.type === "heading" && child.depth === 1) {
+            titleLine = line;
+            foundTitle = true;
+            continue;
+          }
+          if (!foundTitle) continue;
+          if (!foundOverview && child.type === "paragraph" && line > titleLine) {
+            overviewLine = line;
+            foundOverview = true;
+            continue;
+          }
+          if (!firstSubjectLine && child.type === "heading" && child.depth === 2 && line > titleLine) {
+            firstSubjectLine = line;
+          }
+        }
+        if (!titleLine || !firstSubjectLine) return;
+        const hasUngroupedBullet = node.children.some((child) => {
+          if (child.type !== "list") return false;
+          const line = getLine(child);
+          return line > overviewLine && line < firstSubjectLine;
+        });
+        if (hasUngroupedBullet) {
+          context.report({
+            node,
+            message: "policy bullet appears before the first subject heading"
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/guide-link-anchors.ts
+function visitSteps2(node, check) {
+  if (node.type === "list" && node.ordered) {
+    for (const child of node.children) check(child);
+  }
+  if ("children" in node) {
+    for (const child of node.children) visitSteps2(child, check);
+  }
+}
+function collectGuideLinks(node) {
+  if (node.type === "link" && node.url.endsWith("-guide.md")) return [node];
+  if ("children" in node) {
+    return node.children.flatMap(collectGuideLinks);
+  }
+  return [];
+}
+var guideLinkAnchorsRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "A step that links another Guide must link directly to a How To section.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-guide.md")) return;
+        visitSteps2(node, (item) => {
+          for (const link of collectGuideLinks(item)) {
+            if (!link.url.includes("#")) {
+              context.report({
+                node: link,
+                message: `guide link ${link.url} does not point to a specific section`
+              });
+            }
+          }
+        });
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/no-nested-how-to.ts
+var noNestedHowToRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "How To sections must not nest inside other How To sections.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-guide.md")) return;
+        const howToHeadings = [];
+        for (const child of node.children) {
+          if (child.type !== "heading") continue;
+          const text = getTextContent(child).trim();
+          if (!/^How To\b/.test(text)) continue;
+          howToHeadings.push({ line: getLine(child), depth: child.depth, text });
+        }
+        for (let i = 1; i < howToHeadings.length; i++) {
+          const prev = howToHeadings[i - 1];
+          const current = howToHeadings[i];
+          if (prev && current && current.depth > prev.depth) {
+            context.report({
+              node,
+              message: `How To section "${current.text}" nests inside another How To section`
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/glossary-term-linking.ts
+import { readFileSync as readFileSync5 } from "fs";
+import path35 from "path";
+function extractGlossaryTerms(filePath) {
+  const content = readFileSync5(filePath, "utf8");
+  const terms = [];
+  const headingPattern = /^## (?<term>.+)$/gm;
+  let match;
+  while ((match = headingPattern.exec(content)) !== null) {
+    const term = match.groups?.term?.trim();
+    if (term) terms.push(term);
+  }
+  return terms;
+}
+function collectSteps(node) {
+  const texts = [];
+  const firstStepLinks = [];
+  if (node.type === "list" && node.ordered) {
+    for (const item of node.children) {
+      texts.push(getTextContent(item));
+      if (firstStepLinks.length === 0) {
+        collectDocLinks(item, firstStepLinks);
+      }
+    }
+  }
+  if ("children" in node) {
+    for (const child of node.children) {
+      const nested = collectSteps(child);
+      texts.push(...nested.texts);
+      if (firstStepLinks.length === 0) firstStepLinks.push(...nested.firstStepLinks);
+    }
+  }
+  return { texts, firstStepLinks };
+}
+function collectDocLinks(node, out) {
+  if (node.type === "link" && node.url.endsWith(".md")) out.push(node.url);
+  if ("children" in node) {
+    for (const child of node.children) collectDocLinks(child, out);
+  }
+}
+var glossaryTermLinkingRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "A Guide whose steps use glossary terms must link that Reference from its first step.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-guide.md")) return;
+        const docsRoot = findDocsRoot(filename);
+        if (!docsRoot) return;
+        const docs = getProjectDocs(docsRoot);
+        const guideDir = path35.dirname(filename);
+        const guideReferences = docs.filter(
+          (doc) => doc.kind === "reference" && path35.dirname(doc.filePath) === guideDir
+        );
+        if (guideReferences.length === 0) return;
+        const glossaryTerms = [];
+        for (const ref of guideReferences) {
+          glossaryTerms.push(...extractGlossaryTerms(ref.filePath));
+        }
+        if (glossaryTerms.length === 0) return;
+        const { texts: stepTexts, firstStepLinks } = collectSteps(node);
+        const usedTerms = glossaryTerms.filter((term) => stepTexts.some((text) => text.includes(term)));
+        if (usedTerms.length === 0) return;
+        const hasRefLink = firstStepLinks.some((link) => guideReferences.some((ref) => link.includes(ref.fileName)));
+        if (!hasRefLink) {
+          context.report({
+            node,
+            message: `guide uses glossary terms (${usedTerms.join(", ")}) but first step does not link the reference`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/md/index.ts
+var mdRules = {
+  "doc-kind-suffix": docKindSuffixRule,
+  "title-matches-file-name": titleMatchesFileNameRule,
+  "overview-present": overviewPresentRule,
+  "overview-length": overviewLengthRule,
+  "guide-overview-no-links": guideOverviewNoLinksRule,
+  "guide-step-single-sentence": guideStepSingleSentenceRule,
+  "guide-step-single-link": guideStepSingleLinkRule,
+  "guide-states-no-requirement": guideStatesNoRequirementRule,
+  "requirement-present": requirementPresentRule,
+  "rule-paired-examples": rulePairedExamplesRule,
+  "example-heading-description": exampleHeadingDescriptionRule,
+  "policy-no-examples": policyNoExamplesRule,
+  "no-cross-document-link": noCrossDocumentLinkRule,
+  "reference-no-rfc-vocabulary": referenceNoRfcVocabularyRule,
+  "reference-block-headings": referenceBlockHeadingsRule,
+  "support-document-placement": supportDocumentPlacementRule,
+  "no-template-prompt": noTemplatePromptRule,
+  "guide-folder-entry-point": guideFolderEntryPointRule,
+  "rfc-only-in-bullets": rfcOnlyInBulletsRule,
+  "policy-subject-headings": policySubjectHeadingsRule,
+  "guide-link-anchors": guideLinkAnchorsRule,
+  "no-nested-how-to": noNestedHowToRule,
+  "glossary-term-linking": glossaryTermLinkingRule
+};
+
+// eslint/pasika/rules/css/helpers.ts
+function walkNodes(node, visit) {
+  visit(node);
+  if ("children" in node && node.children) {
+    for (const child of node.children) walkNodes(child, visit);
+  }
+  if ("prelude" in node && node.prelude) {
+    walkNodes(node.prelude, visit);
+  }
+  if ("block" in node && node.block) {
+    walkNodes(node.block, visit);
+  }
+}
+function atrules(node) {
+  const result = [];
+  walkNodes(node, (current) => {
+    if (current.type === "Atrule") result.push(current);
+  });
+  return result;
+}
+function atrulesNamed(node, name) {
+  return atrules(node).filter((candidate) => candidate.type === "Atrule" && candidate.name === name);
+}
+function blockChildren(node) {
+  if (!node) return [];
+  if (!("block" in node) || !node.block) return [];
+  return node.block.children;
+}
+function preludeIdentifiers(node) {
+  if (!node) return [];
+  if (!("prelude" in node) || !node.prelude) return [];
+  const names = [];
+  walkNodes(node.prelude, (current) => {
+    if (current.type === "Identifier") names.push(current.name);
+    if (current.type === "Layer") names.push(current.name);
+  });
+  return names;
+}
+function rules(node) {
+  const result = [];
+  walkNodes(node, (current) => {
+    if (current.type === "Rule") result.push(current);
+  });
+  return result;
+}
+function selectorNames(node) {
+  if (!node) return [];
+  if (!("prelude" in node) || !node.prelude) return [];
+  const names = [];
+  walkNodes(node.prelude, (current) => {
+    if (current.type === "PseudoClassSelector" || current.type === "TypeSelector" || current.type === "ClassSelector") {
+      names.push(current.name);
+    }
+  });
+  return names;
+}
+
+// eslint/pasika/rules/css/theme-reset.ts
+var themeResetRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require Tailwind's default theme reset --*: initial."
+    }
+  },
+  create(context) {
+    return {
+      "StyleSheet:exit"(node) {
+        const resetFound = atrulesNamed(node, "theme").some(
+          (theme) => blockChildren(theme).some((child) => {
+            if (child.type === "Declaration") return child.property.startsWith("--*");
+            if (child.type === "Raw") return child.value.includes("--*: initial");
+            return false;
+          })
+        );
+        if (!resetFound) {
+          context.report({
+            node,
+            message: "The global stylesheet must reset Tailwind's default theme with --*: initial inside an @theme block."
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/css/root-variables.ts
+var rootVariablesRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require styling values to be CSS variables in :root referenced through @theme inline."
+    }
+  },
+  create(context) {
+    return {
+      "StyleSheet:exit"(node) {
+        const hasRootVars = rules(node).some((rule) => {
+          if (!selectorNames(rule).includes("root")) return false;
+          return blockChildren(rule).some((child) => child.type === "Declaration");
+        });
+        if (!hasRootVars) {
+          context.report({
+            node,
+            message: "Styling values must be defined as CSS variables in a :root block."
+          });
+        }
+        const referencingThemes = atrulesNamed(node, "theme").filter(
+          (theme) => blockChildren(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) {
+          context.report({
+            node,
+            message: "Tailwind theme variables that reference CSS variables must use @theme inline."
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/css/apply-usage.ts
+var applyUsageRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require @apply for project style declarations inside global selectors."
+    }
+  },
+  create(context) {
+    return {
+      "StyleSheet:exit"(node) {
+        const layers = node.children.filter((child) => child.type === "Atrule" && child.name === "layer");
+        for (const layer of layers) {
+          for (const child of blockChildren(layer)) {
+            if (child.type !== "Rule") continue;
+            for (const declaration of blockChildren(child)) {
+              if (declaration.type !== "Declaration") continue;
+              context.report({
+                node: declaration,
+                message: `Style declaration "${declaration.property}" inside a global selector must use @apply.`
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/css/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 blockChildren(layer)) {
+            if (child.type !== "Rule") continue;
+            if (!selectorNames(child).includes("body")) continue;
+            for (const declaration of blockChildren(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/pasika/rules/css/stylesheet-ordering.ts
+var SECTION_ORDER = ["imports", "custom-variant", "root", "theme", "utility", "base styles", "keyframes"];
+var stylesheetOrderingRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require the global stylesheet sections in the documented order."
+    }
+  },
+  create(context) {
+    return {
+      "StyleSheet:exit"(node) {
+        const sections = [];
+        let index = 0;
+        for (const child of node.children) {
+          if (child.type === "Atrule" && child.name === "import") {
+            sections.push({ name: "imports", at: index });
+          } else if (child.type === "Atrule" && child.name === "custom-variant") {
+            sections.push({ name: "custom-variant", at: index });
+          } else if (child.type === "Atrule" && child.name === "theme") {
+            sections.push({ name: "theme", at: index });
+          } else if (child.type === "Atrule" && child.name === "utility") {
+            sections.push({ name: "utility", at: index });
+          } else if (child.type === "Atrule" && child.name === "keyframes") {
+            sections.push({ name: "keyframes", at: index });
+          } else if (child.type === "Atrule" && child.name === "layer") {
+            if (preludeIdentifiers(child).includes("base")) {
+              sections.push({ name: "base styles", at: index });
+            }
+          } else if (child.type === "Rule" && selectorNames(child).includes("root")) {
+            sections.push({ name: "root", at: index });
+          }
+          index += 1;
+        }
+        const firstAt = /* @__PURE__ */ new Map();
+        for (const section of sections) {
+          if (!firstAt.has(section.name)) firstAt.set(section.name, section.at ?? 0);
+        }
+        let lastSeen = -1;
+        for (const name of SECTION_ORDER) {
+          const at = firstAt.get(name);
+          if (at === void 0) continue;
+          if (at < lastSeen) {
+            context.report({
+              node,
+              message: `Global stylesheet sections must be ordered: imports, @custom-variant, :root, @theme, custom utilities, base styles, keyframes. Found "${name}" before an earlier section.`
+            });
+            return;
+          }
+          lastSeen = at;
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/css/css-variable-naming.ts
+var cssVariableNamingRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require background variables to end in -canvas and text variables to end in -ink."
+    }
+  },
+  create(context) {
+    return {
+      Declaration(node) {
+        const property = node.property;
+        if (!property.startsWith("--")) 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 (lower.includes("text") && !lower.endsWith("-ink")) {
+          context.report({
+            node,
+            message: `CSS variable "${property}" looks like a text token; name it --<role>-ink instead.`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/css/custom-utility-apply.ts
+function rawProperty(raw) {
+  const match = /^\s*(?<property>[a-z][a-z-]*)\s*:/.exec(raw);
+  return match?.groups?.property;
+}
+var customUtilityApplyRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require @utility blocks to style through @apply."
+    }
+  },
+  create(context) {
+    return {
+      "StyleSheet:exit"(node) {
+        for (const utility of atrulesNamed(node, "utility")) {
+          for (const child of blockChildren(utility)) {
+            if (child.type === "Atrule" && child.name === "apply") continue;
+            if (child.type === "Declaration") {
+              context.report({
+                node: child,
+                message: `Custom utility must use @apply for styling declaration "${child.property}".`
+              });
+              continue;
+            }
+            if (child.type === "Raw") {
+              const property = rawProperty(child.value);
+              if (property !== void 0) {
+                context.report({
+                  node: child,
+                  message: `Custom utility must use @apply for styling declaration "${property}".`
+                });
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/css/surface-utility.ts
+var surfaceUtilityRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require repeated canvas+ink combinations to become a *-surface utility."
+    }
+  },
+  create(context) {
+    return {
+      "StyleSheet:exit"(node) {
+        const combinations = /* @__PURE__ */ new Map();
+        for (const apply of atrulesNamed(node, "apply")) {
+          const classes = preludeIdentifiers(apply);
+          if (!classes.some((name) => name.includes("canvas")) || !classes.some((name) => name.includes("ink"))) {
+            continue;
+          }
+          const key = [...classes].sort().join(" ");
+          combinations.set(key, (combinations.get(key) ?? 0) + 1);
+        }
+        for (const [combo, count] of combinations) {
+          if (count < 2) continue;
+          context.report({
+            node,
+            message: `Combination "${combo}" appears ${String(count)} times. Create a *-surface custom Tailwind utility for it.`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/css/theme-variable-namespace.ts
+var themeVariableNamespaceRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require utility classes from the same theme namespace to share a prefix."
+    }
+  },
+  create(context) {
+    return {
+      "StyleSheet:exit"(node) {
+        const namespaces = /* @__PURE__ */ new Set();
+        for (const theme of atrulesNamed(node, "theme")) {
+          for (const child of blockChildren(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.`
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/css/global-css-location.ts
+var globalCssLocationRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require project global CSS to live only in the entry point stylesheet."
+    }
+  },
+  create(context) {
+    return {
+      "StyleSheet:exit"(node) {
+        const registersTailwind = node.children.some(
+          (child) => child.type === "Atrule" && child.name === "import" && JSON.stringify(child.prelude).includes("tailwindcss")
+        );
+        if (registersTailwind) return;
+        const hasProjectCss = node.children.some((child) => {
+          if (child.type === "Atrule" && child.name === "import") return false;
+          if (child.type === "Comment") return false;
+          return true;
+        });
+        if (!hasProjectCss) return;
+        context.report({
+          node,
+          message: "Global CSS must live in the global stylesheet entry point that registers Tailwind, not in this file."
+        });
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/css/index.ts
+var cssRules = {
+  "theme-reset": themeResetRule,
+  "root-variables": rootVariablesRule,
+  "apply-usage": applyUsageRule,
+  "base-layer-pair": baseLayerPairRule,
+  "stylesheet-ordering": stylesheetOrderingRule,
+  "css-variable-naming": cssVariableNamingRule,
+  "custom-utility-apply": customUtilityApplyRule,
+  "surface-utility": surfaceUtilityRule,
+  "theme-variable-namespace": themeVariableNamespaceRule,
+  "global-css-location": globalCssLocationRule
+};
+
+// eslint/pasika/rules/json/no-cache-flag.ts
+function memberName(member) {
+  return member.name.type === "String" ? member.name.value : member.name.name;
+}
+var noCacheFlagRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require lint scripts to not pass ESLint's --cache flag."
+    }
+  },
+  create(context) {
+    return {
+      Document(node) {
+        const root = node.body;
+        if (root.type !== "Object") return;
+        const scripts = root.members.find((member) => memberName(member) === "scripts");
+        if (scripts?.value.type !== "Object") return;
+        for (const member of scripts.value.members) {
+          const name = memberName(member);
+          if (name !== "lint" && name !== "fix") continue;
+          if (member.value.type !== "String") continue;
+          if (member.value.value.includes("--cache")) {
+            context.report({
+              node: member,
+              message: "Lint scripts must not pass ESLint's --cache flag because cross-file rules require every file in the run."
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/json/no-vulyk-dependency.ts
+function memberName2(member) {
+  return member.name.type === "String" ? member.name.value : member.name.name;
+}
+var noVulykDependencyRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require vulyk to run as an ephemeral command, not a package.json dependency."
+    }
+  },
+  create(context) {
+    return {
+      Document(node) {
+        const root = node.body;
+        if (root.type !== "Object") return;
+        for (const key of ["dependencies", "devDependencies"]) {
+          const section = root.members.find((member) => memberName2(member) === key);
+          if (section?.value.type !== "Object") continue;
+          const vulyk = section.value.members.find((member) => memberName2(member) === "vulyk");
+          if (vulyk) {
+            context.report({
+              node: vulyk,
+              message: 'Vulyk must not be a package.json dependency. Run it as "npx vulyk@latest" instead.'
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/json/index.ts
+var jsonRules = {
+  "no-cache-flag": noCacheFlagRule,
+  "no-vulyk-dependency": noVulykDependencyRule
+};
+
+// eslint/pasika/index.ts
+var pasikaRules = {
+  "component-placement": componentPlacementRule,
+  "support-file-placement": supportFilePlacementRule,
+  "application-structure": applicationStructureRule,
+  "named-exports": namedExportsRule,
+  "data-testid-case": dataTestIdCaseRule,
+  "support-folder-shape": supportFolderShapeRule,
+  "import-through-index": importThroughIndexRule,
+  "util-file-name": utilFileNameRule,
+  "no-util-barrel": noUtilBarrelRule,
+  "jsx-hygiene": jsxHygieneRule,
+  "interactive-component": interactiveComponentRule,
+  "ui-state": uiStateRule,
+  "filename-case": filenameCaseRule,
+  "import-boundaries": importBoundariesRule,
+  "no-mixed-concerns": noMixedConcernsRule,
+  "no-arbitrary-tailwind": noArbitraryTailwindRule,
+  "enforce-cn-merge": enforceCnMergeRule,
+  "enforce-cva-variant-props": enforceCvaVariantPropsRule,
+  "cva-appearance-props": cvaAppearancePropsRule,
+  "cva-boolean-variants": cvaBooleanVariantsRule,
+  "enforce-barrel-exports": enforceBarrelExportsRule,
+  "cross-feature-import": crossFeatureImportRule,
+  "pure-function-extract": pureFunctionExtractRule,
+  "hook-complexity": hookComplexityRule,
+  "locale-dotted-path": localeDottedPathRule,
+  "locales-location": localesLocationRule,
+  "hook-extraction": hookExtractionRule,
+  "value-extraction": valueExtractionRule,
+  "config-extraction": configExtractionRule,
+  "component-nesting": componentNestingRule,
+  "stay-flat": stayFlatRule,
+  "type-extraction": typeExtractionRule,
+  "locale-placement": localePlacementRule,
+  "shared-style-dedup": sharedStyleDedupRule,
+  "no-eslint-disable": noEslintDisableRule,
+  "zod-schema-validation": zodSchemaValidationRule,
+  "source-under-src": sourceUnderSrcRule
+};
+var pasikaRuleIds = Object.keys(pasikaRules).map((name) => `pasika/${name}`);
+var pasikaMdRuleIds = Object.keys(mdRules).map((name) => `pasika/${name}`);
+var pasikaCssRuleIds = Object.keys(cssRules).map((name) => `pasika/${name}`);
+var pasikaJsonRuleIds = Object.keys(jsonRules).map((name) => `pasika/${name}`);
+var allPasikaRuleIds = [...pasikaRuleIds, ...pasikaMdRuleIds, ...pasikaCssRuleIds, ...pasikaJsonRuleIds];
+var pasikaConfig = {
+  files: ["src/**/*.{cjs,cts,js,jsx,mjs,mts,ts,tsx}"],
+  plugins: {
+    pasika: { rules: pasikaRules }
+  },
+  rules: Object.fromEntries(pasikaRuleIds.map((id) => [id, "error"]))
+};
+export {
+  allPasikaRuleIds,
+  cssRules,
+  jsonRules,
+  mdRules,
+  pasikaConfig,
+  pasikaCssRuleIds,
+  pasikaJsonRuleIds,
+  pasikaMdRuleIds,
+  pasikaRuleIds,
+  pasikaRules
 };