@xylabs/eslint-config-flat 8.2.0 → 8.2.2

package/dist/neutral/index.mjs

@@ -1,5 +1,5 @@
-// src/core/index.ts
-import js from "@eslint/js";
+// src/json/index.ts
+import json from "@eslint/json";
 
 // src/ignores.ts
 var ignores = [
@@ -22,6 +22,32 @@ var ignores = [
   "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 = [
@@ -91,7 +117,34 @@ function scopeConfigs(configs, options = {}) {
   return (Array.isArray(configs) ? configs : [configs]).map((config2) => scopeConfig(config2, options));
 }
 
-// src/rules/index.ts
+// src/markdown/index.ts
+var markdownConfig = scopeConfigs(markdown.configs.recommended);
+
+// 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",
@@ -102,6 +155,33 @@ var restrictedImportPaths = [
   "../../../../../../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: [
@@ -115,25 +195,8 @@ var restrictedSrcImportPatterns = [
 var rulesConfig = {
   ignores,
   rules: {
-    "complexity": ["error", 18],
-    "max-depth": ["error", 6],
-    "max-lines": [
-      "error",
-      {
-        max: 512,
-        skipBlankLines: true
-      }
-    ],
-    "array-element-newline": ["warn", "consistent"],
-    "max-nested-callbacks": ["error", 6],
-    "max-statements": ["error", 32],
-    "no-restricted-imports": [
-      "error",
-      { paths: restrictedImportPaths }
-    ],
-    "no-tabs": ["error"],
-    "no-unused-vars": "off",
-    "no-useless-escape": "off"
+    ...correctnessRulesConfig.rules,
+    ...consistencyRulesConfig.rules
   }
 };
 var srcImportsConfig = {
@@ -143,7 +206,7 @@ var srcImportsConfig = {
     "no-restricted-imports": [
       "error",
       {
-        paths: restrictedImportPaths,
+        paths: restrictedImportPaths2,
         patterns: restrictedSrcImportPatterns
       }
     ]
@@ -152,14 +215,12 @@ var srcImportsConfig = {
 
 // src/unicorn/index.ts
 import unicornPlugin from "eslint-plugin-unicorn";
-var unicornV66NewRules = [
+var unicornV66MigrationQueue = [
   "unicorn/class-reference-in-static-methods",
   "unicorn/comment-content",
-  "unicorn/consistent-class-member-order",
   "unicorn/consistent-export-decorator-position",
   "unicorn/consistent-optional-chaining",
   "unicorn/explicit-timer-delay",
-  "unicorn/max-nested-calls",
   "unicorn/no-array-reverse",
   "unicorn/no-array-sort",
   "unicorn/no-break-in-nested-loop",
@@ -225,20 +286,32 @@ var unicornV66NewRules = [
   "unicorn/require-array-sort-compare",
   "unicorn/require-proxy-trap-boolean-return"
 ];
+var unicornV66NewRules = unicornV66MigrationQueue;
 var unicornConfig = {
   ...unicornPlugin.configs.recommended,
   plugins: { unicorn: unicornPlugin },
   rules: {
     ...unicornPlugin.configs.recommended.rules,
-    ...Object.fromEntries(unicornV66NewRules.map((rule) => [rule, "warn"])),
+    ...Object.fromEntries(unicornV66MigrationQueue.map((rule) => [rule, "warn"])),
+    // 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"],
     "unicorn/prefer-module": ["off"],
     "unicorn/prefer-top-level-await": ["off"],
@@ -254,19 +327,27 @@ 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 coreConfig = [
+var correctnessCoreConfig = [
   scopeConfig(js.configs.recommended, { files: scriptFiles, languageOptions: scriptLanguageOptions }),
-  rulesConfig,
+  correctnessRulesConfig,
   srcImportsConfig,
-  scopeConfig(unicornConfig, { files: scriptFiles }),
   workspacesConfig
 ];
+var bestPracticesCoreConfig = [
+  scopeConfig(unicornConfig, { files: scriptFiles })
+];
+var coreConfig = [
+  ...correctnessCoreConfig,
+  consistencyRulesConfig,
+  ...bestPracticesCoreConfig
+];
 
 // src/import/index.ts
 import importPlugin from "eslint-plugin-import-x";
@@ -284,13 +365,15 @@ var importConfig = [
     },
     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-absolute-path": ["warn"],
       "import-x/no-unresolved": ["off"],
+      "import-x/no-absolute-path": ["warn"],
       "import-x/no-cycle": [
         "warn",
         { maxDepth: 5 }
@@ -305,57 +388,281 @@ var importConfig = [
   }
 ];
 
-// src/json/index.ts
-import json from "@eslint/json";
-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 = {
+// src/sonar/index.ts
+import sonarjs from "eslint-plugin-sonarjs";
+var sonarConfig = {
+  plugins: { sonarjs },
   ignores,
-  files: ["**/*.json5"],
-  plugins: { json },
-  language: "json/json5",
-  rules: { "json/no-duplicate-keys": ["error"] }
+  rules: {
+    "sonarjs/no-small-switch": ["off"],
+    "sonarjs/os-command": ["off"],
+    "sonarjs/no-os-command-from-path": ["off"],
+    "sonarjs/no-nested-conditional": ["off"],
+    "sonarjs/todo-tag": ["off"],
+    "sonarjs/deprecation": ["warn"],
+    "sonarjs/no-nested-functions": ["off"],
+    "sonarjs/function-return-type": ["off"],
+    "sonarjs/pseudo-random": ["off"],
+    "sonarjs/public-static-readonly": ["warn"],
+    "sonarjs/post-message": ["off"],
+    "sonarjs/different-types-comparison": ["off"],
+    // Owned by simple-import-sort/imports
+    "sonarjs/no-alphabetical-sort": ["off"],
+    "sonarjs/no-identical-functions": ["warn"],
+    "sonarjs/no-empty-test-file": ["off"],
+    "sonarjs/no-dead-store": ["warn"],
+    "sonarjs/no-redundant-jump": ["warn"],
+    "sonarjs/void-use": ["off"],
+    // Owned by complexity
+    "sonarjs/cognitive-complexity": ["off"],
+    // Owned by @typescript-eslint/no-unused-vars
+    "sonarjs/unused-import": ["off"],
+    "sonarjs/no-unused-vars": ["off"],
+    "sonarjs/no-commented-code": ["off"],
+    "sonarjs/prefer-single-boolean-return": ["off"],
+    "sonarjs/redundant-type-aliases": ["off"]
+  }
 };
 
-// src/markdown/index.ts
-import markdown from "@eslint/markdown";
-var markdownConfig = scopeConfigs(markdown.configs.recommended);
+// 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", "sonarjs/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: "Cyclomatic complexity per function",
+    owner: "complexity",
+    disabled: ["sonarjs/cognitive-complexity"]
+  },
+  {
+    description: "Unused import detection",
+    owner: "@typescript-eslint/no-unused-vars",
+    disabled: ["sonarjs/unused-import"]
+  },
+  {
+    description: "Import statement ordering",
+    owner: "simple-import-sort/imports",
+    disabled: ["import-x/order", "sonarjs/no-alphabetical-sort"]
+  }
+];
+function isRuleEnabled(setting) {
+  if (setting === void 0) {
+    return false;
+  }
+  if (setting === "off" || setting === 0) {
+    return false;
+  }
+  if (Array.isArray(setting) && setting[0] === "off") {
+    return false;
+  }
+  return true;
+}
+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;
-function createTypeScriptOverride(languageOptions) {
+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-object-type": ["off"],
       "@typescript-eslint/no-empty-function": "warn",
       "@stylistic/eol-last": "warn",
       "@typescript-eslint/explicit-member-accessibility": ["warn", { accessibility: "no-public" }],
-      "@typescript-eslint/explicit-module-boundary-types": "off",
       "@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"],
-      "@typescript-eslint/triple-slash-reference": ["off"],
       "@stylistic/member-delimiter-style": [
         "error",
         {
@@ -399,185 +706,331 @@ function createTypeScriptOverride(languageOptions) {
           message: "Enums are disallowed. Consider using a union of string literals or a `const` object instead."
         }
       ],
-      "@typescript-eslint/member-ordering": [
-        "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"
-          }
-        }
-      ],
-      "@typescript-eslint/no-unused-vars": [
-        "warn",
-        {
-          argsIgnorePattern: "^_",
-          varsIgnorePattern: "^_",
-          ignoreRestSiblings: true
-        }
-      ],
-      "@typescript-eslint/require-await": "off",
-      "@typescript-eslint/strict-boolean-expressions": ["off"],
-      "quotes": ["off"],
-      "require-await": "off",
-      "semi": ["warn", "never"]
+      "@typescript-eslint/member-ordering": memberOrderingRule
     }
   };
 }
-var typescriptConfig = [
+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 }),
-  createTypeScriptOverride(scriptLanguageOptions)
+  createConsistencyOverride(scriptLanguageOptions)
 ];
-var typescriptTypeCheckedConfig = [
+var typescriptTypeCheckedCorrectnessConfig = [
   ...scopeConfigs(flatConfigs["flat/recommended-type-checked"], { files: scriptFiles, languageOptions: typeCheckedLanguageOptions }),
-  ...scopeConfigs(flatConfigs["flat/stylistic-type-checked"], { files: scriptFiles, languageOptions: typeCheckedLanguageOptions }),
-  createTypeScriptOverride(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/sonar/index.ts
-import sonarjs from "eslint-plugin-sonarjs";
-var sonarConfig = {
-  plugins: { sonarjs },
-  ignores,
+// src/tiers/opinionated.ts
+var opinionatedLayerConfig = {
+  files: scriptFiles,
   rules: {
-    "sonarjs/no-small-switch": ["off"],
-    "sonarjs/os-command": ["off"],
-    "sonarjs/no-os-command-from-path": ["off"],
-    "sonarjs/no-nested-conditional": ["off"],
-    "sonarjs/todo-tag": ["off"],
-    "sonarjs/deprecation": ["warn"],
-    "sonarjs/no-nested-functions": ["off"],
-    "sonarjs/function-return-type": ["off"],
-    "sonarjs/pseudo-random": ["off"],
-    "sonarjs/public-static-readonly": ["warn"],
-    "sonarjs/post-message": ["off"],
-    "sonarjs/different-types-comparison": ["off"],
-    "sonarjs/no-alphabetical-sort": ["warn"],
-    "sonarjs/no-identical-functions": ["warn"],
-    "sonarjs/no-empty-test-file": ["off"],
-    "sonarjs/no-dead-store": ["warn"],
-    "sonarjs/no-redundant-jump": ["warn"],
-    "sonarjs/void-use": ["off"],
-    // handled by ESLint
-    "sonarjs/cognitive-complexity": ["off"],
-    "sonarjs/unused-import": ["off"],
-    // handled by typescript-eslint
-    "sonarjs/no-unused-vars": ["off"],
-    "sonarjs/no-commented-code": ["off"],
-    "sonarjs/prefer-single-boolean-return": ["off"],
-    "sonarjs/redundant-type-aliases": ["off"]
+    "@typescript-eslint/strict-boolean-expressions": "warn",
+    "unicorn/filename-case": ["warn", { case: "kebabCase" }],
+    "unicorn/no-await-expression-member": "warn",
+    "unicorn/number-literal-case": "warn",
+    "workspaces/no-relative-imports": "warn",
+    "workspaces/require-dependency": "warn"
   }
 };
+var strictPromotionRules = {
+  "@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",
+  "sonarjs/deprecation": "error",
+  "sonarjs/no-dead-store": "error",
+  "sonarjs/no-identical-functions": "error",
+  "sonarjs/no-redundant-jump": "error",
+  "sonarjs/public-static-readonly": "error",
+  "unicorn/no-useless-undefined": "error",
+  ...Object.fromEntries(unicornV66MigrationQueue.map((rule) => [rule, "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/filename-case",
+    "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 strictLayerConfig = {
+  files: scriptFiles,
+  rules: strictPromotionRules
+};
+
+// src/tiers/index.ts
+function mergeTierConfigs(...parts) {
+  return parts.flat();
+}
+var configTier0Correctness = mergeTierConfigs(
+  markdownConfig,
+  correctnessCoreConfig,
+  typescriptCorrectnessConfig
+);
+var configTier0CorrectnessTypeChecked = mergeTierConfigs(
+  markdownConfig,
+  correctnessCoreConfig,
+  typescriptTypeCheckedCorrectnessConfig
+);
+var configTier1Consistency = mergeTierConfigs(
+  configTier0Correctness,
+  [consistencyRulesConfig],
+  typescriptConsistencyConfig,
+  [typescriptDelegationConfig]
+);
+var configTier1ConsistencyTypeChecked = mergeTierConfigs(
+  configTier0CorrectnessTypeChecked,
+  [consistencyRulesConfig],
+  typescriptTypeCheckedConsistencyConfig,
+  [typescriptDelegationConfig]
+);
+var configTier2BestPractices = mergeTierConfigs(
+  configTier1Consistency,
+  bestPracticesCoreConfig,
+  importConfig
+);
+var configTier2BestPracticesTypeChecked = mergeTierConfigs(
+  configTier1ConsistencyTypeChecked,
+  bestPracticesCoreConfig,
+  importConfig
+);
+var configTier3Opinionated = mergeTierConfigs(
+  configTier2BestPractices,
+  [opinionatedLayerConfig]
+);
+var configTier3OpinionatedTypeChecked = mergeTierConfigs(
+  configTier2BestPracticesTypeChecked,
+  [opinionatedLayerConfig]
+);
+var configTier4Strict = mergeTierConfigs(
+  configTier3Opinionated,
+  [sonarConfig, strictLayerConfig]
+);
+var configTier4StrictTypeChecked = mergeTierConfigs(
+  configTier3OpinionatedTypeChecked,
+  [sonarConfig, strictLayerConfig]
+);
+var recommendedConfig = configTier2BestPractices;
+var recommendedTypeCheckedConfig = configTier2BestPracticesTypeChecked;
+var config = configTier2BestPracticesTypeChecked;
+
+// 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 tsPlugin2 from "@typescript-eslint/eslint-plugin";
+import importPlugin2 from "eslint-plugin-import-x";
+import simpleImportSort2 from "eslint-plugin-simple-import-sort";
+import sonarjs2 from "eslint-plugin-sonarjs";
+import unicornPlugin2 from "eslint-plugin-unicorn";
+import workspacesPlugin2 from "eslint-plugin-workspaces";
+var compareStrings = (left, right) => left.localeCompare(right);
+function sortedRuleNames(rules) {
+  if (!rules) {
+    return [];
+  }
+  return Object.keys(rules).toSorted(compareStrings);
+}
+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(compareStrings).map((ruleName) => `${prefix}/${ruleName}`);
+}
+function collectPluginRuleSnapshots() {
+  const unicornRecommended = unicornPlugin2.configs["flat/recommended"];
+  const importRecommended = importPlugin2.flatConfigs.recommended;
+  const flatConfigs2 = tsPlugin2.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-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-sonarjs",
+      rules: pluginRuleNames(sonarjs2),
+      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 recommendedConfig = [
-  ...markdownConfig,
-  ...coreConfig,
-  ...typescriptConfig,
-  ...importConfig
-];
-var recommendedTypeCheckedConfig = [
-  ...markdownConfig,
-  ...coreConfig,
-  ...typescriptTypeCheckedConfig,
-  ...importConfig
-];
 var docsConfig = [
   ...markdownConfig,
   jsonConfig,
   jsoncConfig,
   json5Config
 ];
-var config = recommendedTypeCheckedConfig;
 export {
+  RULE_OWNERSHIP_GROUPS,
+  assertNoRuleOwnershipConflicts,
+  bestPracticesCoreConfig,
+  collectPluginRuleSnapshots,
   config,
+  configTier0Correctness,
+  configTier0CorrectnessTypeChecked,
+  configTier1Consistency,
+  configTier1ConsistencyTypeChecked,
+  configTier2BestPractices,
+  configTier2BestPracticesTypeChecked,
+  configTier3Opinionated,
+  configTier3OpinionatedTypeChecked,
+  configTier4Strict,
+  configTier4StrictTypeChecked,
+  consistencyRulesConfig,
   coreConfig,
+  correctnessCoreConfig,
+  correctnessRulesConfig,
   docsConfig,
+  findRuleOwnershipConflicts,
   ignores,
   importConfig,
   json5Config,
   jsonConfig,
   jsoncConfig,
   markdownConfig,
+  mergeConfigRules,
+  opinionatedLayerConfig,
   recommendedConfig,
   recommendedTypeCheckedConfig,
   rulesConfig,
+  serializePluginRuleSnapshots,
   sonarConfig,
   srcImportsConfig,
+  strictLayerConfig,
+  strictPromotionRules,
   typescriptConfig,
+  typescriptConsistencyConfig,
+  typescriptCorrectnessConfig,
+  typescriptDelegationConfig,
   typescriptTypeCheckedConfig,
+  typescriptTypeCheckedConsistencyConfig,
+  typescriptTypeCheckedCorrectnessConfig,
   unicornConfig,
+  unicornV66MigrationQueue,
   unicornV66NewRules,
   workspacesConfig
 };