eslint-plugin-typefest 1.0.6 → 1.0.7

package/dist/plugin.cjs

@@ -34,13 +34,13 @@ __export(plugin_exports, {
 });
 module.exports = __toCommonJS(plugin_exports);
 var import_parser3 = __toESM(require("@typescript-eslint/parser"), 1);
-var import_ts_extras39 = require("ts-extras");
+var import_ts_extras41 = require("ts-extras");
 
 // package.json
 var package_default = {
   $schema: "https://www.schemastore.org/package.json",
   name: "eslint-plugin-typefest",
-  version: "1.0.6",
+  version: "1.0.7",
   private: false,
   description: "ESLint rules for adopting type-fest and ts-extras conventions.",
   keywords: [
@@ -254,10 +254,10 @@ var package_default = {
     "jsonc-eslint-parser": "$jsonc-eslint-parser"
   },
   dependencies: {
-    "@typescript-eslint/parser": "^8.57.1",
-    "@typescript-eslint/type-utils": "^8.57.1",
-    "@typescript-eslint/utils": "^8.57.1",
-    "ts-extras": "^0.17.0",
+    "@typescript-eslint/parser": "^8.57.2",
+    "@typescript-eslint/type-utils": "^8.57.2",
+    "@typescript-eslint/utils": "^8.57.2",
+    "ts-extras": "^0.19.0",
     "type-fest": "^5.5.0"
   },
   devDependencies: {
@@ -265,7 +265,7 @@ var package_default = {
     "@csstools/stylelint-formatter-github": "^2.0.0",
     "@docusaurus/eslint-plugin": "^3.9.2",
     "@double-great/remark-lint-alt-text": "^1.1.1",
-    "@double-great/stylelint-a11y": "^3.4.6",
+    "@double-great/stylelint-a11y": "^3.4.7",
     "@eslint-community/eslint-plugin-eslint-comments": "^4.7.1",
     "@eslint-react/eslint-plugin": "^3.0.0",
     "@eslint/compat": "^2.0.3",
@@ -315,11 +315,11 @@ var package_default = {
     "@types/postcss-normalize": "^9.0.4",
     "@types/postcss-reporter": "^7.0.5",
     "@types/sloc": "^0.2.3",
-    "@typescript-eslint/eslint-plugin": "^8.57.1",
-    "@typescript-eslint/rule-tester": "^8.57.1",
-    "@vitest/coverage-v8": "^4.1.0",
-    "@vitest/eslint-plugin": "^1.6.12",
-    "@vitest/ui": "^4.1.0",
+    "@typescript-eslint/eslint-plugin": "^8.57.2",
+    "@typescript-eslint/rule-tester": "^8.57.2",
+    "@vitest/coverage-v8": "^4.1.1",
+    "@vitest/eslint-plugin": "^1.6.13",
+    "@vitest/ui": "^4.1.1",
     actionlint: "^2.0.6",
     "all-contributors-cli": "^6.26.1",
     "cognitive-complexity-ts": "^0.8.1",
@@ -329,7 +329,7 @@ var package_default = {
     depcheck: "^1.4.7",
     "detect-secrets": "^1.0.6",
     eslint: "^10.1.0",
-    "eslint-config-flat-gitignore": "^2.2.1",
+    "eslint-config-flat-gitignore": "^2.3.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-formatter-unix": "^9.0.1",
     "eslint-import-resolver-typescript": "^4.4.4",
@@ -345,20 +345,19 @@ var package_default = {
     "eslint-plugin-etc": "^2.0.3",
     "eslint-plugin-etc-misc": "^1.0.4",
     "eslint-plugin-file-progress-2": "^3.4.3",
+    "eslint-plugin-github-actions-2": "^1.0.0",
     "eslint-plugin-html": "^8.1.4",
-    "eslint-plugin-immutable-2": "^1.0.5",
+    "eslint-plugin-immutable-2": "^1.0.6",
     "eslint-plugin-import-x": "^4.16.2",
     "eslint-plugin-jsdoc": "^62.8.0",
     "eslint-plugin-jsonc": "^3.1.2",
     "eslint-plugin-jsx-a11y": "^6.10.2",
     "eslint-plugin-listeners": "^1.5.1",
-    "eslint-plugin-loadable-imports": "^1.0.1",
     "eslint-plugin-math": "^0.13.1",
     "eslint-plugin-module-interop": "^0.3.1",
     "eslint-plugin-n": "^17.24.0",
     "eslint-plugin-nitpick": "^0.12.0",
     "eslint-plugin-no-barrel-files": "^1.2.2",
-    "eslint-plugin-no-explicit-type-exports": "^0.12.1",
     "eslint-plugin-no-function-declare-after-return": "^1.1.0",
     "eslint-plugin-no-lookahead-lookbehind-regexp": "^0.4.0",
     "eslint-plugin-no-only-tests": "^3.3.0",
@@ -368,7 +367,6 @@ var package_default = {
     "eslint-plugin-node-dependencies": "^2.2.0",
     "eslint-plugin-package-json": "^0.91.0",
     "eslint-plugin-perfectionist": "^5.7.0",
-    "eslint-plugin-prefer-arrow": "^1.2.3",
     "eslint-plugin-prettier": "^5.5.5",
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-redos": "^4.5.0",
@@ -378,12 +376,12 @@ var package_default = {
     "eslint-plugin-security": "^4.0.0",
     "eslint-plugin-sonarjs": "^4.0.2",
     "eslint-plugin-sort-class-members": "^1.21.0",
-    "eslint-plugin-testing-library": "^7.16.1",
+    "eslint-plugin-testing-library": "^7.16.2",
     "eslint-plugin-toml": "^1.3.1",
     "eslint-plugin-total-functions": "^7.1.0",
     "eslint-plugin-tsdoc": "^0.5.2",
     "eslint-plugin-tsdoc-require-2": "^1.0.6",
-    "eslint-plugin-typefest": "^1.0.5",
+    "eslint-plugin-typefest": "^1.0.6",
     "eslint-plugin-undefined-css-classes": "^0.1.5",
     "eslint-plugin-unicorn": "^63.0.0",
     "eslint-plugin-unused-imports": "^4.4.1",
@@ -398,7 +396,7 @@ var package_default = {
     htmlhint: "^1.9.2",
     jscpd: "^4.0.8",
     "jsonc-eslint-parser": "^3.1.0",
-    knip: "^6.0.1",
+    knip: "^6.0.4",
     leasot: "^14.4.0",
     madge: "^8.0.0",
     "markdown-link-check": "^3.14.2",
@@ -418,7 +416,7 @@ var package_default = {
     "postcss-reporter": "^7.1.0",
     "postcss-round-subpixels": "^2.0.0",
     "postcss-scss": "^4.0.9",
-    "postcss-sort-media-queries": "^6.3.2",
+    "postcss-sort-media-queries": "^6.3.3",
     "postcss-styled-jsx": "^1.0.1",
     "postcss-styled-syntax": "^0.7.1",
     "postcss-viewport-height-correction": "^1.1.1",
@@ -576,7 +574,7 @@ var package_default = {
     "stylelint-order": "^8.1.1",
     "stylelint-plugin-defensive-css": "^2.8.0",
     "stylelint-plugin-logical-css": "^2.0.2",
-    "stylelint-plugin-use-baseline": "^1.4.0",
+    "stylelint-plugin-use-baseline": "^1.4.1",
     "stylelint-prettier": "^5.0.3",
     "stylelint-react-native": "^2.7.0",
     "stylelint-scales": "^5.0.0",
@@ -585,20 +583,20 @@ var package_default = {
     "stylelint-value-no-unknown-custom-properties": "^6.1.1",
     "toml-eslint-parser": "^1.0.3",
     "ts-unused-exports": "^11.0.1",
-    typedoc: "^0.28.17",
-    typescript: "^5.9.3",
-    "typescript-eslint": "^8.57.1",
+    typedoc: "^0.28.18",
+    typescript: "^6.0.2",
+    "typescript-eslint": "^8.57.2",
     typesync: "^0.14.3",
     vfile: "^6.0.3",
-    vite: "^8.0.1",
+    vite: "^8.0.2",
     "vite-tsconfig-paths": "^6.1.1",
-    vitest: "^4.1.0",
+    vitest: "^4.1.1",
     "yaml-eslint-parser": "^2.0.0",
     "yamllint-js": "^0.2.4"
   },
   peerDependencies: {
     eslint: "^9.0.0 || ^10.1.0",
-    typescript: ">=5.0.0"
+    typescript: "^5.0.0 || ^6.0.0"
   },
   packageManager: "npm@11.12.0",
   engines: {
@@ -634,6 +632,7 @@ var createRuleDocsUrl = (ruleName) => `${RULE_DOCS_URL_BASE}${ruleName}`;
 var import_ts_extras = require("ts-extras");
 var typefestConfigNames = [
   "all",
+  "experimental",
   "minimal",
   "recommended",
   "recommended-type-checked",
@@ -648,6 +647,12 @@ var typefestConfigMetadataByName = {
     readmeOrder: 5,
     requiresTypeChecking: true
   },
+  experimental: {
+    icon: "\u{1F9EA}",
+    presetName: "typefest:experimental",
+    readmeOrder: 6,
+    requiresTypeChecking: true
+  },
   minimal: {
     icon: "\u{1F7E2}",
     presetName: "typefest:minimal",
@@ -675,18 +680,19 @@ var typefestConfigMetadataByName = {
   "ts-extras/type-guards": {
     icon: "\u2734\uFE0F",
     presetName: "typefest:ts-extras/type-guards",
-    readmeOrder: 7,
+    readmeOrder: 8,
     requiresTypeChecking: true
   },
   "type-fest/types": {
     icon: "\u{1F4A0}",
     presetName: "typefest:type-fest/types",
-    readmeOrder: 6,
+    readmeOrder: 7,
     requiresTypeChecking: false
   }
 };
 var typefestConfigReferenceToName = {
   "typefest.configs.all": "all",
+  "typefest.configs.experimental": "experimental",
   "typefest.configs.minimal": "minimal",
   "typefest.configs.recommended": "recommended",
   "typefest.configs.recommended-type-checked": "recommended-type-checked",
@@ -1865,6 +1871,24 @@ function getSafeLocalNameForImportedValueInScope({ importedName, imports, source
   }
   return null;
 }
+var getSafeLocalNameForImportedValue = ({ context, importedName, imports, referenceNode, sourceModuleName }) => {
+  const sourceScope = resolveReferenceScope({
+    context,
+    referenceNode
+  });
+  if (sourceScope === null) {
+    return getFirstImportedAliasName({
+      importedName,
+      imports
+    });
+  }
+  return getSafeLocalNameForImportedValueInScope({
+    importedName,
+    imports,
+    sourceModuleName,
+    sourceScope
+  });
+};
 var getSafeReplacementNameAndImportFixFactory = ({ context, importedName, imports, referenceNode, sourceModuleName }) => {
   const sourceScope = resolveReferenceScope({
     context,
@@ -2349,7 +2373,18 @@ var orderedRuleNames = [
   "prefer-type-fest-conditional-pick-deep",
   "prefer-type-fest-union-to-tuple",
   "prefer-type-fest-less-than",
-  "prefer-type-fest-less-than-or-equal"
+  "prefer-type-fest-less-than-or-equal",
+  "prefer-ts-extras-object-map-values",
+  "prefer-type-fest-conditional-except",
+  "prefer-type-fest-merge",
+  "prefer-type-fest-stringified",
+  "prefer-type-fest-union-to-intersection",
+  "prefer-type-fest-distributed-omit",
+  "prefer-type-fest-distributed-pick",
+  "prefer-type-fest-set-return-type",
+  "prefer-type-fest-asyncify",
+  "prefer-type-fest-pick-index-signature",
+  "prefer-type-fest-conditional-keys"
 ];
 var toRuleCatalogId = (ruleNumber) => `R${String(ruleNumber).padStart(3, "0")}`;
 var isTypefestRuleNamePattern2 = (ruleName) => ruleName.startsWith("prefer-");
@@ -5974,6 +6009,168 @@ var preferTsExtrasObjectKeysRule = createTypedRule({
 });
 var prefer_ts_extras_object_keys_default = preferTsExtrasObjectKeysRule;
 
+// dist/rules/prefer-ts-extras-object-map-values.js
+var getSingleExpressionArgument = (callExpression) => {
+  if (callExpression.arguments.length !== 1) {
+    return null;
+  }
+  const [argument] = callExpression.arguments;
+  if (!argument || argument.type === "SpreadElement") {
+    return null;
+  }
+  return argument;
+};
+var unwrapTransparentExpression2 = (expression) => {
+  let currentExpression = expression;
+  while (true) {
+    if (currentExpression.type === "TSAsExpression") {
+      currentExpression = currentExpression.expression;
+      continue;
+    }
+    if (currentExpression.type === "TSNonNullExpression") {
+      currentExpression = currentExpression.expression;
+      continue;
+    }
+    if (currentExpression.type === "TSSatisfiesExpression") {
+      currentExpression = currentExpression.expression;
+      continue;
+    }
+    if (currentExpression.type === "TSTypeAssertion") {
+      currentExpression = currentExpression.expression;
+      continue;
+    }
+    return currentExpression;
+  }
+};
+var getReturnedExpression = (callback) => {
+  if (callback.body.type !== "BlockStatement") {
+    return callback.body;
+  }
+  if (callback.body.body.length !== 1) {
+    return null;
+  }
+  const [statement] = callback.body.body;
+  if (statement?.type !== "ReturnStatement") {
+    return null;
+  }
+  return statement.argument;
+};
+var getKeyIdentifierFromEntriesTupleParameter = (parameter) => {
+  if (parameter.type !== "ArrayPattern" || parameter.elements.length !== 2) {
+    return null;
+  }
+  const [firstElement, secondElement] = parameter.elements;
+  if (firstElement?.type !== "Identifier" || secondElement?.type !== "Identifier") {
+    return null;
+  }
+  return firstElement;
+};
+var isKeyPreservingMappedTupleReturn = (returnedExpression, keyIdentifier) => {
+  const unwrappedExpression = unwrapTransparentExpression2(returnedExpression);
+  if (unwrappedExpression.type !== "ArrayExpression" || unwrappedExpression.elements.length !== 2) {
+    return false;
+  }
+  const [firstElement, secondElement] = unwrappedExpression.elements;
+  if (!firstElement || !secondElement || firstElement.type === "SpreadElement" || secondElement.type === "SpreadElement") {
+    return false;
+  }
+  return areEquivalentExpressions(firstElement, keyIdentifier);
+};
+var preferTsExtrasObjectMapValuesRule = createTypedRule({
+  create(context) {
+    const tsExtrasImports = collectDirectNamedValueImportsFromSource(context.sourceCode, TS_EXTRAS_MODULE_SOURCE);
+    return {
+      'CallExpression[callee.type="Identifier"]'(node) {
+        if (node.optional || node.callee.type !== "Identifier") {
+          return;
+        }
+        const objectFromEntriesLocalName = getSafeLocalNameForImportedValue({
+          context,
+          importedName: "objectFromEntries",
+          imports: tsExtrasImports,
+          referenceNode: node,
+          sourceModuleName: TS_EXTRAS_MODULE_SOURCE
+        });
+        if (objectFromEntriesLocalName === null || node.callee.name !== objectFromEntriesLocalName) {
+          return;
+        }
+        const mapCallExpression = getSingleExpressionArgument(node);
+        if (mapCallExpression?.type !== "CallExpression") {
+          return;
+        }
+        const mapMemberCall = getIdentifierPropertyMemberCall({
+          memberName: "map",
+          node: mapCallExpression
+        });
+        if (mapMemberCall === null) {
+          return;
+        }
+        const mapCallback = getSingleExpressionArgument(mapMemberCall);
+        if (mapCallback?.type !== "ArrowFunctionExpression") {
+          return;
+        }
+        const objectEntriesLocalName = getSafeLocalNameForImportedValue({
+          context,
+          importedName: "objectEntries",
+          imports: tsExtrasImports,
+          referenceNode: mapMemberCall,
+          sourceModuleName: TS_EXTRAS_MODULE_SOURCE
+        });
+        if (objectEntriesLocalName === null) {
+          return;
+        }
+        const entriesCallExpression = mapMemberCall.callee.object;
+        if (entriesCallExpression.type !== "CallExpression" || entriesCallExpression.callee.type !== "Identifier" || entriesCallExpression.callee.name !== objectEntriesLocalName || getSingleExpressionArgument(entriesCallExpression) === null) {
+          return;
+        }
+        if (mapCallback.params.length !== 1) {
+          return;
+        }
+        const [tupleParameter] = mapCallback.params;
+        if (tupleParameter === void 0) {
+          return;
+        }
+        const keyIdentifier = getKeyIdentifierFromEntriesTupleParameter(tupleParameter);
+        if (keyIdentifier === null) {
+          return;
+        }
+        const returnedExpression = getReturnedExpression(mapCallback);
+        if (returnedExpression === null) {
+          return;
+        }
+        if (!isKeyPreservingMappedTupleReturn(returnedExpression, keyIdentifier)) {
+          return;
+        }
+        reportWithOptionalFix({
+          context,
+          fix: null,
+          messageId: "preferTsExtrasObjectMapValues",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require ts-extras objectMapValues over objectFromEntries(objectEntries(...).map(...)) chains that only remap values.",
+      frozen: false,
+      recommended: false,
+      requiresTypeChecking: false,
+      typefestConfigs: ["typefest.configs.experimental"],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-ts-extras-object-map-values"
+    },
+    messages: {
+      preferTsExtrasObjectMapValues: "Prefer `objectMapValues` from `ts-extras` over `objectFromEntries(objectEntries(...).map(...))` when the map callback preserves keys and only remaps values."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-ts-extras-object-map-values"
+});
+var prefer_ts_extras_object_map_values_default = preferTsExtrasObjectMapValuesRule;
+
 // dist/rules/prefer-ts-extras-object-values.js
 var preferTsExtrasObjectValuesRule = createTypedRule({
   create(context) {
@@ -6770,6 +6967,10 @@ var prefer_type_fest_array_length_default = preferTypeFestArrayLengthRule;
 
 // dist/_internal/type-reference-node.js
 var isIdentifierTypeReference = (node, identifierName) => node.type === "TSTypeReference" && node.typeName.type === "Identifier" && node.typeName.name === identifierName;
+var unwrapParenthesizedTypeNode = (node) => {
+  const parenthesizedCandidate = node;
+  return parenthesizedCandidate.type === "TSParenthesizedType" && parenthesizedCandidate.typeAnnotation !== void 0 ? unwrapParenthesizedTypeNode(parenthesizedCandidate.typeAnnotation) : node;
+};
 
 // dist/rules/prefer-type-fest-arrayable.js
 var ARRAY_TYPE_NAME = "Array";
@@ -6925,34 +7126,98 @@ var preferTypeFestAsyncReturnTypeRule = createTypedRule({
 });
 var prefer_type_fest_async_return_type_default = preferTypeFestAsyncReturnTypeRule;
 
-// dist/rules/prefer-type-fest-conditional-pick-deep.js
-var conditionalPickDeepAliasReplacements = {
-  PickDeepByType: "ConditionalPickDeep",
-  PickDeepByTypes: "ConditionalPickDeep"
+// dist/_internal/function-type-reference-patterns.js
+var getSingleTypeArgument2 = (node) => {
+  const typeArguments = node.typeArguments?.params ?? [];
+  if (typeArguments.length !== 1) {
+    return null;
+  }
+  const [onlyTypeArgument] = typeArguments;
+  return onlyTypeArgument ?? null;
 };
-var preferTypeFestConditionalPickDeepRule = createTypedRule({
+var getParameterTypeAnnotation = (parameter) => {
+  if (parameter.type === "Identifier") {
+    return parameter.typeAnnotation === void 0 ? null : unwrapParenthesizedTypeNode(parameter.typeAnnotation.typeAnnotation);
+  }
+  if (parameter.type !== "RestElement") {
+    return null;
+  }
+  return parameter.typeAnnotation === void 0 ? null : unwrapParenthesizedTypeNode(parameter.typeAnnotation.typeAnnotation);
+};
+var getParametersFunctionArgumentFromFunctionType = (node) => {
+  if (node.params.length !== 1) {
+    return null;
+  }
+  const [onlyParameter] = node.params;
+  if (onlyParameter?.type !== "RestElement") {
+    return null;
+  }
+  const restParameterType = getParameterTypeAnnotation(onlyParameter);
+  if (restParameterType?.type !== "TSTypeReference" || !isIdentifierTypeReference(restParameterType, "Parameters")) {
+    return null;
+  }
+  return getSingleTypeArgument2(restParameterType);
+};
+var isReturnTypeReferenceForFunction = (node, functionType) => {
+  const normalizedNode = unwrapParenthesizedTypeNode(node);
+  if (normalizedNode.type !== "TSTypeReference" || !isIdentifierTypeReference(normalizedNode, "ReturnType")) {
+    return false;
+  }
+  const referencedFunctionType = getSingleTypeArgument2(normalizedNode);
+  return referencedFunctionType !== null && areEquivalentTypeNodes(unwrapParenthesizedTypeNode(referencedFunctionType), unwrapParenthesizedTypeNode(functionType));
+};
+var isPromiseAwaitedReturnTypeReferenceForFunction = (node, functionType) => {
+  const normalizedNode = unwrapParenthesizedTypeNode(node);
+  if (normalizedNode.type !== "TSTypeReference" || !isIdentifierTypeReference(normalizedNode, "Promise")) {
+    return false;
+  }
+  const promisedType = getSingleTypeArgument2(normalizedNode);
+  if (promisedType?.type !== "TSTypeReference" || !isIdentifierTypeReference(promisedType, "Awaited")) {
+    return false;
+  }
+  const awaitedInnerType = getSingleTypeArgument2(promisedType);
+  return awaitedInnerType !== null && isReturnTypeReferenceForFunction(awaitedInnerType, functionType);
+};
+
+// dist/rules/prefer-type-fest-asyncify.js
+var isAsyncifyEquivalentSetReturnTypeReference = (node, setReturnTypeLocalNames) => {
+  if (node.typeName.type !== "Identifier" || !setContainsValue(setReturnTypeLocalNames, node.typeName.name)) {
+    return false;
+  }
+  const typeArguments = node.typeArguments?.params;
+  if (typeArguments?.length !== 2) {
+    return false;
+  }
+  const [functionType, returnType] = typeArguments;
+  return functionType !== void 0 && returnType !== void 0 && isPromiseAwaitedReturnTypeReferenceForFunction(returnType, functionType);
+};
+var preferTypeFestAsyncifyRule = createTypedRule({
   create(context) {
-    const importedAliasMatches = collectImportedTypeAliasMatches(context.sourceCode, conditionalPickDeepAliasReplacements);
-    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    const setReturnTypeLocalNames = collectNamedImportLocalNamesFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE, "SetReturnType");
     return {
-      'TSTypeReference[typeName.type="Identifier"]'(node) {
-        if (node.typeName.type !== "Identifier") {
+      TSFunctionType(node) {
+        const functionType = getParametersFunctionArgumentFromFunctionType(node);
+        const returnType = node.returnType?.typeAnnotation;
+        if (functionType === null || returnType === void 0 || !isPromiseAwaitedReturnTypeReferenceForFunction(returnType, functionType)) {
           return;
         }
-        const importedAliasMatch = importedAliasMatches.get(node.typeName.name);
-        if (!importedAliasMatch) {
+        reportWithOptionalFix({
+          context,
+          fix: null,
+          messageId: "preferAsyncify",
+          node
+        });
+      },
+      'TSTypeReference[typeName.type="Identifier"]'(node) {
+        const normalizedNode = unwrapParenthesizedTypeNode(node);
+        if (normalizedNode.type !== "TSTypeReference" || !isAsyncifyEquivalentSetReturnTypeReference(normalizedNode, setReturnTypeLocalNames)) {
           return;
         }
-        const aliasReplacementFix = createSafeTypeReferenceReplacementFix(node, importedAliasMatch.replacementName, typeFestDirectImports);
         reportWithOptionalFix({
           context,
-          data: {
-            alias: importedAliasMatch.importedName,
-            replacement: importedAliasMatch.replacementName
-          },
-          fix: aliasReplacementFix,
-          messageId: "preferConditionalPickDeep",
-          node
+          fix: null,
+          messageId: "preferAsyncify",
+          node: normalizedNode
         });
       }
     };
@@ -6961,55 +7226,67 @@ var preferTypeFestConditionalPickDeepRule = createTypedRule({
   meta: {
     deprecated: false,
     docs: {
-      description: "require TypeFest ConditionalPickDeep over imported aliases such as PickDeepByTypes.",
+      description: "require TypeFest Asyncify over async function-type wrappers built from Parameters + Promise<Awaited<ReturnType<...>>>.",
       frozen: false,
-      recommended: true,
+      recommended: false,
       requiresTypeChecking: false,
-      typefestConfigs: [
-        "typefest.configs.recommended",
-        "typefest.configs.strict",
-        "typefest.configs.all",
-        "typefest.configs.type-fest/types"
-      ],
-      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-conditional-pick-deep"
+      typefestConfigs: ["typefest.configs.experimental"],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-asyncify"
     },
-    fixable: "code",
     messages: {
-      preferConditionalPickDeep: "Prefer `{{replacement}}` from type-fest for deep conditional property filtering instead of legacy alias `{{alias}}`."
+      preferAsyncify: "Prefer `Asyncify<Function>` from type-fest over manual async wrappers built from `Parameters<Function>` and `Promise<Awaited<ReturnType<Function>>>`."
     },
     schema: [],
     type: "suggestion"
   },
-  name: "prefer-type-fest-conditional-pick-deep"
+  name: "prefer-type-fest-asyncify"
 });
-var prefer_type_fest_conditional_pick_deep_default = preferTypeFestConditionalPickDeepRule;
+var prefer_type_fest_asyncify_default = preferTypeFestAsyncifyRule;
 
-// dist/rules/prefer-type-fest-conditional-pick.js
-var conditionalPickAliasReplacements = {
-  PickByTypes: "ConditionalPick"
+// dist/rules/prefer-type-fest-conditional-except.js
+var getConditionalKeysReference = (node, conditionalKeysLocalNames) => {
+  const normalizedNode = unwrapParenthesizedTypeNode(node);
+  if (normalizedNode.type !== "TSTypeReference" || normalizedNode.typeName.type !== "Identifier" || !setContainsValue(conditionalKeysLocalNames, normalizedNode.typeName.name)) {
+    return null;
+  }
+  return normalizedNode;
 };
-var preferTypeFestConditionalPickRule = createTypedRule({
+var preferTypeFestConditionalExceptRule = createTypedRule({
   create(context) {
-    const importedAliasMatches = collectImportedTypeAliasMatches(context.sourceCode, conditionalPickAliasReplacements);
-    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    const exceptLocalNames = collectNamedImportLocalNamesFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE, "Except");
+    const conditionalKeysLocalNames = collectNamedImportLocalNamesFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE, "ConditionalKeys");
     return {
       'TSTypeReference[typeName.type="Identifier"]'(node) {
-        if (node.typeName.type !== "Identifier") {
+        if (node.typeName.type !== "Identifier" || !setContainsValue(exceptLocalNames, node.typeName.name)) {
           return;
         }
-        const importedAliasMatch = importedAliasMatches.get(node.typeName.name);
-        if (!importedAliasMatch) {
+        const typeArguments = node.typeArguments?.params;
+        if (typeArguments?.length !== 2) {
+          return;
+        }
+        const [baseType, excludedKeysType] = typeArguments;
+        if (baseType === void 0 || excludedKeysType === void 0) {
+          return;
+        }
+        const conditionalKeysReference = getConditionalKeysReference(excludedKeysType, conditionalKeysLocalNames);
+        if (conditionalKeysReference === null) {
+          return;
+        }
+        const conditionalKeysArguments = conditionalKeysReference.typeArguments?.params;
+        if (conditionalKeysArguments?.length !== 2) {
+          return;
+        }
+        const [conditionalBaseType] = conditionalKeysArguments;
+        if (conditionalBaseType === void 0) {
+          return;
+        }
+        if (!areEquivalentTypeNodes(baseType, conditionalBaseType)) {
           return;
         }
-        const aliasReplacementFix = createSafeTypeReferenceReplacementFix(node, importedAliasMatch.replacementName, typeFestDirectImports);
         reportWithOptionalFix({
           context,
-          data: {
-            alias: importedAliasMatch.importedName,
-            replacement: importedAliasMatch.replacementName
-          },
-          fix: aliasReplacementFix,
-          messageId: "preferConditionalPick",
+          fix: null,
+          messageId: "preferConditionalExcept",
           node
         });
       }
@@ -7019,42 +7296,215 @@ var preferTypeFestConditionalPickRule = createTypedRule({
   meta: {
     deprecated: false,
     docs: {
-      description: "require TypeFest ConditionalPick over imported aliases such as PickByTypes.",
+      description: "require TypeFest ConditionalExcept over Except<T, ConditionalKeys<T, Condition>> compositions.",
       frozen: false,
-      recommended: true,
+      recommended: false,
       requiresTypeChecking: false,
-      typefestConfigs: [
-        "typefest.configs.recommended",
-        "typefest.configs.strict",
-        "typefest.configs.all",
-        "typefest.configs.type-fest/types"
-      ],
-      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-conditional-pick"
+      typefestConfigs: ["typefest.configs.experimental"],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-conditional-except"
     },
-    fixable: "code",
     messages: {
-      preferConditionalPick: "Prefer `{{replacement}}` from type-fest to pick keys whose values match a condition instead of legacy alias `{{alias}}`."
+      preferConditionalExcept: "Prefer `ConditionalExcept<Base, Condition>` from type-fest over `Except<Base, ConditionalKeys<Base, Condition>>` when excluding keys by value condition."
     },
     schema: [],
     type: "suggestion"
   },
-  name: "prefer-type-fest-conditional-pick"
+  name: "prefer-type-fest-conditional-except"
 });
-var prefer_type_fest_conditional_pick_default = preferTypeFestConditionalPickRule;
+var prefer_type_fest_conditional_except_default = preferTypeFestConditionalExceptRule;
 
-// dist/rules/prefer-type-fest-constructor.js
-var import_ts_extras33 = require("ts-extras");
-var preferTypeFestConstructorRule = createTypedRule({
-  create(context) {
-    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
-    const { sourceCode } = context;
-    return {
-      TSConstructorType(node) {
-        if (node.abstract) {
-          return;
-        }
-        const replacementFix = !(0, import_ts_extras33.isDefined)(node.typeParameters) && (0, import_ts_extras33.isDefined)(node.returnType) ? createSafeTypeNodeTextReplacementFix(node, "Constructor", `Constructor<${sourceCode.getText(node.returnType.typeAnnotation)}, [${(0, import_ts_extras33.arrayJoin)(node.params.map((parameter) => sourceCode.getText(parameter)), ", ")}]>`, typeFestDirectImports) : null;
-        reportWithOptionalFix({
+// dist/rules/prefer-type-fest-conditional-keys.js
+var hasConditionalKeysKeyRemapShape = (node) => {
+  if (node.operator !== "keyof" || node.typeAnnotation === void 0) {
+    return false;
+  }
+  const normalizedOperand = unwrapParenthesizedTypeNode(node.typeAnnotation);
+  if (normalizedOperand.type !== "TSMappedType" || normalizedOperand.key.type !== "Identifier") {
+    return false;
+  }
+  const mappedKeyName = normalizedOperand.key.name;
+  const constraint = normalizedOperand.constraint;
+  if (constraint?.type !== "TSTypeOperator" || constraint.operator !== "keyof" || constraint.typeAnnotation === void 0) {
+    return false;
+  }
+  const baseType = unwrapParenthesizedTypeNode(constraint.typeAnnotation);
+  const keyRemapType = normalizedOperand.nameType;
+  if (keyRemapType?.type !== "TSConditionalType") {
+    return false;
+  }
+  const checkedValueType = unwrapParenthesizedTypeNode(keyRemapType.checkType);
+  if (checkedValueType.type !== "TSIndexedAccessType" || !areEquivalentTypeNodes(unwrapParenthesizedTypeNode(checkedValueType.objectType), baseType) || checkedValueType.indexType.type !== "TSTypeReference" || checkedValueType.indexType.typeName.type !== "Identifier" || checkedValueType.indexType.typeName.name !== mappedKeyName) {
+    return false;
+  }
+  return keyRemapType.trueType.type === "TSTypeReference" && keyRemapType.trueType.typeName.type === "Identifier" && keyRemapType.trueType.typeName.name === mappedKeyName && keyRemapType.falseType.type === "TSNeverKeyword";
+};
+var preferTypeFestConditionalKeysRule = createTypedRule({
+  create(context) {
+    return {
+      TSTypeOperator(node) {
+        if (!hasConditionalKeysKeyRemapShape(node)) {
+          return;
+        }
+        reportWithOptionalFix({
+          context,
+          fix: null,
+          messageId: "preferConditionalKeys",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest ConditionalKeys over keyof-remapped mapped types that filter keys by value condition.",
+      frozen: false,
+      recommended: false,
+      requiresTypeChecking: false,
+      typefestConfigs: ["typefest.configs.experimental"],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-conditional-keys"
+    },
+    messages: {
+      preferConditionalKeys: "Prefer `ConditionalKeys<Base, Condition>` from type-fest over manual `keyof { [K in keyof Base as Base[K] extends Condition ? K : never]: ... }` key filters."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-conditional-keys"
+});
+var prefer_type_fest_conditional_keys_default = preferTypeFestConditionalKeysRule;
+
+// dist/rules/prefer-type-fest-conditional-pick-deep.js
+var conditionalPickDeepAliasReplacements = {
+  PickDeepByType: "ConditionalPickDeep",
+  PickDeepByTypes: "ConditionalPickDeep"
+};
+var preferTypeFestConditionalPickDeepRule = createTypedRule({
+  create(context) {
+    const importedAliasMatches = collectImportedTypeAliasMatches(context.sourceCode, conditionalPickDeepAliasReplacements);
+    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    return {
+      'TSTypeReference[typeName.type="Identifier"]'(node) {
+        if (node.typeName.type !== "Identifier") {
+          return;
+        }
+        const importedAliasMatch = importedAliasMatches.get(node.typeName.name);
+        if (!importedAliasMatch) {
+          return;
+        }
+        const aliasReplacementFix = createSafeTypeReferenceReplacementFix(node, importedAliasMatch.replacementName, typeFestDirectImports);
+        reportWithOptionalFix({
+          context,
+          data: {
+            alias: importedAliasMatch.importedName,
+            replacement: importedAliasMatch.replacementName
+          },
+          fix: aliasReplacementFix,
+          messageId: "preferConditionalPickDeep",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest ConditionalPickDeep over imported aliases such as PickDeepByTypes.",
+      frozen: false,
+      recommended: true,
+      requiresTypeChecking: false,
+      typefestConfigs: [
+        "typefest.configs.recommended",
+        "typefest.configs.strict",
+        "typefest.configs.all",
+        "typefest.configs.type-fest/types"
+      ],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-conditional-pick-deep"
+    },
+    fixable: "code",
+    messages: {
+      preferConditionalPickDeep: "Prefer `{{replacement}}` from type-fest for deep conditional property filtering instead of legacy alias `{{alias}}`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-conditional-pick-deep"
+});
+var prefer_type_fest_conditional_pick_deep_default = preferTypeFestConditionalPickDeepRule;
+
+// dist/rules/prefer-type-fest-conditional-pick.js
+var conditionalPickAliasReplacements = {
+  PickByTypes: "ConditionalPick"
+};
+var preferTypeFestConditionalPickRule = createTypedRule({
+  create(context) {
+    const importedAliasMatches = collectImportedTypeAliasMatches(context.sourceCode, conditionalPickAliasReplacements);
+    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    return {
+      'TSTypeReference[typeName.type="Identifier"]'(node) {
+        if (node.typeName.type !== "Identifier") {
+          return;
+        }
+        const importedAliasMatch = importedAliasMatches.get(node.typeName.name);
+        if (!importedAliasMatch) {
+          return;
+        }
+        const aliasReplacementFix = createSafeTypeReferenceReplacementFix(node, importedAliasMatch.replacementName, typeFestDirectImports);
+        reportWithOptionalFix({
+          context,
+          data: {
+            alias: importedAliasMatch.importedName,
+            replacement: importedAliasMatch.replacementName
+          },
+          fix: aliasReplacementFix,
+          messageId: "preferConditionalPick",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest ConditionalPick over imported aliases such as PickByTypes.",
+      frozen: false,
+      recommended: true,
+      requiresTypeChecking: false,
+      typefestConfigs: [
+        "typefest.configs.recommended",
+        "typefest.configs.strict",
+        "typefest.configs.all",
+        "typefest.configs.type-fest/types"
+      ],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-conditional-pick"
+    },
+    fixable: "code",
+    messages: {
+      preferConditionalPick: "Prefer `{{replacement}}` from type-fest to pick keys whose values match a condition instead of legacy alias `{{alias}}`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-conditional-pick"
+});
+var prefer_type_fest_conditional_pick_default = preferTypeFestConditionalPickRule;
+
+// dist/rules/prefer-type-fest-constructor.js
+var import_ts_extras33 = require("ts-extras");
+var preferTypeFestConstructorRule = createTypedRule({
+  create(context) {
+    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    const { sourceCode } = context;
+    return {
+      TSConstructorType(node) {
+        if (node.abstract) {
+          return;
+        }
+        const replacementFix = !(0, import_ts_extras33.isDefined)(node.typeParameters) && (0, import_ts_extras33.isDefined)(node.returnType) ? createSafeTypeNodeTextReplacementFix(node, "Constructor", `Constructor<${sourceCode.getText(node.returnType.typeAnnotation)}, [${(0, import_ts_extras33.arrayJoin)(node.params.map((parameter) => sourceCode.getText(parameter)), ", ")}]>`, typeFestDirectImports) : null;
+        reportWithOptionalFix({
           context,
           fix: replacementFix,
           messageId: "preferConstructorSignature",
@@ -7090,6 +7540,145 @@ var preferTypeFestConstructorRule = createTypedRule({
 });
 var prefer_type_fest_constructor_default = preferTypeFestConstructorRule;
 
+// dist/rules/prefer-type-fest-distributed-omit.js
+var isDistributiveConditionalExtendsType = (node) => {
+  const normalizedNode = unwrapParenthesizedTypeNode(node);
+  return normalizedNode.type === "TSAnyKeyword" || normalizedNode.type === "TSUnknownKeyword";
+};
+var isDistributedOmitEquivalent = (node) => {
+  if (node.falseType.type !== "TSNeverKeyword" || !isDistributiveConditionalExtendsType(node.extendsType)) {
+    return false;
+  }
+  const normalizedTrueType = unwrapParenthesizedTypeNode(node.trueType);
+  if (normalizedTrueType.type !== "TSTypeReference" || !isIdentifierTypeReference(normalizedTrueType, "Omit")) {
+    return false;
+  }
+  const typeArguments = normalizedTrueType.typeArguments?.params;
+  if (typeArguments?.length !== 2) {
+    return false;
+  }
+  const [objectType] = typeArguments;
+  return objectType !== void 0 && areEquivalentTypeNodes(unwrapParenthesizedTypeNode(objectType), unwrapParenthesizedTypeNode(node.checkType));
+};
+var preferTypeFestDistributedOmitRule = createTypedRule({
+  create(context) {
+    return {
+      TSConditionalType(node) {
+        if (!isDistributedOmitEquivalent(node)) {
+          return;
+        }
+        reportWithOptionalFix({
+          context,
+          fix: null,
+          messageId: "preferDistributedOmit",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest DistributedOmit over distributive conditional helpers of the form T extends unknown ? Omit<T, K> : never.",
+      frozen: false,
+      recommended: false,
+      requiresTypeChecking: false,
+      typefestConfigs: ["typefest.configs.experimental"],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-distributed-omit"
+    },
+    messages: {
+      preferDistributedOmit: "Prefer `DistributedOmit<ObjectType, KeyType>` from type-fest over distributive conditional helpers like `T extends unknown ? Omit<T, K> : never`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-distributed-omit"
+});
+var prefer_type_fest_distributed_omit_default = preferTypeFestDistributedOmitRule;
+
+// dist/rules/prefer-type-fest-distributed-pick.js
+var isDistributiveConditionalExtendsType2 = (node) => {
+  const normalizedNode = unwrapParenthesizedTypeNode(node);
+  return normalizedNode.type === "TSAnyKeyword" || normalizedNode.type === "TSUnknownKeyword";
+};
+var isKeyofBaseType = (node, baseType) => {
+  const normalizedNode = unwrapParenthesizedTypeNode(node);
+  if (normalizedNode.type !== "TSTypeOperator" || normalizedNode.operator !== "keyof" || normalizedNode.typeAnnotation === void 0) {
+    return false;
+  }
+  return areEquivalentTypeNodes(unwrapParenthesizedTypeNode(normalizedNode.typeAnnotation), unwrapParenthesizedTypeNode(baseType));
+};
+var isExtractOverKeyofBaseType = (node, baseType) => {
+  const normalizedNode = unwrapParenthesizedTypeNode(node);
+  if (normalizedNode.type !== "TSTypeReference" || !isIdentifierTypeReference(normalizedNode, "Extract")) {
+    return false;
+  }
+  const typeArguments = normalizedNode.typeArguments?.params;
+  if (typeArguments?.length !== 2) {
+    return false;
+  }
+  const [, extractedFromType] = typeArguments;
+  return extractedFromType !== void 0 && isKeyofBaseType(extractedFromType, baseType);
+};
+var isDistributedPickEquivalent = (node) => {
+  if (node.falseType.type !== "TSNeverKeyword" || !isDistributiveConditionalExtendsType2(node.extendsType)) {
+    return false;
+  }
+  const normalizedTrueType = unwrapParenthesizedTypeNode(node.trueType);
+  if (normalizedTrueType.type !== "TSTypeReference" || !isIdentifierTypeReference(normalizedTrueType, "Pick")) {
+    return false;
+  }
+  const typeArguments = normalizedTrueType.typeArguments?.params;
+  if (typeArguments?.length !== 2) {
+    return false;
+  }
+  const [objectType, selectedKeysType] = typeArguments;
+  if (objectType === void 0 || selectedKeysType === void 0) {
+    return false;
+  }
+  if (!areEquivalentTypeNodes(unwrapParenthesizedTypeNode(objectType), unwrapParenthesizedTypeNode(node.checkType))) {
+    return false;
+  }
+  return !isIdentifierTypeReference(unwrapParenthesizedTypeNode(selectedKeysType), "Extract") || isExtractOverKeyofBaseType(selectedKeysType, node.checkType);
+};
+var preferTypeFestDistributedPickRule = createTypedRule({
+  create(context) {
+    return {
+      TSConditionalType(node) {
+        if (!isDistributedPickEquivalent(node)) {
+          return;
+        }
+        reportWithOptionalFix({
+          context,
+          fix: null,
+          messageId: "preferDistributedPick",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest DistributedPick over distributive conditional helpers of the form T extends unknown ? Pick<T, K> : never.",
+      frozen: false,
+      recommended: false,
+      requiresTypeChecking: false,
+      typefestConfigs: ["typefest.configs.experimental"],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-distributed-pick"
+    },
+    messages: {
+      preferDistributedPick: "Prefer `DistributedPick<ObjectType, KeyType>` from type-fest over distributive conditional helpers like `T extends unknown ? Pick<T, K> : never`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-distributed-pick"
+});
+var prefer_type_fest_distributed_pick_default = preferTypeFestDistributedPickRule;
+
 // dist/rules/prefer-type-fest-except.js
 var OMIT_TYPE_NAME = "Omit";
 var exceptAliasReplacements = {
@@ -8073,6 +8662,76 @@ var preferTypeFestMergeExclusiveRule = createTypedRule({
 });
 var prefer_type_fest_merge_exclusive_default = preferTypeFestMergeExclusiveRule;
 
+// dist/rules/prefer-type-fest-merge.js
+var isMergeIntersectionExceptReference = (node, siblingType, exceptLocalNames) => {
+  if (node.typeName.type !== "Identifier" || !setContainsValue(exceptLocalNames, node.typeName.name)) {
+    return false;
+  }
+  const typeArguments = node.typeArguments?.params;
+  if (typeArguments?.length !== 2) {
+    return false;
+  }
+  const [, omittedKeysType] = typeArguments;
+  if (omittedKeysType === void 0) {
+    return false;
+  }
+  const normalizedOmittedKeysType = unwrapParenthesizedTypeNode(omittedKeysType);
+  if (normalizedOmittedKeysType.type !== "TSTypeOperator" || normalizedOmittedKeysType.operator !== "keyof") {
+    return false;
+  }
+  const keyedSourceType = normalizedOmittedKeysType.typeAnnotation;
+  if (keyedSourceType === void 0) {
+    return false;
+  }
+  return areEquivalentTypeNodes(unwrapParenthesizedTypeNode(siblingType), keyedSourceType);
+};
+var preferTypeFestMergeRule = createTypedRule({
+  create(context) {
+    const exceptLocalNames = collectNamedImportLocalNamesFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE, "Except");
+    return {
+      'TSIntersectionType > TSTypeReference[typeName.type="Identifier"]'(node) {
+        const intersectionNode = node.parent;
+        if (intersectionNode?.type !== "TSIntersectionType" || intersectionNode.types.length !== 2) {
+          return;
+        }
+        const [leftType, rightType] = intersectionNode.types;
+        if (leftType === void 0 || rightType === void 0) {
+          return;
+        }
+        const siblingType = leftType === node ? rightType : leftType;
+        if (!isMergeIntersectionExceptReference(node, siblingType, exceptLocalNames)) {
+          return;
+        }
+        reportWithOptionalFix({
+          context,
+          fix: null,
+          messageId: "preferMerge",
+          node: intersectionNode
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest Merge over Except<Destination, keyof Source> & Source intersections.",
+      frozen: false,
+      recommended: false,
+      requiresTypeChecking: false,
+      typefestConfigs: ["typefest.configs.experimental"],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-merge"
+    },
+    messages: {
+      preferMerge: "Prefer `Merge<Destination, Source>` from type-fest over `Except<Destination, keyof Source> & Source` when the second object cleanly overrides the first."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-merge"
+});
+var prefer_type_fest_merge_default = preferTypeFestMergeRule;
+
 // dist/rules/prefer-type-fest-non-empty-tuple.js
 var getRequiredTupleElementType = (element) => {
   if (element.type === "TSNamedTupleMember") {
@@ -8460,6 +9119,83 @@ var preferTypeFestPartialDeepRule = createTypedRule({
 });
 var prefer_type_fest_partial_deep_default = preferTypeFestPartialDeepRule;
 
+// dist/rules/prefer-type-fest-pick-index-signature.js
+var import_ts_extras37 = require("ts-extras");
+var isEmptyObjectTypeLiteral = (node) => node.type === "TSTypeLiteral" && node.members.length === 0;
+var hasPickIndexSignatureMappedTypeShape = (node) => {
+  if (node.key.type !== "Identifier") {
+    return false;
+  }
+  if (node.readonly !== false && (0, import_ts_extras37.isDefined)(node.readonly)) {
+    return false;
+  }
+  if (node.optional !== false && (0, import_ts_extras37.isDefined)(node.optional)) {
+    return false;
+  }
+  const constraint = node.constraint;
+  if (constraint?.type !== "TSTypeOperator" || constraint.operator !== "keyof" || constraint.typeAnnotation === void 0) {
+    return false;
+  }
+  const baseType = unwrapParenthesizedTypeNode(constraint.typeAnnotation);
+  const indexedValueType = node.typeAnnotation;
+  if (indexedValueType?.type !== "TSIndexedAccessType" || !areEquivalentTypeNodes(unwrapParenthesizedTypeNode(indexedValueType.objectType), baseType) || indexedValueType.indexType.type !== "TSTypeReference" || indexedValueType.indexType.typeName.type !== "Identifier" || indexedValueType.indexType.typeName.name !== node.key.name) {
+    return false;
+  }
+  const keyRemapType = node.nameType;
+  if (keyRemapType?.type !== "TSConditionalType") {
+    return false;
+  }
+  if (!isEmptyObjectTypeLiteral(unwrapParenthesizedTypeNode(keyRemapType.checkType)) || keyRemapType.falseType.type !== "TSNeverKeyword" || keyRemapType.trueType.type !== "TSTypeReference" || keyRemapType.trueType.typeName.type !== "Identifier" || keyRemapType.trueType.typeName.name !== node.key.name) {
+    return false;
+  }
+  const normalizedExtendsType = unwrapParenthesizedTypeNode(keyRemapType.extendsType);
+  if (normalizedExtendsType.type !== "TSTypeReference" || !isIdentifierTypeReference(normalizedExtendsType, "Record")) {
+    return false;
+  }
+  const recordTypeArguments = normalizedExtendsType.typeArguments?.params;
+  if (recordTypeArguments?.length !== 2) {
+    return false;
+  }
+  const [recordKeyType, recordValueType] = recordTypeArguments;
+  return recordKeyType !== void 0 && recordValueType?.type === "TSUnknownKeyword" && recordKeyType.type === "TSTypeReference" && recordKeyType.typeName.type === "Identifier" && recordKeyType.typeName.name === node.key.name;
+};
+var preferTypeFestPickIndexSignatureRule = createTypedRule({
+  create(context) {
+    return {
+      TSMappedType(node) {
+        if (!hasPickIndexSignatureMappedTypeShape(node)) {
+          return;
+        }
+        reportWithOptionalFix({
+          context,
+          fix: null,
+          messageId: "preferPickIndexSignature",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest PickIndexSignature over manual mapped types that keep only index signatures.",
+      frozen: false,
+      recommended: false,
+      requiresTypeChecking: false,
+      typefestConfigs: ["typefest.configs.experimental"],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-pick-index-signature"
+    },
+    messages: {
+      preferPickIndexSignature: "Prefer `PickIndexSignature<ObjectType>` from type-fest over manual mapped types that keep only index signatures."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-pick-index-signature"
+});
+var prefer_type_fest_pick_index_signature_default = preferTypeFestPickIndexSignatureRule;
+
 // dist/rules/prefer-type-fest-primitive.js
 var import_utils2 = require("@typescript-eslint/utils");
 var primitiveKeywordTypes = [
@@ -8533,7 +9269,7 @@ var preferTypeFestPrimitiveRule = createTypedRule({
 var prefer_type_fest_primitive_default = preferTypeFestPrimitiveRule;
 
 // dist/rules/prefer-type-fest-promisable.js
-var import_ts_extras37 = require("ts-extras");
+var import_ts_extras38 = require("ts-extras");
 var PROMISABLE_TYPE_NAME = "Promisable";
 var PROMISE_TYPE_NAME = "Promise";
 var promisableAliasReplacements = {
@@ -8549,10 +9285,10 @@ var getPromiseInnerType = (node) => {
     return null;
   }
   const typeArguments = node.typeArguments?.params;
-  if (!(0, import_ts_extras37.isDefined)(typeArguments)) {
+  if (!(0, import_ts_extras38.isDefined)(typeArguments)) {
     return null;
   }
-  return (0, import_ts_extras37.arrayFirst)(typeArguments) ?? null;
+  return (0, import_ts_extras38.arrayFirst)(typeArguments) ?? null;
 };
 var preferTypeFestPromisableRule = createTypedRule({
   create(context, [options] = defaultOptions3) {
@@ -9314,6 +10050,49 @@ var preferTypeFestSetRequiredRule = createTypedRule({
 });
 var prefer_type_fest_set_required_default = preferTypeFestSetRequiredRule;
 
+// dist/rules/prefer-type-fest-set-return-type.js
+var preferTypeFestSetReturnTypeRule = createTypedRule({
+  create(context) {
+    return {
+      TSFunctionType(node) {
+        const functionType = getParametersFunctionArgumentFromFunctionType(node);
+        const returnType = node.returnType?.typeAnnotation;
+        if (functionType === null || returnType === void 0) {
+          return;
+        }
+        if (isReturnTypeReferenceForFunction(returnType, functionType) || isPromiseAwaitedReturnTypeReferenceForFunction(returnType, functionType)) {
+          return;
+        }
+        reportWithOptionalFix({
+          context,
+          fix: null,
+          messageId: "preferSetReturnType",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest SetReturnType over direct function-type wrappers of the form (...args: Parameters<F>) => R.",
+      frozen: false,
+      recommended: false,
+      requiresTypeChecking: false,
+      typefestConfigs: ["typefest.configs.experimental"],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-set-return-type"
+    },
+    messages: {
+      preferSetReturnType: "Prefer `SetReturnType<Function, TypeToReturn>` from type-fest over direct function-type wrappers like `(...args: Parameters<Function>) => TypeToReturn`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-set-return-type"
+});
+var prefer_type_fest_set_return_type_default = preferTypeFestSetReturnTypeRule;
+
 // dist/rules/prefer-type-fest-simplify.js
 var simplifyAliasReplacements = {
   Expand: "Simplify",
@@ -9373,6 +10152,67 @@ var preferTypeFestSimplifyRule = createTypedRule({
 });
 var prefer_type_fest_simplify_default = preferTypeFestSimplifyRule;
 
+// dist/rules/prefer-type-fest-stringified.js
+var import_ts_extras39 = require("ts-extras");
+var hasStringifiedMappedTypeShape = (node) => {
+  if (node.readonly !== false && (0, import_ts_extras39.isDefined)(node.readonly)) {
+    return false;
+  }
+  if (node.optional !== false && (0, import_ts_extras39.isDefined)(node.optional)) {
+    return false;
+  }
+  if (node.nameType !== null) {
+    return false;
+  }
+  if (node.key.type !== "Identifier") {
+    return false;
+  }
+  const { constraint } = node;
+  if (constraint?.type !== "TSTypeOperator") {
+    return false;
+  }
+  if (constraint.operator !== "keyof") {
+    return false;
+  }
+  return node.typeAnnotation?.type === "TSStringKeyword";
+};
+var preferTypeFestStringifiedRule = createTypedRule({
+  create(context) {
+    return {
+      TSMappedType(node) {
+        if (!hasStringifiedMappedTypeShape(node)) {
+          return;
+        }
+        reportWithOptionalFix({
+          context,
+          fix: null,
+          messageId: "preferStringified",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest Stringified over manual mapped types of the form { [K in keyof T]: string }.",
+      frozen: false,
+      recommended: false,
+      requiresTypeChecking: false,
+      typefestConfigs: ["typefest.configs.experimental"],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-stringified"
+    },
+    messages: {
+      preferStringified: "Prefer `Stringified<T>` from type-fest over manual mapped types of the form `{ [K in keyof T]: string }`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-stringified"
+});
+var prefer_type_fest_stringified_default = preferTypeFestStringifiedRule;
+
 // dist/rules/prefer-type-fest-tagged-brands.js
 var BRAND_PROPERTY_NAMES = /* @__PURE__ */ new Set([
   "__brand",
@@ -9614,7 +10454,7 @@ var preferTypeFestTupleOfRule = createTypedRule({
 var prefer_type_fest_tuple_of_default = preferTypeFestTupleOfRule;
 
 // dist/rules/prefer-type-fest-union-member.js
-var import_ts_extras38 = require("ts-extras");
+var import_ts_extras40 = require("ts-extras");
 var UNION_MEMBER_TYPE_NAME = "UnionMember";
 var UNION_TO_INTERSECTION_TYPE_NAME = "UnionToIntersection";
 var IS_NEVER_TYPE_NAME = "IsNever";
@@ -9645,7 +10485,7 @@ var getUnionArgumentTextFromExtractor = ({ node, sourceCode }) => {
   if (!isIdentifierTypeReferenceNamed(node.checkType, UNION_TO_INTERSECTION_TYPE_NAME)) {
     return null;
   }
-  const extractorArgument = (0, import_ts_extras38.arrayFirst)(node.checkType.typeArguments?.params ?? []);
+  const extractorArgument = (0, import_ts_extras40.arrayFirst)(node.checkType.typeArguments?.params ?? []);
   if (!extractorArgument) {
     return null;
   }
@@ -9680,7 +10520,7 @@ var getUnionMemberEquivalentArgumentText = ({ node, sourceCode }) => {
   if (!isIdentifierTypeReferenceNamed(node.checkType, IS_NEVER_TYPE_NAME) || !isBooleanLiteralType(node.extendsType, true) || node.trueType.type !== "TSNeverKeyword") {
     return null;
   }
-  const guardedArgument = (0, import_ts_extras38.arrayFirst)(node.checkType.typeArguments?.params ?? []);
+  const guardedArgument = (0, import_ts_extras40.arrayFirst)(node.checkType.typeArguments?.params ?? []);
   if (!guardedArgument) {
     return null;
   }
@@ -9743,6 +10583,102 @@ var preferTypeFestUnionMemberRule = createTypedRule({
 });
 var prefer_type_fest_union_member_default = preferTypeFestUnionMemberRule;
 
+// dist/rules/prefer-type-fest-union-to-intersection.js
+var isDistributiveConditionalExtendsType3 = (node) => {
+  const normalizedNode = unwrapParenthesizedTypeNode(node);
+  return normalizedNode.type === "TSAnyKeyword" || normalizedNode.type === "TSUnknownKeyword";
+};
+var getSingleFunctionParameterType = (node) => {
+  if (node.params.length !== 1) {
+    return null;
+  }
+  const [onlyParameter] = node.params;
+  if (onlyParameter?.type !== "Identifier" || onlyParameter.typeAnnotation === void 0) {
+    return null;
+  }
+  return unwrapParenthesizedTypeNode(onlyParameter.typeAnnotation.typeAnnotation);
+};
+var matchesUnionToIntersectionTrueType = (node, inferredTypeParameterName, unionType) => {
+  const normalizedNode = unwrapParenthesizedTypeNode(node);
+  if (normalizedNode.type === "TSTypeReference" && normalizedNode.typeName.type === "Identifier" && normalizedNode.typeName.name === inferredTypeParameterName) {
+    return true;
+  }
+  if (normalizedNode.type !== "TSIntersectionType" || normalizedNode.types.length !== 2) {
+    return false;
+  }
+  const [leftType, rightType] = normalizedNode.types;
+  if (leftType === void 0 || rightType === void 0) {
+    return false;
+  }
+  const isInferredIdentifier = (typeNode) => typeNode.type === "TSTypeReference" && typeNode.typeName.type === "Identifier" && typeNode.typeName.name === inferredTypeParameterName;
+  return isInferredIdentifier(leftType) && areEquivalentTypeNodes(unwrapParenthesizedTypeNode(rightType), unwrapParenthesizedTypeNode(unionType)) || isInferredIdentifier(rightType) && areEquivalentTypeNodes(unwrapParenthesizedTypeNode(leftType), unwrapParenthesizedTypeNode(unionType));
+};
+var isUnionToIntersectionEquivalent = (node) => {
+  if (node.falseType.type !== "TSNeverKeyword") {
+    return false;
+  }
+  const distributedWrapper = unwrapParenthesizedTypeNode(node.checkType);
+  if (distributedWrapper.type !== "TSConditionalType") {
+    return false;
+  }
+  if (distributedWrapper.falseType.type !== "TSNeverKeyword" || !isDistributiveConditionalExtendsType3(distributedWrapper.extendsType)) {
+    return false;
+  }
+  const distributedTrueType = unwrapParenthesizedTypeNode(distributedWrapper.trueType);
+  if (distributedTrueType.type !== "TSFunctionType") {
+    return false;
+  }
+  const distributedParameterType = getSingleFunctionParameterType(distributedTrueType);
+  if (distributedParameterType === null || !areEquivalentTypeNodes(distributedParameterType, unwrapParenthesizedTypeNode(distributedWrapper.checkType))) {
+    return false;
+  }
+  const extractorFunctionType = unwrapParenthesizedTypeNode(node.extendsType);
+  if (extractorFunctionType.type !== "TSFunctionType") {
+    return false;
+  }
+  const extractorParameterType = getSingleFunctionParameterType(extractorFunctionType);
+  if (extractorParameterType?.type !== "TSInferType") {
+    return false;
+  }
+  return matchesUnionToIntersectionTrueType(node.trueType, extractorParameterType.typeParameter.name.name, distributedWrapper.checkType);
+};
+var preferTypeFestUnionToIntersectionRule = createTypedRule({
+  create(context) {
+    return {
+      TSConditionalType(node) {
+        if (!isUnionToIntersectionEquivalent(node)) {
+          return;
+        }
+        reportWithOptionalFix({
+          context,
+          fix: null,
+          messageId: "preferUnionToIntersection",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest UnionToIntersection over custom distributive conditional helpers that turn unions into intersections.",
+      frozen: false,
+      recommended: false,
+      requiresTypeChecking: false,
+      typefestConfigs: ["typefest.configs.experimental"],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-union-to-intersection"
+    },
+    messages: {
+      preferUnionToIntersection: "Prefer `UnionToIntersection<Union>` from type-fest over custom distributive conditional helpers that convert a union into an intersection."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-union-to-intersection"
+});
+var prefer_type_fest_union_to_intersection_default = preferTypeFestUnionToIntersectionRule;
+
 // dist/rules/prefer-type-fest-union-to-tuple.js
 var unionToTupleAliasReplacements = {
   TupleFromUnion: "UnionToTuple",
@@ -10350,6 +11286,7 @@ var typefestRuleRegistry = {
   "prefer-ts-extras-object-has-in": prefer_ts_extras_object_has_in_default,
   "prefer-ts-extras-object-has-own": prefer_ts_extras_object_has_own_default,
   "prefer-ts-extras-object-keys": prefer_ts_extras_object_keys_default,
+  "prefer-ts-extras-object-map-values": prefer_ts_extras_object_map_values_default,
   "prefer-ts-extras-object-values": prefer_ts_extras_object_values_default,
   "prefer-ts-extras-safe-cast-to": prefer_ts_extras_safe_cast_to_default,
   "prefer-ts-extras-set-has": prefer_ts_extras_set_has_default,
@@ -10359,9 +11296,14 @@ var typefestRuleRegistry = {
   "prefer-type-fest-array-length": prefer_type_fest_array_length_default,
   "prefer-type-fest-arrayable": prefer_type_fest_arrayable_default,
   "prefer-type-fest-async-return-type": prefer_type_fest_async_return_type_default,
+  "prefer-type-fest-asyncify": prefer_type_fest_asyncify_default,
+  "prefer-type-fest-conditional-except": prefer_type_fest_conditional_except_default,
+  "prefer-type-fest-conditional-keys": prefer_type_fest_conditional_keys_default,
   "prefer-type-fest-conditional-pick": prefer_type_fest_conditional_pick_default,
   "prefer-type-fest-conditional-pick-deep": prefer_type_fest_conditional_pick_deep_default,
   "prefer-type-fest-constructor": prefer_type_fest_constructor_default,
+  "prefer-type-fest-distributed-omit": prefer_type_fest_distributed_omit_default,
+  "prefer-type-fest-distributed-pick": prefer_type_fest_distributed_pick_default,
   "prefer-type-fest-except": prefer_type_fest_except_default,
   "prefer-type-fest-if": prefer_type_fest_if_default,
   "prefer-type-fest-iterable-element": prefer_type_fest_iterable_element_default,
@@ -10373,12 +11315,14 @@ var typefestRuleRegistry = {
   "prefer-type-fest-less-than": prefer_type_fest_less_than_default,
   "prefer-type-fest-less-than-or-equal": prefer_type_fest_less_than_or_equal_default,
   "prefer-type-fest-literal-union": prefer_type_fest_literal_union_default,
+  "prefer-type-fest-merge": prefer_type_fest_merge_default,
   "prefer-type-fest-merge-exclusive": prefer_type_fest_merge_exclusive_default,
   "prefer-type-fest-non-empty-tuple": prefer_type_fest_non_empty_tuple_default,
   "prefer-type-fest-omit-index-signature": prefer_type_fest_omit_index_signature_default,
   "prefer-type-fest-optional": prefer_type_fest_optional_default,
   "prefer-type-fest-or-all": prefer_type_fest_or_all_default,
   "prefer-type-fest-partial-deep": prefer_type_fest_partial_deep_default,
+  "prefer-type-fest-pick-index-signature": prefer_type_fest_pick_index_signature_default,
   "prefer-type-fest-primitive": prefer_type_fest_primitive_default,
   "prefer-type-fest-promisable": prefer_type_fest_promisable_default,
   "prefer-type-fest-readonly-deep": prefer_type_fest_readonly_deep_default,
@@ -10392,10 +11336,13 @@ var typefestRuleRegistry = {
   "prefer-type-fest-set-optional": prefer_type_fest_set_optional_default,
   "prefer-type-fest-set-readonly": prefer_type_fest_set_readonly_default,
   "prefer-type-fest-set-required": prefer_type_fest_set_required_default,
+  "prefer-type-fest-set-return-type": prefer_type_fest_set_return_type_default,
   "prefer-type-fest-simplify": prefer_type_fest_simplify_default,
+  "prefer-type-fest-stringified": prefer_type_fest_stringified_default,
   "prefer-type-fest-tagged-brands": prefer_type_fest_tagged_brands_default,
   "prefer-type-fest-tuple-of": prefer_type_fest_tuple_of_default,
   "prefer-type-fest-union-member": prefer_type_fest_union_member_default,
+  "prefer-type-fest-union-to-intersection": prefer_type_fest_union_to_intersection_default,
   "prefer-type-fest-union-to-tuple": prefer_type_fest_union_to_tuple_default,
   "prefer-type-fest-unknown-array": prefer_type_fest_unknown_array_default,
   "prefer-type-fest-unknown-map": prefer_type_fest_unknown_map_default,
@@ -10418,7 +11365,7 @@ function getPackageVersion(pkg) {
   const version = Reflect.get(pkg, "version");
   return typeof version === "string" ? version : "0.0.0";
 }
-var packageJsonValue = (0, import_ts_extras39.safeCastTo)(package_default);
+var packageJsonValue = (0, import_ts_extras41.safeCastTo)(package_default);
 var typeScriptParserValue = import_parser3.default;
 var defaultParserOptions = {
   ecmaVersion: "latest",
@@ -10426,10 +11373,10 @@ var defaultParserOptions = {
 };
 var normalizeParserOptions = (parserOptions) => parserOptions !== null && typeof parserOptions === "object" && !Array.isArray(parserOptions) ? { ...parserOptions } : { ...defaultParserOptions };
 var typefestEslintRules = typefestRules;
-var isTypefestRuleName = (value) => (0, import_ts_extras39.objectHasIn)(typefestRules, value);
+var isTypefestRuleName = (value) => (0, import_ts_extras41.objectHasIn)(typefestRules, value);
 var typefestRuleEntries = (() => {
   const entries = [];
-  for (const [ruleName] of (0, import_ts_extras39.objectEntries)(typefestRules)) {
+  for (const [ruleName] of (0, import_ts_extras41.objectEntries)(typefestRules)) {
     if (!isTypefestRuleName(ruleName)) {
       continue;
     }
@@ -10456,7 +11403,7 @@ var derivePresetRuleNamesByConfig = () => {
   const presetRuleNamesByConfig2 = createEmptyPresetRuleMap();
   for (const [ruleName] of typefestRuleEntries) {
     const configNames = rulePresetMembership[ruleName];
-    if (!(0, import_ts_extras39.isDefined)(configNames) || (0, import_ts_extras39.isEmpty)(configNames)) {
+    if (!(0, import_ts_extras41.isDefined)(configNames) || (0, import_ts_extras41.isEmpty)(configNames)) {
       throw new TypeError(`Rule '${ruleName}' is missing preset membership metadata.`);
     }
     for (const configName of configNames) {
@@ -10465,6 +11412,7 @@ var derivePresetRuleNamesByConfig = () => {
   }
   return {
     all: dedupeRuleNames(presetRuleNamesByConfig2.all),
+    experimental: dedupeRuleNames(presetRuleNamesByConfig2.experimental),
     minimal: dedupeRuleNames(presetRuleNamesByConfig2.minimal),
     recommended: dedupeRuleNames(presetRuleNamesByConfig2.recommended),
     "recommended-type-checked": dedupeRuleNames(presetRuleNamesByConfig2["recommended-type-checked"]),
@@ -10483,7 +11431,7 @@ function errorRulesFor(ruleNames) {
 var presetRuleNamesByConfig = derivePresetRuleNamesByConfig();
 var recommendedRuleNames = [];
 for (const ruleName of presetRuleNamesByConfig.recommended) {
-  if ((0, import_ts_extras39.setHas)(typeCheckedRuleNames, ruleName)) {
+  if ((0, import_ts_extras41.setHas)(typeCheckedRuleNames, ruleName)) {
     continue;
   }
   recommendedRuleNames.push(ruleName);
@@ -10494,6 +11442,10 @@ var recommendedTypeCheckedRuleNames = dedupeRuleNames([
 ]);
 var effectivePresetRuleNamesByConfig = {
   ...presetRuleNamesByConfig,
+  experimental: dedupeRuleNames([
+    ...presetRuleNamesByConfig.all,
+    ...presetRuleNamesByConfig.experimental
+  ]),
   recommended: recommendedRuleNames,
   "recommended-type-checked": recommendedTypeCheckedRuleNames
 };
@@ -10501,7 +11453,7 @@ function withTypefestPlugin(config, plugin, options) {
   const existingLanguageOptions = config.languageOptions ?? {};
   const existingParserOptions = existingLanguageOptions["parserOptions"];
   const parserOptions = normalizeParserOptions(existingParserOptions);
-  if (options.requiresTypeChecking && !(0, import_ts_extras39.objectHasIn)(parserOptions, "projectService")) {
+  if (options.requiresTypeChecking && !(0, import_ts_extras41.objectHasIn)(parserOptions, "projectService")) {
     Reflect.set(parserOptions, "projectService", true);
   }
   const languageOptions = {