@ariestools/eslint-config-flat 8.6.11

package/dist/node/index.mjs

@@ -0,0 +1,1539 @@
+// src/json/index.ts
+import json from "@eslint/json";
+
+// src/ignores.ts
+var ignores = [
+  ".eslintcache",
+  ".github",
+  ".husky",
+  ".jest",
+  ".next",
+  ".vscode",
+  ".yarn",
+  "**/dist",
+  "**/docs",
+  "**/node_modules",
+  "coverage",
+  "cypress",
+  "public",
+  "storybook-static",
+  "tmp",
+  "yarn-error.log",
+  "yarn.lock"
+];
+
+// src/json/index.ts
+var jsonConfig = {
+  ignores,
+  files: ["**/*.json"],
+  plugins: { json },
+  language: "json/json",
+  rules: { "json/no-duplicate-keys": ["error"] }
+};
+var jsoncConfig = {
+  ignores,
+  files: ["**/*.jsonc"],
+  plugins: { json },
+  language: "json/jsonc",
+  rules: { "json/no-duplicate-keys": ["error"] }
+};
+var json5Config = {
+  ignores,
+  files: ["**/*.json5"],
+  plugins: { json },
+  language: "json/json5",
+  rules: { "json/no-duplicate-keys": ["error"] }
+};
+
+// src/markdown/index.ts
+import markdown from "@eslint/markdown";
+
+// src/shared.ts
+import tsParser from "@typescript-eslint/parser";
+var scriptFiles = [
+  "**/*.ts",
+  "**/*.tsx",
+  "**/*.mts",
+  "**/*.cts",
+  "**/*.js",
+  "**/*.jsx",
+  "**/*.cjs",
+  "**/*.mjs",
+  "**/*.d.ts",
+  "**/*.d.tsx",
+  "**/*.d.jsx",
+  "**/*.d.mts",
+  "**/*.d.cts"
+];
+var scriptLanguageOptions = {
+  ecmaVersion: "latest",
+  parser: tsParser,
+  parserOptions: { ecmaFeatures: { jsx: true } },
+  sourceType: "module"
+};
+function currentWorkingDirectory() {
+  return globalThis.process?.cwd?.();
+}
+var tsconfigRootDir = currentWorkingDirectory();
+var typeCheckedParserOptions = {
+  ...scriptLanguageOptions.parserOptions,
+  projectService: true
+};
+if (tsconfigRootDir !== void 0) {
+  typeCheckedParserOptions.tsconfigRootDir = tsconfigRootDir;
+}
+var typeCheckedLanguageOptions = {
+  ...scriptLanguageOptions,
+  parserOptions: typeCheckedParserOptions
+};
+function unique(values) {
+  return [...new Set(values.filter((value) => value !== void 0))];
+}
+function mergeLanguageOptions(base, next) {
+  if (!base) return next;
+  if (!next) return base;
+  return {
+    ...base,
+    ...next,
+    globals: {
+      ...base.globals,
+      ...next.globals
+    },
+    parserOptions: {
+      ...base.parserOptions,
+      ...next.parserOptions
+    }
+  };
+}
+function scopeConfig(config2, {
+  files,
+  languageOptions
+} = {}) {
+  const merged = mergeLanguageOptions(languageOptions, config2.languageOptions);
+  const result = {
+    ...config2,
+    files: files ?? config2.files,
+    ignores: unique([...config2.ignores ?? [], ...ignores])
+  };
+  if (merged) {
+    result.languageOptions = merged;
+  }
+  return result;
+}
+function scopeConfigs(configs, options = {}) {
+  return (Array.isArray(configs) ? configs : [configs]).map((config2) => scopeConfig(config2, options));
+}
+
+// src/markdown/index.ts
+var markdownFiles = ["**/*.md"];
+var markdownConfig = [
+  ...scopeConfigs(markdown.configs.recommended),
+  scopeConfig({ rules: { "markdown/fenced-code-language": "off" } }, { files: markdownFiles })
+];
+
+// src/core/index.ts
+import js from "@eslint/js";
+
+// src/rules/consistency.ts
+var consistencyRulesConfig = {
+  ignores,
+  rules: {
+    "complexity": ["error", 18],
+    "max-depth": ["error", 6],
+    "max-lines": [
+      "error",
+      {
+        max: 512,
+        skipBlankLines: true
+      }
+    ],
+    "array-element-newline": ["warn", "consistent"],
+    // Owned by max-nested-callbacks — measures callback nesting, not call depth
+    "max-nested-callbacks": ["error", 6],
+    "max-statements": ["error", 32],
+    "no-tabs": ["error"]
+  }
+};
+
+// src/rules/correctness.ts
+var restrictedImportPaths = [
+  "./index.ts",
+  "../index.ts",
+  "../../index.ts",
+  "../../../index.ts",
+  "../../../../index.ts",
+  "../../../../../index.ts",
+  "../../../../../../index.ts",
+  "../../../../../../../index.ts"
+];
+var correctnessRulesConfig = {
+  ignores,
+  rules: {
+    // Owned by @typescript-eslint/no-unused-vars
+    "no-unused-vars": "off",
+    // Owned by unicorn/escape-case
+    "no-useless-escape": "off",
+    // Owned by unicorn/prefer-spread
+    "prefer-spread": "off",
+    "no-restricted-imports": [
+      "error",
+      { paths: restrictedImportPaths }
+    ]
+  }
+};
+
+// src/rules/index.ts
+var restrictedImportPaths2 = [
+  "./index.ts",
+  "../index.ts",
+  "../../index.ts",
+  "../../../index.ts",
+  "../../../../index.ts",
+  "../../../../../index.ts",
+  "../../../../../../index.ts",
+  "../../../../../../../index.ts"
+];
+var restrictedSrcImportPatterns = [
+  {
+    group: [
+      "**/src/**",
+      "**/src",
+      "src/**"
+    ],
+    message: "Do not import from another package's src folder. Import the package by its public entry point instead."
+  }
+];
+var rulesConfig = {
+  ignores,
+  rules: {
+    ...correctnessRulesConfig.rules,
+    ...consistencyRulesConfig.rules
+  }
+};
+var srcImportsConfig = {
+  files: scriptFiles.map((pattern) => `**/src/${pattern}`),
+  ignores,
+  rules: {
+    "no-restricted-imports": [
+      "error",
+      {
+        paths: restrictedImportPaths2,
+        patterns: restrictedSrcImportPatterns
+      }
+    ]
+  }
+};
+
+// src/unicorn/index.ts
+import unicornPlugin from "eslint-plugin-unicorn";
+var compareStrings = (left, right) => left.localeCompare(right);
+var unicornRecommendedRules = unicornPlugin.configs.recommended.rules ?? {};
+var unicornUnopinionatedConfig = unicornPlugin.configs.unopinionated;
+var unicornUnopinionatedRules = unicornUnopinionatedConfig.rules ?? {};
+var unicornOpinionatedRules = Object.entries(unicornRecommendedRules).filter(([rule2, severity]) => severity !== "off" && unicornUnopinionatedRules[rule2] === "off").map(([rule2]) => rule2).toSorted(compareStrings);
+var unicornV66MigrationQueue = [
+  "unicorn/class-reference-in-static-methods",
+  "unicorn/comment-content",
+  "unicorn/consistent-export-decorator-position",
+  "unicorn/consistent-optional-chaining",
+  "unicorn/explicit-timer-delay",
+  "unicorn/no-array-reverse",
+  "unicorn/no-array-sort",
+  "unicorn/no-break-in-nested-loop",
+  "unicorn/no-computed-property-existence-check",
+  "unicorn/no-confusing-array-with",
+  "unicorn/no-declarations-before-early-exit",
+  "unicorn/no-duplicate-loops",
+  "unicorn/no-error-property-assignment",
+  "unicorn/no-for-each",
+  "unicorn/no-global-object-property-assignment",
+  "unicorn/no-incorrect-template-string-interpolation",
+  "unicorn/no-invalid-argument-count",
+  "unicorn/no-mismatched-map-key",
+  "unicorn/no-negated-array-predicate",
+  "unicorn/no-negated-comparison",
+  "unicorn/no-object-methods-with-collections",
+  "unicorn/no-optional-chaining-on-undeclared-variable",
+  "unicorn/no-redundant-comparison",
+  "unicorn/no-return-array-push",
+  "unicorn/no-subtraction-comparison",
+  "unicorn/no-top-level-side-effects",
+  "unicorn/no-undeclared-class-members",
+  "unicorn/no-unnecessary-global-this",
+  "unicorn/no-unnecessary-splice",
+  "unicorn/no-unreadable-new-expression",
+  "unicorn/no-unreadable-object-destructuring",
+  "unicorn/no-unsafe-buffer-conversion",
+  "unicorn/no-unsafe-property-key",
+  "unicorn/no-unsafe-string-replacement",
+  "unicorn/no-useless-boolean-cast",
+  "unicorn/no-useless-concat",
+  "unicorn/no-useless-else",
+  "unicorn/no-useless-recursion",
+  "unicorn/no-useless-template-literals",
+  "unicorn/prefer-add-event-listener-options",
+  "unicorn/prefer-array-from-map",
+  "unicorn/prefer-await",
+  "unicorn/prefer-direct-iteration",
+  "unicorn/prefer-early-return",
+  "unicorn/prefer-global-number-constants",
+  "unicorn/prefer-identifier-import-export-specifiers",
+  "unicorn/prefer-iterable-in-constructor",
+  "unicorn/prefer-iterator-to-array",
+  "unicorn/prefer-location-assign",
+  "unicorn/prefer-minimal-ternary",
+  "unicorn/prefer-number-coercion",
+  "unicorn/prefer-number-is-safe-integer",
+  "unicorn/prefer-object-define-properties",
+  "unicorn/prefer-object-destructuring-defaults",
+  "unicorn/prefer-object-iterable-methods",
+  "unicorn/prefer-path2d",
+  "unicorn/prefer-private-class-fields",
+  "unicorn/prefer-scoped-selector",
+  "unicorn/prefer-short-arrow-method",
+  "unicorn/prefer-simple-sort-comparator",
+  "unicorn/prefer-single-array-predicate",
+  "unicorn/prefer-single-object-destructuring",
+  "unicorn/prefer-smaller-scope",
+  "unicorn/prefer-type-literal-last",
+  "unicorn/prefer-uint8array-base64",
+  "unicorn/prefer-unicode-code-point-escapes",
+  "unicorn/prefer-url-href",
+  "unicorn/require-proxy-trap-boolean-return"
+];
+var unicornGloballyDisabledRules = [
+  "unicorn/consistent-boolean-name",
+  "unicorn/require-array-sort-compare"
+];
+var unicornGloballyDisabledRuleSet = new Set(unicornGloballyDisabledRules);
+var unicornV67MigrationQueue = [
+  "unicorn/logical-assignment-operators",
+  "unicorn/no-array-splice",
+  "unicorn/no-non-function-verb-prefix",
+  "unicorn/no-top-level-assignment-in-function",
+  "unicorn/no-uncalled-method",
+  "unicorn/no-unreadable-for-of-expression",
+  "unicorn/no-useless-coercion",
+  "unicorn/no-useless-continue",
+  "unicorn/no-useless-override",
+  "unicorn/operator-assignment",
+  "unicorn/prefer-array-slice",
+  "unicorn/prefer-else-if",
+  "unicorn/prefer-has-check",
+  "unicorn/prefer-map-from-entries"
+];
+var unicornV69MigrationQueue = [
+  "unicorn/consistent-conditional-object-spread",
+  "unicorn/consistent-tuple-labels",
+  "unicorn/default-export-style",
+  "unicorn/no-accidental-bitwise-operator",
+  "unicorn/no-array-concat-in-loop",
+  "unicorn/no-array-sort-for-min-max",
+  "unicorn/no-boolean-sort-comparator",
+  "unicorn/no-chained-comparison",
+  "unicorn/no-collection-bracket-access",
+  "unicorn/no-constant-zero-expression",
+  "unicorn/no-double-comparison",
+  "unicorn/no-duplicate-if-branches",
+  "unicorn/no-duplicate-logical-operands",
+  "unicorn/no-impossible-length-comparison",
+  "unicorn/no-invalid-character-comparison",
+  "unicorn/no-invalid-well-known-symbol-methods",
+  "unicorn/no-late-event-control",
+  "unicorn/no-loop-iterable-mutation",
+  "unicorn/no-misrefactored-assignment",
+  "unicorn/no-nonstandard-builtin-properties",
+  "unicorn/no-selector-as-dom-name",
+  "unicorn/no-unnecessary-boolean-comparison",
+  "unicorn/no-useless-compound-assignment",
+  "unicorn/no-useless-delete-check",
+  "unicorn/no-useless-logical-operand",
+  "unicorn/no-xor-as-exponentiation",
+  "unicorn/prefer-abort-signal-timeout",
+  "unicorn/prefer-aggregate-error",
+  "unicorn/prefer-array-from-async",
+  "unicorn/prefer-array-iterable-methods",
+  "unicorn/prefer-boolean-return",
+  "unicorn/prefer-continue",
+  "unicorn/prefer-dom-node-replace-children",
+  "unicorn/prefer-flat-math-min-max",
+  "unicorn/prefer-hoisting-branch-code",
+  "unicorn/prefer-math-constants",
+  "unicorn/prefer-observer-apis",
+  "unicorn/prefer-promise-try",
+  "unicorn/prefer-promise-with-resolvers",
+  "unicorn/prefer-set-methods",
+  "unicorn/prefer-single-replace",
+  "unicorn/prefer-toggle-attribute",
+  "unicorn/prefer-unary-minus",
+  "unicorn/prefer-url-can-parse",
+  "unicorn/prefer-url-search-parameters",
+  "unicorn/prefer-while-loop-condition"
+];
+var unicornV71MigrationQueue = [
+  "unicorn/no-async-promise-finally",
+  "unicorn/no-unnecessary-array-flat-map",
+  "unicorn/no-unnecessary-fetch-options",
+  "unicorn/no-unsafe-promise-all-settled-values",
+  "unicorn/prefer-abort-signal-any",
+  "unicorn/prefer-array-from-range",
+  "unicorn/prefer-block-statement-over-iife",
+  "unicorn/prefer-group-by",
+  "unicorn/prefer-iterator-helpers",
+  "unicorn/prefer-simplified-conditions"
+];
+var unicornV71MigrationRuleSet = new Set(unicornV71MigrationQueue);
+function isEnabledOpinionatedRule(rule2, tier) {
+  if (unicornGloballyDisabledRuleSet.has(rule2) || unicornV71MigrationRuleSet.has(rule2)) {
+    return false;
+  }
+  if (tier < 4) {
+    return !unicornV67MigrationQueue.includes(rule2) && !unicornV69MigrationQueue.includes(rule2);
+  }
+  return true;
+}
+function unicornOpinionatedRulesForTier(tier) {
+  return unicornOpinionatedRules.filter((rule2) => isEnabledOpinionatedRule(rule2, tier));
+}
+function unicornOpinionatedRuleEntries(severity, tier = 4) {
+  return Object.fromEntries(unicornOpinionatedRulesForTier(tier).map((rule2) => [rule2, severity]));
+}
+var unicornExperimentalMigrationQueue = unicornV67MigrationQueue;
+var unicornV66NewRules = unicornV66MigrationQueue;
+function unicornQueueRules(queue, severity) {
+  return Object.fromEntries(queue.map((rule2) => [rule2, severity]));
+}
+var unicornConfig = {
+  ...unicornUnopinionatedConfig,
+  plugins: { unicorn: unicornPlugin },
+  rules: {
+    ...unicornUnopinionatedRules,
+    ...unicornQueueRules(unicornV66MigrationQueue, "off"),
+    ...unicornQueueRules(unicornV67MigrationQueue, "off"),
+    ...unicornQueueRules(unicornV69MigrationQueue, "off"),
+    ...unicornQueueRules(unicornV71MigrationQueue, "warn"),
+    // Owned by @typescript-eslint/member-ordering
+    "unicorn/consistent-class-member-order": ["off"],
+    // Owned by max-nested-callbacks
+    "unicorn/max-nested-calls": ["off"],
+    // Tier 3 opinionated — enabled in opinionatedConfig
+    "unicorn/new-for-builtins": ["off"],
+    // Formatting — candidate for stylistic tier; overlaps @stylistic formatting
+    "unicorn/number-literal-case": ["off"],
+    // Boolean naming is too disruptive for org-wide enforcement
+    "unicorn/consistent-boolean-name": ["off"],
+    // Sort comparators are often intentional (locale, numeric, custom keys)
+    "unicorn/require-array-sort-compare": ["off"],
+    "unicorn/prefer-module": ["off"],
+    "unicorn/prefer-top-level-await": ["off"],
+    "unicorn/name-replacements": ["off"],
+    "unicorn/prefer-https": ["off"],
+    "unicorn/no-useless-undefined": "warn"
+  }
+};
+
+// src/core/index.ts
+var correctnessCoreConfig = [
+  scopeConfig(js.configs.recommended, { files: scriptFiles, languageOptions: scriptLanguageOptions }),
+  correctnessRulesConfig,
+  srcImportsConfig
+];
+var bestPracticesCoreConfig = [
+  scopeConfig(unicornConfig, { files: scriptFiles })
+];
+var coreConfig = [
+  ...correctnessCoreConfig,
+  consistencyRulesConfig,
+  ...bestPracticesCoreConfig
+];
+
+// src/import/index.ts
+import importPlugin from "eslint-plugin-import-x";
+import simpleImportSort from "eslint-plugin-simple-import-sort";
+var importFlatConfigs = importPlugin.flatConfigs;
+var importConfig = [
+  scopeConfig(importFlatConfigs.recommended, { files: scriptFiles, languageOptions: scriptLanguageOptions }),
+  scopeConfig(importFlatConfigs.typescript, { files: scriptFiles, languageOptions: scriptLanguageOptions }),
+  {
+    files: scriptFiles,
+    languageOptions: scriptLanguageOptions,
+    plugins: {
+      "import-x": importPlugin,
+      "simple-import-sort": simpleImportSort
+    },
+    settings: { "import-x/resolver": { typescript: { alwaysTryTypes: true, project: "./tsconfig.json" } } },
+    rules: {
+      // Owned by simple-import-sort/imports
+      "simple-import-sort/imports": ["warn"],
+      "simple-import-sort/exports": ["warn"],
+      // Type-aware resolution is slow and requires per-repo resolver setup
+      "import-x/default": ["off"],
+      "import-x/named": ["off"],
+      "import-x/namespace": ["off"],
+      "import-x/no-unresolved": ["off"],
+      "import-x/no-absolute-path": ["warn"],
+      "import-x/no-cycle": [
+        "warn",
+        { maxDepth: 5 }
+      ],
+      "import-x/no-deprecated": ["off"],
+      "import-x/no-named-as-default-member": ["off"],
+      "import-x/no-named-as-default": ["off"],
+      "import-x/no-restricted-paths": ["warn"],
+      "import-x/no-self-import": ["warn"],
+      "import-x/no-useless-path-segments": ["warn"]
+    }
+  }
+];
+
+// src/tiers/conflicts.ts
+var RULE_OWNERSHIP_GROUPS = [
+  {
+    description: "Class member ordering with alphabetical within-group sorting",
+    owner: "@typescript-eslint/member-ordering",
+    disabled: ["unicorn/consistent-class-member-order"]
+  },
+  {
+    description: "Callback nesting depth limit",
+    owner: "max-nested-callbacks",
+    disabled: ["unicorn/max-nested-calls"]
+  },
+  {
+    description: "Spread over Function.prototype.apply",
+    owner: "unicorn/prefer-spread",
+    disabled: ["prefer-spread"]
+  },
+  {
+    description: "Semicolon style",
+    owner: "@stylistic/semi",
+    disabled: ["semi"]
+  },
+  {
+    description: "Quote style",
+    owner: "@stylistic/quotes",
+    disabled: ["quotes"]
+  },
+  {
+    description: "Unused variable detection with TypeScript support",
+    owner: "@typescript-eslint/no-unused-vars",
+    disabled: ["no-unused-vars"]
+  },
+  {
+    description: "Escape sequence casing in strings and regexes",
+    owner: "unicorn/escape-case",
+    disabled: ["no-useless-escape"]
+  },
+  {
+    description: "Negated condition style",
+    owner: "unicorn/no-negated-condition",
+    disabled: ["no-negated-condition"]
+  },
+  {
+    description: "Nested ternary restrictions",
+    owner: "unicorn/no-unnecessary-nested-ternary",
+    disabled: ["no-nested-ternary", "unicorn/no-nested-ternary"]
+  },
+  {
+    description: "Import statement ordering",
+    owner: "simple-import-sort/imports",
+    disabled: ["import-x/order"]
+  },
+  {
+    description: "Explicit boolean coercion for non-boolean values",
+    owner: "@typescript-eslint/strict-boolean-expressions",
+    disabled: ["no-extra-boolean-cast", "unicorn/no-useless-boolean-cast"]
+  }
+];
+function getRuleSeverity(setting) {
+  if (setting === void 0) {
+    return void 0;
+  }
+  const level = Array.isArray(setting) ? setting[0] : setting;
+  if (level === "off" || level === 0) {
+    return "off";
+  }
+  if (level === "warn" || level === 1) {
+    return "warn";
+  }
+  if (level === "error" || level === 2) {
+    return "error";
+  }
+  return void 0;
+}
+function isRuleEnabled(setting) {
+  const severity = getRuleSeverity(setting);
+  return severity !== void 0 && severity !== "off";
+}
+function mergeConfigRules(configs) {
+  const merged = {};
+  for (const entry of configs) {
+    if (!entry.rules) {
+      continue;
+    }
+    Object.assign(merged, entry.rules);
+  }
+  return merged;
+}
+function findRuleOwnershipConflicts(rules) {
+  const conflicts = [];
+  for (const group of RULE_OWNERSHIP_GROUPS) {
+    const ownerSetting = rules[group.owner];
+    if (!isRuleEnabled(ownerSetting)) {
+      continue;
+    }
+    for (const conflictingRule of group.disabled) {
+      if (isRuleEnabled(rules[conflictingRule])) {
+        conflicts.push({
+          description: group.description,
+          owner: group.owner,
+          conflictingRule,
+          ownerSetting,
+          conflictingSetting: rules[conflictingRule]
+        });
+      }
+    }
+  }
+  return conflicts;
+}
+function assertNoRuleOwnershipConflicts(configs) {
+  const conflicts = findRuleOwnershipConflicts(mergeConfigRules(configs));
+  if (conflicts.length === 0) {
+    return;
+  }
+  const details = conflicts.map((conflict) => `${conflict.owner} conflicts with ${conflict.conflictingRule} (${conflict.description})`).join("\n");
+  throw new Error(`ESLint rule ownership conflicts detected:
+${details}`);
+}
+
+// src/typescript/index.ts
+import esStylistic from "@stylistic/eslint-plugin";
+import tsPlugin from "@typescript-eslint/eslint-plugin";
+var flatConfigs = tsPlugin.configs;
+var memberOrderingRule = [
+  "warn",
+  {
+    default: {
+      memberTypes: [
+        "signature",
+        "call-signature",
+        "public-static-field",
+        "protected-static-field",
+        "private-static-field",
+        "public-decorated-field",
+        "protected-decorated-field",
+        "private-decorated-field",
+        "public-instance-field",
+        "protected-instance-field",
+        "private-instance-field",
+        "public-abstract-field",
+        "protected-abstract-field",
+        "public-field",
+        "protected-field",
+        "private-field",
+        "static-field",
+        "instance-field",
+        "abstract-field",
+        "decorated-field",
+        "field",
+        "public-constructor",
+        "protected-constructor",
+        "private-constructor",
+        "constructor",
+        ["public-static-get", "public-static-set"],
+        ["protected-static-get", "protected-static-set"],
+        ["private-static-get", "private-static-set"],
+        ["public-decorated-get", "public-decorated-set"],
+        ["protected-decorated-get", "protected-decorated-set"],
+        ["private-decorated-get", "private-decorated-set"],
+        ["public-instance-get", "public-instance-set"],
+        ["protected-instance-get", "protected-instance-set"],
+        ["private-instance-get", "private-instance-set"],
+        ["public-abstract-get", "public-abstract-set"],
+        ["protected-abstract-get", "protected-abstract-set"],
+        ["public-get", "public-set"],
+        ["protected-get", "protected-set"],
+        ["private-get", "private-set"],
+        ["static-get", "static-set"],
+        ["instance-get", "instance-set"],
+        ["abstract-get", "abstract-set"],
+        ["decorated-get", "decorated-set"],
+        "get",
+        "set",
+        "public-static-method",
+        "protected-static-method",
+        "private-static-method",
+        "public-decorated-method",
+        "protected-decorated-method",
+        "private-decorated-method",
+        "public-instance-method",
+        "protected-instance-method",
+        "private-instance-method",
+        "public-abstract-method",
+        "protected-abstract-method",
+        "public-method",
+        "protected-method",
+        "private-method",
+        "static-method",
+        "instance-method",
+        "abstract-method",
+        "decorated-method",
+        "method"
+      ],
+      order: "alphabetically"
+    }
+  }
+];
+function createCorrectnessOverride(languageOptions) {
+  return {
+    files: scriptFiles,
+    languageOptions,
+    rules: {
+      "@typescript-eslint/no-unused-vars": [
+        "warn",
+        {
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+          ignoreRestSiblings: true
+        }
+      ],
+      "@typescript-eslint/require-await": "off",
+      "@typescript-eslint/explicit-module-boundary-types": "off",
+      "@typescript-eslint/no-empty-object-type": ["off"],
+      "@typescript-eslint/triple-slash-reference": ["off"],
+      // Tier 3 opinionated — enabled in opinionatedConfig
+      "@typescript-eslint/strict-boolean-expressions": ["off"],
+      // Owned by @stylistic/quotes
+      "quotes": ["off"],
+      // Owned by @stylistic/semi
+      "semi": ["off"],
+      // Owned by unicorn/prefer-spread
+      "prefer-spread": ["off"],
+      "require-await": "off"
+    }
+  };
+}
+function createConsistencyOverride(languageOptions) {
+  return {
+    files: scriptFiles,
+    languageOptions,
+    plugins: { "@stylistic": esStylistic },
+    rules: {
+      ...esStylistic.configs.recommended.rules,
+      "@typescript-eslint/no-empty-function": "warn",
+      "@stylistic/eol-last": "warn",
+      "@typescript-eslint/explicit-member-accessibility": ["warn", { accessibility: "no-public" }],
+      "@stylistic/brace-style": ["warn", "1tbs", { allowSingleLine: true }],
+      "@stylistic/quotes": ["warn", "single", { avoidEscape: true }],
+      "@typescript-eslint/consistent-type-imports": ["warn", { fixStyle: "separate-type-imports", prefer: "type-imports" }],
+      "@stylistic/object-property-newline": ["warn", { allowAllPropertiesOnSameLine: true }],
+      "@stylistic/function-call-argument-newline": ["warn", "consistent"],
+      "@stylistic/function-paren-newline": ["warn", "multiline-arguments"],
+      "@stylistic/member-delimiter-style": [
+        "error",
+        {
+          multiline: {
+            delimiter: "none",
+            requireLast: true
+          },
+          singleline: {
+            delimiter: "semi",
+            requireLast: false
+          }
+        }
+      ],
+      "@stylistic/object-curly-newline": ["warn", {
+        ObjectExpression: {
+          multiline: true,
+          minProperties: 3,
+          consistent: false
+        },
+        ObjectPattern: {
+          multiline: true,
+          minProperties: 3,
+          consistent: false
+        },
+        ImportDeclaration: {
+          multiline: true,
+          minProperties: 3,
+          consistent: false
+        },
+        ExportDeclaration: {
+          multiline: true,
+          minProperties: 3,
+          consistent: false
+        }
+      }],
+      "@stylistic/max-len": ["warn", { code: 200 }],
+      "no-restricted-syntax": [
+        "warn",
+        {
+          selector: "TSEnumDeclaration",
+          message: "Enums are disallowed. Consider using a union of string literals or a `const` object instead."
+        }
+      ],
+      "@typescript-eslint/member-ordering": memberOrderingRule
+    }
+  };
+}
+var typescriptDelegationConfig = {
+  files: scriptFiles,
+  rules: {
+    // Owned by unicorn/prefer-spread — stylistic presets may re-enable the core rule
+    "prefer-spread": "off",
+    // Owned by @stylistic/semi
+    "semi": "off",
+    // Owned by @stylistic/quotes
+    "quotes": "off"
+  }
+};
+var typescriptCorrectnessConfig = [
+  ...scopeConfigs(flatConfigs["flat/recommended"], { files: scriptFiles, languageOptions: scriptLanguageOptions }),
+  createCorrectnessOverride(scriptLanguageOptions)
+];
+var typescriptConsistencyConfig = [
+  ...scopeConfigs(flatConfigs["flat/stylistic"], { files: scriptFiles, languageOptions: scriptLanguageOptions }),
+  createConsistencyOverride(scriptLanguageOptions)
+];
+var typescriptTypeCheckedCorrectnessConfig = [
+  ...scopeConfigs(flatConfigs["flat/recommended-type-checked"], { files: scriptFiles, languageOptions: typeCheckedLanguageOptions }),
+  createCorrectnessOverride(typeCheckedLanguageOptions),
+  {
+    files: scriptFiles,
+    languageOptions: typeCheckedLanguageOptions,
+    rules: { "@typescript-eslint/no-deprecated": "warn" }
+  }
+];
+var typescriptTypeCheckedConsistencyConfig = [
+  ...scopeConfigs(flatConfigs["flat/stylistic-type-checked"], { files: scriptFiles, languageOptions: typeCheckedLanguageOptions }),
+  createConsistencyOverride(typeCheckedLanguageOptions)
+];
+var typescriptConfig = [
+  ...typescriptCorrectnessConfig,
+  ...typescriptConsistencyConfig,
+  typescriptDelegationConfig
+];
+var typescriptTypeCheckedConfig = [
+  ...typescriptTypeCheckedCorrectnessConfig,
+  ...typescriptTypeCheckedConsistencyConfig,
+  typescriptDelegationConfig
+];
+
+// src/workspaces/index.ts
+import workspacesPlugin from "eslint-plugin-workspaces";
+var workspacesConfig = {
+  plugins: { workspaces: workspacesPlugin },
+  rules: {
+    ...workspacesPlugin.configs.recommended.rules,
+    // Tier 3 opinionated — enabled in opinionatedConfig
+    "workspaces/no-relative-imports": ["off"],
+    "workspaces/require-dependency": ["off"]
+  }
+};
+
+// src/tiers/rule-catalog/managed-rules.ts
+var filenameCaseRuleOptions = {
+  cases: {
+    camelCase: true,
+    kebabCase: true,
+    pascalCase: true
+  }
+};
+function filenameCaseRule(severity) {
+  return [severity, filenameCaseRuleOptions];
+}
+function rule(name, plugin, category, introducedAtTier, severityAtTier, options, isTypeCheckingRequired = false) {
+  return {
+    category,
+    introducedAtTier,
+    isTypeCheckingRequired,
+    options,
+    plugin,
+    rule: name,
+    severityAtTier
+  };
+}
+var MANAGED_RULES = [
+  // Tier 0 — correctness
+  rule("no-unused-vars", "eslint", "correctness", 0, { 0: "off" }),
+  rule("no-useless-escape", "eslint", "correctness", 0, { 0: "off" }),
+  rule("prefer-spread", "eslint", "correctness", 0, { 0: "off" }),
+  rule("no-restricted-imports", "eslint", "correctness", 0, { 0: "error" }),
+  rule("@typescript-eslint/no-unused-vars", "@typescript-eslint", "correctness", 0, { 0: "warn" }, [
+    "warn",
+    {
+      argsIgnorePattern: "^_",
+      ignoreRestSiblings: true,
+      varsIgnorePattern: "^_"
+    }
+  ]),
+  rule("@typescript-eslint/require-await", "@typescript-eslint", "correctness", 0, { 0: "off" }),
+  rule("@typescript-eslint/explicit-module-boundary-types", "@typescript-eslint", "correctness", 0, { 0: "off" }),
+  rule("@typescript-eslint/no-empty-object-type", "@typescript-eslint", "correctness", 0, { 0: "off" }),
+  rule("@typescript-eslint/triple-slash-reference", "@typescript-eslint", "correctness", 0, { 0: "off" }),
+  rule("@typescript-eslint/strict-boolean-expressions", "@typescript-eslint", "correctness", 0, { 0: "off", 3: "error" }, void 0, true),
+  rule("@typescript-eslint/no-deprecated", "@typescript-eslint", "correctness", 0, { 0: "warn", 3: "error" }, void 0, true),
+  rule("quotes", "eslint", "correctness", 0, { 0: "off" }),
+  rule("semi", "eslint", "correctness", 0, { 0: "off" }),
+  rule("require-await", "eslint", "correctness", 0, { 0: "off" }),
+  // Tier 1 — consistency
+  rule("complexity", "eslint", "consistency", 1, { 1: "error" }, ["error", 18]),
+  rule("max-depth", "eslint", "consistency", 1, { 1: "error" }, ["error", 6]),
+  rule("max-lines", "eslint", "consistency", 1, { 1: "error" }, ["error", { max: 512, skipBlankLines: true }]),
+  rule("array-element-newline", "eslint", "consistency", 1, { 1: "warn", 3: "error" }, ["warn", "consistent"]),
+  rule("max-nested-callbacks", "eslint", "consistency", 1, { 1: "error" }),
+  rule("max-statements", "eslint", "consistency", 1, { 1: "error" }, ["error", 32]),
+  rule("no-tabs", "eslint", "consistency", 1, { 1: "error" }),
+  rule("@typescript-eslint/no-empty-function", "@typescript-eslint", "consistency", 1, { 1: "warn", 3: "error" }),
+  rule("@stylistic/eol-last", "@stylistic", "consistency", 1, { 1: "warn", 3: "error" }),
+  rule("@typescript-eslint/explicit-member-accessibility", "@typescript-eslint", "consistency", 1, { 1: "warn", 3: "error" }, [
+    "warn",
+    { accessibility: "no-public" }
+  ]),
+  rule("@stylistic/brace-style", "@stylistic", "consistency", 1, { 1: "warn", 3: "error" }, ["warn", "1tbs", { allowSingleLine: true }]),
+  rule("@stylistic/quotes", "@stylistic", "consistency", 1, { 1: "warn", 3: "error" }, ["warn", "single", { avoidEscape: true }]),
+  rule("@typescript-eslint/consistent-type-imports", "@typescript-eslint", "consistency", 1, { 1: "warn", 3: "error" }, [
+    "warn",
+    { fixStyle: "separate-type-imports", prefer: "type-imports" }
+  ]),
+  rule("@stylistic/object-property-newline", "@stylistic", "consistency", 1, { 1: "warn", 3: "error" }, [
+    "warn",
+    { allowAllPropertiesOnSameLine: true }
+  ]),
+  rule("@stylistic/function-call-argument-newline", "@stylistic", "consistency", 1, { 1: "warn", 3: "error" }, ["warn", "consistent"]),
+  rule("@stylistic/function-paren-newline", "@stylistic", "consistency", 1, { 1: "warn", 3: "error" }, ["warn", "multiline-arguments"]),
+  rule("@stylistic/member-delimiter-style", "@stylistic", "consistency", 1, { 1: "error" }, [
+    "error",
+    {
+      multiline: { delimiter: "none", requireLast: true },
+      singleline: { delimiter: "semi", requireLast: false }
+    }
+  ]),
+  rule("@stylistic/object-curly-newline", "@stylistic", "consistency", 1, { 1: "warn", 3: "error" }, [
+    "warn",
+    {
+      ExportDeclaration: {
+        consistent: false,
+        minProperties: 3,
+        multiline: true
+      },
+      ImportDeclaration: {
+        consistent: false,
+        minProperties: 3,
+        multiline: true
+      },
+      ObjectExpression: {
+        consistent: false,
+        minProperties: 3,
+        multiline: true
+      },
+      ObjectPattern: {
+        consistent: false,
+        minProperties: 3,
+        multiline: true
+      }
+    }
+  ]),
+  rule("@stylistic/max-len", "@stylistic", "consistency", 1, { 1: "warn", 3: "error" }, ["warn", { code: 200 }]),
+  rule("no-restricted-syntax", "eslint", "consistency", 1, { 1: "warn", 3: "error" }, [
+    "warn",
+    {
+      message: "Enums are disallowed. Consider using a union of string literals or a `const` object instead.",
+      selector: "TSEnumDeclaration"
+    }
+  ]),
+  rule("@typescript-eslint/member-ordering", "@typescript-eslint", "consistency", 1, { 1: "warn", 3: "error" }),
+  // Tier 2 — best practices (workspaces moved here from tier 0)
+  rule("workspaces/no-relative-imports", "workspaces", "best-practices", 2, { 2: "off", 3: "error" }),
+  rule("workspaces/require-dependency", "workspaces", "best-practices", 2, { 2: "off", 3: "error" }),
+  rule("simple-import-sort/imports", "simple-import-sort", "best-practices", 2, { 2: "warn", 3: "error" }, ["warn"]),
+  rule("simple-import-sort/exports", "simple-import-sort", "best-practices", 2, { 2: "warn", 3: "error" }, ["warn"]),
+  rule("import-x/default", "import-x", "best-practices", 2, { 2: "off" }),
+  rule("import-x/named", "import-x", "best-practices", 2, { 2: "off" }),
+  rule("import-x/namespace", "import-x", "best-practices", 2, { 2: "off" }),
+  rule("import-x/no-unresolved", "import-x", "best-practices", 2, { 2: "off" }),
+  rule("import-x/no-absolute-path", "import-x", "best-practices", 2, { 2: "warn", 3: "error" }),
+  rule("import-x/no-cycle", "import-x", "best-practices", 2, { 2: "warn", 3: "error" }, ["warn", { maxDepth: 5 }]),
+  rule("import-x/no-deprecated", "import-x", "best-practices", 2, { 2: "off" }),
+  rule("import-x/no-named-as-default-member", "import-x", "best-practices", 2, { 2: "off" }),
+  rule("import-x/no-named-as-default", "import-x", "best-practices", 2, { 2: "off" }),
+  rule("import-x/no-restricted-paths", "import-x", "best-practices", 2, { 2: "warn", 3: "error" }),
+  rule("import-x/no-self-import", "import-x", "best-practices", 2, { 2: "warn", 3: "error" }),
+  rule("import-x/no-useless-path-segments", "import-x", "best-practices", 2, { 2: "warn", 3: "error" }),
+  rule("unicorn/consistent-class-member-order", "unicorn", "best-practices", 2, { 2: "off" }),
+  rule("unicorn/max-nested-calls", "unicorn", "best-practices", 2, { 2: "off" }),
+  rule("unicorn/catch-error-name", "unicorn", "best-practices", 2, { 2: "off" }),
+  rule("unicorn/consistent-function-scoping", "unicorn", "best-practices", 2, { 2: "off" }),
+  rule("unicorn/filename-case", "unicorn", "best-practices", 2, { 2: "off", 3: "error" }, filenameCaseRule("error")),
+  rule("unicorn/new-for-builtins", "unicorn", "best-practices", 2, { 2: "off" }),
+  rule("unicorn/no-array-callback-reference", "unicorn", "best-practices", 2, { 2: "off" }),
+  rule("unicorn/no-await-expression-member", "unicorn", "best-practices", 2, { 2: "off", 3: "error" }),
+  rule("unicorn/no-nested-ternary", "unicorn", "best-practices", 2, { 2: "off" }),
+  rule("unicorn/no-null", "unicorn", "best-practices", 2, { 2: "off" }),
+  rule("unicorn/number-literal-case", "unicorn", "best-practices", 2, { 2: "off", 3: "error" }),
+  rule("unicorn/prefer-module", "unicorn", "best-practices", 2, { 2: "off" }),
+  rule("unicorn/prefer-top-level-await", "unicorn", "best-practices", 2, { 2: "off" }),
+  rule("unicorn/prevent-abbreviations", "unicorn", "best-practices", 2, { 2: "off" }),
+  rule("unicorn/name-replacements", "unicorn", "best-practices", 2, { 2: "off" }),
+  rule("unicorn/prefer-https", "unicorn", "best-practices", 2, { 2: "off" }),
+  rule("unicorn/no-useless-undefined", "unicorn", "best-practices", 2, { 2: "warn", 3: "error" }),
+  // Tier 3 — opinionated ownership delegations
+  rule("no-extra-boolean-cast", "eslint", "opinionated", 3, { 3: "off" }),
+  rule("unicorn/no-useless-boolean-cast", "unicorn", "opinionated", 3, { 3: "off" })
+];
+
+// src/tiers/opinionated.ts
+var filenameCaseRuleOptions2 = {
+  cases: {
+    camelCase: true,
+    kebabCase: true,
+    pascalCase: true
+  }
+};
+function filenameCaseRule2(severity) {
+  return [severity, filenameCaseRuleOptions2];
+}
+function unicornQueueRules2(queue, severity) {
+  return Object.fromEntries(queue.map((rule2) => [rule2, severity]));
+}
+function managedPromotionRules(tier) {
+  const rules = {};
+  for (const definition of MANAGED_RULES) {
+    const severity = definition.severityAtTier[tier];
+    if (severity !== "error") {
+      continue;
+    }
+    const priorSeverity = definition.severityAtTier[tier - 1];
+    if (priorSeverity === severity) {
+      continue;
+    }
+    rules[definition.rule] = definition.options ?? severity;
+  }
+  rules["unicorn/filename-case"] = filenameCaseRule2("error");
+  rules["no-extra-boolean-cast"] = "off";
+  rules["unicorn/no-useless-boolean-cast"] = "off";
+  return rules;
+}
+var opinionatedLayerConfig = {
+  files: scriptFiles,
+  rules: {
+    "@typescript-eslint/strict-boolean-expressions": "warn",
+    "no-extra-boolean-cast": "off",
+    "unicorn/filename-case": filenameCaseRule2("warn"),
+    "unicorn/no-await-expression-member": "warn",
+    "unicorn/no-useless-boolean-cast": "off",
+    "unicorn/number-literal-case": "warn",
+    "workspaces/no-relative-imports": "warn",
+    "workspaces/require-dependency": "warn"
+  }
+};
+function opinionatedUnicornPresetLayerConfigForTier(tier) {
+  return {
+    files: scriptFiles,
+    rules: unicornOpinionatedRuleEntries("error", tier)
+  };
+}
+var opinionatedUnicornPresetLayerConfig = opinionatedUnicornPresetLayerConfigForTier(3);
+var opinionatedUnicornV66LayerConfig = {
+  files: scriptFiles,
+  rules: unicornQueueRules2(unicornV66MigrationQueue, "warn")
+};
+var opinionatedPromotionRules = managedPromotionRules(3);
+var opinionatedPromotionLayerConfig = {
+  files: scriptFiles,
+  rules: opinionatedPromotionRules
+};
+var strictPromotionRules = opinionatedPromotionRules;
+var strictLayerConfig = opinionatedPromotionLayerConfig;
+var experimentalUnicornLayerConfig = {
+  files: scriptFiles,
+  rules: unicornQueueRules2(unicornV67MigrationQueue, "warn")
+};
+var experimentalUnicornV69LayerConfig = {
+  files: scriptFiles,
+  rules: unicornQueueRules2(unicornV69MigrationQueue, "warn")
+};
+var experimentalLayerConfig = experimentalUnicornLayerConfig;
+var experimentalPromotionRules = experimentalUnicornLayerConfig.rules;
+
+// src/tiers/rule-catalog/type-checked-rules.ts
+import tsPlugin2 from "@typescript-eslint/eslint-plugin";
+function ruleNamesFromConfigs(configs) {
+  if (!configs) return /* @__PURE__ */ new Set();
+  return new Set(Object.keys(mergeConfigRules(Array.isArray(configs) ? configs : [configs])));
+}
+function ruleNamesFromPreset(preset) {
+  return ruleNamesFromConfigs(preset);
+}
+function diffRuleSets(typeChecked, untyped) {
+  const onlyTypeChecked = /* @__PURE__ */ new Set();
+  for (const rule2 of typeChecked) {
+    if (!untyped.has(rule2)) {
+      onlyTypeChecked.add(rule2);
+    }
+  }
+  return onlyTypeChecked;
+}
+function typescriptPresetRuleDiff() {
+  const flatConfigs2 = tsPlugin2.configs;
+  const recommendedTypeChecked = ruleNamesFromPreset(flatConfigs2["flat/recommended-type-checked"]);
+  const recommended = ruleNamesFromPreset(flatConfigs2["flat/recommended"]);
+  const stylisticTypeChecked = ruleNamesFromPreset(flatConfigs2["flat/stylistic-type-checked"]);
+  const stylistic = ruleNamesFromPreset(flatConfigs2["flat/stylistic"]);
+  return /* @__PURE__ */ new Set([
+    ...diffRuleSets(recommendedTypeChecked, recommended),
+    ...diffRuleSets(stylisticTypeChecked, stylistic)
+  ]);
+}
+var EXPLICIT_TYPE_CHECKED_RULES = [
+  "@typescript-eslint/no-deprecated",
+  "@typescript-eslint/strict-boolean-expressions"
+];
+var typeCheckedRuleNamesCache = {};
+function collectTypeCheckedRuleNames() {
+  if (typeCheckedRuleNamesCache.names === void 0) {
+    typeCheckedRuleNamesCache.names = /* @__PURE__ */ new Set([
+      ...typescriptPresetRuleDiff(),
+      ...EXPLICIT_TYPE_CHECKED_RULES
+    ]);
+  }
+  return typeCheckedRuleNamesCache.names;
+}
+function buildTypeCheckGateRules() {
+  return Object.fromEntries(
+    [...collectTypeCheckedRuleNames()].map((rule2) => [rule2, "off"])
+  );
+}
+
+// src/tiers/rule-catalog/index.ts
+function severityForTier(definition, tier) {
+  let resolved;
+  for (let current = 0; current <= tier; current = current + 1) {
+    const severity = definition.severityAtTier[current];
+    if (severity !== void 0) {
+      resolved = severity;
+    }
+  }
+  return resolved;
+}
+function managedRulesForTier(tier, isTypeChecked) {
+  return MANAGED_RULES.filter((definition) => definition.introducedAtTier <= tier && (!definition.isTypeCheckingRequired || isTypeChecked));
+}
+function buildManagedRulesMap(tier, isTypeChecked) {
+  const rules = {};
+  for (const definition of managedRulesForTier(tier, isTypeChecked)) {
+    const severity = severityForTier(definition, tier);
+    if (severity === void 0) {
+      continue;
+    }
+    rules[definition.rule] = severity === "off" ? "off" : definition.options ?? severity;
+  }
+  return rules;
+}
+function buildManagedRulesLayer(tier, isTypeChecked) {
+  return {
+    files: scriptFiles,
+    rules: buildManagedRulesMap(tier, isTypeChecked)
+  };
+}
+function buildTypeCheckGateLayer() {
+  return {
+    files: scriptFiles,
+    rules: buildTypeCheckGateRules()
+  };
+}
+function findEnabledTypeCheckedRules(rules) {
+  const typeCheckedRuleNames = collectTypeCheckedRuleNames();
+  return [...typeCheckedRuleNames].filter((rule2) => {
+    const severity = getRuleSeverity(rules[rule2]);
+    return severity !== void 0 && severity !== "off";
+  }).toSorted();
+}
+function categoryForTier(tier) {
+  switch (tier) {
+    case 0: {
+      return "correctness";
+    }
+    case 1: {
+      return "consistency";
+    }
+    case 2: {
+      return "best-practices";
+    }
+    case 3: {
+      return "opinionated";
+    }
+    case 4: {
+      return "experimental";
+    }
+    default: {
+      const unsupported = tier;
+      throw new Error(`Unsupported lint tier ${unsupported}`);
+    }
+  }
+}
+
+// src/tiers/tier-builder.ts
+function mergeTierConfigs(...parts) {
+  return parts.flat();
+}
+function structuralTier0(isTypeChecked) {
+  return mergeTierConfigs(
+    markdownConfig,
+    correctnessCoreConfig,
+    isTypeChecked ? typescriptTypeCheckedCorrectnessConfig : typescriptCorrectnessConfig
+  );
+}
+function structuralTier1(isTypeChecked) {
+  return mergeTierConfigs(
+    structuralTier0(isTypeChecked),
+    [consistencyRulesConfig],
+    isTypeChecked ? typescriptTypeCheckedConsistencyConfig : typescriptConsistencyConfig,
+    [typescriptDelegationConfig]
+  );
+}
+function structuralTier2(isTypeChecked) {
+  return mergeTierConfigs(
+    structuralTier1(isTypeChecked),
+    bestPracticesCoreConfig,
+    importConfig,
+    [workspacesConfig]
+  );
+}
+function structuralLayersForTier(tier, isTypeChecked) {
+  switch (tier) {
+    case 0: {
+      return structuralTier0(isTypeChecked);
+    }
+    case 1: {
+      return structuralTier1(isTypeChecked);
+    }
+    case 2:
+    case 3:
+    case 4: {
+      return structuralTier2(isTypeChecked);
+    }
+    default: {
+      const unsupported = tier;
+      throw new Error(`Unsupported lint tier ${unsupported}`);
+    }
+  }
+}
+function appendTypeCheckGate(configs, isTypeChecked) {
+  if (isTypeChecked) {
+    return configs;
+  }
+  return [...configs, buildTypeCheckGateLayer()];
+}
+function opinionatedLayersForTier(tier) {
+  if (tier < 3) {
+    return [];
+  }
+  const layers = [
+    opinionatedUnicornPresetLayerConfigForTier(tier),
+    opinionatedUnicornV66LayerConfig
+  ];
+  if (tier >= 4) {
+    layers.push(experimentalUnicornLayerConfig, experimentalUnicornV69LayerConfig);
+  }
+  return layers;
+}
+var globalIgnoresConfig = { ignores };
+function buildTierConfig(tier, isTypeChecked) {
+  const configs = mergeTierConfigs(
+    [globalIgnoresConfig],
+    structuralLayersForTier(tier, isTypeChecked),
+    opinionatedLayersForTier(tier),
+    [buildManagedRulesLayer(tier, isTypeChecked)]
+  );
+  return appendTypeCheckGate(configs, isTypeChecked);
+}
+
+// src/tiers/recommendedConfig.ts
+var DEFAULT_RECOMMENDED_CONFIG_OPTIONS = {
+  isTypeChecked: true,
+  tier: 3
+};
+var composedConfigModules = [
+  "bestPracticesCoreConfig",
+  "consistencyRulesConfig",
+  "correctnessCoreConfig",
+  "importConfig",
+  "rulesConfig",
+  "typescriptConfig",
+  "typescriptConsistencyConfig",
+  "typescriptCorrectnessConfig",
+  "typescriptTypeCheckedConfig",
+  "typescriptTypeCheckedConsistencyConfig",
+  "typescriptTypeCheckedCorrectnessConfig",
+  "unicornConfig",
+  "workspacesConfig"
+];
+function resolveRecommendedConfigOptions(options) {
+  return {
+    isTypeChecked: options?.isTypeChecked ?? DEFAULT_RECOMMENDED_CONFIG_OPTIONS.isTypeChecked,
+    tier: options?.tier ?? DEFAULT_RECOMMENDED_CONFIG_OPTIONS.tier
+  };
+}
+function recommendedConfig(options) {
+  const resolved = resolveRecommendedConfigOptions(options);
+  return buildTierConfig(resolved.tier, resolved.isTypeChecked);
+}
+function formatRecommendedConfigCall(options) {
+  const resolved = resolveRecommendedConfigOptions(options);
+  return `recommendedConfig({ tier: ${resolved.tier}, isTypeChecked: ${String(resolved.isTypeChecked)} })`;
+}
+function hasComposedConfigModules(source) {
+  return composedConfigModules.some((module) => source.includes(module));
+}
+function parseRecommendedConfigOptionsLiteral(literal) {
+  const resolved = { ...DEFAULT_RECOMMENDED_CONFIG_OPTIONS };
+  if (literal === void 0 || literal.trim().length === 0) return resolved;
+  const tierMatch = /tier:\s*([0-4])\b/.exec(literal);
+  if (tierMatch !== null) {
+    resolved.tier = Number(tierMatch[1]);
+  }
+  const isTypeCheckedMatch = /isTypeChecked:\s*(true|false)\b/.exec(literal);
+  if (isTypeCheckedMatch === null) {
+    const legacyTypeCheckedMatch = /typeChecked:\s*(true|false)\b/.exec(literal);
+    if (legacyTypeCheckedMatch !== null) {
+      resolved.isTypeChecked = legacyTypeCheckedMatch[1] === "true";
+    }
+  } else {
+    resolved.isTypeChecked = isTypeCheckedMatch[1] === "true";
+  }
+  return resolved;
+}
+function parseRecommendedConfigSource(source) {
+  const callPattern = /recommendedConfig\s*\(\s*(?:\{([^}]*)\})?\s*\)/g;
+  const match = callPattern.exec(source);
+  if (match === null) return void 0;
+  const options = parseRecommendedConfigOptionsLiteral(match[1]);
+  const configKind = hasComposedConfigModules(source) ? "custom" : "preset";
+  return { configKind, options };
+}
+function applyRecommendedConfigTypeChecked(source, isEnabled) {
+  const callPattern = /recommendedConfig\s*\(\s*(?:\{([^}]*)\})?\s*\)/g;
+  return source.replaceAll(callPattern, (_match, literal) => {
+    const options = parseRecommendedConfigOptionsLiteral(literal);
+    options.isTypeChecked = isEnabled;
+    return formatRecommendedConfigCall(options);
+  });
+}
+
+// src/tiers/index.ts
+var configTier0Correctness = recommendedConfig({ tier: 0, isTypeChecked: false });
+var configTier0CorrectnessTypeChecked = recommendedConfig({ tier: 0, isTypeChecked: true });
+var configTier1Consistency = recommendedConfig({ tier: 1, isTypeChecked: false });
+var configTier1ConsistencyTypeChecked = recommendedConfig({ tier: 1, isTypeChecked: true });
+var configTier2BestPractices = recommendedConfig({ tier: 2, isTypeChecked: false });
+var configTier2BestPracticesTypeChecked = recommendedConfig({ tier: 2, isTypeChecked: true });
+var configTier3Opinionated = recommendedConfig({ tier: 3, isTypeChecked: false });
+var configTier3OpinionatedTypeChecked = recommendedConfig({ tier: 3, isTypeChecked: true });
+var configTier4Experimental = recommendedConfig({ tier: 4, isTypeChecked: false });
+var configTier4ExperimentalTypeChecked = recommendedConfig({ tier: 4, isTypeChecked: true });
+var recommendedTypeCheckedConfig = recommendedConfig({ tier: 2, isTypeChecked: true });
+var config = recommendedConfig({ tier: 2, isTypeChecked: true });
+
+// src/tiers/plugin-rules.ts
+import js2 from "@eslint/js";
+import json2 from "@eslint/json";
+import markdown2 from "@eslint/markdown";
+import esStylistic2 from "@stylistic/eslint-plugin";
+import tsPlugin3 from "@typescript-eslint/eslint-plugin";
+import importPlugin2 from "eslint-plugin-import-x";
+import simpleImportSort2 from "eslint-plugin-simple-import-sort";
+import unicornPlugin2 from "eslint-plugin-unicorn";
+import workspacesPlugin2 from "eslint-plugin-workspaces";
+var compareStrings2 = (left, right) => left.localeCompare(right);
+function sortedRuleNames(rules) {
+  if (!rules) {
+    return [];
+  }
+  return Object.keys(rules).toSorted(compareStrings2);
+}
+function sortedRuleNamesFromConfigs(configs) {
+  if (!configs) {
+    return [];
+  }
+  const merged = {};
+  for (const entry of configs) {
+    if (entry.rules) {
+      Object.assign(merged, entry.rules);
+    }
+  }
+  return sortedRuleNames(merged);
+}
+function pluginRuleNames(plugin) {
+  if (!plugin.rules) {
+    return [];
+  }
+  const prefix = typeof plugin.meta?.name === "string" ? plugin.meta.name.replace(/^eslint-plugin-/, "").replace(/^@eslint\//, "") : "unknown";
+  return Object.keys(plugin.rules).toSorted(compareStrings2).map((ruleName) => `${prefix}/${ruleName}`);
+}
+function collectPluginRuleSnapshots() {
+  const unicornRecommended = unicornPlugin2.configs["flat/recommended"];
+  const importRecommended = importPlugin2.flatConfigs.recommended;
+  const flatConfigs2 = tsPlugin3.configs;
+  const workspacesRecommended = workspacesPlugin2.configs.recommended;
+  return [
+    {
+      plugin: "@eslint/js",
+      rules: sortedRuleNames(js2.configs.recommended.rules),
+      source: "configs.recommended"
+    },
+    {
+      plugin: "@eslint/json",
+      rules: pluginRuleNames(json2),
+      source: "plugin.rules"
+    },
+    {
+      plugin: "@eslint/markdown",
+      rules: sortedRuleNames(
+        markdown2.configs.recommended[0]?.rules
+      ),
+      source: "configs.recommended"
+    },
+    {
+      plugin: "@stylistic/eslint-plugin",
+      rules: sortedRuleNames(esStylistic2.configs.recommended.rules),
+      source: "configs.recommended"
+    },
+    {
+      plugin: "@typescript-eslint/eslint-plugin",
+      rules: sortedRuleNamesFromConfigs(flatConfigs2["flat/recommended"]),
+      source: "configs.flat/recommended"
+    },
+    {
+      plugin: "@typescript-eslint/eslint-plugin",
+      rules: sortedRuleNamesFromConfigs(flatConfigs2["flat/stylistic"]),
+      source: "configs.flat/stylistic"
+    },
+    {
+      plugin: "@typescript-eslint/eslint-plugin",
+      rules: sortedRuleNamesFromConfigs(flatConfigs2["flat/recommended-type-checked"]),
+      source: "configs.flat/recommended-type-checked"
+    },
+    {
+      plugin: "@typescript-eslint/eslint-plugin",
+      rules: sortedRuleNamesFromConfigs(flatConfigs2["flat/stylistic-type-checked"]),
+      source: "configs.flat/stylistic-type-checked"
+    },
+    {
+      plugin: "eslint-plugin-import-x",
+      rules: sortedRuleNames(importRecommended.rules),
+      source: "flatConfigs.recommended"
+    },
+    {
+      plugin: "eslint-plugin-import-x",
+      rules: sortedRuleNames(importPlugin2.flatConfigs.typescript.rules),
+      source: "flatConfigs.typescript"
+    },
+    {
+      plugin: "eslint-plugin-simple-import-sort",
+      rules: pluginRuleNames(simpleImportSort2),
+      source: "plugin.rules"
+    },
+    {
+      plugin: "eslint-plugin-unicorn",
+      rules: sortedRuleNames(unicornRecommended?.rules),
+      source: "configs.flat/recommended"
+    },
+    {
+      plugin: "eslint-plugin-workspaces",
+      rules: sortedRuleNames(workspacesRecommended.rules),
+      source: "configs.recommended"
+    }
+  ];
+}
+function serializePluginRuleSnapshots(snapshots) {
+  return `${JSON.stringify(snapshots, null, 2)}
+`;
+}
+
+// src/index.ts
+var docsConfig = [
+  ...markdownConfig,
+  jsonConfig,
+  jsoncConfig,
+  json5Config
+];
+export {
+  DEFAULT_RECOMMENDED_CONFIG_OPTIONS,
+  MANAGED_RULES as RULE_CATALOG,
+  RULE_OWNERSHIP_GROUPS,
+  applyRecommendedConfigTypeChecked,
+  assertNoRuleOwnershipConflicts,
+  bestPracticesCoreConfig,
+  buildManagedRulesLayer,
+  buildTierConfig,
+  buildTypeCheckGateLayer,
+  categoryForTier,
+  collectPluginRuleSnapshots,
+  collectTypeCheckedRuleNames,
+  config,
+  configTier0Correctness,
+  configTier0CorrectnessTypeChecked,
+  configTier1Consistency,
+  configTier1ConsistencyTypeChecked,
+  configTier2BestPractices,
+  configTier2BestPracticesTypeChecked,
+  configTier3Opinionated,
+  configTier3OpinionatedTypeChecked,
+  configTier4Experimental,
+  configTier4ExperimentalTypeChecked,
+  consistencyRulesConfig,
+  coreConfig,
+  correctnessCoreConfig,
+  correctnessRulesConfig,
+  docsConfig,
+  experimentalLayerConfig,
+  experimentalPromotionRules,
+  experimentalUnicornLayerConfig,
+  experimentalUnicornV69LayerConfig,
+  findEnabledTypeCheckedRules,
+  findRuleOwnershipConflicts,
+  formatRecommendedConfigCall,
+  getRuleSeverity,
+  globalIgnoresConfig,
+  ignores,
+  importConfig,
+  json5Config,
+  jsonConfig,
+  jsoncConfig,
+  managedRulesForTier,
+  markdownConfig,
+  mergeConfigRules,
+  opinionatedLayerConfig,
+  opinionatedPromotionLayerConfig,
+  opinionatedPromotionRules,
+  opinionatedUnicornPresetLayerConfig,
+  opinionatedUnicornV66LayerConfig,
+  parseRecommendedConfigSource,
+  recommendedConfig,
+  recommendedTypeCheckedConfig,
+  resolveRecommendedConfigOptions,
+  rulesConfig,
+  serializePluginRuleSnapshots,
+  srcImportsConfig,
+  strictLayerConfig,
+  strictPromotionRules,
+  typescriptConfig,
+  typescriptConsistencyConfig,
+  typescriptCorrectnessConfig,
+  typescriptDelegationConfig,
+  typescriptTypeCheckedConfig,
+  typescriptTypeCheckedConsistencyConfig,
+  typescriptTypeCheckedCorrectnessConfig,
+  unicornConfig,
+  unicornExperimentalMigrationQueue,
+  unicornGloballyDisabledRules,
+  unicornOpinionatedRules,
+  unicornOpinionatedRulesForTier,
+  unicornV66MigrationQueue,
+  unicornV66NewRules,
+  unicornV67MigrationQueue,
+  unicornV69MigrationQueue,
+  unicornV71MigrationQueue,
+  workspacesConfig
+};
+//# sourceMappingURL=index.mjs.map