@xylabs/eslint-config-flat 8.6.10 → 8.6.12

package/dist/neutral/index.mjs

@@ -1,1524 +1,3 @@
-// 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"
-];
-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((rule2) => [rule2, severity]));
-}
-var unicornConfig = {
-  ...unicornUnopinionatedConfig,
-  plugins: { unicorn: unicornPlugin },
-  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"],
-    // 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,
-  workspacesConfig
-};
+export * from "@ariestools/eslint-config-flat";
 //# sourceMappingURL=index.mjs.map