@gaia-harness/lint 0.0.0-stage → 3.0.3

package/dist/index.js

@@ -0,0 +1,1938 @@
+// src/configs/base.ts
+import eslintComments from "@eslint-community/eslint-plugin-eslint-comments/configs";
+import js from "@eslint/js";
+import { configs, plugins, rules } from "eslint-config-airbnb-extended";
+import preferArrowFunctions from "eslint-plugin-prefer-arrow-functions";
+import lodashUnderscore from "eslint-plugin-you-dont-need-lodash-underscore";
+
+// src/configs/restricted-imports.ts
+var RESTRICTED_IMPORT_PATHS = [
+  {
+    importNames: ["FC", "FunctionComponent"],
+    message: "Do not import FC or FunctionComponent from 'react'. Type the props inline: `type ButtonProps = {...}; const Button = ({...}: ButtonProps) => ...`.",
+    name: "react"
+  },
+  {
+    message: "Import from '@conform-to/zod/v4'. The bare '@conform-to/zod' specifier targets Zod v3 and throws at runtime, uncaught by typecheck, lint, and build.",
+    name: "@conform-to/zod"
+  }
+];
+
+// src/configs/base.ts
+var jsConfig = [
+  // ESLint recommended config
+  {
+    name: "js/config",
+    ...js.configs.recommended
+  },
+  // Stylistic plugin
+  plugins.stylistic,
+  // Import X plugin
+  plugins.importX,
+  // Airbnb base recommended config
+  ...configs.base.recommended,
+  // Strict import rules
+  rules.base.importsStrict
+];
+var jsCustomConfig = [
+  {
+    name: "js-custom",
+    rules: {
+      "consistent-return": "off",
+      curly: ["error", "all"],
+      "max-params": "error",
+      "no-param-reassign": "off",
+      // handled by sonarjs
+      "no-undef": "off",
+      "no-unused-vars": "off"
+      // handled by sonarjs
+    }
+  },
+  {
+    files: ["**/*.test.ts?(x)", "**/*.stories.ts?(x)"],
+    name: "test-files/all",
+    rules: {
+      "guard-for-in": "off",
+      "max-params": "off",
+      "no-await-in-loop": "off",
+      "no-plusplus": "off",
+      "no-restricted-syntax": "off"
+    }
+  },
+  {
+    files: [".playwright/**/*.ts?(x)"],
+    name: "playwright/all",
+    rules: {
+      "no-await-in-loop": "off",
+      "no-restricted-syntax": "off"
+    }
+  }
+];
+var typescriptConfig = [
+  // TypeScript ESLint plugin
+  plugins.typescriptEslint,
+  // Airbnb base TypeScript config
+  ...configs.base.typescript,
+  // Strict TypeScript rules
+  rules.typescript.typescriptEslintStrict,
+  rules.typescript.stylistic,
+  // Airbnb React TypeScript config
+  ...configs.react.typescript,
+  {
+    files: ["./*.ts"],
+    name: "root-ts-files",
+    rules: {
+      "global-require": "off",
+      "no-void": "off"
+    }
+  },
+  {
+    files: ["**/*.ts?(x)"],
+    name: "no-void",
+    rules: {
+      "no-void": ["error", { allowAsStatement: true }]
+    }
+  }
+];
+var buildTsEslintConfig = (sourceDir) => [
+  {
+    files: ["**/*.ts?(x)"],
+    name: "typescript/config",
+    rules: {
+      "@typescript-eslint/array-type": ["error", { default: "array" }],
+      "@typescript-eslint/ban-ts-comment": [
+        "error",
+        {
+          minimumDescriptionLength: 10,
+          "ts-check": false,
+          "ts-expect-error": "allow-with-description",
+          "ts-ignore": true,
+          "ts-nocheck": true
+        }
+      ],
+      "@typescript-eslint/consistent-type-definitions": ["error", "type"],
+      "@typescript-eslint/consistent-type-imports": "error",
+      "@typescript-eslint/explicit-module-boundary-types": "off",
+      "@typescript-eslint/method-signature-style": "error",
+      "@typescript-eslint/no-confusing-void-expression": [
+        "error",
+        { ignoreArrowShorthand: true }
+      ],
+      "@typescript-eslint/no-deprecated": "error",
+      "@typescript-eslint/no-floating-promises": [
+        "error",
+        { ignoreIIFE: true, ignoreVoid: true }
+      ],
+      "@typescript-eslint/no-misused-promises": [
+        "error",
+        { checksVoidReturn: false }
+      ],
+      "@typescript-eslint/no-non-null-assertion": "off",
+      "@typescript-eslint/no-throw-literal": "off",
+      "@typescript-eslint/no-unnecessary-boolean-literal-compare": "error",
+      "@typescript-eslint/no-unnecessary-condition": "error",
+      "@typescript-eslint/no-unnecessary-type-conversion": "error",
+      "@typescript-eslint/no-unnecessary-type-parameters": "off",
+      "@typescript-eslint/no-unsafe-argument": "error",
+      "@typescript-eslint/no-unsafe-assignment": "error",
+      "@typescript-eslint/no-unsafe-call": "error",
+      "@typescript-eslint/no-unsafe-member-access": "error",
+      "@typescript-eslint/no-unsafe-return": "error",
+      "@typescript-eslint/only-throw-error": "off",
+      "@typescript-eslint/prefer-nullish-coalescing": "error",
+      "@typescript-eslint/prefer-promise-reject-errors": "off",
+      "@typescript-eslint/restrict-template-expressions": [
+        "error",
+        { allowBoolean: true, allowNumber: true }
+      ],
+      "@typescript-eslint/return-await": "off",
+      "@typescript-eslint/unbound-method": "off"
+    }
+  },
+  {
+    files: [
+      `${sourceDir}/utils/**`,
+      `${sourceDir}/services/**`,
+      `${sourceDir}/hooks/**`
+    ],
+    name: "typescript/explicit-return-types",
+    rules: {
+      "@typescript-eslint/explicit-module-boundary-types": "error"
+    }
+  },
+  {
+    files: ["**/*.test.ts?(x)", "**/*.stories.ts?(x)"],
+    name: "typescript/test-files",
+    rules: {
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-unsafe-argument": "off",
+      "@typescript-eslint/no-unsafe-assignment": "off",
+      "@typescript-eslint/no-unsafe-call": "off",
+      "@typescript-eslint/no-unsafe-member-access": "off"
+    }
+  },
+  {
+    files: ["test/**/*.ts?(x)"],
+    name: "typescript/test-config",
+    rules: {
+      "@typescript-eslint/no-var-requires": "off",
+      "no-plusplus": "off"
+    }
+  },
+  {
+    files: ["**/*.d.ts"],
+    name: "typescript/type-definitions",
+    rules: {
+      "@typescript-eslint/consistent-type-definitions": "off",
+      "@typescript-eslint/method-signature-style": "error",
+      "@typescript-eslint/no-unused-vars": "off"
+    }
+  }
+];
+var NO_UNRESOLVED = [
+  "error",
+  { caseSensitive: true, commonjs: true, ignore: ["^virtual:"] }
+];
+var buildImportXConfig = (sourceDir) => [
+  {
+    name: "import-x-all-files",
+    rules: {
+      "import-x/consistent-type-specifier-style": ["error", "prefer-top-level"],
+      "import-x/extensions": "off",
+      "import-x/no-anonymous-default-export": [
+        "error",
+        {
+          allowArray: true,
+          allowLiteral: true,
+          allowObject: true
+        }
+      ],
+      "import-x/no-namespace": "off",
+      "import-x/no-rename-default": "off",
+      "import-x/no-useless-path-segments": "off",
+      "import-x/order": "off",
+      "import-x/prefer-default-export": "off"
+    }
+  },
+  {
+    files: ["./*.ts"],
+    name: "import-x/root-ts-files",
+    rules: {
+      "import-x/no-extraneous-dependencies": "off",
+      "import-x/no-unresolved": NO_UNRESOLVED,
+      "import-x/prefer-default-export": "off"
+    }
+  },
+  {
+    files: ["**/*.test.ts?(x)", "**/*.stories.ts?(x)"],
+    name: "import-x/test-files",
+    rules: {
+      "import-x/extensions": "off",
+      "import-x/no-extraneous-dependencies": "off"
+    }
+  },
+  {
+    files: [`${sourceDir}/**/*.ts?(x)`],
+    name: "import-x/app-test-files",
+    rules: {
+      "import-x/no-unresolved": NO_UNRESOLVED
+    }
+  },
+  {
+    files: [`${sourceDir}/**/hooks/*.ts?(x)`],
+    name: "import-x/hooks",
+    rules: {
+      "import-x/no-default-export": "error"
+    }
+  },
+  {
+    files: ["test/**/*.ts?(x)"],
+    name: "import-x/test-config-files",
+    rules: {
+      "import-x/no-extraneous-dependencies": "off",
+      "import-x/prefer-default-export": "off"
+    }
+  },
+  {
+    files: [".storybook/**/*.ts?(x)", ".playwright/**/*.ts?(x)"],
+    name: "import-x/storybook-playwright",
+    rules: {
+      "import-x/no-extraneous-dependencies": "off",
+      "import-x/no-unresolved": "off"
+    }
+  }
+];
+var unusedDisableDirectivesConfig = [
+  {
+    linterOptions: { reportUnusedDisableDirectives: "error" },
+    name: "gaia/unused-disable-directives"
+  }
+];
+var eslintCommentsConfig = [
+  {
+    ...eslintComments.recommended,
+    name: "gaia/eslint-comments",
+    rules: {
+      ...eslintComments.recommended.rules,
+      "@eslint-community/eslint-comments/disable-enable-pair": [
+        "error",
+        { allowWholeFile: true }
+      ],
+      "@eslint-community/eslint-comments/require-description": [
+        "error",
+        { ignore: ["eslint-enable"] }
+      ]
+    }
+  }
+];
+var preferArrowFunctionsConfig = [
+  {
+    name: "prefer-arrow",
+    plugins: {
+      "prefer-arrow-functions": preferArrowFunctions
+    },
+    rules: {
+      "prefer-arrow-functions/prefer-arrow-functions": "error"
+    }
+  },
+  {
+    files: ["**/*.d.ts"],
+    name: "ts-definition-files/prefer-arrow-off",
+    rules: {
+      "prefer-arrow-functions/prefer-arrow-functions": "off"
+    }
+  }
+];
+var restrictedSyntaxConfig = [
+  {
+    ignores: ["**/*.d.ts"],
+    name: "gaia/no-restricted-syntax",
+    rules: {
+      "no-restricted-syntax": [
+        "error",
+        {
+          // `prefer-arrow-functions` has a hardcoded exemption for named
+          // default-exported declarations
+          // (`guard.js:hasNameAndIsExportedAsDefaultExport`), so
+          // `export default function Foo() {}` slips through. This selector
+          // closes that gap.
+          message: "Use `const Name = () => {}; export default Name;` instead. The prefer-arrow-functions plugin exempts named default-exported declarations upstream.",
+          selector: "ExportDefaultDeclaration > FunctionDeclaration"
+        },
+        {
+          // GAIA never renders `null`. `cond ? <JSX/> : null` is the
+          // numeric-0-safe `&&` guard written the long way. Both JSX-null
+          // ternary selectors only match a JSXElement/JSXFragment branch, so
+          // they are inert outside `.tsx`/`.jsx`.
+          message: "Do not render `null` from a ternary. Use a boolean-guarded `&&`: `cond && <JSX/>` (coerce a numeric/falsy guard with `!!cond`).",
+          selector: "ConditionalExpression[alternate.raw='null']:matches([consequent.type='JSXElement'], [consequent.type='JSXFragment'])"
+        },
+        {
+          message: "Do not render `null` from a ternary. Invert the condition and use `&&`: `!cond && <JSX/>`.",
+          selector: "ConditionalExpression[consequent.raw='null']:matches([alternate.type='JSXElement'], [alternate.type='JSXFragment'])"
+        },
+        {
+          // A `.length` left operand is always numeric, so `&&` returns the
+          // literal `0` (a renderable value) when the list is empty, leaking
+          // "0" into the DOM. `.length` is the single most common numeric-0
+          // leak and flagging it has zero false positives. The general
+          // `count && <JSX/>` case is caught by `sonarjs/jsx-no-leaked-render`
+          // in `guardrails`, which needs type information; this selector
+          // needs none, so it still holds where types are unavailable.
+          // Report-only: a blind rewrite is unsafe in general.
+          message: 'A numeric `.length` left operand leaks "0" into the DOM when empty. Force a real boolean: `items.length > 0 && <JSX/>`.',
+          selector: "LogicalExpression[operator='&&'][left.property.name='length']:matches([right.type='JSXElement'],[right.type='JSXFragment'])"
+        }
+      ]
+    }
+  }
+];
+var restrictedImportsConfig = [
+  {
+    files: ["**/*.ts?(x)"],
+    name: "gaia/no-restricted-imports",
+    rules: {
+      "no-restricted-imports": ["error", { paths: RESTRICTED_IMPORT_PATHS }]
+    }
+  }
+];
+var lodashUnderscoreConfig = [
+  {
+    name: "you-dont-need-lodash-underscore",
+    plugins: {
+      "you-dont-need-lodash-underscore": lodashUnderscore
+    },
+    rules: {
+      ...lodashUnderscore.configs.compatible.rules
+    }
+  }
+];
+var buildBase = (sourceDir) => [
+  ...jsConfig,
+  ...jsCustomConfig,
+  ...typescriptConfig,
+  ...buildTsEslintConfig(sourceDir),
+  ...buildImportXConfig(sourceDir),
+  ...unusedDisableDirectivesConfig,
+  ...eslintCommentsConfig,
+  ...preferArrowFunctionsConfig,
+  ...restrictedSyntaxConfig,
+  ...restrictedImportsConfig,
+  ...lodashUnderscoreConfig
+];
+
+// src/configs/better-tailwind.ts
+import betterTailwindPlugin from "eslint-plugin-better-tailwindcss";
+var betterTailwind = (opts) => [
+  {
+    name: "better-tailwindcss",
+    plugins: {
+      "better-tailwindcss": betterTailwindPlugin
+    },
+    rules: {
+      // rootFontSize lets a px arbitrary value canonicalize to its scale step
+      // (`w-[16px]` to `w-4`).
+      "better-tailwindcss/enforce-canonical-classes": [
+        "error",
+        { rootFontSize: 16 }
+      ],
+      "better-tailwindcss/enforce-consistent-important-position": "error",
+      "better-tailwindcss/enforce-consistent-variable-syntax": "error",
+      "better-tailwindcss/enforce-shorthand-classes": "error",
+      "better-tailwindcss/no-conflicting-classes": "error",
+      "better-tailwindcss/no-deprecated-classes": "error",
+      "better-tailwindcss/no-unknown-classes": [
+        "error",
+        { ignore: opts.ignore ?? [] }
+      ]
+    },
+    settings: {
+      "better-tailwindcss": {
+        detectComponentClasses: true,
+        entryPoint: opts.entryPoint
+      }
+    }
+  }
+];
+
+// src/configs/guardrails.ts
+import path from "path";
+import noRelativeImportPaths from "eslint-plugin-no-relative-import-paths";
+import * as regexp from "eslint-plugin-regexp";
+import sonarjs from "eslint-plugin-sonarjs";
+
+// src/plugins/cn-conditional.ts
+var findVariable = (scope, name) => {
+  let current = scope;
+  while (current) {
+    const variable = current.set.get(name);
+    if (variable) return variable;
+    current = current.upper;
+  }
+  return void 0;
+};
+var isCnImport = (variable) => variable !== void 0 && variable.defs.length === 1 && variable.defs.every((definition) => {
+  if (definition.type !== "ImportBinding") return false;
+  const specifier = definition.node;
+  return specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "cn" && definition.parent?.type === "ImportDeclaration" && definition.parent.source.value === "cn";
+});
+var isEmptyBranch = (node) => {
+  if (!node) return false;
+  switch (node.type) {
+    case "Identifier":
+      return node.name === "undefined";
+    case "Literal":
+      return node.value === null || node.value === false || node.value === "";
+    case "TemplateLiteral":
+      return node.expressions.length === 0 && node.quasis.every((quasi) => quasi.value.cooked === "");
+    default:
+      return false;
+  }
+};
+var cnConditionalRule = {
+  create: (context) => {
+    const visit = (node) => {
+      if (!node) return;
+      switch (node.type) {
+        case "ArrayExpression":
+          node.elements.forEach((element) => visit(element));
+          break;
+        case "ConditionalExpression":
+          if (isEmptyBranch(node.consequent) || isEmptyBranch(node.alternate)) {
+            context.report({ messageId: "useLogical", node });
+          } else {
+            visit(node.consequent);
+            visit(node.alternate);
+          }
+          break;
+        case "LogicalExpression":
+          if (node.operator === "&&") {
+            visit(node.right);
+          } else {
+            visit(node.left);
+            visit(node.right);
+          }
+          break;
+        case "ObjectExpression":
+          context.report({ messageId: "useLogical", node });
+          break;
+        default:
+          break;
+      }
+    };
+    return {
+      CallExpression: (node) => {
+        if (node.callee.type !== "Identifier") return;
+        const variable = findVariable(
+          context.sourceCode.getScope(node),
+          node.callee.name
+        );
+        if (!isCnImport(variable)) return;
+        node.arguments.forEach((argument) => visit(argument));
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Require conditional classes passed to cn to be written as `cond && 'class'`"
+    },
+    messages: {
+      useLogical: "Write a conditional class as `cond && 'class'` (or `!cond && 'class'`). `cn` does not accept object conditionals or a ternary with an empty branch in GAIA."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var plugin = {
+  meta: {
+    name: "cn-conditional",
+    version: "0.1.0"
+  },
+  rules: {
+    "cn-conditional": cnConditionalRule
+  }
+};
+var cn_conditional_default = plugin;
+
+// src/plugins/no-enum.ts
+var noEnumRule = {
+  create: (context) => ({
+    TSEnumDeclaration: (node) => {
+      context.report({ messageId: "noEnum", node });
+    }
+  }),
+  meta: {
+    docs: { description: "Disallow TypeScript enums" },
+    messages: {
+      noEnum: "Do not use TypeScript enums. Use an object with `as const` instead."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var plugin2 = {
+  meta: {
+    name: "no-enum",
+    version: "0.1.0"
+  },
+  rules: {
+    "no-enum": noEnumRule
+  }
+};
+var no_enum_default = plugin2;
+
+// src/plugins/no-jsx-iife.ts
+var noJsxIifeRule = {
+  create: (context) => ({
+    "JSXExpressionContainer > CallExpression > ArrowFunctionExpression.callee": (node) => {
+      context.report({ messageId: "noJsxIife", node });
+    },
+    "JSXExpressionContainer > CallExpression > FunctionExpression.callee": (node) => {
+      context.report({ messageId: "noJsxIife", node });
+    }
+  }),
+  meta: {
+    docs: { description: "Disallow IIFEs in JSX expressions" },
+    messages: {
+      noJsxIife: "Do not use IIFEs in JSX. Use a computed variable before the return or extract a component instead."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var plugin3 = {
+  meta: {
+    name: "no-jsx-iife",
+    version: "0.1.0"
+  },
+  rules: {
+    "no-jsx-iife": noJsxIifeRule
+  }
+};
+var no_jsx_iife_default = plugin3;
+
+// src/plugins/no-null-render.ts
+var isJsxNode = (node) => node.type === "JSXElement" || node.type === "JSXFragment";
+var noNullRenderRule = {
+  create: (context) => {
+    const stack = [];
+    const enterFunction = (node) => {
+      const frame = { candidates: [], rendersJsx: false };
+      if (node.type === "ArrowFunctionExpression" && isJsxNode(node.body)) {
+        frame.rendersJsx = true;
+      }
+      stack.push(frame);
+    };
+    const exitFunction = () => {
+      const frame = stack.pop();
+      if (!frame || !frame.rendersJsx) {
+        return;
+      }
+      for (const candidate of frame.candidates) {
+        const { argument } = candidate;
+        if (!argument) {
+          continue;
+        }
+        context.report({
+          fix: (fixer) => fixer.replaceText(argument, "undefined"),
+          messageId: "nullRender",
+          node: candidate
+        });
+      }
+    };
+    return {
+      ArrowFunctionExpression: enterFunction,
+      "ArrowFunctionExpression:exit": exitFunction,
+      FunctionDeclaration: enterFunction,
+      "FunctionDeclaration:exit": exitFunction,
+      FunctionExpression: enterFunction,
+      "FunctionExpression:exit": exitFunction,
+      ReturnStatement: (node) => {
+        const frame = stack[stack.length - 1];
+        if (!frame) {
+          return;
+        }
+        const { argument } = node;
+        if (!argument) {
+          return;
+        }
+        if (isJsxNode(argument)) {
+          frame.rendersJsx = true;
+          return;
+        }
+        if (argument.type === "Literal" && argument.value === null && argument.raw === "null") {
+          frame.candidates.push(node);
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Render nothing with `undefined`, not `null`, in render functions"
+    },
+    fixable: "code",
+    messages: {
+      nullRender: "Render nothing with `undefined`, not `null`. GAIA standardizes on `undefined` for the empty render (both are identical to React; this is a consistency convention)."
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+var plugin4 = {
+  meta: {
+    name: "no-null-render",
+    version: "0.1.0"
+  },
+  rules: {
+    "no-null-render": noNullRenderRule
+  }
+};
+var no_null_render_default = plugin4;
+
+// src/plugins/no-switch.ts
+var noSwitchRule = {
+  create: (context) => ({
+    SwitchStatement: (node) => {
+      context.report({ messageId: "noSwitch", node });
+    }
+  }),
+  meta: {
+    docs: { description: "Disallow switch statements" },
+    messages: {
+      noSwitch: "Do not use switch statements. Use an object map or if/else instead."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var plugin5 = {
+  meta: {
+    name: "no-switch",
+    version: "0.1.0"
+  },
+  rules: {
+    "no-switch": noSwitchRule
+  }
+};
+var no_switch_default = plugin5;
+
+// src/plugins/no-zod-enum.ts
+var noZodEnumRule = {
+  create: (context) => ({
+    'CallExpression > MemberExpression.callee[object.name="z"][property.name="enum"]': (node) => {
+      context.report({ messageId: "noZodEnum", node });
+    }
+  }),
+  meta: {
+    docs: { description: "Disallow z.enum(); use z.literal([...]) instead" },
+    messages: {
+      noZodEnum: "Do not use z.enum(). Use z.literal([...]) for string unions (sort values alphanumerically)."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var plugin6 = {
+  meta: {
+    name: "no-zod-enum",
+    version: "0.1.0"
+  },
+  rules: {
+    "no-zod-enum": noZodEnumRule
+  }
+};
+var no_zod_enum_default = plugin6;
+
+// src/configs/guardrails.ts
+var buildSonarConfig = (sourceDir) => [
+  sonarjs.configs.recommended,
+  {
+    name: "sonarjs",
+    rules: {
+      "sonarjs/cognitive-complexity": "error",
+      "sonarjs/fixme-tag": "off",
+      "sonarjs/no-commented-code": "off",
+      "sonarjs/no-nested-conditional": "off",
+      "sonarjs/no-nested-functions": "off",
+      "sonarjs/no-selector-parameter": "off",
+      "sonarjs/regex-complexity": "off",
+      "sonarjs/todo-tag": "off"
+    }
+  },
+  {
+    files: ["**/*.tsx", "**/hooks/*.ts?(x)"],
+    name: "sonarjs/react-files",
+    rules: {
+      "sonarjs/cognitive-complexity": "off",
+      "sonarjs/function-return-type": "off"
+    }
+  },
+  {
+    files: ["**/*.test.ts?(x)", "**/*.stories.ts?(x)"],
+    name: "sonarjs/test-files",
+    rules: {
+      "sonarjs/no-duplicate-string": "off",
+      "sonarjs/no-identical-functions": "off"
+    }
+  },
+  {
+    files: [`${sourceDir}/languages/**/*.ts`, "eslint.config.mjs"],
+    name: "sonarjs/credential-checks",
+    rules: {
+      "sonarjs/no-hardcoded-credentials": "off",
+      "sonarjs/no-hardcoded-passwords": "off"
+    }
+  }
+];
+var regexpConfig = [
+  { ...regexp.configs["flat/recommended"], name: "regexp" }
+];
+var cnConditionalConfig = [
+  {
+    files: ["**/*.ts?(x)", "**/*.js?(x)"],
+    name: "cn-conditional",
+    plugins: { "cn-conditional": cn_conditional_default },
+    rules: { "cn-conditional/cn-conditional": "error" }
+  }
+];
+var noEnumConfig = [
+  {
+    files: ["**/*.ts?(x)"],
+    name: "no-enum",
+    plugins: { "no-enum": no_enum_default },
+    rules: {
+      "no-enum/no-enum": "error"
+    }
+  }
+];
+var noJsxIifeConfig = [
+  {
+    files: ["**/*.tsx", "**/*.jsx"],
+    name: "no-jsx-iife",
+    plugins: { "no-jsx-iife": no_jsx_iife_default },
+    rules: { "no-jsx-iife/no-jsx-iife": "error" }
+  }
+];
+var noNullRenderConfig = [
+  {
+    files: ["**/*.tsx", "**/*.jsx"],
+    name: "no-null-render",
+    plugins: { "no-null-render": no_null_render_default },
+    rules: { "no-null-render/no-null-render": "error" }
+  }
+];
+var noSwitchConfig = [
+  {
+    files: ["**/*.ts?(x)", "**/*.js?(x)"],
+    name: "no-switch",
+    plugins: { "no-switch": no_switch_default },
+    rules: { "no-switch/no-switch": "error" }
+  }
+];
+var noZodEnumConfig = [
+  {
+    files: ["**/*.ts?(x)"],
+    name: "no-zod-enum",
+    plugins: { "no-zod-enum": no_zod_enum_default },
+    rules: { "no-zod-enum/no-zod-enum": "error" }
+  }
+];
+var buildNoRestrictedPathsConfig = (sourceDir) => {
+  const dir = (layer) => `./${sourceDir}/${layer}`;
+  const globDir = (layer) => `./${sourceDir}/${layer}/**`;
+  const routesDir = path.resolve(process.cwd(), sourceDir, "routes").split(path.sep).join("/");
+  const dataEndpoints = [
+    `${routesDir}/actions.*`,
+    `${routesDir}/resources.*`,
+    // Older `+` group folders stay exempt through the 2.x line.
+    `${routesDir}/actions+/**`,
+    `${routesDir}/resources+/**`
+  ];
+  return [
+    {
+      files: [`${sourceDir}/**/!(*.test|*.stories).ts?(x)`],
+      name: "import-x/architecture-boundaries",
+      rules: {
+        "import-x/no-restricted-paths": [
+          "error",
+          {
+            zones: [
+              {
+                except: dataEndpoints,
+                from: [globDir("routes")],
+                message: "Pages may only be imported by routes; a page must not import a route (import direction is routes -> pages -> components). Typed `actions.*`/`resources.*` data-endpoint routes are exempt (the older `actions+`/`resources+` folders are still accepted).",
+                target: dir("pages")
+              },
+              {
+                except: dataEndpoints,
+                from: [globDir("routes"), globDir("pages")],
+                message: "Reusable components must not depend on page- or route-level code (import direction is routes -> pages -> components). Typed `actions.*`/`resources.*` data-endpoint routes are exempt (the older `actions+`/`resources+` folders are still accepted).",
+                target: dir("components")
+              },
+              {
+                except: dataEndpoints,
+                from: [globDir("routes"), globDir("pages"), globDir("components")],
+                message: "Hooks and state sit below the UI tree; they must not import components, pages, or routes. Typed `actions.*`/`resources.*` data-endpoint routes are exempt (the older `actions+`/`resources+` folders are still accepted).",
+                target: [dir("hooks"), dir("state")]
+              },
+              {
+                from: [
+                  dir("routes"),
+                  dir("pages"),
+                  dir("components"),
+                  dir("hooks"),
+                  dir("state")
+                ],
+                message: "The service/data layer sits below the UI and orchestration layers; it must not import components, pages, routes, hooks, or state.",
+                target: dir("services")
+              },
+              {
+                from: [
+                  dir("routes"),
+                  dir("pages"),
+                  dir("components"),
+                  dir("hooks"),
+                  dir("state"),
+                  dir("services")
+                ],
+                message: "Utils are near-leaves; they may import only types and other utils.",
+                target: dir("utils")
+              },
+              {
+                from: [
+                  dir("routes"),
+                  dir("pages"),
+                  dir("components"),
+                  dir("hooks"),
+                  dir("state"),
+                  dir("services"),
+                  dir("utils")
+                ],
+                message: "Types are a pure leaf; they must not import any other app layer.",
+                target: dir("types")
+              }
+            ]
+          }
+        ]
+      }
+    }
+  ];
+};
+var buildNoRelativeImportPathsConfig = (sourceDir) => [
+  {
+    name: "no-relative-import-paths",
+    plugins: {
+      "no-relative-import-paths": noRelativeImportPaths
+    },
+    rules: {
+      "no-relative-import-paths/no-relative-import-paths": [
+        "error",
+        {
+          allowedDepth: 2,
+          allowSameFolder: true,
+          prefix: "~",
+          rootDir: sourceDir
+        }
+      ]
+    }
+  }
+];
+var buildGuardrails = (sourceDir) => [
+  ...buildSonarConfig(sourceDir),
+  ...regexpConfig,
+  ...cnConditionalConfig,
+  ...noEnumConfig,
+  ...noJsxIifeConfig,
+  ...noNullRenderConfig,
+  ...noSwitchConfig,
+  ...noZodEnumConfig,
+  ...buildNoRestrictedPathsConfig(sourceDir),
+  ...buildNoRelativeImportPathsConfig(sourceDir)
+];
+
+// src/configs/i18n.ts
+import i18next from "eslint-plugin-i18next";
+var buildI18n = (sourceDir) => [
+  {
+    files: [`${sourceDir}/**/*.tsx`, `${sourceDir}/**/*.jsx`],
+    ignores: [
+      "**/*.test.tsx",
+      "**/*.stories.tsx",
+      "**/tests/**",
+      `${sourceDir}/components/ui/*.tsx`
+    ],
+    name: "i18n/no-literal-string",
+    plugins: { i18next },
+    rules: {
+      "i18next/no-literal-string": ["error", { mode: "jsx-text-only" }]
+    }
+  }
+];
+
+// src/configs/ignores.ts
+import { includeIgnoreFile } from "@eslint/config-helpers";
+import fs from "fs";
+import path2 from "path";
+var defaultIgnores = [
+  "/.react-router/**",
+  ".claude/**/*.js",
+  ".claude/**/*.cjs",
+  "scripts",
+  "public/**",
+  "**/*.css",
+  "**/*.svg",
+  "**/*.md"
+];
+var ignores = (opts) => {
+  const out = [];
+  const gitignore = opts?.gitignore ?? ".gitignore";
+  if (gitignore !== false) {
+    const resolved = path2.isAbsolute(gitignore) ? gitignore : path2.resolve(process.cwd(), gitignore);
+    if (fs.existsSync(resolved)) {
+      out.push(includeIgnoreFile(resolved));
+    }
+  }
+  out.push({
+    ignores: [...defaultIgnores, ...opts?.extra ?? []],
+    name: "ignored-files"
+  });
+  return out;
+};
+
+// src/configs/playwright.ts
+import playwrightPlugin from "eslint-plugin-playwright";
+var playwright = [
+  {
+    name: "playwright",
+    ...playwrightPlugin.configs["flat/recommended"],
+    files: [".playwright/**/*.ts?(x)"],
+    rules: {
+      ...playwrightPlugin.configs["flat/recommended"].rules,
+      // Every test must assert something. `assertFunctionPatterns` lets custom
+      // `expect*()` helpers count as the assertion. Error, never warn: a test
+      // that asserts nothing is a false green.
+      "playwright/expect-expect": [
+        "error",
+        { assertFunctionPatterns: ["^expect[A-Z]"] }
+      ],
+      // A bare `test.skip()` is a test switched off at author time and stays
+      // flagged at the recommended set's severity. `test.skip(condition, reason)`
+      // is a different thing: Playwright's own API for a test that does not
+      // apply to the environment it just found (a feature the project did not
+      // enable, a browser without the capability). Allow the conditional form.
+      "playwright/no-skipped-test": ["warn", { allowConditional: true }]
+    }
+  }
+];
+
+// src/configs/prettier.ts
+import { rules as prettierConfigRules } from "eslint-config-prettier";
+import prettierPlugin from "eslint-plugin-prettier";
+var prettier = [
+  {
+    name: "prettier/plugin/config",
+    plugins: { prettier: prettierPlugin }
+  },
+  {
+    name: "prettier/config",
+    rules: {
+      ...prettierConfigRules,
+      "@stylistic/padding-line-between-statements": [
+        "error",
+        {
+          blankLine: "always",
+          next: ["block-like", "export", "return", "throw"],
+          prev: "*"
+        }
+      ],
+      "@stylistic/quotes": [
+        "error",
+        "single",
+        {
+          allowTemplateLiterals: "avoidEscape",
+          avoidEscape: true
+        }
+      ],
+      "@stylistic/spaced-comment": "off",
+      "prettier/prettier": ["error", { endOfLine: "auto" }]
+    }
+  }
+];
+
+// src/configs/react.ts
+import eslintReact from "@eslint-react/eslint-plugin";
+import { configs as configs3, plugins as plugins2 } from "eslint-config-airbnb-extended";
+import reactRefresh from "eslint-plugin-react-refresh";
+import youMightNotNeedAnEffect from "eslint-plugin-react-you-might-not-need-an-effect";
+var ONLY_EXPORT_COMPONENTS_OPTIONS = {
+  allowCompoundComponents: true,
+  allowConstantExport: true
+};
+var react = [
+  // React plugin
+  plugins2.react,
+  // React hooks plugin
+  plugins2.reactHooks,
+  // React JSX A11y plugin
+  plugins2.reactA11y,
+  // Airbnb React recommended config
+  ...configs3.react.recommended,
+  {
+    name: "react-custom",
+    rules: {
+      "jsx-a11y/control-has-associated-label": "off",
+      "jsx-a11y/no-autofocus": "off",
+      "react/boolean-prop-naming": [
+        "error",
+        {
+          propTypeNames: ["bool", "mutuallyExclusiveTrueProps"],
+          rule: "^((can|has|hide|is|show)[A-Z]([A-Za-z0-9]?)+|(checked|disabled|hide|required|show))"
+        }
+      ],
+      "react/function-component-definition": "off",
+      "react/jsx-boolean-value": ["error", "always"],
+      "react/jsx-curly-brace-presence": "error",
+      "react/jsx-filename-extension": "off",
+      "react/jsx-fragments": "error",
+      // off by default because it doesn't handle props onXyz function names correctly
+      // turn this on from time to time to check for misnamed handlers elsewhere
+      "react/jsx-handler-names": ["off", { checkLocalVariables: true }],
+      "react/jsx-newline": ["error", { prevent: true }],
+      "react/jsx-no-useless-fragment": ["error", { allowExpressions: true }],
+      "react/no-children-prop": "off",
+      "react/no-danger": "off",
+      "react/prop-types": "off",
+      "react/react-in-jsx-scope": "off",
+      "react/require-default-props": "off"
+    }
+  },
+  // A module that exports anything besides components cannot be hot-swapped:
+  // Fast Refresh falls back to a full reload and drops component state. Test
+  // and story files, and the helpers beside them in `tests/` folders, are never
+  // hot-swapped as components, so they are exempt.
+  {
+    files: ["**/*.tsx", "**/*.jsx"],
+    ignores: ["**/*.test.ts?(x)", "**/*.stories.ts?(x)", "**/tests/**"],
+    name: "react-refresh",
+    plugins: { "react-refresh": reactRefresh },
+    rules: {
+      "react-refresh/only-export-components": [
+        "error",
+        ONLY_EXPORT_COMPONENTS_OPTIONS
+      ]
+    }
+  },
+  // Effects that should not be Effects: state derived from other state or
+  // props, user-event logic, chained updates, notifying a parent, resetting
+  // state on a prop change (use `key`), and hand-rolled store subscriptions
+  // (use `useSyncExternalStore`). Complements `react-hooks/set-state-in-effect`.
+  {
+    files: ["**/*.ts?(x)", "**/*.js?(x)"],
+    name: "react-you-might-not-need-an-effect",
+    plugins: {
+      "react-you-might-not-need-an-effect": youMightNotNeedAnEffect
+    },
+    rules: {
+      "react-you-might-not-need-an-effect/no-adjust-state-on-prop-change": "error",
+      "react-you-might-not-need-an-effect/no-chain-state-updates": "error",
+      "react-you-might-not-need-an-effect/no-derived-state": "error",
+      "react-you-might-not-need-an-effect/no-event-handler": "error",
+      "react-you-might-not-need-an-effect/no-external-store-subscription": "error",
+      "react-you-might-not-need-an-effect/no-initialize-state": "error",
+      "react-you-might-not-need-an-effect/no-pass-data-to-parent": "error",
+      "react-you-might-not-need-an-effect/no-pass-live-state-to-parent": "error",
+      "react-you-might-not-need-an-effect/no-reset-all-state-on-prop-change": "error"
+    }
+  },
+  // Nine rules from @eslint-react, not its preset: the preset re-enables hook
+  // rules `react-hooks` already owns. An Effect that adds a listener, timer,
+  // interval, observer or fetch must tear it down in its cleanup (a fetch
+  // through an AbortController). React 19 forms only: `ref` as a prop instead
+  // of `forwardRef`, `use(Context)` instead of `useContext`, and `<Context>`
+  // instead of `<Context.Provider>`. `no-context-provider` matches by name, so
+  // it reports `ThemeContext.Provider` but not `Ctx.Provider`.
+  {
+    files: ["**/*.ts?(x)", "**/*.js?(x)"],
+    name: "eslint-react",
+    plugins: { "@eslint-react": eslintReact },
+    rules: {
+      "@eslint-react/no-context-provider": "error",
+      "@eslint-react/no-forward-ref": "error",
+      "@eslint-react/no-use-context": "error",
+      "@eslint-react/web-api-no-leaked-event-listener": "error",
+      "@eslint-react/web-api-no-leaked-fetch": "error",
+      "@eslint-react/web-api-no-leaked-intersection-observer": "error",
+      "@eslint-react/web-api-no-leaked-interval": "error",
+      "@eslint-react/web-api-no-leaked-resize-observer": "error",
+      "@eslint-react/web-api-no-leaked-timeout": "error"
+    }
+  },
+  {
+    files: ["**/*.test.ts?(x)", "**/*.stories.ts?(x)"],
+    name: "react/test-files",
+    rules: {
+      "react/jsx-props-no-spreading": "off"
+    }
+  }
+];
+
+// src/plugins/no-imperative-query-fetch.ts
+var BANNED_METHODS = /* @__PURE__ */ new Map([
+  ["ensureInfiniteQueryData", "infiniteQuery"],
+  ["ensureQueryData", "query"],
+  ["fetchInfiniteQuery", "infiniteQuery"],
+  ["fetchQuery", "query"],
+  ["prefetchInfiniteQuery", "infiniteQuery"],
+  ["prefetchQuery", "query"]
+]);
+var getPropertyName = (callee) => {
+  if (callee.type !== "MemberExpression") {
+    return void 0;
+  }
+  const { computed, property } = callee;
+  if (!computed && property.type === "Identifier") {
+    return property.name;
+  }
+  if (computed && property.type === "Literal" && typeof property.value === "string") {
+    return property.value;
+  }
+  return void 0;
+};
+var noImperativeQueryFetchRule = {
+  create: (context) => ({
+    CallExpression: (node) => {
+      const method = getPropertyName(node.callee);
+      const replacement = method && BANNED_METHODS.get(method);
+      if (method && replacement) {
+        context.report({
+          data: { method, replacement },
+          messageId: "banned",
+          node
+        });
+      }
+    }
+  }),
+  meta: {
+    docs: {
+      description: "Disallow imperative TanStack Query fetches; await queryClient.query in a clientLoader and read with useSuspenseQuery"
+    },
+    messages: {
+      banned: "`{{method}}` is banned. Await `queryClient.{{replacement}}(options)` in a clientLoader and read the data with `useSuspenseQuery(options)` in the component."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var plugin7 = {
+  meta: {
+    name: "no-imperative-query-fetch",
+    version: "0.1.0"
+  },
+  rules: {
+    "no-imperative-query-fetch": noImperativeQueryFetchRule
+  }
+};
+var no_imperative_query_fetch_default = plugin7;
+
+// src/configs/react-router.ts
+var ROUTE_MODULE_EXPORTS = [
+  "action",
+  "clientAction",
+  "clientLoader",
+  "clientMiddleware",
+  "ErrorBoundary",
+  "handle",
+  "headers",
+  "HydrateFallback",
+  "Layout",
+  "links",
+  "loader",
+  "meta",
+  "middleware",
+  "shouldRevalidate"
+];
+var buildReactRouter = (sourceDir) => [
+  {
+    files: ["**/routes/**/*.tsx"],
+    name: "react-router/routes",
+    rules: {
+      "no-empty-pattern": "off"
+    }
+  },
+  {
+    files: ["**/routes/**/*.tsx", `${sourceDir}/root.tsx`],
+    ignores: ["**/*.test.tsx", "**/*.stories.tsx", "**/tests/**"],
+    name: "react-router/route-module-exports",
+    rules: {
+      "react-refresh/only-export-components": [
+        "error",
+        { ...ONLY_EXPORT_COMPONENTS_OPTIONS, allowExportNames: ROUTE_MODULE_EXPORTS }
+      ]
+    }
+  },
+  {
+    files: [`${sourceDir}/**/*.ts?(x)`],
+    name: "react-router/no-imperative-query-fetch",
+    plugins: { "no-imperative-query-fetch": no_imperative_query_fetch_default },
+    rules: {
+      "no-imperative-query-fetch/no-imperative-query-fetch": "error"
+    }
+  }
+];
+
+// src/configs/shadcn.ts
+import { plugin as shadcnPlugin } from "@shadcn/lint";
+var SOURCE_EXTENSIONS = "{js,jsx,ts,tsx}";
+var ARBITRARY_COLOR_PATTERN = String.raw`^.*\[(#|rgba?\(|hsla?\(|oklch\(|oklab\(|lab\(|lch\(|color:).*\]$`;
+var VENDORED_HELPER_FILES = [
+  "hooks/use-highlighted-code.ts",
+  "hooks/use-mobile.ts",
+  "utils/highlighter.tsx"
+];
+var VENDORED_UI_RULES_OFF = {
+  // shadcn renders `<Context.Provider>` and calls `useContext` (carousel,
+  // chart, drawer, input-otp, sidebar, toggle-group).
+  "@eslint-react/no-context-provider": "off",
+  "@eslint-react/no-use-context": "off",
+  "@stylistic/padding-line-between-statements": "off",
+  // shadcn emits double-quoted strings.
+  "@stylistic/quotes": "off",
+  // shadcn writes `Array<T>`.
+  "@typescript-eslint/array-type": "off",
+  // Helper exports carry inferred return types (use-mobile, highlighter).
+  "@typescript-eslint/explicit-module-boundary-types": "off",
+  // toggle-group.tsx: `import { type VariantProps } from ...`.
+  "@typescript-eslint/no-import-type-side-effects": "off",
+  // chart.tsx: `payload[key as keyof typeof payload] as string`.
+  "@typescript-eslint/no-unnecessary-type-assertion": "off",
+  // shadcn function declarations use a variable before its declaration
+  // (hoisted, no runtime effect), e.g. select.tsx.
+  "@typescript-eslint/naming-convention": "off",
+  "@typescript-eslint/no-use-before-define": "off",
+  // toggle-group.tsx falls back from context to props with `||`.
+  "@typescript-eslint/prefer-nullish-coalescing": "off",
+  // toast.tsx re-exports namespace members as `const a = Namespace.a`.
+  "@typescript-eslint/prefer-destructuring": "off",
+  // The useMemo callback in field.tsx is flagged; a stylistic async annotation.
+  "@typescript-eslint/promise-function-async": "off",
+  // calendar.tsx and sidebar.tsx arrow bodies are blocks.
+  "arrow-body-style": "off",
+  // Tailwind class rewrites would change vendored class strings.
+  "better-tailwindcss/enforce-canonical-classes": "off",
+  "better-tailwindcss/enforce-shorthand-classes": "off",
+  "better-tailwindcss/no-deprecated-classes": "off",
+  // shadcn writes `export { A, B }` on one line.
+  "canonical/export-specifier-newline": "off",
+  // chart.tsx passes an object to `cn`.
+  "cn-conditional/cn-conditional": "off",
+  // shadcn uses inline `type` specifiers (`import {cva, type VariantProps}`).
+  "import-x/consistent-type-specifier-style": "off",
+  // shadcn renders null from field.tsx.
+  "no-null-render/no-null-render": "off",
+  // `_values` in slider.tsx.
+  "no-underscore-dangle": "off",
+  // carousel.tsx: `{ api: api, ... }`.
+  "object-shorthand": "off",
+  "perfectionist/sort-imports": "off",
+  "perfectionist/sort-intersection-types": "off",
+  "perfectionist/sort-jsx-props": "off",
+  "perfectionist/sort-modules": "off",
+  "perfectionist/sort-named-exports": "off",
+  "perfectionist/sort-named-imports": "off",
+  "perfectionist/sort-object-types": "off",
+  "perfectionist/sort-objects": "off",
+  "perfectionist/sort-union-types": "off",
+  // shadcn components are `function` declarations.
+  "prefer-arrow-functions/prefer-arrow-functions": "off",
+  // Vendored output is never reformatted; it stays byte-identical to
+  // `shadcn add`.
+  "prettier/prettier": "off",
+  // Prop names such as `inset` (dropdown-menu).
+  "react/boolean-prop-naming": "off",
+  // pagination.tsx: a bare `aria-hidden`.
+  "react/jsx-boolean-value": "off",
+  // button.tsx exports `buttonVariants` and toast.tsx exports its toast
+  // manager beside their components. A hot update of either falls back to a
+  // full reload, which costs dev time only.
+  "react-refresh/only-export-components": "off",
+  // `prop?: T | undefined` (calendar, carousel).
+  "sonarjs/no-redundant-optional": "off",
+  "sonarjs/prefer-read-only-props": "off",
+  // chart.tsx: `!payload?.length`, `.replace(/.../g)`, negated ternaries.
+  "unicorn/explicit-length-check": "off",
+  "unicorn/no-negated-condition": "off",
+  "unicorn/prefer-string-replace-all": "off",
+  // The `e` handler parameter in input-group.tsx.
+  "unicorn/prevent-abbreviations": "off",
+  // Sanctioned correctness-class exemptions for vendored output. Each one
+  // trips a pattern in the shadcn source that GAIA does not edit.
+  // sidebar.tsx: `toggleSidebar` returns the setter's void result.
+  "@typescript-eslint/no-confusing-void-expression": "off",
+  // calendar.tsx, carousel.tsx, chart.tsx, sidebar.tsx reuse an outer name
+  // (`props`, `className`, `api`, `config`, `open`) in a nested callback.
+  "@typescript-eslint/no-shadow": "off",
+  // field.tsx FieldError: `uniqueErrors?.length` optional chain on a non-nullish array.
+  "@typescript-eslint/no-unnecessary-condition": "off",
+  // chart.tsx reads recharts payload items, typed `any` upstream.
+  "@typescript-eslint/no-unsafe-argument": "off",
+  "@typescript-eslint/no-unsafe-assignment": "off",
+  "@typescript-eslint/no-unsafe-member-access": "off",
+  "@typescript-eslint/restrict-template-expressions": "off",
+  // field.tsx FieldError: `uniqueErrors?.length == 1`.
+  eqeqeq: "off",
+  // pagination.tsx: PaginationLink's anchor gets its content through spread
+  // `children`, which the rule cannot see.
+  "jsx-a11y/anchor-has-content": "off",
+  // input-group.tsx: InputGroupAddon div with an onClick that focuses the input.
+  "jsx-a11y/click-events-have-key-events": "off",
+  // label.tsx: the generic Label primitive renders a <label> with no static control.
+  "jsx-a11y/label-has-associated-control": "off",
+  // input-group.tsx: the role="group" div with an onClick.
+  "jsx-a11y/no-noninteractive-element-interactions": "off",
+  // code-block.tsx: a scrollable <pre> takes `tabIndex={0}` so the keyboard
+  // can scroll it.
+  "jsx-a11y/no-noninteractive-tabindex": "off",
+  // carousel.tsx syncs Embla's selection into state from an effect;
+  // use-mobile.ts reads `matchMedia` into state on mount.
+  "react-hooks/set-state-in-effect": "off",
+  // calendar.tsx and carousel.tsx call a prop callback from an effect;
+  // use-mobile.ts subscribes to `matchMedia` and initializes state from it.
+  "react-you-might-not-need-an-effect/no-event-handler": "off",
+  "react-you-might-not-need-an-effect/no-external-store-subscription": "off",
+  "react-you-might-not-need-an-effect/no-initialize-state": "off",
+  "react-you-might-not-need-an-effect/no-pass-data-to-parent": "off",
+  // sidebar.tsx: SidebarRail's <button> carries no `type`.
+  "react/button-has-type": "off",
+  // carousel.tsx, chart.tsx, toggle-group.tsx pass an inline object to a
+  // context provider.
+  "react/jsx-no-constructed-context-values": "off",
+  // field.tsx FieldError: `<li key={index}>` over a static deduped error list.
+  "react/no-array-index-key": "off",
+  // calendar.tsx defines DayPicker's `components` slots inline.
+  "react/no-unstable-nested-components": "off",
+  // sidebar.tsx: SidebarMenuSkeleton picks a random skeleton width.
+  "sonarjs/pseudo-random": "off",
+  // sidebar.tsx persists the open state in a cookie.
+  "unicorn/no-document-cookie": "off",
+  // input-group.tsx: a `<Button>` className built dynamically. `no-raw-colors`
+  // still reads those files.
+  "shadcn/require-static-classes": "off",
+  // shadcn writes `import * as React from 'react'`, which the core rule
+  // reports against the `FC` ban because a namespace import could reach those
+  // names. The block re-declares the shared bans minus the `react` entry
+  // (options replace wholesale across blocks), so the other bans hold.
+  "no-restricted-imports": [
+    "error",
+    { paths: RESTRICTED_IMPORT_PATHS.filter((entry) => entry.name !== "react") }
+  ],
+  // Registry items may carry an arbitrary color the token contract bans.
+  "better-tailwindcss/no-restricted-classes": "off",
+  // input-otp.tsx and navigation-menu.tsx carry registry classes GAIA's theme
+  // does not define (`cn-input-otp`, `xs:`, `easing-[ease]`).
+  "better-tailwindcss/no-unknown-classes": "off",
+  // sonner.tsx sets CSS variables through a `style` object.
+  "shadcn/no-inline-styles": "off",
+  // The vendored files compose each other with `className`.
+  "shadcn/no-restyle": "off"
+};
+var buildShadcn = (sourceDir, opts) => {
+  const ui = opts?.ui ?? "~/components/ui";
+  const uiFiles = opts?.uiFiles ?? [
+    `${sourceDir}/components/ui/*.tsx`,
+    ...VENDORED_HELPER_FILES.map((file) => `${sourceDir}/${file}`)
+  ];
+  const restyleOffFiles = opts?.restyleOffFiles ?? [];
+  const configs4 = [
+    {
+      name: "shadcn/settings",
+      plugins: { shadcn: shadcnPlugin },
+      settings: { shadcn: { ui } }
+    },
+    {
+      files: [`${sourceDir}/**/*.${SOURCE_EXTENSIONS}`],
+      name: "shadcn/rules",
+      rules: {
+        // An arbitrary value is allowed where no scale step or token fits;
+        // `enforce-canonical-classes` still rewrites one that has a scale
+        // equivalent. An arbitrary color is banned: colors are role tokens.
+        "better-tailwindcss/no-restricted-classes": [
+          "error",
+          {
+            restrict: [
+              {
+                message: "Arbitrary colors are not allowed; use a theme role token.",
+                pattern: ARBITRARY_COLOR_PATTERN
+              }
+            ]
+          }
+        ],
+        "shadcn/no-arbitrary-values": "off",
+        "shadcn/no-inline-styles": "error",
+        "shadcn/no-raw-colors": "error",
+        "shadcn/no-restyle": ["error", { allow: ["layout"] }],
+        // better-tailwindcss/no-unknown-classes stays the only unknown-class rule.
+        "shadcn/no-unknown-classes": "off",
+        "shadcn/require-static-classes": "error"
+      }
+    },
+    {
+      files: uiFiles,
+      name: "shadcn/vendored-ui",
+      rules: VENDORED_UI_RULES_OFF
+    }
+  ];
+  if (restyleOffFiles.length > 0) {
+    configs4.push({
+      files: restyleOffFiles,
+      // The vendored ui folder (and with it `ui/tests/**`) is never reached.
+      ignores: [`${sourceDir}/components/ui/**`],
+      name: "shadcn/restyle-fallback",
+      rules: { "shadcn/no-restyle": "off" }
+    });
+  }
+  return configs4;
+};
+
+// src/configs/storybook.ts
+import storybookPlugin from "eslint-plugin-storybook";
+var storybook = [
+  ...storybookPlugin.configs["flat/recommended"]
+];
+
+// src/configs/style-hygiene.ts
+import canonical from "eslint-plugin-canonical";
+import checkFile from "eslint-plugin-check-file";
+import perfectionist from "eslint-plugin-perfectionist";
+import unicorn from "eslint-plugin-unicorn";
+import unusedImports from "eslint-plugin-unused-imports";
+var buildCanonicalConfig = (sourceDir) => [
+  canonical.configs["flat/recommended"],
+  {
+    name: "canonical",
+    rules: {
+      "canonical/destructuring-property-newline": "off",
+      "canonical/filename-match-exported": "error",
+      "canonical/id-match": "off",
+      "canonical/import-specifier-newline": "off"
+    }
+  },
+  {
+    // Component and page folders are kebab-case while their default export is
+    // PascalCase, so `theme-switch/index.tsx` exports `ThemeSwitch`. Scoped to
+    // these folders only: a global kebab transform would reject `i18n.ts`
+    // exporting `i18n` (lodash kebabs it to `i-18-n`).
+    files: [`${sourceDir}/components/**/*.tsx`, `${sourceDir}/pages/**/*.tsx`],
+    name: "canonical/filename-match-exported-kebab",
+    rules: {
+      "canonical/filename-match-exported": ["error", { transforms: ["kebab"] }]
+    }
+  },
+  {
+    files: ["**/*.tsx", "**/hooks/*.ts?(x)"],
+    name: "canonical/sort-react-dependencies",
+    rules: {
+      "canonical/sort-react-dependencies": "error"
+    }
+  },
+  {
+    files: [
+      `${sourceDir}/root.tsx`,
+      `${sourceDir}/entry.server.tsx`,
+      // A route page exports `<Name>Page` from `page.tsx`
+      `${sourceDir}/pages/**/page.tsx`,
+      `${sourceDir}/**/tests/*`,
+      "test/**/*.ts?(x)",
+      "**/*.stories.tsx",
+      "**/routes/**/*.tsx",
+      "**/hooks/*.ts?(x)",
+      ".storybook/**/*.ts?(x)",
+      ".playwright/**/*.ts?(x)"
+    ],
+    name: "canonical/filename-match-exported-disabled",
+    rules: {
+      "canonical/filename-match-exported": "off"
+    }
+  }
+];
+var perfectionistConfig = [
+  perfectionist.configs["recommended-natural"],
+  {
+    name: "perfectionist",
+    rules: {
+      "perfectionist/sort-imports": [
+        "error",
+        {
+          customGroups: [
+            {
+              elementNamePattern: "^react$",
+              groupName: "react-type",
+              selector: "type"
+            },
+            {
+              elementNamePattern: "^react$",
+              groupName: "react"
+            },
+            {
+              elementNamePattern: "^react-.+",
+              groupName: "react-other-type",
+              selector: "type"
+            },
+            {
+              elementNamePattern: "^react-.+",
+              groupName: "react-other"
+            }
+          ],
+          groups: [
+            "react-type",
+            "react",
+            "react-other-type",
+            "react-other",
+            ["type-external", "external"],
+            ["type-builtin", "builtin"],
+            ["type-internal", "internal"],
+            ["type-parent", "parent"],
+            ["type-sibling", "sibling"],
+            ["type-index", "index"],
+            "unknown",
+            "style",
+            "side-effect",
+            "side-effect-style"
+          ],
+          newlinesBetween: 0,
+          type: "natural"
+        }
+      ],
+      "perfectionist/sort-jsx-props": [
+        "error",
+        {
+          customGroups: [
+            {
+              elementNamePattern: ["^key$", "^ref$"],
+              groupName: "reserved"
+            }
+          ],
+          groups: ["reserved"],
+          type: "natural"
+        }
+      ]
+    }
+  }
+];
+var unicornConfig = [
+  unicorn.configs.recommended,
+  {
+    name: "unicorn",
+    rules: {
+      "unicorn/consistent-destructuring": "error",
+      "unicorn/consistent-template-literal-escape": "off",
+      "unicorn/filename-case": "off",
+      "unicorn/new-for-builtins": "off",
+      "unicorn/no-array-callback-reference": "off",
+      "unicorn/no-array-for-each": "off",
+      "unicorn/no-array-reduce": "off",
+      "unicorn/no-nested-ternary": "off",
+      "unicorn/no-null": "off",
+      "unicorn/no-useless-undefined": "off",
+      "unicorn/prefer-export-from": "off",
+      "unicorn/prefer-global-this": "off",
+      // `Array#includes` returns a plain boolean, not a type predicate, so it
+      // cannot narrow a union the way an `===` comparison chain does. In a typed
+      // codebase the chain is the type-safe idiom; forcing `.includes()` discards
+      // the narrowing and the value's refined type along with it.
+      "unicorn/prefer-includes-over-repeated-comparisons": "off",
+      "unicorn/prefer-set-has": "off",
+      // Both gate on `definition.kind === 'const'`, which
+      // @typescript-eslint/scope-manager never sets (the `const` lives on
+      // `definition.parent.kind`), so under the TypeScript parser they cannot
+      // report. Off states that instead of implying coverage.
+      "unicorn/no-blob-to-file": "off",
+      "unicorn/prefer-set-size": "off",
+      "unicorn/prefer-switch": "off",
+      "unicorn/prefer-ternary": "off",
+      "unicorn/prevent-abbreviations": [
+        "error",
+        {
+          ignore: [
+            "acc",
+            "ctx",
+            "e2e",
+            "env",
+            "obj",
+            "prev",
+            "req",
+            "res",
+            /args/i,
+            /fn/i,
+            /param/i,
+            /params/i,
+            /props/i,
+            /ref/i,
+            /src/i,
+            /utils/i
+          ]
+        }
+      ],
+      "unicorn/text-encoding-identifier-case": "off"
+    }
+  },
+  {
+    files: ["./*.ts"],
+    name: "unicorn/root-ts-files",
+    rules: {
+      "unicorn/prefer-module": "off",
+      "unicorn/prevent-abbreviations": "off"
+    }
+  }
+];
+var unusedImportsConfig = [
+  {
+    name: "unused-imports",
+    plugins: {
+      "unused-imports": unusedImports
+    },
+    rules: {
+      "@typescript-eslint/no-unused-vars": "off",
+      "no-unused-vars": "off",
+      "sonarjs/no-unused-vars": "off",
+      "sonarjs/unused-import": "off",
+      "unused-imports/no-unused-imports": "error",
+      "unused-imports/no-unused-vars": [
+        "error",
+        {
+          args: "after-used",
+          argsIgnorePattern: "^_",
+          ignoreRestSiblings: true,
+          vars: "all",
+          varsIgnorePattern: "^_"
+        }
+      ]
+    }
+  },
+  {
+    files: ["**/*.d.ts"],
+    name: "unused-imports/ts-definition-files",
+    rules: {
+      "unused-imports/no-unused-vars": "off"
+    }
+  }
+];
+var RESERVED_FOLDERS = "(assets|hooks|state|tests|utils)";
+var RESERVED_AND_UI_FOLDERS = "(assets|hooks|state|tests|ui|utils)";
+var notExactly = (names) => `{!${names},@${names}+([a-z0-9-])}`;
+var buildCheckFileConfig = (sourceDir) => [
+  {
+    plugins: {
+      "check-file": checkFile
+    }
+  },
+  {
+    files: [`${sourceDir}/**/*`],
+    name: "check-file",
+    rules: {
+      "check-file/filename-naming-convention": [
+        "error",
+        {
+          // React hook files are kebab-case with a `use-` prefix (use-theme.ts)
+          "**/hooks/*.{ts,tsx}": "use-+([a-z0-9])*(-+([a-z0-9]))",
+          [`${sourceDir}/state/*.tsx`]: "KEBAB_CASE",
+          // Components live in folders, never directly in components/
+          [`${sourceDir}/components/*.tsx`]: "!(*)",
+          // components/ui/ holds flat kebab-case component files (button.tsx)
+          [`${sourceDir}/components/ui/*.tsx`]: "KEBAB_CASE",
+          // Every other component file is named index.tsx
+          [`${sourceDir}/components/**/${notExactly(RESERVED_AND_UI_FOLDERS)}/*.tsx`]: "index+()",
+          // A page folder holds its route page.tsx, or index.tsx for colocated components
+          [`${sourceDir}/pages/**/${notExactly(RESERVED_FOLDERS)}/*.tsx`]: "@(index|page)",
+          // Generally, non-component files must be named kebab-case
+          [`${sourceDir}/{components,pages}/**/!(hooks)/*.ts`]: "KEBAB_CASE",
+          // Non-component files inside specific components folders must be kebab-case
+          [`${sourceDir}/{components,pages}/**/(assets|state|tests|utils)/*.{ts,tsx}`]: "KEBAB_CASE",
+          "test/**/*.ts?(x)": "KEBAB_CASE"
+        },
+        {
+          ignoreMiddleExtensions: true
+        }
+      ],
+      "check-file/folder-match-with-fex": [
+        "error",
+        {
+          // require stories and test files to be inside tests folders
+          "*.(stories|test).{ts,tsx}": `${sourceDir}/**/tests/`
+        }
+      ],
+      "check-file/folder-naming-convention": [
+        "error",
+        {
+          // enforce kebab-case component and page folders; the reserved
+          // assets, hooks, state, tests, and utils subfolders are kebab-case too
+          [`${sourceDir}/components/**/`]: "KEBAB_CASE",
+          [`${sourceDir}/pages/**/`]: "KEBAB_CASE",
+          // components/ui/ is flat: tests/ is its only subfolder
+          [`${sourceDir}/components/ui/*/`]: "@(tests)"
+        }
+      ]
+    }
+  },
+  {
+    files: ["test/**/*.*"],
+    name: "check-file/test-files",
+    rules: {
+      "check-file/filename-naming-convention": [
+        "error",
+        {
+          "test/**/*.ts?(x)": "KEBAB_CASE"
+        },
+        {
+          ignoreMiddleExtensions: true
+        }
+      ]
+    }
+  }
+];
+var buildStyleHygiene = (sourceDir) => [
+  ...buildCanonicalConfig(sourceDir),
+  ...perfectionistConfig,
+  ...unicornConfig,
+  ...unusedImportsConfig,
+  ...buildCheckFileConfig(sourceDir)
+];
+
+// src/configs/testing.ts
+import vitest from "@vitest/eslint-plugin";
+import jestDom from "eslint-plugin-jest-dom";
+var testing = [
+  {
+    files: [
+      "**/*.test.ts?(x)",
+      "**/*.stories.ts?(x)",
+      "test/**/*.ts?(x)"
+    ],
+    name: "vitest",
+    plugins: {
+      "jest-dom": jestDom,
+      vitest
+    },
+    rules: {
+      ...jestDom.configs["flat/recommended"].rules,
+      ...vitest.configs.recommended.rules,
+      "import-x/no-useless-path-segments": [
+        "error",
+        { noUselessIndex: true }
+      ],
+      "vitest/expect-expect": [
+        "error",
+        { assertFunctionNames: ["expect", "expect*"] }
+      ],
+      // Baseline bump: `recommended` ships no-disabled-tests at `warn`.
+      // .skip is the single biggest gaming vector for a RED-verification
+      // gate (it makes a failing test stop failing), so GAIA forbids it
+      // outright. Park work with test.todo or an inline eslint-disable, not
+      // a silent .skip.
+      "vitest/no-disabled-tests": "error",
+      // --- Hardening beyond the `recommended` preset ---------------------
+      // Rule names and options verified against @vitest/eslint-plugin
+      // v1.6.19. GAIA policy: every lint rule is `error`, never `warn`.
+      //
+      // Consistency: GAIA uses test() exclusively (120 vs 0 it() across the
+      // gaia codebase). In 1.6.19 the `fn` option cascades to the
+      // within-describe keyword, so this also governs test()/it() nested in
+      // describe blocks. Auto-fixable.
+      "vitest/consistent-test-it": ["error", { fn: "test" }],
+      // Consistency: GAIA uses the `vi` mock API (37 vs 0 `vitest.` across the
+      // gaia codebase). Auto-fixable.
+      "vitest/consistent-vitest-vi": ["error", { fn: "vi" }],
+      // RED-gate: a branch in a test body can assert nothing on one path.
+      // Enable ONLY this one; `no-conditional-tests` is a byte-identical
+      // duplicate in 1.6.19 and would double-report.
+      "vitest/no-conditional-in-test": "error",
+      // RED-gate: fdescribe/fit/xdescribe/xit bypass the active
+      // no-focused-tests / no-disabled-tests rules; forbid the prefix
+      // spellings so the focus/skip net stays airtight. Auto-fixable.
+      "vitest/no-test-prefixes": "error",
+      // RED-gate: a returned value/promise can resolve after the test
+      // "passes", swallowing assertions and faking GREEN.
+      "vitest/no-test-return-statement": "error",
+      // RED-gate: empty test('...') stubs pass green and read as coverage;
+      // rewrite to test.todo('...') so the gap is explicit. Contradicts
+      // `warn-todo`, which stays off. Auto-fixable.
+      "vitest/prefer-todo": "error",
+      // Honesty (D-8 / SPEC-006 Rule 3, the cheap-win stand-in for
+      // `gaia-test-honesty/no-call-through-only`). A bare
+      // `toHaveBeenCalled()`/`toBeCalled()` proves the function ran but
+      // asserts nothing about how (arguments) or how many (count) — a
+      // call-through that re-proves the framework, not the behavior.
+      //
+      // SCOPE NOTE: `prefer-called-with` is BROADER than spec Rule 3. The spec
+      // rule fires only when a bare `toHaveBeenCalled()` is the SOLE assertion
+      // in a test; `prefer-called-with` fires on EVERY bare
+      // `toHaveBeenCalled()`/`toBeCalled()` (it exempts only the `.not` form).
+      // So this stands in for Rule 3 rather than matching it exactly.
+      "vitest/prefer-called-with": "error",
+      // A bare .toThrow() passes on ANY throw, masking the wrong error;
+      // require an asserted message or matcher.
+      "vitest/require-to-throw-message": "error"
+    }
+  },
+  {
+    // Honesty (D-8 / SPEC-006 Rule 4, the cheap-win stand-in for
+    // `gaia-test-honesty/no-server-import-from-consumer`). A consumer test,
+    // story, or harness file must not import a server-only (`*.server`) or
+    // internal (`/internals/`) module: those are private surface, and
+    // reaching into them couples the test to implementation the public
+    // interface is meant to hide.
+    //
+    // Same testing glob as the `vitest` block above. The `*.server.test.*`
+    // exemption is the point of Rule 4: a dedicated server-side test IS the
+    // right place to import a `.server` module (mirrors the real
+    // `app/utils/tests/http.server.test.ts` importing `../http.server`).
+    //
+    // Implemented with the core `no-restricted-imports` rule (config only, no
+    // custom plugin) rather than a dedicated AST rule. Chosen over
+    // `import-x/no-restricted-paths` because Rule 4 keys off the import
+    // SPECIFIER shape (`*.server`, `/internals/`) plus a per-file filename
+    // exemption, not the directory `from`/`target` zones that
+    // `no-restricted-paths` models.
+    //
+    // LIMITATION vs the would-be custom rule: `no-restricted-imports` covers
+    // static `import` / `export ... from` only, NOT dynamic
+    // `import('./x.server')`. The dynamic case is intentionally out of scope
+    // for this cheap-win form; the advisory worthiness audit backstops it.
+    //
+    // ERROR severity, per spec (Rule 4 is an error rule).
+    files: [
+      "**/*.test.ts?(x)",
+      "**/*.stories.ts?(x)",
+      "test/**/*.ts?(x)"
+    ],
+    ignores: ["**/*.server.test.*"],
+    name: "gaia-test-honesty/no-server-import-from-consumer",
+    rules: {
+      "no-restricted-imports": [
+        "error",
+        {
+          // `paths` re-declares the global `@conform-to/zod` ban from base.ts.
+          // Flat config replaces a rule's options wholesale, so this later
+          // block would otherwise drop the conform ban on test/story files.
+          // Same shared const as base.ts, to stay DRY.
+          paths: RESTRICTED_IMPORT_PATHS,
+          patterns: [
+            {
+              group: ["**/*.server"],
+              message: "Do not import a server-only ('*.server') module from a consumer test. Server-only modules are private surface: reach them through the public interface, or from a dedicated *.server.test.* file (which is exempt from this rule)."
+            },
+            {
+              group: ["**/internals/**", "**/internals"],
+              message: "Do not import an internal ('/internals/') module from a consumer test. Internal modules are private surface: importing them couples the test to implementation the public interface is meant to hide. Reach the behavior through the public interface instead."
+            }
+          ]
+        }
+      ]
+    }
+  }
+];
+
+// src/configs/zod.ts
+import zodPlugin from "eslint-plugin-zod";
+var zod = [
+  {
+    files: ["**/*.ts?(x)"],
+    name: "zod",
+    plugins: { zod: zodPlugin },
+    rules: {
+      ...zodPlugin.configs.recommended.rules,
+      "zod/consistent-import": "off"
+    }
+  }
+];
+
+// src/index.ts
+var buildIgnoresAccessor = () => {
+  const defaults = ignores();
+  const accessor = ((opts) => ignores(opts));
+  accessor[Symbol.iterator] = () => defaults[Symbol.iterator]();
+  return accessor;
+};
+var gaiaLint = (opts) => {
+  const sourceDir = opts?.sourceDir ?? "app";
+  return {
+    base: buildBase(sourceDir),
+    betterTailwind,
+    guardrails: buildGuardrails(sourceDir),
+    i18n: buildI18n(sourceDir),
+    ignores: buildIgnoresAccessor(),
+    playwright,
+    prettier,
+    react,
+    reactRouter: buildReactRouter(sourceDir),
+    shadcn: (shadcnOpts) => buildShadcn(sourceDir, shadcnOpts),
+    storybook,
+    styleHygiene: buildStyleHygiene(sourceDir),
+    testing,
+    zod
+  };
+};
+var index_default = gaiaLint;
+export {
+  index_default as default
+};
+//# sourceMappingURL=index.js.map