eslint-config-setup 0.5.0 → 0.5.2

package/dist/modules.js

@@ -1,2485 +1,1884 @@
-// src/configs/ai.ts
-var TEST_FILES = ["**/*.test.{ts,tsx}", "**/__tests__/**/*.{ts,tsx}"];
-var E2E_FILES = ["**/*.spec.ts"];
-var CONFIG_FILES = [
-  "**/*.config.{ts,mts,cts,js,mjs,cjs}",
-  "**/vite.config.*",
-  "**/vitest.config.*",
-  "**/next.config.*"
+import eslint from "@eslint/js";
+import compatPlugin from "eslint-plugin-compat";
+import cspellPlugin from "@cspell/eslint-plugin";
+import deMorganPlugin from "eslint-plugin-de-morgan";
+import importXPlugin from "eslint-plugin-import-x";
+import unusedImportsPlugin from "eslint-plugin-unused-imports";
+import jsdocPlugin from "eslint-plugin-jsdoc";
+import jsonPlugin from "@eslint/json";
+import * as mdxPlugin from "eslint-plugin-mdx";
+import nodePlugin from "eslint-plugin-n";
+import globals from "globals";
+import { configs } from "eslint-plugin-package-json";
+import perfectionistPlugin from "eslint-plugin-perfectionist";
+import prettierConfig from "eslint-config-prettier";
+import eslintReactPlugin from "@eslint-react/eslint-plugin";
+import stylisticPlugin from "@stylistic/eslint-plugin";
+import jsxA11yPlugin from "eslint-plugin-jsx-a11y";
+import reactHooksPlugin from "eslint-plugin-react-hooks";
+import reactPerfPlugin from "eslint-plugin-react-perf";
+import reactRefreshPlugin from "eslint-plugin-react-refresh";
+import reactEffectPlugin from "eslint-plugin-react-you-might-not-need-an-effect";
+import { configs as configs$1 } from "eslint-plugin-regexp";
+import securityPlugin from "eslint-plugin-security";
+import sonarjsPlugin from "eslint-plugin-sonarjs";
+import tseslint from "typescript-eslint";
+import unicornPlugin from "eslint-plugin-unicorn";
+import playwrightPlugin from "eslint-plugin-playwright";
+import storybookPlugin from "eslint-plugin-storybook";
+import vitestPlugin from "@vitest/eslint-plugin";
+import testingLibraryPlugin from "eslint-plugin-testing-library";
+import oxlintPlugin from "eslint-plugin-oxlint";
+//#region src/configs/ai.ts
+/**
+* AI mode — cross-cutting concerns that span multiple domains.
+*
+* Domain-specific AI rules live in their respective configs (base.ts,
+* typescript.ts, react.ts, unicorn.ts, sonarjs.ts, regexp.ts, jsdoc.ts,
+* node.ts) behind an `ai` flag. This file only contains:
+*
+* 1. Test framework rules (vitest) — no dedicated domain config
+* 2. File-scoped relaxations — cross-domain, must come last to override
+*
+* @see ADR-0006: docs/adr/0006-ai-mode-as-dedicated-flag.md
+*/
+const TEST_FILES$1 = ["**/*.test.{ts,tsx}", "**/__tests__/**/*.{ts,tsx}"];
+const E2E_FILES = ["**/*.spec.ts"];
+const CONFIG_FILES = [
+	"**/*.config.{ts,mts,cts,js,mjs,cjs}",
+	"**/vite.config.*",
+	"**/vitest.config.*",
+	"**/next.config.*"
 ];
-var AI_TESTS_STRICT_CONFIG = {
-  name: "eslint-config-setup/ai-tests-strict",
-  files: TEST_FILES,
-  rules: {
-    // Every test must be inside a describe block — organized test suites
-    "vitest/require-top-level-describe": "error",
-    // Hooks (beforeEach, afterEach) must be at the top of describe — predictable setup
-    "vitest/prefer-hooks-on-top": "error"
-  }
+const AI_TESTS_STRICT_CONFIG = {
+	name: "eslint-config-setup/ai-tests-strict",
+	files: TEST_FILES$1,
+	rules: {
+		"vitest/require-top-level-describe": "error",
+		"vitest/prefer-hooks-on-top": "error"
+	}
 };
-var AI_TESTS_RELAXED_CONFIG = {
-  name: "eslint-config-setup/ai-tests-relaxed",
-  files: TEST_FILES,
-  rules: {
-    "max-lines": "off",
-    "max-lines-per-function": "off",
-    "max-statements": "off",
-    "max-nested-callbacks": "off",
-    "@typescript-eslint/no-magic-numbers": "off",
-    "sonarjs/no-duplicate-string": "off",
-    "@typescript-eslint/explicit-function-return-type": "off",
-    "@typescript-eslint/naming-convention": "off",
-    "unicorn/prevent-abbreviations": "off"
-  }
+const AI_TESTS_RELAXED_CONFIG = {
+	name: "eslint-config-setup/ai-tests-relaxed",
+	files: TEST_FILES$1,
+	rules: {
+		"max-lines": "off",
+		"max-lines-per-function": "off",
+		"max-statements": "off",
+		"max-nested-callbacks": "off",
+		"@typescript-eslint/no-magic-numbers": "off",
+		"sonarjs/no-duplicate-string": "off",
+		"@typescript-eslint/explicit-function-return-type": "off",
+		"@typescript-eslint/naming-convention": "off",
+		"unicorn/prevent-abbreviations": "off"
+	}
 };
-var AI_E2E_RELAXED_CONFIG = {
-  name: "eslint-config-setup/ai-e2e-relaxed",
-  files: E2E_FILES,
-  rules: {
-    "max-lines": "off",
-    "max-lines-per-function": "off",
-    "max-statements": "off",
-    "@typescript-eslint/no-magic-numbers": "off",
-    "@typescript-eslint/explicit-function-return-type": "off"
-  }
+const AI_E2E_RELAXED_CONFIG = {
+	name: "eslint-config-setup/ai-e2e-relaxed",
+	files: E2E_FILES,
+	rules: {
+		"max-lines": "off",
+		"max-lines-per-function": "off",
+		"max-statements": "off",
+		"@typescript-eslint/no-magic-numbers": "off",
+		"@typescript-eslint/explicit-function-return-type": "off"
+	}
 };
-var AI_CONFIG_RELAXED_CONFIG = {
-  name: "eslint-config-setup/ai-config-relaxed",
-  files: CONFIG_FILES,
-  rules: {
-    complexity: "off",
-    "max-lines": "off",
-    "max-lines-per-function": "off",
-    "max-statements": "off",
-    "@typescript-eslint/no-magic-numbers": "off",
-    "@typescript-eslint/explicit-function-return-type": "off",
-    "@typescript-eslint/naming-convention": "off"
-  }
+const AI_CONFIG_RELAXED_CONFIG = {
+	name: "eslint-config-setup/ai-config-relaxed",
+	files: CONFIG_FILES,
+	rules: {
+		complexity: "off",
+		"max-lines": "off",
+		"max-lines-per-function": "off",
+		"max-statements": "off",
+		"@typescript-eslint/no-magic-numbers": "off",
+		"@typescript-eslint/explicit-function-return-type": "off",
+		"@typescript-eslint/naming-convention": "off"
+	}
 };
-var AI_DECLARATIONS_RELAXED_CONFIG = {
-  name: "eslint-config-setup/ai-declarations-relaxed",
-  files: ["**/*.d.ts"],
-  rules: {
-    "@typescript-eslint/explicit-function-return-type": "off",
-    "@typescript-eslint/naming-convention": "off",
-    "@typescript-eslint/no-explicit-any": "off",
-    "@typescript-eslint/no-magic-numbers": "off",
-    "unicorn/prevent-abbreviations": "off",
-    "unicorn/filename-case": "off"
-  }
+const AI_DECLARATIONS_RELAXED_CONFIG = {
+	name: "eslint-config-setup/ai-declarations-relaxed",
+	files: ["**/*.d.ts"],
+	rules: {
+		"@typescript-eslint/explicit-function-return-type": "off",
+		"@typescript-eslint/naming-convention": "off",
+		"@typescript-eslint/no-explicit-any": "off",
+		"@typescript-eslint/no-magic-numbers": "off",
+		"unicorn/prevent-abbreviations": "off",
+		"unicorn/filename-case": "off"
+	}
 };
 function aiConfig() {
-  return [
-    AI_TESTS_STRICT_CONFIG,
-    AI_TESTS_RELAXED_CONFIG,
-    AI_E2E_RELAXED_CONFIG,
-    AI_CONFIG_RELAXED_CONFIG,
-    AI_DECLARATIONS_RELAXED_CONFIG
-  ];
+	return [
+		AI_TESTS_STRICT_CONFIG,
+		AI_TESTS_RELAXED_CONFIG,
+		AI_E2E_RELAXED_CONFIG,
+		AI_CONFIG_RELAXED_CONFIG,
+		AI_DECLARATIONS_RELAXED_CONFIG
+	];
 }
-
-// src/configs/base.ts
-import eslint from "@eslint/js";
-
-// src/build/config-builder.ts
+//#endregion
+//#region src/build/config-builder.ts
 function createConfig(options) {
-  const presetRules2 = /* @__PURE__ */ new Map();
-  const presetPlugins = {};
-  if (options.presets) {
-    for (const preset of options.presets) {
-      if (preset.plugins) {
-        Object.assign(presetPlugins, preset.plugins);
-      }
-      if (preset.rules) {
-        for (const [name, value] of Object.entries(preset.rules)) {
-          if (value !== void 0) {
-            presetRules2.set(name, value);
-          }
-        }
-      }
-    }
-  }
-  const overrides = /* @__PURE__ */ new Map();
-  const additions = /* @__PURE__ */ new Map();
-  const disabled = /* @__PURE__ */ new Set();
-  const removed = /* @__PURE__ */ new Set();
-  const fileOverrides = [];
-  const builder = {
-    overrideRule(name, value) {
-      if (!presetRules2.has(name)) {
-        throw new Error(
-          `overrideRule("${name}"): rule not found in preset. Cannot override a rule that doesn't exist in the preset.`
-        );
-      }
-      overrides.set(name, value);
-      return builder;
-    },
-    overrideSeverity(name, severity) {
-      if (!presetRules2.has(name)) {
-        throw new Error(
-          `overrideSeverity("${name}"): rule not found in preset. Cannot override severity of a rule that doesn't exist in the preset.`
-        );
-      }
-      const existing = presetRules2.get(name);
-      if (Array.isArray(existing)) {
-        const [, ...restOptions] = existing;
-        overrides.set(name, [severity, ...restOptions]);
-      } else {
-        overrides.set(name, severity);
-      }
-      return builder;
-    },
-    overrideOptions(name, ...ruleOptions) {
-      if (!presetRules2.has(name)) {
-        throw new Error(
-          `overrideOptions("${name}"): rule not found in preset. Cannot override options of a rule that doesn't exist in the preset.`
-        );
-      }
-      const existing = presetRules2.get(name);
-      const severity = Array.isArray(existing) ? existing[0] : existing;
-      overrides.set(name, [severity, ...ruleOptions]);
-      return builder;
-    },
-    addRule(name, value) {
-      if (presetRules2.has(name)) {
-        throw new Error(
-          `addRule("${name}"): rule already exists in preset. Use overrideRule() to change its value, or removeRule() to drop it.`
-        );
-      }
-      if (additions.has(name)) {
-        throw new Error(
-          `addRule("${name}"): rule was already added. Each rule can only be added once.`
-        );
-      }
-      additions.set(name, value);
-      return builder;
-    },
-    disableRule(name) {
-      if (!presetRules2.has(name) && !additions.has(name)) {
-        throw new Error(
-          `disableRule("${name}"): rule not found in preset or additions. Cannot disable a rule that doesn't exist.`
-        );
-      }
-      disabled.add(name);
-      return builder;
-    },
-    removeRule(name) {
-      if (!presetRules2.has(name) && !additions.has(name)) {
-        throw new Error(
-          `removeRule("${name}"): rule not found in preset or additions. Cannot remove a rule that doesn't exist.`
-        );
-      }
-      removed.add(name);
-      return builder;
-    },
-    addFileOverride(name, files, rules) {
-      fileOverrides.push({ name, files, rules });
-      return builder;
-    },
-    build() {
-      const rules = {};
-      for (const [name, value] of presetRules2) {
-        if (!removed.has(name)) {
-          rules[name] = value;
-        }
-      }
-      for (const [name, value] of overrides) {
-        if (!removed.has(name)) {
-          rules[name] = value;
-        }
-      }
-      for (const [name, value] of additions) {
-        if (!removed.has(name)) {
-          rules[name] = value;
-        }
-      }
-      for (const name of disabled) {
-        if (!removed.has(name)) {
-          rules[name] = "off";
-        }
-      }
-      const mainBlock = {
-        name: options.name,
-        rules
-      };
-      const mergedPlugins = { ...presetPlugins, ...options.plugins };
-      if (Object.keys(mergedPlugins).length > 0) {
-        mainBlock.plugins = mergedPlugins;
-      }
-      if (options.languageOptions) {
-        mainBlock.languageOptions = options.languageOptions;
-      }
-      if (options.settings) {
-        mainBlock.settings = options.settings;
-      }
-      if (options.files) {
-        mainBlock.files = options.files;
-      }
-      if (options.ignores) {
-        mainBlock.ignores = options.ignores;
-      }
-      const result = [];
-      if (options.passthrough) {
-        result.push(...options.passthrough);
-      }
-      result.push(mainBlock);
-      for (const fo of fileOverrides) {
-        result.push({
-          name: fo.name,
-          files: fo.files,
-          rules: fo.rules
-        });
-      }
-      return result;
-    }
-  };
-  return builder;
+	const presetRules = /* @__PURE__ */ new Map();
+	const presetPlugins = {};
+	if (options.presets) for (const preset of options.presets) {
+		if (preset.plugins) Object.assign(presetPlugins, preset.plugins);
+		if (preset.rules) {
+			for (const [name, value] of Object.entries(preset.rules)) if (value !== void 0) presetRules.set(name, value);
+		}
+	}
+	const overrides = /* @__PURE__ */ new Map();
+	const additions = /* @__PURE__ */ new Map();
+	const disabled = /* @__PURE__ */ new Set();
+	const removed = /* @__PURE__ */ new Set();
+	const fileOverrides = [];
+	const builder = {
+		overrideRule(name, value) {
+			if (!presetRules.has(name)) throw new Error(`overrideRule("${name}"): rule not found in preset. Cannot override a rule that doesn't exist in the preset.`);
+			overrides.set(name, value);
+			return builder;
+		},
+		overrideSeverity(name, severity) {
+			if (!presetRules.has(name)) throw new Error(`overrideSeverity("${name}"): rule not found in preset. Cannot override severity of a rule that doesn't exist in the preset.`);
+			const existing = presetRules.get(name);
+			if (Array.isArray(existing)) {
+				const [, ...restOptions] = existing;
+				overrides.set(name, [severity, ...restOptions]);
+			} else overrides.set(name, severity);
+			return builder;
+		},
+		overrideOptions(name, ...ruleOptions) {
+			if (!presetRules.has(name)) throw new Error(`overrideOptions("${name}"): rule not found in preset. Cannot override options of a rule that doesn't exist in the preset.`);
+			const existing = presetRules.get(name);
+			const severity = Array.isArray(existing) ? existing[0] : existing;
+			overrides.set(name, [severity, ...ruleOptions]);
+			return builder;
+		},
+		addRule(name, value) {
+			if (presetRules.has(name)) throw new Error(`addRule("${name}"): rule already exists in preset. Use overrideRule() to change its value, or removeRule() to drop it.`);
+			if (additions.has(name)) throw new Error(`addRule("${name}"): rule was already added. Each rule can only be added once.`);
+			additions.set(name, value);
+			return builder;
+		},
+		disableRule(name) {
+			if (!presetRules.has(name) && !additions.has(name)) throw new Error(`disableRule("${name}"): rule not found in preset or additions. Cannot disable a rule that doesn't exist.`);
+			disabled.add(name);
+			return builder;
+		},
+		removeRule(name) {
+			if (!presetRules.has(name) && !additions.has(name)) throw new Error(`removeRule("${name}"): rule not found in preset or additions. Cannot remove a rule that doesn't exist.`);
+			removed.add(name);
+			return builder;
+		},
+		addFileOverride(name, files, rules) {
+			fileOverrides.push({
+				name,
+				files,
+				rules
+			});
+			return builder;
+		},
+		build() {
+			const rules = {};
+			for (const [name, value] of presetRules) if (!removed.has(name)) rules[name] = value;
+			for (const [name, value] of overrides) if (!removed.has(name)) rules[name] = value;
+			for (const [name, value] of additions) if (!removed.has(name)) rules[name] = value;
+			for (const name of disabled) if (!removed.has(name)) rules[name] = "off";
+			const mainBlock = {
+				name: options.name,
+				rules
+			};
+			const mergedPlugins = {
+				...presetPlugins,
+				...options.plugins
+			};
+			if (Object.keys(mergedPlugins).length > 0) mainBlock.plugins = mergedPlugins;
+			if (options.languageOptions) mainBlock.languageOptions = options.languageOptions;
+			if (options.settings) mainBlock.settings = options.settings;
+			if (options.files) mainBlock.files = options.files;
+			if (options.ignores) mainBlock.ignores = options.ignores;
+			const result = [];
+			if (options.passthrough) result.push(...options.passthrough);
+			result.push(mainBlock);
+			for (const fo of fileOverrides) result.push({
+				name: fo.name,
+				files: fo.files,
+				rules: fo.rules
+			});
+			return result;
+		}
+	};
+	return builder;
 }
-
-// src/configs/base.ts
-var ERROR_PREVENTION_RULES = {
-  "accessor-pairs": ["error", { enforceForClassMembers: true }],
-  "array-callback-return": ["error", { allowImplicit: true }],
-  "no-constructor-return": "error",
-  "no-promise-executor-return": "error",
-  "no-self-compare": "error",
-  "no-template-curly-in-string": "error",
-  "no-unreachable-loop": "error",
-  "require-atomic-updates": "error",
-  "no-unmodified-loop-condition": "error",
-  "grouped-accessor-pairs": ["error", "getBeforeSet"],
-  "no-useless-rename": "error",
-  "no-useless-computed-key": ["error", { enforceForClassMembers: true }]
+//#endregion
+//#region src/configs/base.ts
+const ERROR_PREVENTION_RULES = {
+	"accessor-pairs": ["error", { enforceForClassMembers: true }],
+	"array-callback-return": ["error", { allowImplicit: true }],
+	"no-constructor-return": "error",
+	"no-promise-executor-return": "error",
+	"no-self-compare": "error",
+	"no-template-curly-in-string": "error",
+	"no-unreachable-loop": "error",
+	"require-atomic-updates": "error",
+	"no-unmodified-loop-condition": "error",
+	"grouped-accessor-pairs": ["error", "getBeforeSet"],
+	"no-useless-rename": "error",
+	"no-useless-computed-key": ["error", { enforceForClassMembers: true }]
 };
-var DANGEROUS_PATTERN_RULES = {
-  "no-eval": "error",
-  "no-alert": "error",
-  "no-caller": "error",
-  "no-extend-native": "error",
-  "no-new-func": "error",
-  "no-new-wrappers": "error",
-  "no-object-constructor": "error",
-  "no-proto": "error",
-  "no-iterator": "error",
-  "no-script-url": "error",
-  "no-octal-escape": "error",
-  "no-implicit-globals": "error"
+const DANGEROUS_PATTERN_RULES = {
+	"no-eval": "error",
+	"no-alert": "error",
+	"no-caller": "error",
+	"no-extend-native": "error",
+	"no-new-func": "error",
+	"no-new-wrappers": "error",
+	"no-object-constructor": "error",
+	"no-proto": "error",
+	"no-iterator": "error",
+	"no-script-url": "error",
+	"no-octal-escape": "error",
+	"no-implicit-globals": "error"
 };
-var CODE_QUALITY_RULES = {
-  eqeqeq: ["error", "smart"],
-  "guard-for-in": "error",
-  "default-case-last": "error",
-  radix: "error",
-  yoda: "error",
-  "no-sequences": ["error", { allowInParentheses: false }],
-  "no-new": "error",
-  "no-labels": "error",
-  "no-extra-bind": "error",
-  "no-lone-blocks": "error",
-  "no-useless-call": "error",
-  "no-useless-concat": "error",
-  "no-useless-return": "error",
-  "no-return-assign": ["error", "always"],
-  "no-multi-str": "error",
-  "prefer-regex-literals": ["error", { disallowRedundantWrapping: true }]
+const CODE_QUALITY_RULES = {
+	eqeqeq: ["error", "smart"],
+	"guard-for-in": "error",
+	"default-case-last": "error",
+	radix: "error",
+	yoda: "error",
+	"no-sequences": ["error", { allowInParentheses: false }],
+	"no-new": "error",
+	"no-labels": "error",
+	"no-extra-bind": "error",
+	"no-lone-blocks": "error",
+	"no-useless-call": "error",
+	"no-useless-concat": "error",
+	"no-useless-return": "error",
+	"no-return-assign": ["error", "always"],
+	"no-multi-str": "error",
+	"prefer-regex-literals": ["error", { disallowRedundantWrapping: true }]
 };
-var MODERN_STYLE_RULES = {
-  "no-var": "error",
-  "prefer-const": ["error", { destructuring: "all" }],
-  "prefer-object-has-own": "error",
-  "prefer-object-spread": "error",
-  "prefer-rest-params": "error",
-  "prefer-spread": "error",
-  "symbol-description": "error",
-  "prefer-numeric-literals": "error",
-  "object-shorthand": ["error", "always", { avoidExplicitReturnArrows: true, avoidQuotes: true }]
+const MODERN_STYLE_RULES = {
+	"no-var": "error",
+	"prefer-const": ["error", { destructuring: "all" }],
+	"prefer-object-has-own": "error",
+	"prefer-object-spread": "error",
+	"prefer-rest-params": "error",
+	"prefer-spread": "error",
+	"symbol-description": "error",
+	"prefer-numeric-literals": "error",
+	"object-shorthand": [
+		"error",
+		"always",
+		{
+			avoidExplicitReturnArrows: true,
+			avoidQuotes: true
+		}
+	]
 };
-var AI_STRUCTURAL_RULES = {
-  curly: ["error", "all"],
-  "no-else-return": ["error", { allowElseIf: false }],
-  "no-nested-ternary": "error",
-  "no-unneeded-ternary": "error",
-  "no-negated-condition": "error",
-  "no-lonely-if": "error",
-  "no-param-reassign": ["error", { props: true }],
-  "no-multi-assign": "error",
-  "one-var": ["error", "never"],
-  "no-implicit-coercion": "error",
-  "arrow-body-style": "error",
-  "prefer-arrow-callback": ["error", { allowNamedFunctions: true }],
-  "logical-assignment-operators": ["error", "always", { enforceForIfStatements: true }],
-  "max-statements-per-line": ["error", { max: 1 }],
-  "prefer-exponentiation-operator": "error",
-  "prefer-named-capture-group": "error",
-  "require-unicode-regexp": "error",
-  "no-warning-comments": "warn",
-  "no-await-in-loop": "error"
+const AI_STRUCTURAL_RULES = {
+	curly: ["error", "all"],
+	"no-else-return": ["error", { allowElseIf: false }],
+	"no-nested-ternary": "error",
+	"no-unneeded-ternary": "error",
+	"no-negated-condition": "error",
+	"no-lonely-if": "error",
+	"no-param-reassign": ["error", { props: true }],
+	"no-multi-assign": "error",
+	"one-var": ["error", "never"],
+	"no-implicit-coercion": "error",
+	"arrow-body-style": "error",
+	"prefer-arrow-callback": ["error", { allowNamedFunctions: true }],
+	"logical-assignment-operators": [
+		"error",
+		"always",
+		{ enforceForIfStatements: true }
+	],
+	"max-statements-per-line": ["error", { max: 1 }],
+	"prefer-exponentiation-operator": "error",
+	"prefer-named-capture-group": "error",
+	"require-unicode-regexp": "error",
+	"no-warning-comments": "warn",
+	"no-await-in-loop": "error"
 };
-function addRules(builder, rules) {
-  for (const [ruleName, value] of Object.entries(rules)) {
-    builder.addRule(ruleName, value);
-  }
+function addRules$1(builder, rules) {
+	for (const [ruleName, value] of Object.entries(rules)) builder.addRule(ruleName, value);
 }
 function addBaseOverrides(builder) {
-  builder.overrideRule("use-isnan", ["error", { enforceForIndexOf: true, enforceForSwitchCase: true }]);
-  builder.overrideRule("valid-typeof", ["error", { requireStringLiterals: true }]);
+	builder.overrideRule("use-isnan", ["error", {
+		enforceForIndexOf: true,
+		enforceForSwitchCase: true
+	}]);
+	builder.overrideRule("valid-typeof", ["error", { requireStringLiterals: true }]);
 }
 function addComplexityRules(builder, isAi) {
-  builder.addRule("complexity", ["error", isAi ? 10 : 20]);
-  builder.addRule("max-depth", ["error", isAi ? 3 : 5]);
-  builder.addRule("max-nested-callbacks", ["error", isAi ? 2 : 4]);
-  builder.addRule("max-params", ["error", isAi ? 3 : 5]);
-  builder.addRule("max-statements", ["error", isAi ? 15 : 25]);
-  builder.addRule("max-lines-per-function", [
-    "error",
-    { max: isAi ? 100 : 200, skipBlankLines: true, skipComments: true }
-  ]);
-  builder.addRule("max-lines", [
-    "error",
-    { max: isAi ? 300 : 500, skipBlankLines: true, skipComments: true }
-  ]);
-  builder.addRule("sonarjs/cognitive-complexity", ["error", isAi ? 10 : 20]);
+	builder.addRule("complexity", ["error", isAi ? 10 : 20]);
+	builder.addRule("max-depth", ["error", isAi ? 3 : 5]);
+	builder.addRule("max-nested-callbacks", ["error", isAi ? 2 : 4]);
+	builder.addRule("max-params", ["error", isAi ? 3 : 5]);
+	builder.addRule("max-statements", ["error", isAi ? 15 : 25]);
+	builder.addRule("max-lines-per-function", ["error", {
+		max: isAi ? 100 : 200,
+		skipBlankLines: true,
+		skipComments: true
+	}]);
+	builder.addRule("max-lines", ["error", {
+		max: isAi ? 300 : 500,
+		skipBlankLines: true,
+		skipComments: true
+	}]);
+	builder.addRule("sonarjs/cognitive-complexity", ["error", isAi ? 10 : 20]);
 }
 function addModernStyleRules(builder, isAi) {
-  addRules(builder, MODERN_STYLE_RULES);
-  builder.addRule("prefer-template", isAi ? "error" : "warn");
+	addRules$1(builder, MODERN_STYLE_RULES);
+	builder.addRule("prefer-template", isAi ? "error" : "warn");
 }
+/**
+* Base ESLint config — extends `eslint.configs.recommended` with additional
+* best-practice rules for error prevention and modern JS style.
+*
+* Rules with TypeScript equivalents (no-implied-eval, dot-notation, etc.)
+* are NOT included here — they are handled by the typescript-eslint presets.
+*
+* Preset: `@eslint/js` recommended
+* @see https://eslint.org/docs/latest/rules/
+*/
 function baseConfig(opts) {
-  const isAi = opts?.ai ?? false;
-  const builder = createConfig({
-    name: "eslint-config-setup/base",
-    presets: [eslint.configs.recommended]
-  });
-  addRules(builder, ERROR_PREVENTION_RULES);
-  addBaseOverrides(builder);
-  addRules(builder, DANGEROUS_PATTERN_RULES);
-  addRules(builder, CODE_QUALITY_RULES);
-  addComplexityRules(builder, isAi);
-  addModernStyleRules(builder, isAi);
-  if (isAi) {
-    addRules(builder, AI_STRUCTURAL_RULES);
-  }
-  return builder.build();
+	const isAi = opts?.ai ?? false;
+	const builder = createConfig({
+		name: "eslint-config-setup/base",
+		presets: [eslint.configs.recommended]
+	});
+	addRules$1(builder, ERROR_PREVENTION_RULES);
+	addBaseOverrides(builder);
+	addRules$1(builder, DANGEROUS_PATTERN_RULES);
+	addRules$1(builder, CODE_QUALITY_RULES);
+	addComplexityRules(builder, isAi);
+	addModernStyleRules(builder, isAi);
+	if (isAi) addRules$1(builder, AI_STRUCTURAL_RULES);
+	return builder.build();
 }
-
-// src/configs/compat.ts
-import compatPlugin from "eslint-plugin-compat";
+//#endregion
+//#region src/configs/compat.ts
+/**
+* Browser compatibility config — checks that browser APIs are available
+* in the project's browserslist targets. Uses MDN compatibility data.
+*
+* Activated automatically for non-Node projects (when `node: false`).
+* If no browserslist config exists, the default applies:
+* `> 0.5%, last 2 versions, Firefox ESR, not dead`
+*
+* @see https://github.com/amilajack/eslint-plugin-compat
+* @see https://browsersl.ist/
+*/
 function compatConfig() {
-  return [
-    {
-      name: "eslint-config-setup/compat",
-      plugins: {
-        compat: compatPlugin
-      },
-      rules: {
-        // Warn when using browser APIs not supported in browserslist targets
-        // https://github.com/amilajack/eslint-plugin-compat#usage
-        "compat/compat": "warn"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/compat",
+		plugins: { compat: compatPlugin },
+		rules: { "compat/compat": "warn" }
+	}];
 }
-
-// src/configs/cspell.ts
-import cspellPlugin from "@cspell/eslint-plugin";
+//#endregion
+//#region src/configs/cspell.ts
+/**
+* CSpell config — spell checking for identifiers and comments.
+* Catches typos in variable names, function names, and documentation.
+* Severity is "warn" because dictionary misses are common for domain terms.
+*
+* @see https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-eslint-plugin#readme
+*/
 function cspellConfig() {
-  return [
-    {
-      name: "eslint-config-setup/cspell",
-      plugins: {
-        "@cspell": cspellPlugin
-      },
-      rules: {
-        // Check spelling in identifiers and comments — catches typos in API names
-        // Strings are excluded (may contain user-facing text, URLs, etc.)
-        // Auto-fix disabled — spelling corrections need human review
-        // https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-eslint-plugin#rules
-        "@cspell/spellchecker": [
-          "warn",
-          {
-            checkComments: true,
-            checkIdentifiers: true,
-            checkStrings: false,
-            autoFix: false
-          }
-        ]
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/cspell",
+		plugins: { "@cspell": cspellPlugin },
+		rules: { "@cspell/spellchecker": ["warn", {
+			checkComments: true,
+			checkIdentifiers: true,
+			checkStrings: false,
+			autoFix: false
+		}] }
+	}];
 }
-
-// src/configs/de-morgan.ts
-import deMorganPlugin from "eslint-plugin-de-morgan";
+//#endregion
+//#region src/configs/de-morgan.ts
+/**
+* De Morgan config — enforces De Morgan's laws on negated boolean expressions.
+* Both rules are auto-fixable: !(A && B) → !A || !B and !(A || B) → !A && !B.
+*
+* Complements sonarjs/no-inverted-boolean-check (which handles simple !(a === b) → a !== b)
+* by targeting compound expressions with && and ||.
+*
+* @see https://github.com/azat-io/eslint-plugin-de-morgan
+*/
 function deMorganConfig() {
-  return [
-    {
-      name: "eslint-config-setup/de-morgan",
-      plugins: {
-        "de-morgan": deMorganPlugin
-      },
-      rules: {
-        // Transform !(A && B) → !A || !B — more readable negated conjunction
-        // https://github.com/azat-io/eslint-plugin-de-morgan/blob/main/docs/no-negated-conjunction.md
-        "de-morgan/no-negated-conjunction": "error",
-        // Transform !(A || B) → !A && !B — more readable negated disjunction
-        // https://github.com/azat-io/eslint-plugin-de-morgan/blob/main/docs/no-negated-disjunction.md
-        "de-morgan/no-negated-disjunction": "error"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/de-morgan",
+		plugins: { "de-morgan": deMorganPlugin },
+		rules: {
+			"de-morgan/no-negated-conjunction": "error",
+			"de-morgan/no-negated-disjunction": "error"
+		}
+	}];
 }
-
-// src/configs/imports.ts
-import importXPlugin from "eslint-plugin-import-x";
-import unusedImportsPlugin from "eslint-plugin-unused-imports";
+//#endregion
+//#region src/configs/imports.ts
+/**
+* Import/export config — two plugins with clear separation of concerns:
+* - `import-x` handles import **validation** (cycles, duplicates, etc.)
+* - `unused-imports` handles **removal** of unused imports (auto-fixable)
+*
+* Import/export **ordering** is handled by perfectionist (see perfectionist.ts).
+*
+* @see https://github.com/un-ts/eslint-plugin-import-x
+* @see https://github.com/sweepline/eslint-plugin-unused-imports
+*/
 function importsConfig() {
-  return [
-    {
-      name: "eslint-config-setup/imports",
-      plugins: {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Plugin type is compatible
-        "import": importXPlugin,
-        "unused-imports": unusedImportsPlugin
-      },
-      rules: {
-        // ── Validation (import-x) ────────────────────────────────────
-        // Merge duplicate import paths into one statement — reduces noise
-        // https://github.com/un-ts/eslint-plugin-import/blob/master/docs/rules/no-duplicates.md
-        "import/no-duplicates": "error",
-        // Forbid a module from importing itself — always a bug
-        // https://github.com/un-ts/eslint-plugin-import/blob/master/docs/rules/no-self-import.md
-        "import/no-self-import": "error",
-        // Detect circular dependencies — limited to depth 3 for performance
-        // https://github.com/un-ts/eslint-plugin-import/blob/master/docs/rules/no-cycle.md
-        "import/no-cycle": ["error", { maxDepth: 3 }],
-        // Remove unnecessary path segments (e.g., ./foo/../foo → ./foo)
-        // https://github.com/un-ts/eslint-plugin-import/blob/master/docs/rules/no-useless-path-segments.md
-        "import/no-useless-path-segments": "error",
-        // Forbid mutable export bindings — prevents shared mutable state
-        // https://github.com/un-ts/eslint-plugin-import/blob/master/docs/rules/no-mutable-exports.md
-        "import/no-mutable-exports": "error",
-        // Imports must come before other statements — consistent module structure
-        // https://github.com/un-ts/eslint-plugin-import/blob/master/docs/rules/first.md
-        "import/first": "error",
-        // Require blank line after import block — visual separation
-        // https://github.com/un-ts/eslint-plugin-import/blob/master/docs/rules/newline-after-import.md
-        "import/newline-after-import": "error",
-        // Detect `import Foo from './Foo'` when Foo is also a named export — likely wrong
-        // https://github.com/un-ts/eslint-plugin-import-x/blob/master/docs/rules/no-named-as-default.md
-        "import/no-named-as-default": "error",
-        // Detect `Foo.bar` when `bar` is a named export — use `import { bar }` instead
-        // https://github.com/un-ts/eslint-plugin-import-x/blob/master/docs/rules/no-named-as-default-member.md
-        "import/no-named-as-default-member": "error",
-        // Detect empty `import {} from 'foo'` — leftover after refactoring
-        // https://github.com/un-ts/eslint-plugin-import-x/blob/master/docs/rules/no-empty-named-blocks.md
-        "import/no-empty-named-blocks": "error",
-        // Forbid absolute file paths in imports — not portable across machines
-        // https://github.com/un-ts/eslint-plugin-import-x/blob/master/docs/rules/no-absolute-path.md
-        "import/no-absolute-path": "error",
-        // Forbid imports of packages not listed in package.json — catches phantom deps
-        // https://github.com/un-ts/eslint-plugin-import-x/blob/master/docs/rules/no-extraneous-dependencies.md
-        "import/no-extraneous-dependencies": ["error", { includeTypes: true }],
-        // Forbid side-effect-only imports — make dependencies explicit
-        // https://github.com/un-ts/eslint-plugin-import-x/blob/master/docs/rules/no-unassigned-import.md
-        "import/no-unassigned-import": [
-          "error",
-          {
-            allow: [
-              "@babel/polyfill",
-              "**/register",
-              "**/register.*",
-              "**/register/**",
-              "**/register/**.*",
-              "**/*.css",
-              "**/*.scss",
-              "**/*.sass",
-              "**/*.less"
-            ]
-          }
-        ],
-        // Forbid `import { default as Foo }` — use `import Foo` instead
-        // https://github.com/un-ts/eslint-plugin-import-x/blob/master/docs/rules/no-named-default.md
-        "import/no-named-default": "error",
-        // ── Disabled: ordering handled by perfectionist ────────────────
-        // https://github.com/un-ts/eslint-plugin-import/blob/master/docs/rules/order.md
-        "import/order": "off",
-        // https://github.com/un-ts/eslint-plugin-import/blob/master/docs/rules/sort-imports.md
-        "import/sort-imports": "off",
-        // ── Unused import removal ─────────────────────────────────────
-        // Auto-remove unused imports — keeps imports clean (auto-fixable)
-        // https://github.com/sweepline/eslint-plugin-unused-imports#usage
-        "unused-imports/no-unused-imports": "error"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/imports",
+		plugins: {
+			"import": importXPlugin,
+			"unused-imports": unusedImportsPlugin
+		},
+		rules: {
+			"import/no-duplicates": "error",
+			"import/no-self-import": "error",
+			"import/no-cycle": ["error", { maxDepth: 3 }],
+			"import/no-useless-path-segments": "error",
+			"import/no-mutable-exports": "error",
+			"import/first": "error",
+			"import/newline-after-import": "error",
+			"import/no-named-as-default": "error",
+			"import/no-named-as-default-member": "error",
+			"import/no-empty-named-blocks": "error",
+			"import/no-absolute-path": "error",
+			"import/no-extraneous-dependencies": ["error", { includeTypes: true }],
+			"import/no-unassigned-import": ["error", { allow: [
+				"@babel/polyfill",
+				"**/register",
+				"**/register.*",
+				"**/register/**",
+				"**/register/**.*",
+				"**/*.css",
+				"**/*.scss",
+				"**/*.sass",
+				"**/*.less"
+			] }],
+			"import/no-named-default": "error",
+			"import/order": "off",
+			"import/sort-imports": "off",
+			"unused-imports/no-unused-imports": "error"
+		}
+	}];
 }
-
-// src/configs/jsdoc.ts
-import jsdocPlugin from "eslint-plugin-jsdoc";
+//#endregion
+//#region src/configs/jsdoc.ts
+/**
+* JSDoc config — validates existing JSDoc annotations without requiring them.
+*
+* Preset: `flat/recommended-typescript-error` — all recommended JSDoc rules
+* adapted for TypeScript (types are in TS, not JSDoc).
+*
+* Overrides:
+* - `require-jsdoc` OFF — we validate existing JSDoc, we don't mandate it
+* - param/return descriptions downgraded to warn — helpful but not blocking
+* @see https://github.com/gajus/eslint-plugin-jsdoc#rules
+*/
 function jsdocConfig(opts) {
-  const isAi = opts?.ai ?? false;
-  const builder = createConfig({
-    name: "eslint-config-setup/jsdoc",
-    presets: [jsdocPlugin.configs["flat/recommended-typescript-error"]]
-  }).overrideRule("jsdoc/require-jsdoc", "off").overrideRule("jsdoc/require-param", "off").overrideRule("jsdoc/require-returns", "off").overrideRule("jsdoc/require-yields", "off").overrideRule("jsdoc/require-param-description", "warn").overrideRule("jsdoc/require-returns-description", "warn").overrideRule("jsdoc/check-tag-names", "error").overrideRule("jsdoc/no-undefined-types", "error").overrideRule("jsdoc/tag-lines", "off");
-  if (isAi) {
-    builder.overrideRule("jsdoc/require-param", "error");
-    builder.overrideRule("jsdoc/require-returns", "error");
-    builder.overrideRule("jsdoc/informative-docs", "error");
-  }
-  return builder.build();
+	const isAi = opts?.ai ?? false;
+	const builder = createConfig({
+		name: "eslint-config-setup/jsdoc",
+		presets: [jsdocPlugin.configs["flat/recommended-typescript-error"]]
+	}).overrideRule("jsdoc/require-jsdoc", "off").overrideRule("jsdoc/require-param", "off").overrideRule("jsdoc/require-returns", "off").overrideRule("jsdoc/require-yields", "off").overrideRule("jsdoc/require-param-description", "warn").overrideRule("jsdoc/require-returns-description", "warn").overrideRule("jsdoc/check-tag-names", "error").overrideRule("jsdoc/no-undefined-types", "error").overrideRule("jsdoc/tag-lines", "off");
+	if (isAi) {
+		builder.overrideRule("jsdoc/require-param", "error");
+		builder.overrideRule("jsdoc/require-returns", "error");
+		builder.overrideRule("jsdoc/informative-docs", "error");
+	}
+	return builder.build();
 }
-
-// src/configs/json.ts
-import jsonPlugin from "@eslint/json";
-var plugin = jsonPlugin;
+//#endregion
+//#region src/configs/json.ts
+const plugin$1 = jsonPlugin;
+/**
+* JSON/JSONC config — native JSON linting using the official `@eslint/json` plugin.
+* Two blocks: strict JSON for most files, JSONC (with comments) for tsconfig etc.
+*
+* @see https://github.com/eslint/json#rules
+*/
 function jsonConfig() {
-  return [
-    {
-      name: "eslint-config-setup/json",
-      files: ["**/*.json"],
-      ignores: ["**/package-lock.json"],
-      language: "json/json",
-      plugins: {
-        json: plugin
-      },
-      rules: {
-        // Detect duplicate keys in JSON — last-write-wins is confusing
-        // https://github.com/eslint/json#rules
-        "json/no-duplicate-keys": "error",
-        // Detect empty string keys — likely a mistake
-        // https://github.com/eslint/json#rules
-        "json/no-empty-keys": "error",
-        // Detect unsafe values (NaN, Infinity, lone surrogates) — invalid JSON
-        // https://github.com/eslint/json#rules
-        "json/no-unsafe-values": "error",
-        // Detect unnormalized Unicode keys — prevents invisible key mismatches
-        // https://github.com/eslint/json#rules
-        "json/no-unnormalized-keys": "error"
-      }
-    },
-    {
-      name: "eslint-config-setup/jsonc",
-      files: [
-        "**/tsconfig.json",
-        "**/tsconfig.*.json",
-        "**/.vscode/*.json",
-        "**/turbo.json"
-      ],
-      language: "json/jsonc",
-      plugins: {
-        json: plugin
-      },
-      rules: {
-        // Detect duplicate keys in JSONC — same rationale as JSON
-        // https://github.com/eslint/json#rules
-        "json/no-duplicate-keys": "error",
-        // Detect empty string keys — likely a mistake
-        // https://github.com/eslint/json#rules
-        "json/no-empty-keys": "error",
-        // Detect unsafe values (NaN, Infinity, lone surrogates) — invalid JSON
-        // https://github.com/eslint/json#rules
-        "json/no-unsafe-values": "error",
-        // Detect unnormalized Unicode keys — prevents invisible key mismatches
-        // https://github.com/eslint/json#rules
-        "json/no-unnormalized-keys": "error"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/json",
+		files: ["**/*.json"],
+		ignores: ["**/package-lock.json"],
+		language: "json/json",
+		plugins: { json: plugin$1 },
+		rules: {
+			"json/no-duplicate-keys": "error",
+			"json/no-empty-keys": "error",
+			"json/no-unsafe-values": "error",
+			"json/no-unnormalized-keys": "error"
+		}
+	}, {
+		name: "eslint-config-setup/jsonc",
+		files: [
+			"**/tsconfig.json",
+			"**/tsconfig.*.json",
+			"**/.vscode/*.json",
+			"**/turbo.json"
+		],
+		language: "json/jsonc",
+		plugins: { json: plugin$1 },
+		rules: {
+			"json/no-duplicate-keys": "error",
+			"json/no-empty-keys": "error",
+			"json/no-unsafe-values": "error",
+			"json/no-unnormalized-keys": "error"
+		}
+	}];
 }
-
-// src/configs/markdown.ts
-import * as mdxPlugin from "eslint-plugin-mdx";
+//#endregion
+//#region src/configs/markdown.ts
+/**
+* Markdown & MDX config — lints code blocks inside Markdown and MDX files
+* using eslint-plugin-mdx. Code examples in docs get the same ESLint rules
+* as your source code. Covers both `.md` and `.mdx` files.
+*
+* Markdown structure linting (headings, links, etc.) is intentionally left
+* to dedicated tools like markdownlint.
+*
+* @see https://github.com/mdx-js/eslint-mdx
+* @see https://github.com/DavidAnson/markdownlint-cli2 (recommended for Markdown structure linting)
+*/
 function markdownConfig() {
-  const codeBlockLanguageOptions = mdxPlugin.flatCodeBlocks.languageOptions ?? {};
-  const codeBlockParserOptions = codeBlockLanguageOptions.parserOptions ?? {};
-  return [
-    // ── MDX / Markdown parsing ─────────────────────────────────────
-    {
-      ...mdxPlugin.flat,
-      processor: mdxPlugin.createRemarkProcessor({
-        lintCodeBlocks: true,
-        languageMapper: {}
-      })
-    },
-    // ── Code block linting ─────────────────────────────────────────
-    // Applies ESLint rules to fenced code blocks extracted from .md/.mdx.
-    // Relaxes rules that don't apply to incomplete code snippets.
-    {
-      ...mdxPlugin.flatCodeBlocks,
-      languageOptions: {
-        ...codeBlockLanguageOptions,
-        parserOptions: {
-          ...codeBlockParserOptions,
-          projectService: false
-        }
-      },
-      rules: {
-        ...mdxPlugin.flatCodeBlocks.rules,
-        // Snippets don't need trailing newlines
-        "eol-last": "off",
-        // Variables may be defined elsewhere
-        "no-undef": "off",
-        // Snippets often show standalone expressions
-        "no-unused-expressions": "off",
-        // Variables are often declared for demonstration
-        "no-unused-vars": "off",
-        // Padding is irrelevant in snippets
-        "padded-blocks": "off",
-        // Strict mode is irrelevant in snippets
-        strict: "off",
-        // BOM is irrelevant in snippets
-        "unicode-bom": "off"
-      }
-    }
-  ];
+	const codeBlockLanguageOptions = mdxPlugin.flatCodeBlocks.languageOptions ?? {};
+	const codeBlockParserOptions = codeBlockLanguageOptions.parserOptions ?? {};
+	return [{
+		...mdxPlugin.flat,
+		processor: mdxPlugin.createRemarkProcessor({
+			lintCodeBlocks: true,
+			languageMapper: {}
+		})
+	}, {
+		...mdxPlugin.flatCodeBlocks,
+		languageOptions: {
+			...codeBlockLanguageOptions,
+			parserOptions: {
+				...codeBlockParserOptions,
+				projectService: false
+			}
+		},
+		rules: {
+			...mdxPlugin.flatCodeBlocks.rules,
+			"eol-last": "off",
+			"no-undef": "off",
+			"no-unused-expressions": "off",
+			"no-unused-vars": "off",
+			"padded-blocks": "off",
+			strict: "off",
+			"unicode-bom": "off"
+		}
+	}];
 }
-
-// src/configs/node.ts
-import nodePlugin from "eslint-plugin-n";
-import globals from "globals";
+//#endregion
+//#region src/configs/node.ts
+/**
+* Node.js config — rules for server-side JavaScript/TypeScript.
+* Hand-picked subset of eslint-plugin-n. We don't use the full preset because
+* module resolution rules (`no-missing-import`, `no-unpublished-import`) are
+* handled better by TypeScript.
+*
+* @see https://github.com/eslint-community/eslint-plugin-n#-rules
+*/
 function nodeConfig(opts) {
-  const isAi = opts?.ai ?? false;
-  const builder = createConfig({
-    name: "eslint-config-setup/node",
-    presets: [
-      {
-        rules: {
-          // Detect usage of deprecated Node.js APIs (fs.exists, url.parse, etc.)
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/no-deprecated-api.md
-          "node/no-deprecated-api": "error",
-          // Prevent `module.exports = ...` assignment in ES modules
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/no-exports-assign.md
-          "node/no-exports-assign": "error",
-          // OFF: TypeScript resolves imports — this rule has false positives
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/no-missing-import.md
-          "node/no-missing-import": "off",
-          // OFF: TypeScript resolves requires — this rule has false positives
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/no-missing-require.md
-          "node/no-missing-require": "off",
-          // Warn on process.exit() — prefer throwing errors for clean shutdown
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/no-process-exit.md
-          "node/no-process-exit": "warn",
-          // OFF: Too many false positives with monorepos and devDependencies
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/no-unpublished-import.md
-          "node/no-unpublished-import": "off",
-          // Validate hashbang lines — correct syntax, Unix linebreaks, only in entry files
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/hashbang.md
-          "node/hashbang": "error",
-          // Detect `__dirname + '/foo'` — use path.join() instead (breaks on Windows)
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/no-path-concat.md
-          "node/no-path-concat": "error",
-          // Treat process.exit() as throw — prevents false positives in unreachable code analysis
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/process-exit-as-throw.md
-          "node/process-exit-as-throw": "error",
-          // Ensure error parameters in callbacks are handled — don't silently swallow errors
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/handle-callback-err.md
-          "node/handle-callback-err": "error",
-          // ── Prefer global builtins ────────────────────────────────────
-          // Use global Buffer instead of require('buffer').Buffer
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/prefer-global/buffer.md
-          "node/prefer-global/buffer": ["error", "always"],
-          // Use global console — always available in Node.js
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/prefer-global/console.md
-          "node/prefer-global/console": ["error", "always"],
-          // Use global process — always available in Node.js
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/prefer-global/process.md
-          "node/prefer-global/process": ["error", "always"],
-          // Use global URL — available since Node.js 10
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/prefer-global/url.md
-          "node/prefer-global/url": ["error", "always"],
-          // Use global URLSearchParams — available since Node.js 10
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/prefer-global/url-search-params.md
-          "node/prefer-global/url-search-params": ["error", "always"],
-          // ── Prefer promise-based APIs ─────────────────────────────────
-          // Use dns.promises instead of callback-based dns — modern async
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/prefer-promises/dns.md
-          "node/prefer-promises/dns": "error",
-          // Use fs.promises instead of callback-based fs — modern async
-          // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/prefer-promises/fs.md
-          "node/prefer-promises/fs": "error"
-        }
-      }
-    ],
-    plugins: { node: nodePlugin },
-    languageOptions: { globals: { ...globals.node } }
-  });
-  if (isAi) {
-    builder.addRule("node/no-unsupported-features/node-builtins", "error");
-  }
-  return builder.build();
+	const isAi = opts?.ai ?? false;
+	const builder = createConfig({
+		name: "eslint-config-setup/node",
+		presets: [{ rules: {
+			"node/no-deprecated-api": "error",
+			"node/no-exports-assign": "error",
+			"node/no-missing-import": "off",
+			"node/no-missing-require": "off",
+			"node/no-process-exit": "warn",
+			"node/no-unpublished-import": "off",
+			"node/hashbang": "error",
+			"node/no-path-concat": "error",
+			"node/process-exit-as-throw": "error",
+			"node/handle-callback-err": "error",
+			"node/prefer-global/buffer": ["error", "always"],
+			"node/prefer-global/console": ["error", "always"],
+			"node/prefer-global/process": ["error", "always"],
+			"node/prefer-global/url": ["error", "always"],
+			"node/prefer-global/url-search-params": ["error", "always"],
+			"node/prefer-promises/dns": "error",
+			"node/prefer-promises/fs": "error"
+		} }],
+		plugins: { node: nodePlugin },
+		languageOptions: { globals: { ...globals.node } }
+	});
+	if (isAi) builder.addRule("node/no-unsupported-features/node-builtins", "error");
+	return builder.build();
 }
-
-// src/configs/package-json.ts
-import { configs as packageJsonConfigs } from "eslint-plugin-package-json";
+//#endregion
+//#region src/configs/package-json.ts
+/**
+* Package.json config — semantic validation of package.json files.
+*
+* Uses the recommended preset from eslint-plugin-package-json which includes:
+* - All valid-* rules (only fire on malformed existing fields, never on missing)
+* - Conservative require-* rules with ignorePrivate: true by default
+* - Quality rules (no-empty-fields, unique-dependencies, etc.)
+*
+* Sorting/ordering rules are off by default — enabled only in AI mode.
+*
+* @see https://github.com/JoshuaKGoldberg/eslint-plugin-package-json
+*/
 function packageJsonConfig() {
-  const recommended = packageJsonConfigs.recommended;
-  return [
-    {
-      ...recommended,
-      name: "eslint-config-setup/package-json"
-    }
-  ];
+	return [{
+		...configs.recommended,
+		name: "eslint-config-setup/package-json"
+	}];
 }
+/**
+* Package.json AI config — enables ordering and sorting rules.
+* Only active in AI mode where deterministic structure is enforced.
+*/
 function packageJsonAiConfig() {
-  return [
-    {
-      name: "eslint-config-setup/package-json-ai",
-      files: ["**/package.json"],
-      rules: {
-        // Enforce consistent property ordering in package.json
-        // https://github.com/JoshuaKGoldberg/eslint-plugin-package-json
-        "package-json/order-properties": "error",
-        // Sort dependencies, scripts, exports, etc. alphabetically
-        // https://github.com/JoshuaKGoldberg/eslint-plugin-package-json
-        "package-json/sort-collections": "error"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/package-json-ai",
+		files: ["**/package.json"],
+		rules: {
+			"package-json/order-properties": "error",
+			"package-json/sort-collections": "error"
+		}
+	}];
 }
-
-// src/configs/perfectionist.ts
-import perfectionistPlugin from "eslint-plugin-perfectionist";
+//#endregion
+//#region src/configs/perfectionist.ts
+/**
+* Perfectionist config — deterministic sorting of code elements.
+*
+* Sorts everything Prettier doesn't: imports, exports, union types,
+* object keys, interface members, etc. Especially valuable for
+* AI-generated code where ordering is arbitrary.
+*
+* Replaces `simple-import-sort` — perfectionist handles everything
+* simple-import-sort does, plus TypeScript path alias recognition
+* and named import sorting.
+*
+* Core philosophy: `partitionByNewLine: true` globally — semantic
+* grouping via blank lines is preserved, within groups natural sort.
+*
+* @see https://perfectionist.dev
+*/
+/**
+* Mechanical sorting rules — always active.
+* These have no semantic dimension: the order of imports, named exports,
+* or union type members carries no meaning.
+*/
 function perfectionistConfig() {
-  return [
-    {
-      name: "eslint-config-setup/perfectionist",
-      plugins: {
-        perfectionist: perfectionistPlugin
-      },
-      settings: {
-        perfectionist: {
-          type: "natural",
-          order: "asc",
-          partitionByNewLine: true
-        }
-      },
-      rules: {
-        // Auto-sort import statements — deterministic ordering regardless of input
-        // Replaces simple-import-sort/imports
-        // https://perfectionist.dev/rules/sort-imports
-        "perfectionist/sort-imports": [
-          "error",
-          {
-            partitionByNewLine: false
-          }
-        ],
-        // Sort specifiers inside `import { a, b, c }` — deterministic
-        // https://perfectionist.dev/rules/sort-named-imports
-        "perfectionist/sort-named-imports": "error",
-        // Sort specifiers inside `export { a, b, c }` — deterministic
-        // https://perfectionist.dev/rules/sort-named-exports
-        "perfectionist/sort-named-exports": "error",
-        // Auto-sort export statements — deterministic ordering
-        // Replaces simple-import-sort/exports
-        // https://perfectionist.dev/rules/sort-exports
-        "perfectionist/sort-exports": "error",
-        // Sort union type members — `number | string` has no semantic order
-        // https://perfectionist.dev/rules/sort-union-types
-        "perfectionist/sort-union-types": "error",
-        // Sort intersection type members — `A & B` has no semantic order
-        // https://perfectionist.dev/rules/sort-intersection-types
-        "perfectionist/sort-intersection-types": "error"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/perfectionist",
+		plugins: { perfectionist: perfectionistPlugin },
+		settings: { perfectionist: {
+			type: "natural",
+			order: "asc",
+			partitionByNewLine: true
+		} },
+		rules: {
+			"perfectionist/sort-imports": ["error", { partitionByNewLine: false }],
+			"perfectionist/sort-named-imports": "error",
+			"perfectionist/sort-named-exports": "error",
+			"perfectionist/sort-exports": "error",
+			"perfectionist/sort-union-types": "error",
+			"perfectionist/sort-intersection-types": "error"
+		}
+	}];
 }
+/**
+* Structural sorting rules — AI mode only.
+* These sort code elements that *could* have semantic ordering
+* (e.g., object keys grouped by concern). Enforcing alphabetical
+* order here is a trade-off: consistency over intent. Worth it
+* for AI-generated code where "intent" is often random.
+*/
 function perfectionistAiConfig() {
-  return [
-    {
-      name: "eslint-config-setup/perfectionist-ai",
-      rules: {
-        // Sort interface members — consistent shape definitions
-        // https://perfectionist.dev/rules/sort-interfaces
-        "perfectionist/sort-interfaces": "error",
-        // Sort object type members — consistent type definitions
-        // https://perfectionist.dev/rules/sort-object-types
-        "perfectionist/sort-object-types": "error",
-        // Sort enum members — consistent enum definitions
-        // https://perfectionist.dev/rules/sort-enums
-        "perfectionist/sort-enums": "error",
-        // Sort JSX props — consistent component usage
-        // https://perfectionist.dev/rules/sort-jsx-props
-        "perfectionist/sort-jsx-props": "error",
-        // Sort object keys — consistent object literals
-        // https://perfectionist.dev/rules/sort-objects
-        "perfectionist/sort-objects": "error",
-        // Sort class members — consistent class structure
-        // https://perfectionist.dev/rules/sort-classes
-        "perfectionist/sort-classes": "error",
-        // Sort switch cases — consistent case ordering
-        // https://perfectionist.dev/rules/sort-switch-case
-        "perfectionist/sort-switch-case": "error",
-        // Sort Map entries — consistent Map initialization
-        // https://perfectionist.dev/rules/sort-maps
-        "perfectionist/sort-maps": "error",
-        // Sort Set entries — consistent Set initialization
-        // https://perfectionist.dev/rules/sort-sets
-        "perfectionist/sort-sets": "error",
-        // Sort array.includes() members — consistent membership checks
-        // https://perfectionist.dev/rules/sort-array-includes
-        "perfectionist/sort-array-includes": "error"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/perfectionist-ai",
+		rules: {
+			"perfectionist/sort-interfaces": "error",
+			"perfectionist/sort-object-types": "error",
+			"perfectionist/sort-enums": "error",
+			"perfectionist/sort-jsx-props": "error",
+			"perfectionist/sort-objects": "error",
+			"perfectionist/sort-classes": "error",
+			"perfectionist/sort-switch-case": "error",
+			"perfectionist/sort-maps": "error",
+			"perfectionist/sort-sets": "error",
+			"perfectionist/sort-array-includes": "error"
+		}
+	}];
 }
-
-// src/configs/prettier.ts
-import prettierConfig from "eslint-config-prettier";
+//#endregion
+//#region src/configs/prettier.ts
+/**
+* Prettier compat config — disables all ESLint rules that conflict with Prettier.
+* Must be the last config block (before OxLint if enabled).
+*
+* Preset: eslint-config-prettier (turns off ~30 formatting rules)
+* @see https://github.com/prettier/eslint-config-prettier#readme
+*/
 function prettierCompatConfig() {
-  return createConfig({
-    name: "eslint-config-setup/prettier",
-    presets: [prettierConfig]
-  }).build();
+	return createConfig({
+		name: "eslint-config-setup/prettier",
+		presets: [prettierConfig]
+	}).build();
 }
-
-// src/configs/react.ts
-import eslintReactPlugin2 from "@eslint-react/eslint-plugin";
-import stylisticPlugin from "@stylistic/eslint-plugin";
-import jsxA11yPlugin from "eslint-plugin-jsx-a11y";
-import reactHooksPlugin from "eslint-plugin-react-hooks";
-import reactPerfPlugin from "eslint-plugin-react-perf";
-import reactRefreshPlugin from "eslint-plugin-react-refresh";
-import globals2 from "globals";
-
-// src/file-patterns.ts
-var TYPESCRIPT_SOURCE_FILES = [
-  "**/*.ts",
-  "**/*.tsx",
-  "**/*.mts",
-  "**/*.cts"
+//#endregion
+//#region src/file-patterns.ts
+const TYPESCRIPT_SOURCE_FILES = [
+	"**/*.ts",
+	"**/*.tsx",
+	"**/*.mts",
+	"**/*.cts"
 ];
-var MARKDOWN_CODE_BLOCK_FILES = ["**/*.{md,mdx}/**"];
-
-// src/plugins/react-compat.ts
-import eslintReactPlugin from "@eslint-react/eslint-plugin";
-var coreRules = eslintReactPlugin.rules;
+const MARKDOWN_CODE_BLOCK_FILES = ["**/*.{md,mdx}/**"];
+//#endregion
+//#region src/plugins/react-compat.ts
+/**
+* React Compat Plugin — merges all `@eslint-react` sub-plugins into a single
+* `react` namespace and re-exports rules under legacy `eslint-plugin-react`
+* names where a 1:1 equivalent exists.
+*
+* **Why?** OxLint implements many React rules under the classic `react/` prefix
+* with legacy names (e.g. `react/jsx-key`, `react/no-danger`). By registering
+* the modern `@eslint-react` rule implementations under those legacy names, we
+* get automatic OxLint coverage — OxLint runs the fast Rust check and ESLint
+* skips the JS version via `eslint-plugin-oxlint`'s `flat/react` config.
+*
+* Rules without a legacy equivalent keep their `@eslint-react` short name
+* (e.g. `react/no-context-provider`, `react/no-leaked-event-listener`).
+* As OxLint expands React support, more rules will automatically be covered.
+*
+* @see https://eslint-react.xyz/docs/rules/overview - `@eslint-react` rules overview
+* @see https://oxc.rs/docs/guide/usage/linter/rules.html - OxLint rules
+*/
+const coreRules = eslintReactPlugin.rules;
 function selectPrefixedRules(prefix) {
-  const result = {};
-  for (const [name, rule] of Object.entries(coreRules)) {
-    if (name.startsWith(prefix)) {
-      result[name.slice(prefix.length)] = rule;
-    }
-  }
-  return result;
+	const result = {};
+	for (const [name, rule] of Object.entries(coreRules)) if (name.startsWith(prefix)) result[name.slice(prefix.length)] = rule;
+	return result;
 }
-var domRules = selectPrefixedRules("dom-");
-var jsxRules = selectPrefixedRules("jsx-");
-var namingRules = selectPrefixedRules("naming-convention-");
-var rscRules = selectPrefixedRules("rsc-");
-var webApiRules = selectPrefixedRules("web-api-");
-var LEGACY_ALIASES = {
-  // ── Core: identical names ──────────────────────────────────────────
-  "no-access-state-in-setstate": [coreRules, "no-access-state-in-setstate"],
-  "no-array-index-key": [coreRules, "no-array-index-key"],
-  "no-children-prop": [jsxRules, "no-children-prop"],
-  "no-direct-mutation-state": [coreRules, "no-direct-mutation-state"],
-  "no-unused-class-component-members": [
-    coreRules,
-    "no-unused-class-component-members"
-  ],
-  "no-unused-state": [coreRules, "no-unused-state"],
-  "jsx-no-comment-textnodes": [jsxRules, "no-comment-textnodes"],
-  // ── Core: renamed 1:1 ──────────────────────────────────────────────
-  "jsx-key": [coreRules, "no-missing-key"],
-  "jsx-key-before-spread": [jsxRules, "no-key-after-spread"],
-  "jsx-no-constructed-context-values": [
-    coreRules,
-    "no-unstable-context-value"
-  ],
-  "jsx-no-leaked-render": [coreRules, "no-leaked-conditional-rendering"],
-  "jsx-no-useless-fragment": [jsxRules, "no-useless-fragment"],
-  "no-object-type-as-default-prop": [coreRules, "no-unstable-default-props"],
-  "no-unstable-nested-components": [
-    coreRules,
-    "no-nested-component-definitions"
-  ],
-  "display-name": [coreRules, "no-missing-component-display-name"],
-  "forward-ref-uses-ref": [coreRules, "no-forward-ref"],
-  "no-did-mount-set-state": [
-    coreRules,
-    "no-set-state-in-component-did-mount"
-  ],
-  "no-did-update-set-state": [
-    coreRules,
-    "no-set-state-in-component-did-update"
-  ],
-  "no-will-update-set-state": [
-    coreRules,
-    "no-set-state-in-component-will-update"
-  ],
-  // ── Naming convention → legacy names ───────────────────────────────
-  "hook-use-state": [coreRules, "use-state"],
-  // ── DOM → legacy react/ names (not react-dom/) ─────────────────────
-  "no-danger": [domRules, "no-dangerously-set-innerhtml"],
-  "no-danger-with-children": [
-    domRules,
-    "no-dangerously-set-innerhtml-with-children"
-  ],
-  "no-find-dom-node": [domRules, "no-find-dom-node"],
-  "no-namespace": [jsxRules, "no-namespace"],
-  "no-render-return-value": [domRules, "no-render-return-value"],
-  "jsx-no-script-url": [domRules, "no-script-url"],
-  "jsx-no-target-blank": [domRules, "no-unsafe-target-blank"],
-  "no-unknown-property": [domRules, "no-unknown-property"],
-  "void-dom-elements-no-children": [
-    domRules,
-    "no-void-elements-with-children"
-  ],
-  "button-has-type": [domRules, "no-missing-button-type"],
-  "iframe-missing-sandbox": [domRules, "no-missing-iframe-sandbox"],
-  "style-prop-object": [domRules, "no-string-style-prop"]
+const domRules = selectPrefixedRules("dom-");
+const jsxRules = selectPrefixedRules("jsx-");
+const namingRules = selectPrefixedRules("naming-convention-");
+const rscRules = selectPrefixedRules("rsc-");
+const webApiRules = selectPrefixedRules("web-api-");
+const LEGACY_ALIASES = {
+	"no-access-state-in-setstate": [coreRules, "no-access-state-in-setstate"],
+	"no-array-index-key": [coreRules, "no-array-index-key"],
+	"no-children-prop": [jsxRules, "no-children-prop"],
+	"no-direct-mutation-state": [coreRules, "no-direct-mutation-state"],
+	"no-unused-class-component-members": [coreRules, "no-unused-class-component-members"],
+	"no-unused-state": [coreRules, "no-unused-state"],
+	"jsx-no-comment-textnodes": [jsxRules, "no-comment-textnodes"],
+	"jsx-key": [coreRules, "no-missing-key"],
+	"jsx-key-before-spread": [jsxRules, "no-key-after-spread"],
+	"jsx-no-constructed-context-values": [coreRules, "no-unstable-context-value"],
+	"jsx-no-leaked-render": [coreRules, "no-leaked-conditional-rendering"],
+	"jsx-no-useless-fragment": [jsxRules, "no-useless-fragment"],
+	"no-object-type-as-default-prop": [coreRules, "no-unstable-default-props"],
+	"no-unstable-nested-components": [coreRules, "no-nested-component-definitions"],
+	"display-name": [coreRules, "no-missing-component-display-name"],
+	"forward-ref-uses-ref": [coreRules, "no-forward-ref"],
+	"no-did-mount-set-state": [coreRules, "no-set-state-in-component-did-mount"],
+	"no-did-update-set-state": [coreRules, "no-set-state-in-component-did-update"],
+	"no-will-update-set-state": [coreRules, "no-set-state-in-component-will-update"],
+	"hook-use-state": [coreRules, "use-state"],
+	"no-danger": [domRules, "no-dangerously-set-innerhtml"],
+	"no-danger-with-children": [domRules, "no-dangerously-set-innerhtml-with-children"],
+	"no-find-dom-node": [domRules, "no-find-dom-node"],
+	"no-namespace": [jsxRules, "no-namespace"],
+	"no-render-return-value": [domRules, "no-render-return-value"],
+	"jsx-no-script-url": [domRules, "no-script-url"],
+	"jsx-no-target-blank": [domRules, "no-unsafe-target-blank"],
+	"no-unknown-property": [domRules, "no-unknown-property"],
+	"void-dom-elements-no-children": [domRules, "no-void-elements-with-children"],
+	"button-has-type": [domRules, "no-missing-button-type"],
+	"iframe-missing-sandbox": [domRules, "no-missing-iframe-sandbox"],
+	"style-prop-object": [domRules, "no-string-style-prop"]
 };
-var aliasedOriginals = /* @__PURE__ */ new Set();
-for (const [source, originalName] of Object.values(LEGACY_ALIASES)) {
-  if (source === coreRules) {
-    aliasedOriginals.add(originalName);
-  } else if (source === domRules) {
-    aliasedOriginals.add(`dom-${originalName}`);
-  } else if (source === jsxRules) {
-    aliasedOriginals.add(`jsx-${originalName}`);
-  } else if (source === namingRules) {
-    aliasedOriginals.add(`naming-convention-${originalName}`);
-  } else if (source === rscRules) {
-    aliasedOriginals.add(`rsc-${originalName}`);
-  } else if (source === webApiRules) {
-    aliasedOriginals.add(`web-api-${originalName}`);
-  }
-}
-var mergedRules = {};
-for (const [name, rule] of Object.entries(coreRules)) {
-  if (!aliasedOriginals.has(name)) {
-    mergedRules[name] = rule;
-  }
-}
-var subPlugins = [
-  [domRules, /* @__PURE__ */ new Set(["prefer-namespace-import"])],
-  [jsxRules, /* @__PURE__ */ new Set()],
-  [webApiRules, /* @__PURE__ */ new Set()],
-  [namingRules, /* @__PURE__ */ new Set()],
-  [rscRules, /* @__PURE__ */ new Set()]
+const aliasedOriginals = /* @__PURE__ */ new Set();
+for (const [source, originalName] of Object.values(LEGACY_ALIASES)) if (source === coreRules) aliasedOriginals.add(originalName);
+else if (source === domRules) aliasedOriginals.add(`dom-${originalName}`);
+else if (source === jsxRules) aliasedOriginals.add(`jsx-${originalName}`);
+else if (source === namingRules) aliasedOriginals.add(`naming-convention-${originalName}`);
+else if (source === rscRules) aliasedOriginals.add(`rsc-${originalName}`);
+else if (source === webApiRules) aliasedOriginals.add(`web-api-${originalName}`);
+const mergedRules = {};
+for (const [name, rule] of Object.entries(coreRules)) if (!aliasedOriginals.has(name)) mergedRules[name] = rule;
+const subPlugins = [
+	[domRules, /* @__PURE__ */ new Set(["prefer-namespace-import"])],
+	[jsxRules, /* @__PURE__ */ new Set()],
+	[webApiRules, /* @__PURE__ */ new Set()],
+	[namingRules, /* @__PURE__ */ new Set()],
+	[rscRules, /* @__PURE__ */ new Set()]
 ];
-for (const [rules, skip] of subPlugins) {
-  for (const [name, rule] of Object.entries(rules)) {
-    if (skip.has(name)) continue;
-    const isAliased = Object.values(LEGACY_ALIASES).some(
-      ([source, originalName]) => source === rules && originalName === name
-    );
-    if (!isAliased) {
-      mergedRules[name] = rule;
-    }
-  }
-}
-for (const [legacyName, [source, originalName]] of Object.entries(
-  LEGACY_ALIASES
-)) {
-  mergedRules[legacyName] = source[originalName];
+for (const [rules, skip] of subPlugins) for (const [name, rule] of Object.entries(rules)) {
+	if (skip.has(name)) continue;
+	if (!Object.values(LEGACY_ALIASES).some(([source, originalName]) => source === rules && originalName === name)) mergedRules[name] = rule;
 }
-var originalToCompat = /* @__PURE__ */ new Map();
+for (const [legacyName, [source, originalName]] of Object.entries(LEGACY_ALIASES)) mergedRules[legacyName] = source[originalName];
+const originalToCompat = /* @__PURE__ */ new Map();
 for (const [legacyName, [source, originalName]] of Object.entries(LEGACY_ALIASES)) {
-  originalToCompat.set(originalName, legacyName);
-  if (source === domRules) {
-    originalToCompat.set(`dom-${originalName}`, legacyName);
-  } else if (source === jsxRules) {
-    originalToCompat.set(`jsx-${originalName}`, legacyName);
-  } else if (source === namingRules) {
-    originalToCompat.set(`naming-convention-${originalName}`, legacyName);
-  } else if (source === rscRules) {
-    originalToCompat.set(`rsc-${originalName}`, legacyName);
-  } else if (source === webApiRules) {
-    originalToCompat.set(`web-api-${originalName}`, legacyName);
-  }
+	originalToCompat.set(originalName, legacyName);
+	if (source === domRules) originalToCompat.set(`dom-${originalName}`, legacyName);
+	else if (source === jsxRules) originalToCompat.set(`jsx-${originalName}`, legacyName);
+	else if (source === namingRules) originalToCompat.set(`naming-convention-${originalName}`, legacyName);
+	else if (source === rscRules) originalToCompat.set(`rsc-${originalName}`, legacyName);
+	else if (source === webApiRules) originalToCompat.set(`web-api-${originalName}`, legacyName);
 }
-function translatePresetRules(presetRules2) {
-  const result = {};
-  for (const [key, value] of Object.entries(presetRules2)) {
-    const shortName = key.replace(
-      /^@eslint-react\/(?:dom|web-api|naming-convention|rsc)\//,
-      ""
-    ).replace(/^@eslint-react\//, "").replace(/^(?:dom|web-api|naming-convention|rsc)-/, "");
-    const compatName = originalToCompat.get(shortName) ?? shortName;
-    if (compatName in mergedRules) {
-      result[`react/${compatName}`] = value;
-    }
-  }
-  return result;
+/**
+* Translates rules from an `@eslint-react` preset (e.g. `recommended`, `strict`)
+* into `react/` compat names that match our unified plugin namespace.
+*
+* Example: `"@eslint-react/no-missing-key": "error"` → `"react/jsx-key": "error"`
+*/
+function translatePresetRules(presetRules) {
+	const result = {};
+	for (const [key, value] of Object.entries(presetRules)) {
+		const shortName = key.replace(/^@eslint-react\/(?:dom|web-api|naming-convention|rsc)\//, "").replace(/^@eslint-react\//, "").replace(/^(?:dom|web-api|naming-convention|rsc)-/, "");
+		const compatName = originalToCompat.get(shortName) ?? shortName;
+		if (compatName in mergedRules) result[`react/${compatName}`] = value;
+	}
+	return result;
 }
-var reactCompatPlugin = {
-  meta: {
-    name: "react-compat",
-    version: "1.0.0"
-  },
-  rules: mergedRules
+/**
+* Unified React plugin registered as `react` in ESLint flat config.
+* Contains all `@eslint-react` rule implementations under OxLint-compatible names.
+*/
+const reactCompatPlugin = {
+	meta: {
+		name: "react-compat",
+		version: "1.0.0"
+	},
+	rules: mergedRules
 };
-
-// src/configs/react.ts
-var typedConfigs = eslintReactPlugin2.configs;
-var strictTypeCheckedRules = typedConfigs["strict-type-checked"].rules;
-var REACT_HOOKS_REPLACED_ESLINT_REACT_RULES = [
-  "error-boundaries",
-  "exhaustive-deps",
-  "purity",
-  "rules-of-hooks",
-  "set-state-in-effect",
-  "set-state-in-render",
-  "static-components",
-  "unsupported-syntax",
-  "use-memo"
-];
-var reactHooksReplacedRules = new Set(
-  REACT_HOOKS_REPLACED_ESLINT_REACT_RULES
-);
+//#endregion
+//#region src/configs/react.ts
+const strictTypeCheckedRules = eslintReactPlugin.configs["strict-type-checked"].rules;
+const reactHooksReplacedRules = /* @__PURE__ */ new Set([
+	"error-boundaries",
+	"exhaustive-deps",
+	"purity",
+	"rules-of-hooks",
+	"set-state-in-effect",
+	"set-state-in-render",
+	"static-components",
+	"unsupported-syntax",
+	"use-memo"
+]);
 function filterReactHooksRules(rules) {
-  const filtered = {};
-  for (const [ruleName, value] of Object.entries(rules)) {
-    const shortName = ruleName.replace(/^@eslint-react\//, "");
-    if (!reactHooksReplacedRules.has(shortName)) {
-      filtered[ruleName] = value;
-    }
-  }
-  return filtered;
+	const filtered = {};
+	for (const [ruleName, value] of Object.entries(rules)) {
+		const shortName = ruleName.replace(/^@eslint-react\//, "");
+		if (!reactHooksReplacedRules.has(shortName)) filtered[ruleName] = value;
+	}
+	return filtered;
 }
-var presetRules = translatePresetRules(filterReactHooksRules(strictTypeCheckedRules));
-var reactHooksRecommendedLatest = reactHooksPlugin.configs.flat["recommended-latest"];
-var reactHooksPluginForEslint = reactHooksPlugin;
-var EXTRA_REACT_RULES = {
-  "react/no-duplicate-key": "error",
-  "react/no-implicit-key": "error",
-  "react/no-unknown-property": "error",
-  "react/style-prop-object": "error"
-};
-var AI_ADDED_REACT_RULES = {
-  "react/no-unused-state": "error"
+const presetRules = translatePresetRules(filterReactHooksRules(strictTypeCheckedRules));
+const reactHooksRecommendedLatest = reactHooksPlugin.configs.flat["recommended-latest"];
+const reactHooksPluginForEslint = reactHooksPlugin;
+const EXTRA_REACT_RULES = {
+	"react/no-duplicate-key": "error",
+	"react/no-implicit-key": "error",
+	"react/no-unknown-property": "error",
+	"react/style-prop-object": "error"
 };
-var AI_REACT_PERF_RULES = {
-  "react-perf/jsx-no-jsx-as-prop": "error",
-  "react-perf/jsx-no-new-array-as-prop": "error",
-  "react-perf/jsx-no-new-function-as-prop": "error",
-  "react-perf/jsx-no-new-object-as-prop": "error"
+const AI_ADDED_REACT_RULES = { "react/no-unused-state": "error" };
+const AI_REACT_PERF_RULES = {
+	"react-perf/jsx-no-jsx-as-prop": "error",
+	"react-perf/jsx-no-new-array-as-prop": "error",
+	"react-perf/jsx-no-new-function-as-prop": "error",
+	"react-perf/jsx-no-new-object-as-prop": "error"
 };
-var JSX_A11Y_ERROR_RULES = {
-  "jsx-a11y/alt-text": "error",
-  "jsx-a11y/anchor-has-content": "error",
-  "jsx-a11y/anchor-is-valid": "error",
-  "jsx-a11y/aria-activedescendant-has-tabindex": "error",
-  "jsx-a11y/aria-props": "error",
-  "jsx-a11y/aria-proptypes": "error",
-  "jsx-a11y/aria-role": "error",
-  "jsx-a11y/aria-unsupported-elements": "error",
-  "jsx-a11y/click-events-have-key-events": "error",
-  "jsx-a11y/heading-has-content": "error",
-  "jsx-a11y/html-has-lang": "error",
-  "jsx-a11y/img-redundant-alt": "error",
-  "jsx-a11y/label-has-associated-control": "error",
-  "jsx-a11y/mouse-events-have-key-events": "error",
-  "jsx-a11y/no-access-key": "error",
-  "jsx-a11y/no-distracting-elements": "error",
-  "jsx-a11y/no-redundant-roles": "error",
-  "jsx-a11y/role-has-required-aria-props": "error",
-  "jsx-a11y/role-supports-aria-props": "error",
-  "jsx-a11y/scope": "error",
-  "jsx-a11y/tabindex-no-positive": "error",
-  "jsx-a11y/lang": "error",
-  "jsx-a11y/autocomplete-valid": "error"
+const JSX_A11Y_ERROR_RULES = {
+	"jsx-a11y/alt-text": "error",
+	"jsx-a11y/anchor-has-content": "error",
+	"jsx-a11y/anchor-is-valid": "error",
+	"jsx-a11y/aria-activedescendant-has-tabindex": "error",
+	"jsx-a11y/aria-props": "error",
+	"jsx-a11y/aria-proptypes": "error",
+	"jsx-a11y/aria-role": "error",
+	"jsx-a11y/aria-unsupported-elements": "error",
+	"jsx-a11y/click-events-have-key-events": "error",
+	"jsx-a11y/heading-has-content": "error",
+	"jsx-a11y/html-has-lang": "error",
+	"jsx-a11y/img-redundant-alt": "error",
+	"jsx-a11y/label-has-associated-control": "error",
+	"jsx-a11y/mouse-events-have-key-events": "error",
+	"jsx-a11y/no-access-key": "error",
+	"jsx-a11y/no-distracting-elements": "error",
+	"jsx-a11y/no-redundant-roles": "error",
+	"jsx-a11y/role-has-required-aria-props": "error",
+	"jsx-a11y/role-supports-aria-props": "error",
+	"jsx-a11y/scope": "error",
+	"jsx-a11y/tabindex-no-positive": "error",
+	"jsx-a11y/lang": "error",
+	"jsx-a11y/autocomplete-valid": "error"
 };
-var AI_PROMOTED_REACT_RULES = [
-  "react/jsx-no-comment-textnodes",
-  "react/jsx-no-useless-fragment",
-  "react/jsx-no-constructed-context-values",
-  "react/no-array-index-key",
-  "react/no-object-type-as-default-prop",
-  "react/jsx-no-target-blank",
-  "react/button-has-type",
-  "react/iframe-missing-sandbox",
-  "react/forward-ref-uses-ref",
-  "react/no-context-provider",
-  "react/no-use-context",
-  "react/no-leaked-event-listener",
-  "react/no-leaked-interval",
-  "react/no-leaked-timeout",
-  "react/no-leaked-resize-observer"
+const AI_PROMOTED_REACT_RULES = [
+	"react/jsx-no-comment-textnodes",
+	"react/jsx-no-useless-fragment",
+	"react/jsx-no-constructed-context-values",
+	"react/no-array-index-key",
+	"react/no-object-type-as-default-prop",
+	"react/jsx-no-target-blank",
+	"react/button-has-type",
+	"react/iframe-missing-sandbox",
+	"react/forward-ref-uses-ref",
+	"react/no-context-provider",
+	"react/no-use-context",
+	"react/no-leaked-event-listener",
+	"react/no-leaked-interval",
+	"react/no-leaked-timeout",
+	"react/no-leaked-resize-observer"
 ];
-var AI_A11Y_RULES = [
-  "jsx-a11y/no-static-element-interactions",
-  "jsx-a11y/no-noninteractive-element-interactions",
-  "jsx-a11y/interactive-supports-focus"
+const AI_A11Y_RULES = [
+	"jsx-a11y/no-static-element-interactions",
+	"jsx-a11y/no-noninteractive-element-interactions",
+	"jsx-a11y/interactive-supports-focus"
 ];
-function addRules2(builder, rules) {
-  for (const [ruleName, value] of Object.entries(rules)) {
-    builder.addRule(ruleName, value);
-  }
+function addRules(builder, rules) {
+	for (const [ruleName, value] of Object.entries(rules)) builder.addRule(ruleName, value);
 }
 function addExtraReactRules(builder) {
-  addRules2(builder, EXTRA_REACT_RULES);
+	addRules(builder, EXTRA_REACT_RULES);
 }
 function addStylisticReactRules(builder) {
-  builder.addRule("@stylistic/jsx-self-closing-comp", "error");
-  builder.addRule("@stylistic/jsx-curly-brace-presence", [
-    "error",
-    { props: "never", children: "never" }
-  ]);
+	builder.addRule("@stylistic/jsx-self-closing-comp", "error");
+	builder.addRule("@stylistic/jsx-curly-brace-presence", ["error", {
+		props: "never",
+		children: "never"
+	}]);
 }
 function addReactRefreshRules(builder) {
-  builder.addRule("react-refresh/only-export-components", [
-    "warn",
-    { allowConstantExport: true }
-  ]);
+	builder.addRule("react-refresh/only-export-components", ["warn", { allowConstantExport: true }]);
 }
 function addAccessibilityRules(builder) {
-  addRules2(builder, JSX_A11Y_ERROR_RULES);
-  builder.addRule("jsx-a11y/no-autofocus", ["error", { ignoreNonDOM: true }]);
+	addRules(builder, JSX_A11Y_ERROR_RULES);
+	builder.addRule("jsx-a11y/no-autofocus", ["error", { ignoreNonDOM: true }]);
 }
 function applyAiReactRules(builder) {
-  for (const ruleName of AI_PROMOTED_REACT_RULES) {
-    builder.overrideSeverity(ruleName, "error");
-  }
-  addRules2(builder, AI_ADDED_REACT_RULES);
-  addRules2(builder, AI_REACT_PERF_RULES);
-  for (const ruleName of AI_A11Y_RULES) {
-    builder.addRule(ruleName, "error");
-  }
+	for (const ruleName of AI_PROMOTED_REACT_RULES) builder.overrideSeverity(ruleName, "error");
+	addRules(builder, AI_ADDED_REACT_RULES);
+	addRules(builder, AI_REACT_PERF_RULES);
+	for (const ruleName of AI_A11Y_RULES) builder.addRule(ruleName, "error");
 }
 function addReactFileOverrides(builder) {
-  builder.addFileOverride(
-    "eslint-config-setup/react-typescript",
-    [...TYPESCRIPT_SOURCE_FILES],
-    {
-      // Allow async event handlers — onClick={async () => {...}} is idiomatic React
-      "@typescript-eslint/no-misused-promises": [
-        "error",
-        { checksVoidReturn: false }
-      ]
-    }
-  );
+	builder.addFileOverride("eslint-config-setup/react-typescript", [...TYPESCRIPT_SOURCE_FILES], { "@typescript-eslint/no-misused-promises": ["error", { checksVoidReturn: false }] });
 }
+/**
+* React config — React 19+, Hooks, JSX accessibility, and Web API leak detection.
+*
+* Uses `@eslint-react` (eslint-plugin-react-x) for React, DOM, Web API,
+* naming-convention, and RSC rules under the `react/` compat namespace.
+* Rules of Hooks and React Compiler linting come from Meta's
+* eslint-plugin-react-hooks under the native `react-hooks/` namespace.
+*
+* Base React severities come from the `@eslint-react` `strict-type-checked` preset.
+* When `ai: true`, preset "warn" rules that AI should always get right are
+* promoted to "error", and React performance rules are enabled as errors.
+*
+* @see https://eslint-react.xyz/docs/rules/overview
+* @see https://www.npmjs.com/package/eslint-plugin-react-hooks
+* @see https://github.com/cvazac/eslint-plugin-react-perf
+* @see https://github.com/ArnaudBarre/eslint-plugin-react-refresh
+* @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y#supported-rules
+*/
 function reactConfig(opts) {
-  const isAi = opts?.ai ?? false;
-  const builder = createConfig({
-    name: "eslint-config-setup/react",
-    presets: [{ rules: presetRules }, reactHooksRecommendedLatest],
-    plugins: {
-      react: reactCompatPlugin,
-      "@stylistic": stylisticPlugin,
-      "react-hooks": reactHooksPluginForEslint,
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Plugin from untyped module
-      "react-perf": reactPerfPlugin,
-      "react-refresh": reactRefreshPlugin,
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Plugin from untyped module
-      "jsx-a11y": jsxA11yPlugin
-    },
-    languageOptions: {
-      globals: {
-        ...globals2.browser
-      },
-      parserOptions: {
-        ecmaFeatures: {
-          jsx: true
-        }
-      }
-    }
-  });
-  addExtraReactRules(builder);
-  addStylisticReactRules(builder);
-  addReactRefreshRules(builder);
-  addAccessibilityRules(builder);
-  if (isAi) {
-    applyAiReactRules(builder);
-  }
-  addReactFileOverrides(builder);
-  return builder.build();
+	const isAi = opts?.ai ?? false;
+	const builder = createConfig({
+		name: "eslint-config-setup/react",
+		presets: [{ rules: presetRules }, reactHooksRecommendedLatest],
+		plugins: {
+			react: reactCompatPlugin,
+			"@stylistic": stylisticPlugin,
+			"react-hooks": reactHooksPluginForEslint,
+			"react-perf": reactPerfPlugin,
+			"react-refresh": reactRefreshPlugin,
+			"jsx-a11y": jsxA11yPlugin
+		},
+		languageOptions: {
+			globals: { ...globals.browser },
+			parserOptions: { ecmaFeatures: { jsx: true } }
+		}
+	});
+	addExtraReactRules(builder);
+	addStylisticReactRules(builder);
+	addReactRefreshRules(builder);
+	addAccessibilityRules(builder);
+	if (isAi) applyAiReactRules(builder);
+	addReactFileOverrides(builder);
+	return builder.build();
 }
-
-// src/configs/react-effect.ts
-import reactEffectPlugin from "eslint-plugin-react-you-might-not-need-an-effect";
+//#endregion
+//#region src/configs/react-effect.ts
+/**
+* React effect config — catches unnecessary useEffect anti-patterns.
+* Codifies the patterns from the React docs article "You Might Not Need an Effect".
+*
+* Complements react-hooks (which checks dependency arrays are correct) by
+* detecting when the entire effect is unnecessary — derived state, chained
+* state updates, prop-triggered resets, and more.
+*
+* @see https://react.dev/learn/you-might-not-need-an-effect
+* @see https://github.com/nickjvandyke/eslint-plugin-react-you-might-not-need-an-effect
+*/
 function reactEffectConfig() {
-  return [
-    {
-      name: "eslint-config-setup/react-effect",
-      plugins: {
-        "react-you-might-not-need-an-effect": reactEffectPlugin
-      },
-      rules: {
-        // Disallow storing derived state in an effect — compute at render time or useMemo
-        // https://github.com/nickjvandyke/eslint-plugin-react-you-might-not-need-an-effect
-        "react-you-might-not-need-an-effect/no-derived-state": "error",
-        // Disallow chaining state updates in an effect — update together instead
-        // https://github.com/nickjvandyke/eslint-plugin-react-you-might-not-need-an-effect
-        "react-you-might-not-need-an-effect/no-chain-state-updates": "error",
-        // Disallow using state + effect as an event handler — call logic directly
-        // https://github.com/nickjvandyke/eslint-plugin-react-you-might-not-need-an-effect
-        "react-you-might-not-need-an-effect/no-event-handler": "error",
-        // Disallow adjusting state when a prop changes — compute inline during render
-        // https://github.com/nickjvandyke/eslint-plugin-react-you-might-not-need-an-effect
-        "react-you-might-not-need-an-effect/no-adjust-state-on-prop-change": "warn",
-        // Disallow resetting all state when a prop changes — use the key prop instead
-        // https://github.com/nickjvandyke/eslint-plugin-react-you-might-not-need-an-effect
-        "react-you-might-not-need-an-effect/no-reset-all-state-on-prop-change": "error",
-        // Disallow passing live state to parent via effect — lift state up instead
-        // https://github.com/nickjvandyke/eslint-plugin-react-you-might-not-need-an-effect
-        "react-you-might-not-need-an-effect/no-pass-live-state-to-parent": "error",
-        // Disallow passing fetched data to parent via effect — fetch in parent instead
-        // https://github.com/nickjvandyke/eslint-plugin-react-you-might-not-need-an-effect
-        "react-you-might-not-need-an-effect/no-pass-data-to-parent": "error",
-        // Disallow external-store subscriptions in an effect — use useSyncExternalStore
-        // https://github.com/nickjvandyke/eslint-plugin-react-you-might-not-need-an-effect
-        "react-you-might-not-need-an-effect/no-external-store-subscription": "error",
-        // Disallow initializing state in an effect — pass initial value to useState
-        // https://github.com/nickjvandyke/eslint-plugin-react-you-might-not-need-an-effect
-        "react-you-might-not-need-an-effect/no-initialize-state": "error"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/react-effect",
+		plugins: { "react-you-might-not-need-an-effect": reactEffectPlugin },
+		rules: {
+			"react-you-might-not-need-an-effect/no-derived-state": "error",
+			"react-you-might-not-need-an-effect/no-chain-state-updates": "error",
+			"react-you-might-not-need-an-effect/no-event-handler": "error",
+			"react-you-might-not-need-an-effect/no-adjust-state-on-prop-change": "warn",
+			"react-you-might-not-need-an-effect/no-reset-all-state-on-prop-change": "error",
+			"react-you-might-not-need-an-effect/no-pass-live-state-to-parent": "error",
+			"react-you-might-not-need-an-effect/no-pass-data-to-parent": "error",
+			"react-you-might-not-need-an-effect/no-external-store-subscription": "error",
+			"react-you-might-not-need-an-effect/no-initialize-state": "error"
+		}
+	}];
 }
-
-// src/configs/regexp.ts
-import { configs as regexpConfigs } from "eslint-plugin-regexp";
+//#endregion
+//#region src/configs/regexp.ts
+/**
+* RegExp config — uses the full `flat/recommended` preset from eslint-plugin-regexp.
+* Validates regular expression syntax, detects common mistakes, and suggests
+* simpler patterns.
+*
+* Preset: eslint-plugin-regexp flat/recommended (all rules at their default severity)
+* @see https://ota-meshi.github.io/eslint-plugin-regexp/
+* @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/
+*/
 function regexpConfig(opts) {
-  const isAi = opts?.ai ?? false;
-  const builder = createConfig({
-    name: "eslint-config-setup/regexp",
-    presets: [regexpConfigs["flat/recommended"]]
-  }).addRule("regexp/no-control-character", "error").addRule("regexp/no-octal", "error").addRule("regexp/no-standalone-backslash", "error").addRule("regexp/no-super-linear-move", "error").addRule("regexp/prefer-escape-replacement-dollar-char", "error");
-  if (isAi) {
-    builder.addRule("regexp/prefer-lookaround", "error");
-    builder.addRule("regexp/prefer-named-backreference", "error");
-    builder.addRule("regexp/prefer-named-replacement", "error");
-    builder.addRule("regexp/prefer-quantifier", "error");
-    builder.addRule("regexp/prefer-result-array-groups", "error");
-    builder.addRule("regexp/require-unicode-sets-regexp", "error");
-  }
-  return builder.build();
+	const isAi = opts?.ai ?? false;
+	const builder = createConfig({
+		name: "eslint-config-setup/regexp",
+		presets: [configs$1["flat/recommended"]]
+	}).addRule("regexp/no-control-character", "error").addRule("regexp/no-octal", "error").addRule("regexp/no-standalone-backslash", "error").addRule("regexp/no-super-linear-move", "error").addRule("regexp/prefer-escape-replacement-dollar-char", "error");
+	if (isAi) {
+		builder.addRule("regexp/prefer-lookaround", "error");
+		builder.addRule("regexp/prefer-named-backreference", "error");
+		builder.addRule("regexp/prefer-named-replacement", "error");
+		builder.addRule("regexp/prefer-quantifier", "error");
+		builder.addRule("regexp/prefer-result-array-groups", "error");
+		builder.addRule("regexp/require-unicode-sets-regexp", "error");
+	}
+	return builder.build();
 }
-
-// src/configs/security.ts
-import securityPlugin from "eslint-plugin-security";
-var plugin2 = securityPlugin;
+//#endregion
+//#region src/configs/security.ts
+const plugin = securityPlugin;
+/**
+* Security config — Node.js security patterns from eslint-plugin-security.
+* We manually select rules instead of using the preset because the preset
+* enables `detect-object-injection` which produces too many false positives.
+*
+* @see https://github.com/eslint-community/eslint-plugin-security#rules
+*/
 function securityConfig() {
-  return [
-    {
-      name: "eslint-config-setup/security",
-      plugins: {
-        security: plugin2
-      },
-      rules: {
-        // ── Errors: dangerous patterns that should never appear ────────
-        // Detect Buffer read/write without noAssert — can read out of bounds
-        // https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-buffer-noassert.md
-        "security/detect-buffer-noassert": "error",
-        // Detect child_process usage — potential command injection vector
-        // https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-child-process.md
-        "security/detect-child-process": "error",
-        // Detect disabled mustache escaping — XSS risk in templates
-        // https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-disable-mustache-escape.md
-        "security/detect-disable-mustache-escape": "error",
-        // Detect eval() with variable arguments — code injection risk
-        // https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-eval-with-expression.md
-        "security/detect-eval-with-expression": "error",
-        // Detect new Buffer(n) — deprecated, use Buffer.alloc() instead
-        // https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-new-buffer.md
-        "security/detect-new-buffer": "error",
-        // Detect CSRF middleware placed after method-override — CSRF bypass
-        // https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-no-csrf-before-method-override.md
-        "security/detect-no-csrf-before-method-override": "error",
-        // Detect Math.random() / pseudoRandomBytes — not cryptographically secure
-        // https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-pseudoRandomBytes.md
-        "security/detect-pseudoRandomBytes": "error",
-        // Detect regexes vulnerable to ReDoS (catastrophic backtracking)
-        // https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-unsafe-regex.md
-        "security/detect-unsafe-regex": "error",
-        // ── Warnings: worth reviewing but may have legitimate uses ─────
-        // Detect dynamic fs paths — potential path traversal (many false positives)
-        // https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-non-literal-fs-filename.md
-        "security/detect-non-literal-fs-filename": "warn",
-        // Detect dynamic regex construction — potential ReDoS
-        // https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-non-literal-regexp.md
-        "security/detect-non-literal-regexp": "warn",
-        // Detect dynamic require() — potential code injection
-        // https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-non-literal-require.md
-        "security/detect-non-literal-require": "warn",
-        // Detect string comparisons that may leak timing info — side-channel risk
-        // https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-possible-timing-attacks.md
-        "security/detect-possible-timing-attacks": "warn",
-        // Detect Unicode bidirectional control characters — source code trojan attack
-        // https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-bidi-characters.md
-        "security/detect-bidi-characters": "error",
-        // ── Disabled: too many false positives ────────────────────────
-        // Flags all bracket notation (obj[key]) — nearly every codebase triggers this
-        // https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-object-injection.md
-        "security/detect-object-injection": "off"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/security",
+		plugins: { security: plugin },
+		rules: {
+			"security/detect-buffer-noassert": "error",
+			"security/detect-child-process": "error",
+			"security/detect-disable-mustache-escape": "error",
+			"security/detect-eval-with-expression": "error",
+			"security/detect-new-buffer": "error",
+			"security/detect-no-csrf-before-method-override": "error",
+			"security/detect-pseudoRandomBytes": "error",
+			"security/detect-unsafe-regex": "error",
+			"security/detect-non-literal-fs-filename": "warn",
+			"security/detect-non-literal-regexp": "warn",
+			"security/detect-non-literal-require": "warn",
+			"security/detect-possible-timing-attacks": "warn",
+			"security/detect-bidi-characters": "error",
+			"security/detect-object-injection": "off"
+		}
+	}];
 }
-
-// src/configs/sonarjs.ts
-import sonarjsPlugin from "eslint-plugin-sonarjs";
+//#endregion
+//#region src/configs/sonarjs.ts
+/**
+* SonarJS config — code-quality rules from SonarSource.
+* Hand-picked subset focused on bug detection and code smells.
+* We don't use the full preset because many SonarJS rules overlap with
+* typescript-eslint and unicorn.
+*
+* @see https://github.com/SonarSource/SonarJS/tree/master/packages/jsts/src/rules#readme
+*/
 function sonarjsConfig(opts) {
-  const isAi = opts?.ai === true;
-  const builder = createConfig({
-    name: "eslint-config-setup/sonarjs",
-    presets: [{
-      plugins: { sonarjs: sonarjsPlugin },
-      rules: {
-        // Detect copy-pasted functions — extract to shared helper instead
-        // https://sonarsource.github.io/rspec/#/rspec/S4144/javascript
-        "sonarjs/no-identical-functions": "error",
-        // Merge nested if-statements that can be combined — reduces nesting
-        // https://sonarsource.github.io/rspec/#/rspec/S1066/javascript
-        "sonarjs/no-collapsible-if": "error",
-        // Simplify `if (x) return true; else return false;` → `return x`
-        // https://sonarsource.github.io/rspec/#/rspec/S1125/javascript
-        "sonarjs/no-redundant-boolean": "error",
-        // Detect collections that are populated but never read — dead code
-        // https://sonarsource.github.io/rspec/#/rspec/S4030/javascript
-        "sonarjs/no-unused-collection": "error",
-        // Return value directly instead of storing in temp variable first
-        // https://sonarsource.github.io/rspec/#/rspec/S1488/javascript
-        "sonarjs/prefer-immediate-return": "error",
-        // Simplify boolean return patterns — `return cond` instead of `if/else`
-        // https://sonarsource.github.io/rspec/#/rspec/S1126/javascript
-        "sonarjs/prefer-single-boolean-return": "error",
-        // Detect identical sub-expressions on both sides of operator (x && x)
-        // https://sonarsource.github.io/rspec/#/rspec/S1764/javascript
-        "sonarjs/no-identical-expressions": "error",
-        // Simplify `!(a === b)` → `a !== b` — more readable
-        // https://sonarsource.github.io/rspec/#/rspec/S1940/javascript
-        "sonarjs/no-inverted-boolean-check": "error",
-        // Detect size/length comparisons that are always true/false
-        // https://sonarsource.github.io/rspec/#/rspec/S3981/javascript
-        "sonarjs/no-collection-size-mischeck": "error",
-        // Detect duplicate conditions in if/else-if chains — copy-paste bug
-        // https://sonarsource.github.io/rspec/#/rspec/S1862/javascript
-        "sonarjs/no-identical-conditions": "error",
-        // Detect identical code in if and else branches — refactoring leftover
-        // https://sonarsource.github.io/rspec/#/rspec/S1871/javascript
-        "sonarjs/no-duplicated-branches": "error",
-        // Detect .filter()/.map()/.slice() called without using the result
-        // https://sonarsource.github.io/rspec/#/rspec/S2201/javascript
-        "sonarjs/no-ignored-return": "error",
-        // Detect redundant return/break/continue at end of block
-        // https://sonarsource.github.io/rspec/#/rspec/S3626/javascript
-        "sonarjs/no-redundant-jump": "error",
-        // Prevent .only() from being committed — blocks CI for others
-        // https://sonarsource.github.io/rspec/#/rspec/S6426/javascript
-        "sonarjs/no-exclusive-tests": "error",
-        // Detect `const sorted = arr.sort()` — .sort() mutates the original
-        // https://sonarsource.github.io/rspec/#/rspec/S4043/javascript
-        "sonarjs/no-misleading-array-reverse": "error",
-        // Require initial value for .reduce() — crashes on empty arrays without it
-        // https://sonarsource.github.io/rspec/#/rspec/S6959/javascript
-        "sonarjs/reduce-initial-value": "error",
-        // Disallow async operations in constructors — use factory methods
-        // https://sonarsource.github.io/rspec/#/rspec/S7059/javascript
-        "sonarjs/no-async-constructor": "error",
-        // Detect `field?: string | undefined` — the `?` already implies undefined
-        // https://sonarsource.github.io/rspec/#/rspec/S4782/javascript
-        "sonarjs/no-redundant-optional": "error",
-        // Detect `string | number | string` — duplicate constituents in unions
-        // https://sonarsource.github.io/rspec/#/rspec/S4621/javascript
-        "sonarjs/no-duplicate-in-composite": "error",
-        // Detect hardcoded secrets (API keys, passwords, tokens) in source code
-        // https://sonarsource.github.io/rspec/#/rspec/S6418/javascript
-        "sonarjs/no-hardcoded-secrets": "warn"
-      }
-    }]
-  });
-  if (isAi) {
-    builder.addRule("sonarjs/no-nested-switch", "error");
-    builder.addRule("sonarjs/no-nested-template-literals", "error");
-    builder.addRule("sonarjs/max-union-size", ["error", { threshold: 5 }]);
-    builder.addRule("sonarjs/prefer-type-guard", "error");
-    builder.addRule("sonarjs/public-static-readonly", "error");
-    builder.addRule("sonarjs/no-duplicate-string", ["error", { threshold: 3 }]);
-  }
-  return builder.build();
+	const isAi = opts?.ai === true;
+	const builder = createConfig({
+		name: "eslint-config-setup/sonarjs",
+		presets: [{
+			plugins: { sonarjs: sonarjsPlugin },
+			rules: {
+				"sonarjs/no-identical-functions": "error",
+				"sonarjs/no-collapsible-if": "error",
+				"sonarjs/no-redundant-boolean": "error",
+				"sonarjs/no-unused-collection": "error",
+				"sonarjs/prefer-immediate-return": "error",
+				"sonarjs/prefer-single-boolean-return": "error",
+				"sonarjs/no-identical-expressions": "error",
+				"sonarjs/no-inverted-boolean-check": "error",
+				"sonarjs/no-collection-size-mischeck": "error",
+				"sonarjs/no-identical-conditions": "error",
+				"sonarjs/no-duplicated-branches": "error",
+				"sonarjs/no-ignored-return": "error",
+				"sonarjs/no-redundant-jump": "error",
+				"sonarjs/no-exclusive-tests": "error",
+				"sonarjs/no-misleading-array-reverse": "error",
+				"sonarjs/reduce-initial-value": "error",
+				"sonarjs/no-async-constructor": "error",
+				"sonarjs/no-redundant-optional": "error",
+				"sonarjs/no-duplicate-in-composite": "error",
+				"sonarjs/no-hardcoded-secrets": "warn"
+			}
+		}]
+	});
+	if (isAi) {
+		builder.addRule("sonarjs/no-nested-switch", "error");
+		builder.addRule("sonarjs/no-nested-template-literals", "error");
+		builder.addRule("sonarjs/max-union-size", ["error", { threshold: 5 }]);
+		builder.addRule("sonarjs/prefer-type-guard", "error");
+		builder.addRule("sonarjs/public-static-readonly", "error");
+		builder.addRule("sonarjs/no-duplicate-string", ["error", { threshold: 3 }]);
+	}
+	return builder.build();
 }
-
-// src/configs/typescript.ts
-import tseslint from "typescript-eslint";
+//#endregion
+//#region src/configs/typescript.ts
+/**
+* TypeScript config — extends typescript-eslint strict presets with project-wide type checking.
+*
+* Presets used:
+* - `tseslint.configs.strictTypeChecked` — all recommended + strict rules with type info
+* - `tseslint.configs.stylisticTypeChecked` — consistent code style with type info
+*
+* The presets already handle many core ESLint rules by disabling them and enabling
+* TS-aware equivalents (no-implied-eval, dot-notation, no-throw-literal, etc.).
+*
+* @see https://typescript-eslint.io/getting-started/
+* @see https://typescript-eslint.io/rules/
+*/
 function typescriptConfig(opts) {
-  const isAi = opts?.ai ?? false;
-  const isReact = opts?.react ?? false;
-  const typeChecked = tseslint.configs.strictTypeChecked;
-  const stylistic = tseslint.configs.stylisticTypeChecked;
-  const structuralBlocks = typeChecked.slice(0, 2);
-  const ruleBlocks = [typeChecked[2], stylistic[2]];
-  const builder = createConfig({
-    name: "eslint-config-setup/typescript",
-    passthrough: structuralBlocks,
-    presets: ruleBlocks,
-    files: [...TYPESCRIPT_SOURCE_FILES],
-    ignores: [...MARKDOWN_CODE_BLOCK_FILES],
-    languageOptions: {
-      parserOptions: {
-        // Use project service for automatic tsconfig resolution
-        // https://typescript-eslint.io/packages/parser#projectservice
-        projectService: true
-      }
-    }
-  });
-  builder.overrideRule("@typescript-eslint/no-unused-vars", [
-    "error",
-    {
-      args: "all",
-      argsIgnorePattern: "^_",
-      caughtErrors: "all",
-      caughtErrorsIgnorePattern: "^_",
-      destructuredArrayIgnorePattern: "^_",
-      varsIgnorePattern: "^_",
-      ignoreRestSiblings: true
-    }
-  ]);
-  builder.overrideRule("@typescript-eslint/array-type", [
-    "error",
-    { default: "array-simple" }
-  ]);
-  builder.overrideRule("@typescript-eslint/return-await", [
-    "error",
-    "in-try-catch"
-  ]);
-  builder.overrideSeverity("@typescript-eslint/no-deprecated", "warn");
-  builder.overrideRule("@typescript-eslint/no-explicit-any", [
-    "warn",
-    { fixToUnknown: true }
-  ]);
-  builder.overrideRule("@typescript-eslint/consistent-type-definitions", [
-    "error",
-    "type"
-  ]);
-  builder.overrideOptions("@typescript-eslint/ban-ts-comment", {
-    "ts-expect-error": "allow-with-description"
-  });
-  builder.overrideOptions("@typescript-eslint/no-floating-promises", {
-    checkThenables: true,
-    ignoreIIFE: true
-  });
-  builder.addRule("@typescript-eslint/consistent-type-imports", [
-    "error",
-    { fixStyle: isAi ? "inline-type-imports" : "separate-type-imports" }
-  ]);
-  builder.addRule("@typescript-eslint/consistent-type-exports", [
-    "error",
-    { fixMixedExportsWithInlineTypeSpecifier: true }
-  ]);
-  builder.addRule("@typescript-eslint/no-import-type-side-effects", "error");
-  builder.addRule("@typescript-eslint/no-unnecessary-qualifier", "error");
-  builder.addRule("@typescript-eslint/no-useless-empty-export", "error");
-  builder.addRule(
-    "@typescript-eslint/no-unnecessary-parameter-property-assignment",
-    "error"
-  );
-  builder.addRule("@typescript-eslint/strict-void-return", "error");
-  builder.addRule("@typescript-eslint/prefer-readonly", isAi ? "error" : "warn");
-  builder.addRule("@typescript-eslint/require-array-sort-compare", [
-    "error",
-    { ignoreStringArrays: true }
-  ]);
-  builder.addRule("@typescript-eslint/no-unsafe-type-assertion", "error");
-  builder.addRule("@typescript-eslint/switch-exhaustiveness-check", [
-    "error",
-    {
-      allowDefaultCaseForExhaustiveSwitch: false,
-      requireDefaultForNonUnion: true
-    }
-  ]);
-  builder.addRule("@typescript-eslint/promise-function-async", "error");
-  builder.addRule("@typescript-eslint/method-signature-style", [
-    "error",
-    "property"
-  ]);
-  builder.addRule("no-shadow", "off");
-  builder.addRule("@typescript-eslint/no-shadow", [
-    "error",
-    {
-      hoist: "all",
-      allow: ["resolve", "reject", "done", "next", "error"],
-      ignoreTypeValueShadow: true,
-      ignoreFunctionTypeParameterNameValueShadow: true
-    }
-  ]);
-  builder.overrideOptions("@typescript-eslint/restrict-template-expressions", { allowNumber: true });
-  builder.addRule("@typescript-eslint/strict-boolean-expressions", [
-    "error",
-    { allowNullableBoolean: true, allowNullableObject: true }
-  ]);
-  builder.addFileOverride(
-    "eslint-config-setup/typescript-js-compat",
-    ["**/*.{js,mjs,cjs}"],
-    tseslint.configs.disableTypeChecked.rules ?? {}
-  );
-  if (isAi) {
-    builder.overrideSeverity("@typescript-eslint/no-explicit-any", "error");
-    builder.overrideRule("@typescript-eslint/no-floating-promises", [
-      "error",
-      { checkThenables: true, ignoreVoid: true }
-    ]);
-    builder.addRule("@typescript-eslint/no-magic-numbers", [
-      "error",
-      {
-        ignore: [-1, 0, 1, 2],
-        ignoreArrayIndexes: true,
-        ignoreDefaultValues: true,
-        enforceConst: true,
-        ignoreClassFieldInitialValues: true,
-        ignoreEnums: true,
-        ignoreNumericLiteralTypes: true,
-        ignoreReadonlyClassProperties: true,
-        ignoreTypeIndexes: true
-      }
-    ]);
-    builder.addRule("@typescript-eslint/explicit-function-return-type", [
-      "error",
-      {
-        allowExpressions: true,
-        allowTypedFunctionExpressions: true,
-        allowHigherOrderFunctions: true,
-        allowIIFEs: true
-      }
-    ]);
-    builder.addRule(
-      "@typescript-eslint/explicit-member-accessibility",
-      "error"
-    );
-    builder.addRule(
-      "@typescript-eslint/prefer-enum-initializers",
-      "error"
-    );
-    builder.addRule("@typescript-eslint/naming-convention", [
-      "error",
-      {
-        selector: "variable",
-        format: isReact ? ["strictCamelCase", "UPPER_CASE", "StrictPascalCase"] : ["strictCamelCase", "UPPER_CASE"],
-        leadingUnderscore: "allowSingleOrDouble",
-        trailingUnderscore: "allow",
-        filter: { regex: "[- ]", match: false }
-      },
-      {
-        selector: "function",
-        format: isReact ? ["strictCamelCase", "StrictPascalCase"] : ["strictCamelCase"]
-      },
-      {
-        selector: "parameter",
-        format: ["strictCamelCase"],
-        leadingUnderscore: "allow"
-      },
-      {
-        selector: "import",
-        format: ["strictCamelCase", "StrictPascalCase", "UPPER_CASE"]
-      },
-      {
-        selector: [
-          "classProperty",
-          "parameterProperty",
-          "classMethod",
-          "objectLiteralMethod",
-          "typeMethod",
-          "accessor"
-        ],
-        format: ["strictCamelCase"],
-        leadingUnderscore: "allowSingleOrDouble",
-        trailingUnderscore: "allow",
-        filter: { regex: "[- ]", match: false }
-      },
-      {
-        selector: ["objectLiteralProperty", "typeProperty"],
-        format: null
-      },
-      { selector: "typeLike", format: ["StrictPascalCase"] },
-      {
-        selector: "interface",
-        format: ["StrictPascalCase"],
-        custom: { regex: "^I[A-Z]", match: false }
-      },
-      {
-        selector: "typeParameter",
-        format: ["PascalCase"],
-        custom: {
-          regex: "^(T([A-Z][a-zA-Z]*)?|[A-Z])$",
-          match: true
-        }
-      },
-      {
-        selector: "variable",
-        types: ["boolean"],
-        format: ["StrictPascalCase"],
-        prefix: ["is", "has", "can", "should", "will", "did"]
-      },
-      {
-        selector: ["classProperty", "objectLiteralProperty"],
-        format: null,
-        modifiers: ["requiresQuotes"]
-      }
-    ]);
-    builder.addRule("@typescript-eslint/member-ordering", [
-      "warn",
-      {
-        default: [
-          "signature",
-          "call-signature",
-          "public-static-field",
-          "protected-static-field",
-          "private-static-field",
-          "#private-static-field",
-          "static-field",
-          "public-static-method",
-          "protected-static-method",
-          "private-static-method",
-          "#private-static-method",
-          "static-method",
-          "public-decorated-field",
-          "protected-decorated-field",
-          "private-decorated-field",
-          "public-instance-field",
-          "protected-instance-field",
-          "private-instance-field",
-          "#private-instance-field",
-          "public-abstract-field",
-          "protected-abstract-field",
-          "field",
-          "public-constructor",
-          "protected-constructor",
-          "private-constructor",
-          "constructor",
-          ["public-get", "public-set"],
-          ["protected-get", "protected-set"],
-          ["private-get", "private-set"],
-          ["#private-get", "#private-set"],
-          "public-decorated-method",
-          "protected-decorated-method",
-          "private-decorated-method",
-          "public-instance-method",
-          "protected-instance-method",
-          "private-instance-method",
-          "#private-instance-method",
-          "public-abstract-method",
-          "protected-abstract-method",
-          "method"
-        ]
-      }
-    ]);
-  }
-  return builder.build();
+	const isAi = opts?.ai ?? false;
+	const isReact = opts?.react ?? false;
+	const typeChecked = tseslint.configs.strictTypeChecked;
+	const stylistic = tseslint.configs.stylisticTypeChecked;
+	const builder = createConfig({
+		name: "eslint-config-setup/typescript",
+		passthrough: typeChecked.slice(0, 2),
+		presets: [typeChecked[2], stylistic[2]],
+		files: [...TYPESCRIPT_SOURCE_FILES],
+		ignores: [...MARKDOWN_CODE_BLOCK_FILES],
+		languageOptions: { parserOptions: { projectService: true } }
+	});
+	builder.overrideRule("@typescript-eslint/no-unused-vars", ["error", {
+		args: "all",
+		argsIgnorePattern: "^_",
+		caughtErrors: "all",
+		caughtErrorsIgnorePattern: "^_",
+		destructuredArrayIgnorePattern: "^_",
+		varsIgnorePattern: "^_",
+		ignoreRestSiblings: true
+	}]);
+	builder.overrideRule("@typescript-eslint/array-type", ["error", { default: "array-simple" }]);
+	builder.overrideRule("@typescript-eslint/return-await", ["error", "in-try-catch"]);
+	builder.overrideSeverity("@typescript-eslint/no-deprecated", "warn");
+	builder.overrideRule("@typescript-eslint/no-explicit-any", ["warn", { fixToUnknown: true }]);
+	builder.overrideRule("@typescript-eslint/consistent-type-definitions", ["error", "type"]);
+	builder.overrideOptions("@typescript-eslint/ban-ts-comment", { "ts-expect-error": "allow-with-description" });
+	builder.overrideOptions("@typescript-eslint/no-floating-promises", {
+		checkThenables: true,
+		ignoreIIFE: true
+	});
+	builder.addRule("@typescript-eslint/consistent-type-imports", ["error", { fixStyle: isAi ? "inline-type-imports" : "separate-type-imports" }]);
+	builder.addRule("@typescript-eslint/consistent-type-exports", ["error", { fixMixedExportsWithInlineTypeSpecifier: true }]);
+	builder.addRule("@typescript-eslint/no-import-type-side-effects", "error");
+	builder.addRule("@typescript-eslint/no-unnecessary-qualifier", "error");
+	builder.addRule("@typescript-eslint/no-useless-empty-export", "error");
+	builder.addRule("@typescript-eslint/no-unnecessary-parameter-property-assignment", "error");
+	builder.addRule("@typescript-eslint/strict-void-return", "error");
+	builder.addRule("@typescript-eslint/prefer-readonly", isAi ? "error" : "warn");
+	builder.addRule("@typescript-eslint/require-array-sort-compare", ["error", { ignoreStringArrays: true }]);
+	builder.addRule("@typescript-eslint/no-unsafe-type-assertion", "error");
+	builder.addRule("@typescript-eslint/switch-exhaustiveness-check", ["error", {
+		allowDefaultCaseForExhaustiveSwitch: false,
+		requireDefaultForNonUnion: true
+	}]);
+	builder.addRule("@typescript-eslint/promise-function-async", "error");
+	builder.addRule("@typescript-eslint/method-signature-style", ["error", "property"]);
+	builder.addRule("no-shadow", "off");
+	builder.addRule("@typescript-eslint/no-shadow", ["error", {
+		hoist: "all",
+		allow: [
+			"resolve",
+			"reject",
+			"done",
+			"next",
+			"error"
+		],
+		ignoreTypeValueShadow: true,
+		ignoreFunctionTypeParameterNameValueShadow: true
+	}]);
+	builder.overrideOptions("@typescript-eslint/restrict-template-expressions", { allowNumber: true });
+	builder.addRule("@typescript-eslint/strict-boolean-expressions", ["error", {
+		allowNullableBoolean: true,
+		allowNullableObject: true
+	}]);
+	builder.addFileOverride("eslint-config-setup/typescript-js-compat", ["**/*.{js,mjs,cjs}"], tseslint.configs.disableTypeChecked.rules ?? {});
+	if (isAi) {
+		builder.overrideSeverity("@typescript-eslint/no-explicit-any", "error");
+		builder.overrideRule("@typescript-eslint/no-floating-promises", ["error", {
+			checkThenables: true,
+			ignoreVoid: true
+		}]);
+		builder.addRule("@typescript-eslint/no-magic-numbers", ["error", {
+			ignore: [
+				-1,
+				0,
+				1,
+				2
+			],
+			ignoreArrayIndexes: true,
+			ignoreDefaultValues: true,
+			enforceConst: true,
+			ignoreClassFieldInitialValues: true,
+			ignoreEnums: true,
+			ignoreNumericLiteralTypes: true,
+			ignoreReadonlyClassProperties: true,
+			ignoreTypeIndexes: true
+		}]);
+		builder.addRule("@typescript-eslint/explicit-function-return-type", ["error", {
+			allowExpressions: true,
+			allowTypedFunctionExpressions: true,
+			allowHigherOrderFunctions: true,
+			allowIIFEs: true
+		}]);
+		builder.addRule("@typescript-eslint/explicit-member-accessibility", "error");
+		builder.addRule("@typescript-eslint/prefer-enum-initializers", "error");
+		builder.addRule("@typescript-eslint/naming-convention", [
+			"error",
+			{
+				selector: "variable",
+				format: isReact ? [
+					"strictCamelCase",
+					"UPPER_CASE",
+					"StrictPascalCase"
+				] : ["strictCamelCase", "UPPER_CASE"],
+				leadingUnderscore: "allowSingleOrDouble",
+				trailingUnderscore: "allow",
+				filter: {
+					regex: "[- ]",
+					match: false
+				}
+			},
+			{
+				selector: "function",
+				format: isReact ? ["strictCamelCase", "StrictPascalCase"] : ["strictCamelCase"]
+			},
+			{
+				selector: "parameter",
+				format: ["strictCamelCase"],
+				leadingUnderscore: "allow"
+			},
+			{
+				selector: "import",
+				format: [
+					"strictCamelCase",
+					"StrictPascalCase",
+					"UPPER_CASE"
+				]
+			},
+			{
+				selector: [
+					"classProperty",
+					"parameterProperty",
+					"classMethod",
+					"objectLiteralMethod",
+					"typeMethod",
+					"accessor"
+				],
+				format: ["strictCamelCase"],
+				leadingUnderscore: "allowSingleOrDouble",
+				trailingUnderscore: "allow",
+				filter: {
+					regex: "[- ]",
+					match: false
+				}
+			},
+			{
+				selector: ["objectLiteralProperty", "typeProperty"],
+				format: null
+			},
+			{
+				selector: "typeLike",
+				format: ["StrictPascalCase"]
+			},
+			{
+				selector: "interface",
+				format: ["StrictPascalCase"],
+				custom: {
+					regex: "^I[A-Z]",
+					match: false
+				}
+			},
+			{
+				selector: "typeParameter",
+				format: ["PascalCase"],
+				custom: {
+					regex: "^(T([A-Z][a-zA-Z]*)?|[A-Z])$",
+					match: true
+				}
+			},
+			{
+				selector: "variable",
+				types: ["boolean"],
+				format: ["StrictPascalCase"],
+				prefix: [
+					"is",
+					"has",
+					"can",
+					"should",
+					"will",
+					"did"
+				]
+			},
+			{
+				selector: ["classProperty", "objectLiteralProperty"],
+				format: null,
+				modifiers: ["requiresQuotes"]
+			}
+		]);
+		builder.addRule("@typescript-eslint/member-ordering", ["warn", { default: [
+			"signature",
+			"call-signature",
+			"public-static-field",
+			"protected-static-field",
+			"private-static-field",
+			"#private-static-field",
+			"static-field",
+			"public-static-method",
+			"protected-static-method",
+			"private-static-method",
+			"#private-static-method",
+			"static-method",
+			"public-decorated-field",
+			"protected-decorated-field",
+			"private-decorated-field",
+			"public-instance-field",
+			"protected-instance-field",
+			"private-instance-field",
+			"#private-instance-field",
+			"public-abstract-field",
+			"protected-abstract-field",
+			"field",
+			"public-constructor",
+			"protected-constructor",
+			"private-constructor",
+			"constructor",
+			["public-get", "public-set"],
+			["protected-get", "protected-set"],
+			["private-get", "private-set"],
+			["#private-get", "#private-set"],
+			"public-decorated-method",
+			"protected-decorated-method",
+			"private-decorated-method",
+			"public-instance-method",
+			"protected-instance-method",
+			"private-instance-method",
+			"#private-instance-method",
+			"public-abstract-method",
+			"protected-abstract-method",
+			"method"
+		] }]);
+	}
+	return builder.build();
 }
-
-// src/configs/unicorn.ts
-import unicornPlugin from "eslint-plugin-unicorn";
+//#endregion
+//#region src/configs/unicorn.ts
+/**
+* Unicorn config — modern JavaScript idioms and best practices.
+* We hand-pick rules instead of using `flat/recommended` because the
+* recommended preset includes opinionated rules we disagree with
+* (e.g., `no-null`, `no-nested-ternary`, `filename-case`).
+*
+* @see https://github.com/sindresorhus/eslint-plugin-unicorn#rules
+*/
 function unicornConfig(opts) {
-  const isAi = opts?.ai === true;
-  const builder = createConfig({
-    name: "eslint-config-setup/unicorn",
-    presets: [{
-      plugins: { unicorn: unicornPlugin },
-      rules: {
-        // ── Error prevention ──────────────────────────────────────────
-        // Forbid `/* eslint-disable */` without specific rule — too broad
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-abusive-eslint-disable.md
-        "unicorn/no-abusive-eslint-disable": "error",
-        // Disallow `instanceof` with built-in objects — use proper checks instead
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-instanceof-builtins.md
-        "unicorn/no-instanceof-builtins": "error",
-        // Prevent passing non-function to removeEventListener — common mistake
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-invalid-remove-event-listener.md
-        "unicorn/no-invalid-remove-event-listener": "error",
-        // Disallow invalid fetch() options — catches typos at lint time
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-invalid-fetch-options.md
-        "unicorn/no-invalid-fetch-options": "error",
-        // Prefer direct undefined checks over typeof — cleaner with strict mode
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-typeof-undefined.md
-        "unicorn/no-typeof-undefined": "error",
-        // Remove useless fallback in object spread ({ ...a, x: a.x ?? y })
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-fallback-in-spread.md
-        "unicorn/no-useless-fallback-in-spread": "error",
-        // Remove unnecessary .length checks before array operations
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-length-check.md
-        "unicorn/no-useless-length-check": "error",
-        // Remove unnecessary spread operators ([...array] when array already exists)
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-spread.md
-        "unicorn/no-useless-spread": "error",
-        // Remove useless Promise.resolve/reject wrappers — simplify async code
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-promise-resolve-reject.md
-        "unicorn/no-useless-promise-resolve-reject": "error",
-        // Disallow redundant undefined where omission preserves semantics.
-        // Keep call arguments unchecked: TypeScript often needs explicit
-        // `undefined` for required parameters typed as `T | undefined`.
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-useless-undefined.md
-        "unicorn/no-useless-undefined": ["warn", { checkArguments: false }],
-        // Disallow `await` in Promise.all/race arguments — already a promise
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-await-in-promise-methods.md
-        "unicorn/no-await-in-promise-methods": "error",
-        // Catch `!a === b` bugs — use `a !== b` instead
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-negation-in-equality-check.md
-        "unicorn/no-negation-in-equality-check": "error",
-        // Disallow objects with `.then` property — prevents accidental thenables
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-thenable.md
-        "unicorn/no-thenable": "error",
-        // Disallow `(await foo).bar` — assign to variable first for clarity
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-await-expression-member.md
-        "unicorn/no-await-expression-member": "error",
-        // Disallow `const self = this` — use arrow functions instead
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-this-assignment.md
-        "unicorn/no-this-assignment": "error",
-        // Disallow `await` on non-promise values — unnecessary overhead
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unnecessary-await.md
-        "unicorn/no-unnecessary-await": "error",
-        // Disallow unnecessary slice end argument — `.length` is the default
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unnecessary-slice-end.md
-        "unicorn/no-unnecessary-slice-end": "error",
-        // OFF: Stylistic — developers should decide their own array initialization pattern
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-immediate-mutation.md
-        "unicorn/no-immediate-mutation": "off",
-        // Disallow recursive access in getters/setters — infinite loop risk
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-accessor-recursion.md
-        "unicorn/no-accessor-recursion": "error",
-        // Disallow anonymous default exports — hard to find and refactor
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-anonymous-default-export.md
-        "unicorn/no-anonymous-default-export": "error",
-        // Disallow `this` argument in array methods — use arrow functions
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-method-this-argument.md
-        "unicorn/no-array-method-this-argument": "error",
-        // Disallow passing function references directly to iterator methods
-        // Prevents bugs like `['1','2'].map(parseInt)` → [1, NaN]
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-callback-reference.md
-        "unicorn/no-array-callback-reference": "error",
-        // Disallow unreadable IIFEs — extract to named function
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unreadable-iife.md
-        "unicorn/no-unreadable-iife": "error",
-        // Require Error messages — aids debugging
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/error-message.md
-        "unicorn/error-message": "error",
-        // Require `new` keyword when throwing errors — consistent pattern
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/throw-new-error.md
-        "unicorn/throw-new-error": "error",
-        // Prefer consistent types when spreading a ternary in an array literal
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-empty-array-spread.md
-        "unicorn/consistent-empty-array-spread": "error",
-        // Prefer passing Date directly to constructor when cloning
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-date-clone.md
-        "unicorn/consistent-date-clone": "error",
-        // Enforce consistent style for indexOf/findIndex existence checks
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-existence-index-check.md
-        "unicorn/consistent-existence-index-check": "error",
-        // Move functions to the smallest possible scope — avoids re-creation on every call,
-        // improves testability, and makes dependencies explicit
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/consistent-function-scoping.md
-        "unicorn/consistent-function-scoping": "warn",
-        // Enforce consistent filename casing — camelCase, PascalCase, or kebab-case (no snake_case)
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/filename-case.md
-        "unicorn/filename-case": [
-          "error",
-          {
-            cases: {
-              camelCase: true,
-              pascalCase: true,
-              kebabCase: true
-            },
-            ignore: ["__tests__"]
-          }
-        ],
-        // Discourage Array.reduce() — hard to read for many developers, prefer for...of or other methods
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-array-reduce.md
-        "unicorn/no-array-reduce": "warn",
-        // Prefer for...of over C-style for loops — more readable when index isn't needed
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-for-loop.md
-        "unicorn/no-for-loop": "warn",
-        // ── Modern API preferences ────────────────────────────────────
-        // Prefer .flatMap() over .map().flat() — single pass, more readable
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-array-flat-map.md
-        "unicorn/prefer-array-flat-map": "error",
-        // Prefer .find() over .filter()[0] — stops at first match
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-array-find.md
-        "unicorn/prefer-array-find": "error",
-        // Prefer .flat() over manual recursive flattening
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-array-flat.md
-        "unicorn/prefer-array-flat": "error",
-        // Prefer .indexOf() over manual search loops
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-array-index-of.md
-        "unicorn/prefer-array-index-of": "error",
-        // Prefer .some() over .find() !== undefined — semantic intent
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-array-some.md
-        "unicorn/prefer-array-some": "error",
-        // Prefer .at(-1) over arr[arr.length - 1] — cleaner negative indexing
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-at.md
-        "unicorn/prefer-at": "error",
-        // Prefer .includes() over .indexOf() !== -1 — boolean intent
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-includes.md
-        "unicorn/prefer-includes": "error",
-        // Prefer .before()/.after()/.replaceWith() over parent.insertBefore()
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-modern-dom-apis.md
-        "unicorn/prefer-modern-dom-apis": "error",
-        // Prefer element.dataset.foo over setAttribute('data-foo') — modern, readable
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-dom-node-dataset.md
-        "unicorn/prefer-dom-node-dataset": "error",
-        // Prefer Math.log10/Math.hypot over manual math — accurate and readable
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-modern-math-apis.md
-        "unicorn/prefer-modern-math-apis": "error",
-        // Prefer negative index over length-based — cleaner with .slice(-n)
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-negative-index.md
-        "unicorn/prefer-negative-index": "error",
-        // Prefer Number.isFinite/Number.isNaN over global — no coercion
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-number-properties.md
-        "unicorn/prefer-number-properties": "error",
-        // Prefer Object.fromEntries() over manual reduce for key-value mapping
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-object-from-entries.md
-        "unicorn/prefer-object-from-entries": "error",
-        // Prefer Set.has() over Array.includes() for repeated lookups — O(1)
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-set-has.md
-        "unicorn/prefer-set-has": "error",
-        // Prefer .replaceAll() over regex with global flag — clearer intent
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-replace-all.md
-        "unicorn/prefer-string-replace-all": "error",
-        // Prefer .slice() over .substr()/.substring() — consistent, no gotchas
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-slice.md
-        "unicorn/prefer-string-slice": "error",
-        // Prefer .startsWith()/.endsWith() over regex — simpler, faster
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-starts-ends-with.md
-        "unicorn/prefer-string-starts-ends-with": "error",
-        // Prefer .trimStart()/.trimEnd() over .trimLeft()/.trimRight()
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-string-trim-start-end.md
-        "unicorn/prefer-string-trim-start-end": "error",
-        // Prefer structuredClone() over JSON.parse(JSON.stringify()) — handles more types
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-structured-clone.md
-        "unicorn/prefer-structured-clone": "error",
-        // Prefer top-level await over async IIFE — cleaner module pattern
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-top-level-await.md
-        "unicorn/prefer-top-level-await": "error",
-        // Throw TypeError for type checks — correct error type
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-type-error.md
-        "unicorn/prefer-type-error": "error",
-        // ── Regex ─────────────────────────────────────────────────────
-        // Disabled — conflicts with regexp/strict from eslint-plugin-regexp.
-        // Both rules auto-fix regex escaping but disagree on whether characters
-        // like { } ] should be escaped, causing circular fixes.
-        // regexp/strict is the more thorough rule, so we defer to it.
-        "unicorn/better-regex": "off",
-        // ── Misc ──────────────────────────────────────────────────────
-        // Enforce `error` name in catch blocks — consistent naming
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/catch-error-name.md
-        "unicorn/catch-error-name": ["error", { name: "error" }],
-        // Enforce `new` for builtins that require it (Map, Set, WeakMap, etc.)
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/new-for-builtins.md
-        "unicorn/new-for-builtins": "error",
-        // Prefer Array.from({length}) or fill() over new Array(n) — explicit intent
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-new-array.md
-        "unicorn/no-new-array": "error",
-        // Prefer Buffer.from()/Buffer.alloc() over new Buffer() — deprecated
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-new-buffer.md
-        "unicorn/no-new-buffer": "error",
-        // Forbid unreadable destructuring like `const [,,, d] = arr`
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unreadable-array-destructuring.md
-        "unicorn/no-unreadable-array-destructuring": "error",
-        // Remove unnecessary `.0` in numbers (1.0 → 1) — cleaner
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-zero-fractions.md
-        "unicorn/no-zero-fractions": "error",
-        // Enforce lowercase hex (0xff not 0xFF) — consistent
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/number-literal-case.md
-        "unicorn/number-literal-case": "error",
-        // Enforce numeric separators (1_000_000 not 1000000) — readable large numbers
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/numeric-separators-style.md
-        "unicorn/numeric-separators-style": "error",
-        // Prefer `export { x } from 'y'` over import then re-export
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-export-from.md
-        "unicorn/prefer-export-from": ["error", { checkUsedVariables: false }],
-        // Prefer built-in coercion (String, Number, Boolean) over wrapper functions
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-native-coercion-functions.md
-        "unicorn/prefer-native-coercion-functions": "error",
-        // Prefer .test() over .match() for boolean regex checks
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-regexp-test.md
-        "unicorn/prefer-regexp-test": "error",
-        // Prefer [...iterable] spread over Array.from(iterable) — concise
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-spread.md
-        "unicorn/prefer-spread": "error",
-        // Prefer relative URLs over absolute same-origin URLs
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/relative-url-style.md
-        "unicorn/relative-url-style": "error",
-        // Prefer `node:fs` over `fs` — explicit built-in module protocol
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-node-protocol.md
-        "unicorn/prefer-node-protocol": "error",
-        // Prefer `globalThis` over `window`/`self`/`global` — universal
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-global-this.md
-        "unicorn/prefer-global-this": "error",
-        // Prefer omitting unused catch binding — cleaner syntax
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-optional-catch-binding.md
-        "unicorn/prefer-optional-catch-binding": "error",
-        // Prefer `Date.now()` over `new Date().getTime()` — direct and readable
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-date-now.md
-        "unicorn/prefer-date-now": "error",
-        // Enforce consistent `utf-8` casing for text encoding identifiers
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/text-encoding-identifier-case.md
-        "unicorn/text-encoding-identifier-case": "error",
-        // Prefer `import.meta.url`/`import.meta.dirname` over `__filename`/`__dirname`
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-import-meta-properties.md
-        "unicorn/prefer-import-meta-properties": "error",
-        // OFF: Sequential .push() is natural in codegen and conditional builders.
-        // No real performance benefit in modern V8 — purely stylistic.
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/prefer-single-call.md
-        "unicorn/prefer-single-call": "off"
-      }
-    }]
-  });
-  if (isAi) {
-    builder.overrideSeverity("unicorn/consistent-function-scoping", "error");
-    builder.overrideSeverity("unicorn/no-array-reduce", "error");
-    builder.overrideSeverity("unicorn/no-for-loop", "error");
-    builder.addRule("unicorn/no-for-each", "error");
-    builder.addRule("unicorn/prefer-ternary", ["error", "only-single-line"]);
-    builder.addRule("unicorn/prefer-switch", ["error", { minimumCases: 3 }]);
-    builder.addRule("unicorn/prevent-abbreviations", "error");
-    builder.addRule("unicorn/no-useless-switch-case", "error");
-    builder.addRule("unicorn/custom-error-definition", "error");
-    builder.addRule("unicorn/prefer-default-parameters", "error");
-    builder.addRule("unicorn/prefer-logical-operator-over-ternary", "error");
-    builder.addRule("unicorn/prefer-math-min-max", "error");
-    builder.addRule("unicorn/prefer-set-size", "error");
-    builder.addRule("unicorn/explicit-length-check", "error");
-    builder.addRule("unicorn/switch-case-braces", "error");
-    builder.addRule("unicorn/no-array-push-push", "error");
-  }
-  return builder.build();
+	const isAi = opts?.ai === true;
+	const builder = createConfig({
+		name: "eslint-config-setup/unicorn",
+		presets: [{
+			plugins: { unicorn: unicornPlugin },
+			rules: {
+				"unicorn/no-abusive-eslint-disable": "error",
+				"unicorn/no-instanceof-builtins": "error",
+				"unicorn/no-invalid-remove-event-listener": "error",
+				"unicorn/no-invalid-fetch-options": "error",
+				"unicorn/no-typeof-undefined": "error",
+				"unicorn/no-useless-fallback-in-spread": "error",
+				"unicorn/no-useless-length-check": "error",
+				"unicorn/no-useless-spread": "error",
+				"unicorn/no-useless-promise-resolve-reject": "error",
+				"unicorn/no-useless-undefined": ["warn", { checkArguments: false }],
+				"unicorn/no-await-in-promise-methods": "error",
+				"unicorn/no-negation-in-equality-check": "error",
+				"unicorn/no-thenable": "error",
+				"unicorn/no-await-expression-member": "error",
+				"unicorn/no-this-assignment": "error",
+				"unicorn/no-unnecessary-await": "error",
+				"unicorn/no-unnecessary-slice-end": "error",
+				"unicorn/no-immediate-mutation": "off",
+				"unicorn/no-accessor-recursion": "error",
+				"unicorn/no-anonymous-default-export": "error",
+				"unicorn/no-array-method-this-argument": "error",
+				"unicorn/no-array-callback-reference": "error",
+				"unicorn/no-unreadable-iife": "error",
+				"unicorn/error-message": "error",
+				"unicorn/throw-new-error": "error",
+				"unicorn/consistent-empty-array-spread": "error",
+				"unicorn/consistent-date-clone": "error",
+				"unicorn/consistent-existence-index-check": "error",
+				"unicorn/consistent-function-scoping": "warn",
+				"unicorn/filename-case": ["error", {
+					cases: {
+						camelCase: true,
+						pascalCase: true,
+						kebabCase: true
+					},
+					ignore: ["__tests__"]
+				}],
+				"unicorn/no-array-reduce": "warn",
+				"unicorn/no-for-loop": "warn",
+				"unicorn/prefer-array-flat-map": "error",
+				"unicorn/prefer-array-find": "error",
+				"unicorn/prefer-array-flat": "error",
+				"unicorn/prefer-array-index-of": "error",
+				"unicorn/prefer-array-some": "error",
+				"unicorn/prefer-at": "error",
+				"unicorn/prefer-includes": "error",
+				"unicorn/prefer-modern-dom-apis": "error",
+				"unicorn/prefer-dom-node-dataset": "error",
+				"unicorn/prefer-modern-math-apis": "error",
+				"unicorn/prefer-negative-index": "error",
+				"unicorn/prefer-number-properties": "error",
+				"unicorn/prefer-object-from-entries": "error",
+				"unicorn/prefer-set-has": "error",
+				"unicorn/prefer-string-replace-all": "error",
+				"unicorn/prefer-string-slice": "error",
+				"unicorn/prefer-string-starts-ends-with": "error",
+				"unicorn/prefer-string-trim-start-end": "error",
+				"unicorn/prefer-structured-clone": "error",
+				"unicorn/prefer-top-level-await": "error",
+				"unicorn/prefer-type-error": "error",
+				"unicorn/better-regex": "off",
+				"unicorn/catch-error-name": ["error", { name: "error" }],
+				"unicorn/new-for-builtins": "error",
+				"unicorn/no-new-array": "error",
+				"unicorn/no-new-buffer": "error",
+				"unicorn/no-unreadable-array-destructuring": "error",
+				"unicorn/no-zero-fractions": "error",
+				"unicorn/number-literal-case": "error",
+				"unicorn/numeric-separators-style": "error",
+				"unicorn/prefer-export-from": ["error", { checkUsedVariables: false }],
+				"unicorn/prefer-native-coercion-functions": "error",
+				"unicorn/prefer-regexp-test": "error",
+				"unicorn/prefer-spread": "error",
+				"unicorn/relative-url-style": "error",
+				"unicorn/prefer-node-protocol": "error",
+				"unicorn/prefer-global-this": "error",
+				"unicorn/prefer-optional-catch-binding": "error",
+				"unicorn/prefer-date-now": "error",
+				"unicorn/text-encoding-identifier-case": "error",
+				"unicorn/prefer-import-meta-properties": "error",
+				"unicorn/prefer-single-call": "off"
+			}
+		}]
+	});
+	if (isAi) {
+		builder.overrideSeverity("unicorn/consistent-function-scoping", "error");
+		builder.overrideSeverity("unicorn/no-array-reduce", "error");
+		builder.overrideSeverity("unicorn/no-for-loop", "error");
+		builder.addRule("unicorn/no-for-each", "error");
+		builder.addRule("unicorn/prefer-ternary", ["error", "only-single-line"]);
+		builder.addRule("unicorn/prefer-switch", ["error", { minimumCases: 3 }]);
+		builder.addRule("unicorn/no-useless-switch-case", "error");
+		builder.addRule("unicorn/custom-error-definition", "error");
+		builder.addRule("unicorn/prefer-default-parameters", "error");
+		builder.addRule("unicorn/prefer-logical-operator-over-ternary", "error");
+		builder.addRule("unicorn/prefer-math-min-max", "error");
+		builder.addRule("unicorn/prefer-set-size", "error");
+		builder.addRule("unicorn/explicit-length-check", "error");
+		builder.addRule("unicorn/switch-case-braces", "error");
+		builder.addRule("unicorn/no-array-push-push", "error");
+	}
+	return builder.build();
 }
-
-// src/overrides/config-files.ts
+//#endregion
+//#region src/overrides/config-files.ts
+/**
+* Config file overrides — relaxed rules for tool configuration files.
+* Config files (vite, vitest, next, tailwind, postcss) have their own
+* patterns that conflict with strict app-code rules.
+*
+* File patterns: *.config.*, vite.config.*, vitest.config.*, etc.
+*/
 function configFilesOverride() {
-  return [
-    {
-      name: "eslint-config-setup/config-files",
-      files: [
-        "**/*.config.{ts,mts,cts,js,mjs,cjs}",
-        "**/vite.config.*",
-        "**/vitest.config.*",
-        "**/next.config.*",
-        "**/tailwind.config.*",
-        "**/postcss.config.*"
-      ],
-      rules: {
-        // Config files often require default exports (Vite, Next.js, Tailwind)
-        "import/no-default-export": "off",
-        // Config files can have complex configuration objects
-        complexity: "off",
-        "max-lines": "off",
-        "max-lines-per-function": "off",
-        "max-statements": "off",
-        // Config files may use require() for dynamic plugin loading
-        "@typescript-eslint/no-require-imports": "off",
-        // Config files may log build info to console
-        "no-console": "off",
-        // Config files often have magic numbers (ports, sizes, timeouts)
-        "no-magic-numbers": "off",
-        "@typescript-eslint/no-magic-numbers": "off"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/config-files",
+		files: [
+			"**/*.config.{ts,mts,cts,js,mjs,cjs}",
+			"**/vite.config.*",
+			"**/vitest.config.*",
+			"**/next.config.*",
+			"**/tailwind.config.*",
+			"**/postcss.config.*"
+		],
+		rules: {
+			"import/no-default-export": "off",
+			complexity: "off",
+			"max-lines": "off",
+			"max-lines-per-function": "off",
+			"max-statements": "off",
+			"@typescript-eslint/no-require-imports": "off",
+			"no-console": "off",
+			"no-magic-numbers": "off",
+			"@typescript-eslint/no-magic-numbers": "off"
+		}
+	}];
 }
-
-// src/overrides/declarations.ts
+//#endregion
+//#region src/overrides/declarations.ts
+/**
+* Declaration file overrides — minimal rules for `.d.ts` files.
+* Declaration files follow their own patterns (ambient declarations,
+* interface merging, namespaces) that conflict with app-code rules.
+*
+* File pattern: *.d.ts files
+*/
 function declarationsOverride() {
-  return [
-    {
-      name: "eslint-config-setup/declarations",
-      files: ["**/*.d.ts"],
-      rules: {
-        // Declaration files often have unused type parameters/variables
-        "@typescript-eslint/no-unused-vars": "off",
-        // Empty interfaces are valid for declaration merging
-        "@typescript-eslint/no-empty-interface": "off",
-        // Empty object types are used for extensible interfaces
-        "@typescript-eslint/no-empty-object-type": "off",
-        // `any` is sometimes necessary in third-party type declarations
-        "@typescript-eslint/no-explicit-any": "off",
-        // Both `type` and `interface` are valid in declarations
-        "@typescript-eslint/consistent-type-definitions": "off",
-        // Namespaces are standard in ambient declarations
-        "@typescript-eslint/no-namespace": "off",
-        // Duplicate imports happen with declaration merging
-        "import/no-duplicates": "off",
-        // Unused imports are common in re-export declaration files
-        "unused-imports/no-unused-imports": "off",
-        // ── AI mode rules that don't apply to declaration files ────────
-        // Declarations inherit return types from the implementation
-        "@typescript-eslint/explicit-function-return-type": "off",
-        // Third-party naming conventions must be followed as-is
-        "@typescript-eslint/naming-convention": "off",
-        // Abbreviations in third-party types are unavoidable
-        "unicorn/prevent-abbreviations": "off",
-        // .d.ts filename is dictated by the module it declares
-        "unicorn/filename-case": "off"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/declarations",
+		files: ["**/*.d.ts"],
+		rules: {
+			"@typescript-eslint/no-unused-vars": "off",
+			"@typescript-eslint/no-empty-interface": "off",
+			"@typescript-eslint/no-empty-object-type": "off",
+			"@typescript-eslint/no-explicit-any": "off",
+			"@typescript-eslint/consistent-type-definitions": "off",
+			"@typescript-eslint/no-namespace": "off",
+			"import/no-duplicates": "off",
+			"unused-imports/no-unused-imports": "off",
+			"@typescript-eslint/explicit-function-return-type": "off",
+			"@typescript-eslint/naming-convention": "off",
+			"unicorn/prevent-abbreviations": "off",
+			"unicorn/filename-case": "off"
+		}
+	}];
 }
-
-// src/overrides/e2e.ts
-import playwrightPlugin from "eslint-plugin-playwright";
+//#endregion
+//#region src/overrides/e2e.ts
+/**
+* E2E test overrides — Playwright rules + relaxed strictness for E2E tests.
+*
+* File pattern: *.spec.ts (Playwright convention)
+*
+* @see https://github.com/playwright-community/eslint-plugin-playwright#rules
+*/
 function e2eOverride() {
-  return [
-    {
-      name: "eslint-config-setup/e2e",
-      files: ["**/*.spec.ts"],
-      plugins: {
-        playwright: playwrightPlugin
-      },
-      rules: {
-        // ── Playwright rules ──────────────────────────────────────────
-        // Every test must contain at least one expect()
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/expect-expect.md
-        "playwright/expect-expect": "error",
-        // Limit describe nesting to 3 levels — keeps tests readable
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/max-nested-describe.md
-        "playwright/max-nested-describe": ["error", { max: 3 }],
-        // Detect missing await on Playwright async methods — common mistake
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/missing-playwright-await.md
-        "playwright/missing-playwright-await": "error",
-        // No expect() inside conditionals — tests should be deterministic
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/no-conditional-expect.md
-        "playwright/no-conditional-expect": "error",
-        // Warn on conditional logic in tests — tests should be linear
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/no-conditional-in-test.md
-        "playwright/no-conditional-in-test": "warn",
-        // Prefer locators over element handles — auto-retry, less flaky
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/no-element-handle.md
-        "playwright/no-element-handle": "error",
-        // No page.evaluate with arbitrary code — brittle, hard to debug
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/no-eval.md
-        "playwright/no-eval": "error",
-        // No test.only — prevents accidentally skipping tests in CI
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/no-focused-test.md
-        "playwright/no-focused-test": "error",
-        // Warn on { force: true } — bypasses visibility/actionability checks
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/no-force-option.md
-        "playwright/no-force-option": "warn",
-        // No waitUntil: "networkidle" — unreliable, use specific waits
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/no-networkidle.md
-        "playwright/no-networkidle": "error",
-        // No page.pause() — debugging artifact, breaks CI
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/no-page-pause.md
-        "playwright/no-page-pause": "error",
-        // Warn on test.skip — track disabled tests
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/no-skipped-test.md
-        "playwright/no-skipped-test": "warn",
-        // No unnecessary await on non-promise values
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/no-useless-await.md
-        "playwright/no-useless-await": "error",
-        // No double-negative assertions: expect(x).not.not...
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/no-useless-not.md
-        "playwright/no-useless-not": "error",
-        // Warn on waitForSelector — prefer locators with auto-wait
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/no-wait-for-selector.md
-        "playwright/no-wait-for-selector": "warn",
-        // No hardcoded timeouts — use Playwright's built-in waiting
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/no-wait-for-timeout.md
-        "playwright/no-wait-for-timeout": "error",
-        // Prefer web-first assertions (toBeVisible, toHaveText) — auto-retry
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/prefer-web-first-assertions.md
-        "playwright/prefer-web-first-assertions": "error",
-        // Validate expect() usage — proper matcher and argument count
-        // https://github.com/playwright-community/eslint-plugin-playwright/blob/main/docs/rules/valid-expect.md
-        "playwright/valid-expect": "error",
-        // ── Relaxed rules for E2E tests ───────────────────────────────
-        // E2E tests are long procedural scripts with many page interactions
-        "max-lines": "off",
-        "max-lines-per-function": "off",
-        "max-statements": "off"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/e2e",
+		files: ["**/*.spec.ts"],
+		plugins: { playwright: playwrightPlugin },
+		rules: {
+			"playwright/expect-expect": "error",
+			"playwright/max-nested-describe": ["error", { max: 3 }],
+			"playwright/missing-playwright-await": "error",
+			"playwright/no-conditional-expect": "error",
+			"playwright/no-conditional-in-test": "warn",
+			"playwright/no-element-handle": "error",
+			"playwright/no-eval": "error",
+			"playwright/no-focused-test": "error",
+			"playwright/no-force-option": "warn",
+			"playwright/no-networkidle": "error",
+			"playwright/no-page-pause": "error",
+			"playwright/no-skipped-test": "warn",
+			"playwright/no-useless-await": "error",
+			"playwright/no-useless-not": "error",
+			"playwright/no-wait-for-selector": "warn",
+			"playwright/no-wait-for-timeout": "error",
+			"playwright/prefer-web-first-assertions": "error",
+			"playwright/valid-expect": "error",
+			"max-lines": "off",
+			"max-lines-per-function": "off",
+			"max-statements": "off"
+		}
+	}];
 }
-
-// src/overrides/scripts.ts
+//#endregion
+//#region src/overrides/scripts.ts
+/**
+* Script file overrides — relaxed rules for build/dev scripts.
+* Scripts are CLI tools that legitimately use console.log and process.exit.
+*
+* File pattern: scripts dir (*.ts, *.mts, *.js, *.mjs)
+*/
 function scriptsOverride() {
-  return [
-    {
-      name: "eslint-config-setup/scripts",
-      files: ["**/scripts/**/*.{ts,mts,js,mjs}"],
-      rules: {
-        // Scripts use console for user-facing output
-        "no-console": "off",
-        // Scripts use process.exit for clean termination
-        // https://github.com/eslint-community/eslint-plugin-n/blob/master/docs/rules/no-process-exit.md
-        "node/no-process-exit": "off",
-        // Scripts can be long (build pipelines, code generators)
-        "max-lines": "off",
-        "max-lines-per-function": "off",
-        // Scripts are often procedural without explicit return types
-        "@typescript-eslint/explicit-function-return-type": "off",
-        // Scripts legitimately call process.exit()
-        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-process-exit.md
-        "unicorn/no-process-exit": "off"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/scripts",
+		files: ["**/scripts/**/*.{ts,mts,js,mjs}"],
+		rules: {
+			"no-console": "off",
+			"node/no-process-exit": "off",
+			"max-lines": "off",
+			"max-lines-per-function": "off",
+			"@typescript-eslint/explicit-function-return-type": "off",
+			"unicorn/no-process-exit": "off"
+		}
+	}];
 }
-
-// src/overrides/stories.ts
-import storybookPlugin from "eslint-plugin-storybook";
+//#endregion
+//#region src/overrides/stories.ts
+/**
+* Storybook overrides — Storybook best-practice rules for story files.
+*
+* File pattern: *.stories.{ts,tsx}
+*
+* @see https://github.com/storybookjs/eslint-plugin-storybook#supported-rules
+*/
 function storiesOverride() {
-  return [
-    {
-      name: "eslint-config-setup/stories",
-      files: ["**/*.stories.{ts,tsx}"],
-      plugins: {
-        storybook: storybookPlugin
-      },
-      rules: {
-        // ── Storybook rules ───────────────────────────────────────────
-        // Await play function interactions — prevents race conditions
-        // https://github.com/storybookjs/eslint-plugin-storybook/blob/main/docs/rules/await-interactions.md
-        "storybook/await-interactions": "error",
-        // Stories must have a default export (meta) — Storybook requirement
-        // https://github.com/storybookjs/eslint-plugin-storybook/blob/main/docs/rules/default-exports.md
-        "storybook/default-exports": "error",
-        // Use / for hierarchy separators, not | or . — Storybook 7+ convention
-        // https://github.com/storybookjs/eslint-plugin-storybook/blob/main/docs/rules/hierarchy-separator.md
-        "storybook/hierarchy-separator": "error",
-        // No redundant story names that match export name — DRY
-        // https://github.com/storybookjs/eslint-plugin-storybook/blob/main/docs/rules/no-redundant-story-name.md
-        "storybook/no-redundant-story-name": "error",
-        // No deprecated storiesOf() API — use CSF (Component Story Format)
-        // https://github.com/storybookjs/eslint-plugin-storybook/blob/main/docs/rules/no-stories-of.md
-        "storybook/no-stories-of": "error",
-        // Warn if title is in meta — auto-title is preferred in CSF 3
-        // https://github.com/storybookjs/eslint-plugin-storybook/blob/main/docs/rules/no-title-property-in-meta.md
-        "storybook/no-title-property-in-meta": "warn",
-        // Story exports should be PascalCase — component naming convention
-        // https://github.com/storybookjs/eslint-plugin-storybook/blob/main/docs/rules/prefer-pascal-case.md
-        "storybook/prefer-pascal-case": "error",
-        // File must export at least one story — prevents empty story files
-        // https://github.com/storybookjs/eslint-plugin-storybook/blob/main/docs/rules/story-exports.md
-        "storybook/story-exports": "error",
-        // Use Storybook's expect() instead of Jest/Vitest in play functions
-        // https://github.com/storybookjs/eslint-plugin-storybook/blob/main/docs/rules/use-storybook-expect.md
-        "storybook/use-storybook-expect": "error",
-        // Use Storybook's Testing Library, not direct import
-        // https://github.com/storybookjs/eslint-plugin-storybook/blob/main/docs/rules/use-storybook-testing-library.md
-        "storybook/use-storybook-testing-library": "error",
-        // Enforce `satisfies Meta<typeof Component>` on default export — type-safe meta
-        // https://github.com/storybookjs/eslint-plugin-storybook/blob/main/docs/rules/meta-satisfies-type.md
-        "storybook/meta-satisfies-type": "error",
-        // ── Relaxed rules for stories ─────────────────────────────────
-        // Stories require default exports (meta object)
-        "import/no-default-export": "off",
-        // Stories can be long (many variants of a component)
-        "max-lines": "off",
-        "max-lines-per-function": "off"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/stories",
+		files: ["**/*.stories.{ts,tsx}"],
+		plugins: { storybook: storybookPlugin },
+		rules: {
+			"storybook/await-interactions": "error",
+			"storybook/default-exports": "error",
+			"storybook/hierarchy-separator": "error",
+			"storybook/no-redundant-story-name": "error",
+			"storybook/no-stories-of": "error",
+			"storybook/no-title-property-in-meta": "warn",
+			"storybook/prefer-pascal-case": "error",
+			"storybook/story-exports": "error",
+			"storybook/use-storybook-expect": "error",
+			"storybook/use-storybook-testing-library": "error",
+			"storybook/meta-satisfies-type": "error",
+			"import/no-default-export": "off",
+			"max-lines": "off",
+			"max-lines-per-function": "off"
+		}
+	}];
 }
-
-// src/overrides/tests.ts
-import vitestPlugin from "@vitest/eslint-plugin";
-import testingLibraryPlugin from "eslint-plugin-testing-library";
-var TEST_FILES2 = ["**/*.test.{ts,tsx}", "**/__tests__/**/*.{ts,tsx}"];
-var VITEST_RULES = {
-  // ── Vitest rules ──────────────────────────────────────────────
-  // Every test must contain at least one assertion
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/expect-expect.md
-  "vitest/expect-expect": "error",
-  // Prevent duplicate test titles within a describe block
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-identical-title.md
-  "vitest/no-identical-title": "error",
-  // No it.only / describe.only — prevents accidentally skipping tests in CI
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-focused-tests.md
-  "vitest/no-focused-tests": "error",
-  // Warn on it.skip / describe.skip — track disabled tests
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-disabled-tests.md
-  "vitest/no-disabled-tests": "warn",
-  // No duplicate beforeEach/afterEach hooks — merge them
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-duplicate-hooks.md
-  "vitest/no-duplicate-hooks": "error",
-  // Prefer .toBe() over .toEqual() for primitives — clearer intent
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/prefer-to-be.md
-  "vitest/prefer-to-be": "error",
-  // Prefer .toHaveLength() over .toBe(arr.length) — better errors
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/prefer-to-have-length.md
-  "vitest/prefer-to-have-length": "error",
-  // Validate expect() usage — no dangling expect without assertion
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/valid-expect.md
-  "vitest/valid-expect": "error",
-  // Validate test/describe title format — no empty or invalid titles
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/valid-title.md
-  "vitest/valid-title": "error",
-  // No conditional logic (if/else) inside tests — split into separate tests
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-conditional-in-test.md
-  "vitest/no-conditional-in-test": "error",
-  // No expect() inside conditional blocks — always assert unconditionally
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-conditional-expect.md
-  "vitest/no-conditional-expect": "error",
-  // No standalone expect() outside test blocks — always wrap in it/test
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-standalone-expect.md
-  "vitest/no-standalone-expect": "error",
-  // Prefer .toStrictEqual() over .toEqual() — catches undefined vs missing
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/prefer-strict-equal.md
-  "vitest/prefer-strict-equal": "error",
-  // Prefer vi.spyOn() over vi.fn() for method mocks — preserves original
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/prefer-spy-on.md
-  "vitest/prefer-spy-on": "error",
-  // Require message argument in toThrow/toThrowError — verify correct error
-  // https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/require-to-throw-message.md
-  "vitest/require-to-throw-message": "error",
-  // ── Relaxed rules for tests ───────────────────────────────────
-  // Tests are naturally verbose and use patterns banned in prod code
-  // Tests can be long (setup + many assertions)
-  "max-lines": "off",
-  "max-lines-per-function": "off",
-  "max-statements": "off",
-  // Tests often need `any` for mocking and type assertions
-  "@typescript-eslint/no-explicit-any": "off",
-  "@typescript-eslint/no-non-null-assertion": "off",
-  "@typescript-eslint/no-unsafe-assignment": "off",
-  "@typescript-eslint/no-unsafe-member-access": "off"
+//#endregion
+//#region src/overrides/tests.ts
+const TEST_FILES = ["**/*.test.{ts,tsx}", "**/__tests__/**/*.{ts,tsx}"];
+const VITEST_RULES = {
+	"vitest/expect-expect": "error",
+	"vitest/no-identical-title": "error",
+	"vitest/no-focused-tests": "error",
+	"vitest/no-disabled-tests": "warn",
+	"vitest/no-duplicate-hooks": "error",
+	"vitest/prefer-to-be": "error",
+	"vitest/prefer-to-have-length": "error",
+	"vitest/valid-expect": "error",
+	"vitest/valid-title": "error",
+	"vitest/no-conditional-in-test": "error",
+	"vitest/no-conditional-expect": "error",
+	"vitest/no-standalone-expect": "error",
+	"vitest/prefer-strict-equal": "error",
+	"vitest/prefer-spy-on": "error",
+	"vitest/require-to-throw-message": "error",
+	"max-lines": "off",
+	"max-lines-per-function": "off",
+	"max-statements": "off",
+	"@typescript-eslint/no-explicit-any": "off",
+	"@typescript-eslint/no-non-null-assertion": "off",
+	"@typescript-eslint/no-unsafe-assignment": "off",
+	"@typescript-eslint/no-unsafe-member-access": "off"
 };
-var TESTING_LIBRARY_RULES = {
-  // ── Testing Library rules ───────────────────────────────────
-  // Await async events (userEvent.click, etc.) — prevents race conditions
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/await-async-events.md
-  "testing-library/await-async-events": "error",
-  // Await async queries (findBy*) — they return promises
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/await-async-queries.md
-  "testing-library/await-async-queries": "error",
-  // Await async utilities (waitFor, waitForElementToBeRemoved)
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/await-async-utils.md
-  "testing-library/await-async-utils": "error",
-  // Don't await synchronous events — misleading
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/no-await-sync-events.md
-  "testing-library/no-await-sync-events": "error",
-  // Don't await synchronous queries (getBy*, queryBy*) — not promises
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/no-await-sync-queries.md
-  "testing-library/no-await-sync-queries": "error",
-  // Don't use container.querySelector — use queries instead
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/no-container.md
-  "testing-library/no-container": "error",
-  // Warn on debug()/prettyDOM() left in tests — debugging artifacts
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/no-debugging-utils.md
-  "testing-library/no-debugging-utils": "warn",
-  // Don't access DOM nodes directly — use queries
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/no-node-access.md
-  "testing-library/no-node-access": "error",
-  // Don't call render in beforeEach — call in each test
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/no-render-in-lifecycle.md
-  "testing-library/no-render-in-lifecycle": "error",
-  // No unnecessary act() wrappers — TL handles this internally
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/no-unnecessary-act.md
-  "testing-library/no-unnecessary-act": "error",
-  // One assertion per waitFor — multiple can mask failures
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/no-wait-for-multiple-assertions.md
-  "testing-library/no-wait-for-multiple-assertions": "error",
-  // No side effects in waitFor — only assertions
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/no-wait-for-side-effects.md
-  "testing-library/no-wait-for-side-effects": "error",
-  // Prefer findBy* over waitFor + getBy* — built-in combination
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/prefer-find-by.md
-  "testing-library/prefer-find-by": "error",
-  // Use getBy* (throws) for present elements, queryBy* for absent
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/prefer-presence-queries.md
-  "testing-library/prefer-presence-queries": "error",
-  // Use queryBy* for disappearance checks — returns null when gone
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/prefer-query-by-disappearance.md
-  "testing-library/prefer-query-by-disappearance": "error",
-  // Use screen.getBy* over destructured render result — consistent
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/prefer-screen-queries.md
-  "testing-library/prefer-screen-queries": "error",
-  // Name render result consistently (e.g., `const { getByText } = render(...)`)
-  // https://github.com/testing-library/eslint-plugin-testing-library/blob/main/docs/rules/render-result-naming-convention.md
-  "testing-library/render-result-naming-convention": "error"
+const TESTING_LIBRARY_RULES = {
+	"testing-library/await-async-events": "error",
+	"testing-library/await-async-queries": "error",
+	"testing-library/await-async-utils": "error",
+	"testing-library/no-await-sync-events": "error",
+	"testing-library/no-await-sync-queries": "error",
+	"testing-library/no-container": "error",
+	"testing-library/no-debugging-utils": "warn",
+	"testing-library/no-node-access": "error",
+	"testing-library/no-render-in-lifecycle": "error",
+	"testing-library/no-unnecessary-act": "error",
+	"testing-library/no-wait-for-multiple-assertions": "error",
+	"testing-library/no-wait-for-side-effects": "error",
+	"testing-library/prefer-find-by": "error",
+	"testing-library/prefer-presence-queries": "error",
+	"testing-library/prefer-query-by-disappearance": "error",
+	"testing-library/prefer-screen-queries": "error",
+	"testing-library/render-result-naming-convention": "error"
 };
+/**
+* Test file overrides — Vitest rules + Testing Library + relaxed strictness.
+*
+* File patterns: *.test.{ts,tsx}, __tests__/*.{ts,tsx}
+*
+* @see https://github.com/vitest-dev/eslint-plugin-vitest#rules
+* @see https://github.com/testing-library/eslint-plugin-testing-library#supported-rules
+*/
 function testsOverride() {
-  return [
-    {
-      name: "eslint-config-setup/tests",
-      files: TEST_FILES2,
-      plugins: {
-        vitest: vitestPlugin
-      },
-      rules: VITEST_RULES
-    },
-    {
-      name: "eslint-config-setup/tests-testing-library",
-      files: TEST_FILES2,
-      plugins: {
-        "testing-library": testingLibraryPlugin
-      },
-      rules: TESTING_LIBRARY_RULES
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/tests",
+		files: TEST_FILES,
+		plugins: { vitest: vitestPlugin },
+		rules: VITEST_RULES
+	}, {
+		name: "eslint-config-setup/tests-testing-library",
+		files: TEST_FILES,
+		plugins: { "testing-library": testingLibraryPlugin },
+		rules: TESTING_LIBRARY_RULES
+	}];
 }
-
-// src/oxlint/integration.ts
-import oxlintPlugin from "eslint-plugin-oxlint";
-var typedPlugin = oxlintPlugin;
+//#endregion
+//#region src/oxlint/integration.ts
+const typedPlugin = oxlintPlugin;
 function addOxlintConfig(configs, configName, blockName) {
-  const raw = typedPlugin.configs[configName];
-  const items = Array.isArray(raw) ? raw : [raw];
-  for (const [index, item] of items.entries()) {
-    const suffix = items.length > 1 ? `-${index + 1}` : "";
-    configs.push({ ...item, name: `eslint-config-setup/${blockName}${suffix}` });
-  }
+	const raw = typedPlugin.configs[configName];
+	const items = Array.isArray(raw) ? raw : [raw];
+	for (const [index, item] of items.entries()) {
+		const suffix = items.length > 1 ? `-${index + 1}` : "";
+		configs.push({
+			...item,
+			name: `eslint-config-setup/${blockName}${suffix}`
+		});
+	}
 }
 function addReactOxlintConfigs(configs, opts) {
-  if (!opts.react) {
-    return;
-  }
-  addOxlintConfig(configs, "flat/react", "oxlint-react");
-  addOxlintConfig(configs, "flat/jsx-a11y", "oxlint-jsx-a11y");
-  addOxlintConfig(configs, "flat/react-hooks", "oxlint-react-hooks");
-  if (opts.ai) {
-    addOxlintConfig(configs, "flat/react-perf", "oxlint-react-perf");
-  }
+	if (!opts.react) return;
+	addOxlintConfig(configs, "flat/react", "oxlint-react");
+	addOxlintConfig(configs, "flat/jsx-a11y", "oxlint-jsx-a11y");
+	addOxlintConfig(configs, "flat/react-hooks", "oxlint-react-hooks");
+	if (opts.ai) addOxlintConfig(configs, "flat/react-perf", "oxlint-react-perf");
 }
+/**
+* Appends eslint-plugin-oxlint configs that disable all ESLint rules
+* already covered by OxLint. Must be the LAST config in the array.
+*
+* This allows running `oxlint && eslint` where OxLint handles the fast
+* checks and ESLint only runs type-aware and specialty rules.
+*/
 function oxlintIntegration(opts) {
-  const configs = [];
-  addOxlintConfig(configs, "flat/recommended", "oxlint");
-  addReactOxlintConfigs(configs, opts);
-  if (opts.node) {
-    addOxlintConfig(configs, "flat/node", "oxlint-node");
-  }
-  addOxlintConfig(configs, "flat/typescript", "oxlint-typescript");
-  addOxlintConfig(configs, "flat/unicorn", "oxlint-unicorn");
-  addOxlintConfig(configs, "flat/import", "oxlint-import");
-  addOxlintConfig(configs, "flat/jsdoc", "oxlint-jsdoc");
-  return configs;
+	const configs = [];
+	addOxlintConfig(configs, "flat/recommended", "oxlint");
+	addReactOxlintConfigs(configs, opts);
+	if (opts.node) addOxlintConfig(configs, "flat/node", "oxlint-node");
+	addOxlintConfig(configs, "flat/typescript", "oxlint-typescript");
+	addOxlintConfig(configs, "flat/unicorn", "oxlint-unicorn");
+	addOxlintConfig(configs, "flat/import", "oxlint-import");
+	addOxlintConfig(configs, "flat/jsdoc", "oxlint-jsdoc");
+	return configs;
 }
-
-// src/presets/standard.ts
+//#endregion
+//#region src/presets/standard.ts
+/**
+* Complexity preset — limits for production code that encourage small,
+* focused functions and aggressive extraction of helper functions.
+* @see https://eslint.org/docs/latest/rules/#suggestions (complexity rules)
+*/
 function standardComplexity() {
-  return [
-    {
-      name: "eslint-config-setup/complexity",
-      rules: {
-        // Max cyclomatic complexity per function — 10 branches
-        // https://eslint.org/docs/latest/rules/complexity
-        complexity: ["error", 10],
-        // Max nesting depth — 3 levels
-        // https://eslint.org/docs/latest/rules/max-depth
-        "max-depth": ["error", 3],
-        // Max nested callbacks — 2 levels
-        // https://eslint.org/docs/latest/rules/max-nested-callbacks
-        "max-nested-callbacks": ["error", 2],
-        // Max function parameters — 3 before using options object
-        // https://eslint.org/docs/latest/rules/max-params
-        "max-params": ["error", 3],
-        // Max statements per function — 15
-        // https://eslint.org/docs/latest/rules/max-statements
-        "max-statements": ["error", 15],
-        // Max lines per function — 50 (excluding blanks and comments)
-        // https://eslint.org/docs/latest/rules/max-lines-per-function
-        "max-lines-per-function": [
-          "error",
-          { max: 50, skipBlankLines: true, skipComments: true }
-        ],
-        // Max lines per file — 300 (excluding blanks and comments)
-        // https://eslint.org/docs/latest/rules/max-lines
-        "max-lines": [
-          "error",
-          { max: 300, skipBlankLines: true, skipComments: true }
-        ],
-        // Cognitive complexity — measures how hard code is to understand
-        // https://sonarsource.github.io/rspec/#/rspec/S3776/javascript
-        "sonarjs/cognitive-complexity": ["error", 10]
-      }
-    },
-    {
-      name: "eslint-config-setup/complexity-tests-relaxed",
-      files: ["**/*.test.{ts,tsx}", "**/__tests__/**/*.{ts,tsx}", "**/*.spec.ts"],
-      rules: {
-        "max-nested-callbacks": "off",
-        "max-lines": "off",
-        "max-lines-per-function": "off",
-        "max-statements": "off"
-      }
-    }
-  ];
+	return [{
+		name: "eslint-config-setup/complexity",
+		rules: {
+			complexity: ["error", 10],
+			"max-depth": ["error", 3],
+			"max-nested-callbacks": ["error", 2],
+			"max-params": ["error", 3],
+			"max-statements": ["error", 15],
+			"max-lines-per-function": ["error", {
+				max: 50,
+				skipBlankLines: true,
+				skipComments: true
+			}],
+			"max-lines": ["error", {
+				max: 300,
+				skipBlankLines: true,
+				skipComments: true
+			}],
+			"sonarjs/cognitive-complexity": ["error", 10]
+		}
+	}, {
+		name: "eslint-config-setup/complexity-tests-relaxed",
+		files: [
+			"**/*.test.{ts,tsx}",
+			"**/__tests__/**/*.{ts,tsx}",
+			"**/*.spec.ts"
+		],
+		rules: {
+			"max-nested-callbacks": "off",
+			"max-lines": "off",
+			"max-lines-per-function": "off",
+			"max-statements": "off"
+		}
+	}];
 }
-
-// src/build/compose.ts
+//#endregion
+//#region src/build/compose.ts
+/**
+* Composes a full flat config array from the given options.
+* This is the core logic used by the build system to generate configs.
+*/
 function addCoreConfigs(config, opts) {
-  const ai = opts.ai;
-  config.push(
-    ...baseConfig({ ai }),
-    ...typescriptConfig({ ai, react: opts.react }),
-    ...importsConfig(),
-    ...perfectionistConfig(),
-    ...unicornConfig({ ai }),
-    ...regexpConfig({ ai }),
-    ...jsdocConfig({ ai }),
-    ...cspellConfig(),
-    ...sonarjsConfig({ ai }),
-    ...securityConfig(),
-    ...deMorganConfig()
-  );
+	const ai = opts.ai;
+	config.push(...baseConfig({ ai }), ...typescriptConfig({
+		ai,
+		react: opts.react
+	}), ...importsConfig(), ...perfectionistConfig(), ...unicornConfig({ ai }), ...regexpConfig({ ai }), ...jsdocConfig({ ai }), ...cspellConfig(), ...sonarjsConfig({ ai }), ...securityConfig(), ...deMorganConfig());
 }
 function addConditionalConfigs(config, opts) {
-  if (!opts.node) {
-    config.push(...compatConfig());
-  }
-  if (!opts.ai) {
-    config.push(...standardComplexity());
-  }
-  if (opts.node) {
-    config.push(...nodeConfig({ ai: opts.ai }));
-  }
-  if (opts.react) {
-    config.push(...reactConfig({ ai: opts.ai }));
-    config.push(...reactEffectConfig());
-  }
-  if (opts.ai) {
-    config.push(...aiConfig());
-    config.push(...perfectionistAiConfig());
-    config.push(...packageJsonAiConfig());
-  }
+	if (!opts.node) config.push(...compatConfig());
+	if (!opts.ai) config.push(...standardComplexity());
+	if (opts.node) config.push(...nodeConfig({ ai: opts.ai }));
+	if (opts.react) {
+		config.push(...reactConfig({ ai: opts.ai }));
+		config.push(...reactEffectConfig());
+	}
+	if (opts.ai) {
+		config.push(...aiConfig());
+		config.push(...perfectionistAiConfig());
+		config.push(...packageJsonAiConfig());
+	}
 }
 function addFileTypeOverrides(config) {
-  config.push(
-    ...testsOverride(),
-    ...e2eOverride(),
-    ...storiesOverride(),
-    ...configFilesOverride(),
-    ...declarationsOverride(),
-    ...scriptsOverride()
-  );
+	config.push(...testsOverride(), ...e2eOverride(), ...storiesOverride(), ...configFilesOverride(), ...declarationsOverride(), ...scriptsOverride());
 }
 function addFinalConfigs(config, opts) {
-  config.push(...jsonConfig(), ...packageJsonConfig(), ...markdownConfig(), ...prettierCompatConfig());
-  if (opts.oxlint) {
-    config.push(...oxlintIntegration(opts));
-  }
+	config.push(...jsonConfig(), ...packageJsonConfig(), ...markdownConfig(), ...prettierCompatConfig());
+	if (opts.oxlint) config.push(...oxlintIntegration(opts));
 }
 function composeConfig(opts) {
-  const config = [];
-  addCoreConfigs(config, opts);
-  addConditionalConfigs(config, opts);
-  addFileTypeOverrides(config);
-  addFinalConfigs(config, opts);
-  return config;
+	const config = [];
+	addCoreConfigs(config, opts);
+	addConditionalConfigs(config, opts);
+	addFileTypeOverrides(config);
+	addFinalConfigs(config, opts);
+	return config;
 }
-export {
-  aiConfig as ai,
-  baseConfig as base,
-  composeConfig,
-  configFilesOverride as configFiles,
-  cspellConfig as cspell,
-  deMorganConfig as deMorgan,
-  declarationsOverride as declarations,
-  e2eOverride as e2e,
-  importsConfig as imports,
-  jsdocConfig as jsdoc,
-  jsonConfig as json,
-  markdownConfig as markdown,
-  nodeConfig as node,
-  oxlintIntegration as oxlint,
-  packageJsonConfig as packageJson,
-  packageJsonAiConfig as packageJsonAi,
-  perfectionistConfig as perfectionist,
-  perfectionistAiConfig as perfectionistAi,
-  prettierCompatConfig as prettier,
-  reactConfig as react,
-  reactEffectConfig as reactEffect,
-  regexpConfig as regexp,
-  scriptsOverride as scripts,
-  securityConfig as security,
-  sonarjsConfig as sonarjs,
-  standardComplexity,
-  storiesOverride as stories,
-  testsOverride as tests,
-  typescriptConfig as typescript,
-  unicornConfig as unicorn
-};
+//#endregion
+export { aiConfig as ai, baseConfig as base, composeConfig, configFilesOverride as configFiles, cspellConfig as cspell, deMorganConfig as deMorgan, declarationsOverride as declarations, e2eOverride as e2e, importsConfig as imports, jsdocConfig as jsdoc, jsonConfig as json, markdownConfig as markdown, nodeConfig as node, oxlintIntegration as oxlint, packageJsonConfig as packageJson, packageJsonAiConfig as packageJsonAi, perfectionistConfig as perfectionist, perfectionistAiConfig as perfectionistAi, prettierCompatConfig as prettier, reactConfig as react, reactEffectConfig as reactEffect, regexpConfig as regexp, scriptsOverride as scripts, securityConfig as security, sonarjsConfig as sonarjs, standardComplexity, storiesOverride as stories, testsOverride as tests, typescriptConfig as typescript, unicornConfig as unicorn };
+
 //# sourceMappingURL=modules.js.map