@xylabs/eslint-config-flat 8.3.0 → 8.4.1

package/dist/neutral/index.mjs

@@ -226,6 +226,11 @@ var srcImportsConfig = {
 
 // 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",
@@ -294,11 +299,14 @@ var unicornV66MigrationQueue = [
   "unicorn/prefer-uint8array-base64",
   "unicorn/prefer-unicode-code-point-escapes",
   "unicorn/prefer-url-href",
-  "unicorn/require-array-sort-compare",
   "unicorn/require-proxy-trap-boolean-return"
 ];
-var unicornV67MigrationQueue = [
+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",
@@ -314,64 +322,112 @@ var unicornV67MigrationQueue = [
   "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 unicornMigrationQueueRuleSet = /* @__PURE__ */ new Set([
+  ...unicornV66MigrationQueue,
+  ...unicornV67MigrationQueue,
+  ...unicornV69MigrationQueue
+]);
+function isEnabledOpinionatedRule(rule2, tier) {
+  if (unicornGloballyDisabledRuleSet.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((rule) => [rule, severity]));
+  return Object.fromEntries(queue.map((rule2) => [rule2, severity]));
 }
 var unicornConfig = {
-  ...unicornPlugin.configs.recommended,
+  ...unicornUnopinionatedConfig,
   plugins: { unicorn: unicornPlugin },
   rules: {
-    ...unicornPlugin.configs.recommended.rules,
+    ...unicornUnopinionatedRules,
     ...unicornQueueRules(unicornV66MigrationQueue, "off"),
     ...unicornQueueRules(unicornV67MigrationQueue, "off"),
+    ...unicornQueueRules(unicornV69MigrationQueue, "off"),
     // Owned by @typescript-eslint/member-ordering
     "unicorn/consistent-class-member-order": ["off"],
     // Owned by max-nested-callbacks
     "unicorn/max-nested-calls": ["off"],
-    // Naming preference — too disruptive for org-wide enforcement
-    "unicorn/catch-error-name": ["off"],
-    // Closure patterns are valid in our codebase
-    "unicorn/consistent-function-scoping": ["off"],
     // Tier 3 opinionated — enabled in opinionatedConfig
-    "unicorn/filename-case": ["off"],
     "unicorn/new-for-builtins": ["off"],
-    "unicorn/no-array-callback-reference": ["off"],
-    // Tier 3 opinionated — enabled in opinionatedConfig
-    "unicorn/no-await-expression-member": ["off"],
-    // Owned by unicorn/no-unnecessary-nested-ternary
-    "unicorn/no-nested-ternary": ["off"],
-    // Org uses null alongside undefined
-    "unicorn/no-null": ["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/prevent-abbreviations": ["off"],
+    "unicorn/name-replacements": ["off"],
     "unicorn/prefer-https": ["off"],
     "unicorn/no-useless-undefined": "warn"
   }
 };
 
-// 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/core/index.ts
 var correctnessCoreConfig = [
   scopeConfig(js.configs.recommended, { files: scriptFiles, languageOptions: scriptLanguageOptions }),
   correctnessRulesConfig,
-  srcImportsConfig,
-  workspacesConfig
+  srcImportsConfig
 ];
 var bestPracticesCoreConfig = [
   scopeConfig(unicornConfig, { files: scriptFiles })
@@ -479,17 +535,25 @@ var RULE_OWNERSHIP_GROUPS = [
     disabled: ["no-extra-boolean-cast", "unicorn/no-useless-boolean-cast"]
   }
 ];
-function isRuleEnabled(setting) {
+function getRuleSeverity(setting) {
   if (setting === void 0) {
-    return false;
+    return void 0;
   }
-  if (setting === "off" || setting === 0) {
-    return false;
+  const level = Array.isArray(setting) ? setting[0] : setting;
+  if (level === "off" || level === 0) {
+    return "off";
   }
-  if (Array.isArray(setting) && setting[0] === "off") {
-    return false;
+  if (level === "warn" || level === 1) {
+    return "warn";
   }
-  return true;
+  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 = {};
@@ -745,7 +809,19 @@ var typescriptTypeCheckedConfig = [
   typescriptDelegationConfig
 ];
 
-// src/tiers/opinionated.ts
+// 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,
@@ -756,15 +832,184 @@ var filenameCaseRuleOptions = {
 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((rule) => [rule, 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": filenameCaseRule("warn"),
+    "unicorn/filename-case": filenameCaseRule2("warn"),
     "unicorn/no-await-expression-member": "warn",
     "unicorn/no-useless-boolean-cast": "off",
     "unicorn/number-literal-case": "warn",
@@ -772,45 +1017,18 @@ var opinionatedLayerConfig = {
     "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 = {
-  "@stylistic/eol-last": "error",
-  "@typescript-eslint/no-empty-function": "error",
-  "@typescript-eslint/no-deprecated": "error",
-  "array-element-newline": "error",
-  "import-x/no-absolute-path": "error",
-  "import-x/no-cycle": "error",
-  "import-x/no-restricted-paths": "error",
-  "import-x/no-self-import": "error",
-  "import-x/no-useless-path-segments": "error",
-  "no-restricted-syntax": "error",
-  "simple-import-sort/exports": "error",
-  "simple-import-sort/imports": "error",
-  "unicorn/no-useless-undefined": "error",
-  "no-extra-boolean-cast": "off",
-  "unicorn/no-useless-boolean-cast": "off",
-  "unicorn/filename-case": filenameCaseRule("error"),
-  ...Object.fromEntries([
-    "@typescript-eslint/consistent-type-imports",
-    "@typescript-eslint/explicit-member-accessibility",
-    "@typescript-eslint/member-ordering",
-    "@stylistic/brace-style",
-    "@stylistic/function-call-argument-newline",
-    "@stylistic/function-paren-newline",
-    "@stylistic/object-curly-newline",
-    "@stylistic/object-property-newline",
-    "@stylistic/quotes",
-    "@stylistic/max-len",
-    "unicorn/no-await-expression-member",
-    "unicorn/number-literal-case",
-    "workspaces/no-relative-imports",
-    "workspaces/require-dependency",
-    "@typescript-eslint/strict-boolean-expressions"
-  ].map((rule) => [rule, "error"]))
-};
+var opinionatedPromotionRules = managedPromotionRules(3);
 var opinionatedPromotionLayerConfig = {
   files: scriptFiles,
   rules: opinionatedPromotionRules
@@ -821,82 +1039,169 @@ 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/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"
+// 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 buildTier0(isTypeChecked) {
+function structuralTier0(isTypeChecked) {
   return mergeTierConfigs(
     markdownConfig,
     correctnessCoreConfig,
     isTypeChecked ? typescriptTypeCheckedCorrectnessConfig : typescriptCorrectnessConfig
   );
 }
-function buildTier1(isTypeChecked) {
+function structuralTier1(isTypeChecked) {
   return mergeTierConfigs(
-    buildTier0(isTypeChecked),
+    structuralTier0(isTypeChecked),
     [consistencyRulesConfig],
     isTypeChecked ? typescriptTypeCheckedConsistencyConfig : typescriptConsistencyConfig,
     [typescriptDelegationConfig]
   );
 }
-function buildTier2(isTypeChecked) {
+function structuralTier2(isTypeChecked) {
   return mergeTierConfigs(
-    buildTier1(isTypeChecked),
+    structuralTier1(isTypeChecked),
     bestPracticesCoreConfig,
-    importConfig
+    importConfig,
+    [workspacesConfig]
   );
 }
-function buildTier3(isTypeChecked) {
-  return mergeTierConfigs(
-    buildTier2(isTypeChecked),
-    [opinionatedUnicornV66LayerConfig, opinionatedPromotionLayerConfig]
-  );
-}
-function buildTier4(isTypeChecked) {
-  return mergeTierConfigs(
-    buildTier3(isTypeChecked),
-    [experimentalUnicornLayerConfig]
-  );
-}
-function buildTierConfig(tier, isTypeChecked) {
+function structuralLayersForTier(tier, isTypeChecked) {
   switch (tier) {
     case 0: {
-      return buildTier0(isTypeChecked);
+      return structuralTier0(isTypeChecked);
     }
     case 1: {
-      return buildTier1(isTypeChecked);
-    }
-    case 2: {
-      return buildTier2(isTypeChecked);
-    }
-    case 3: {
-      return buildTier3(isTypeChecked);
+      return structuralTier1(isTypeChecked);
     }
+    case 2:
+    case 3:
     case 4: {
-      return buildTier4(isTypeChecked);
+      return structuralTier2(isTypeChecked);
     }
     default: {
       const unsupported = tier;
@@ -904,6 +1209,56 @@ function buildTierConfig(tier, isTypeChecked) {
     }
   }
 }
+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,
@@ -975,17 +1330,17 @@ import js2 from "@eslint/js";
 import json2 from "@eslint/json";
 import markdown2 from "@eslint/markdown";
 import esStylistic2 from "@stylistic/eslint-plugin";
-import tsPlugin2 from "@typescript-eslint/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 compareStrings = (left, right) => left.localeCompare(right);
+var compareStrings2 = (left, right) => left.localeCompare(right);
 function sortedRuleNames(rules) {
   if (!rules) {
     return [];
   }
-  return Object.keys(rules).toSorted(compareStrings);
+  return Object.keys(rules).toSorted(compareStrings2);
 }
 function sortedRuleNamesFromConfigs(configs) {
   if (!configs) {
@@ -1004,12 +1359,12 @@ function pluginRuleNames(plugin) {
     return [];
   }
   const prefix = typeof plugin.meta?.name === "string" ? plugin.meta.name.replace(/^eslint-plugin-/, "").replace(/^@eslint\//, "") : "unknown";
-  return Object.keys(plugin.rules).toSorted(compareStrings).map((ruleName) => `${prefix}/${ruleName}`);
+  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 = tsPlugin2.configs;
+  const flatConfigs2 = tsPlugin3.configs;
   const workspacesRecommended = workspacesPlugin2.configs.recommended;
   return [
     {
@@ -1034,6 +1389,16 @@ function collectPluginRuleSnapshots() {
       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"]),
@@ -1085,11 +1450,17 @@ var docsConfig = [
 ];
 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,
@@ -1109,18 +1480,24 @@ export {
   experimentalLayerConfig,
   experimentalPromotionRules,
   experimentalUnicornLayerConfig,
+  experimentalUnicornV69LayerConfig,
+  findEnabledTypeCheckedRules,
   findRuleOwnershipConflicts,
   formatRecommendedConfigCall,
+  getRuleSeverity,
+  globalIgnoresConfig,
   ignores,
   importConfig,
   json5Config,
   jsonConfig,
   jsoncConfig,
+  managedRulesForTier,
   markdownConfig,
   mergeConfigRules,
   opinionatedLayerConfig,
   opinionatedPromotionLayerConfig,
   opinionatedPromotionRules,
+  opinionatedUnicornPresetLayerConfig,
   opinionatedUnicornV66LayerConfig,
   parseRecommendedConfigSource,
   recommendedConfig,
@@ -1140,9 +1517,13 @@ export {
   typescriptTypeCheckedCorrectnessConfig,
   unicornConfig,
   unicornExperimentalMigrationQueue,
+  unicornGloballyDisabledRules,
+  unicornOpinionatedRules,
+  unicornOpinionatedRulesForTier,
   unicornV66MigrationQueue,
   unicornV66NewRules,
   unicornV67MigrationQueue,
+  unicornV69MigrationQueue,
   workspacesConfig
 };
 //# sourceMappingURL=index.mjs.map