eslint-plugin-valibot 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2588 @@
+// package.json
+var package_default = {
+  name: "eslint-plugin-valibot",
+  version: "0.1.0",
+  description: "ESLint rules for safer, more maintainable Valibot usage.",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/nimaebra/eslint-plugin-valibot.git"
+  },
+  homepage: "https://github.com/nimaebra/eslint-plugin-valibot#readme",
+  bugs: {
+    url: "https://github.com/nimaebra/eslint-plugin-valibot/issues"
+  },
+  type: "module",
+  sideEffects: false,
+  main: "./dist/index.cjs",
+  module: "./dist/index.mjs",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  files: [
+    "dist"
+  ],
+  keywords: [
+    "eslint",
+    "eslint-plugin",
+    "eslintplugin",
+    "valibot",
+    "schema",
+    "validation",
+    "typescript"
+  ],
+  engines: {
+    node: "^20.19.0 || ^22.13.0 || >=24.0.0"
+  },
+  packageManager: "pnpm@10.33.4",
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsup --config tsup.config.ts",
+    changeset: "changeset",
+    clean: "rimraf dist coverage",
+    "configs:check": "tsx scripts/check-configs.ts",
+    "create:rule": "tsx scripts/generate-rule.ts",
+    "docs:build": "eslint-doc-generator . && tsx scripts/build-configs-doc.ts",
+    "docs:check": "eslint-doc-generator --check . && tsx scripts/check-docs.ts",
+    format: "prettier . --write",
+    "format:check": "prettier . --check",
+    lint: "eslint .",
+    "lint:fix": "eslint . --fix",
+    knip: "knip",
+    "pack:dry-run": "pnpm pack --dry-run",
+    prepublishOnly: "pnpm check",
+    "release:publish": "changeset publish",
+    "smoke:pack": "tsx scripts/smoke-pack.ts",
+    typecheck: "tsc -p tsconfig.json --noEmit",
+    test: "vitest run tests/rules tests/configs",
+    "test:integration": "vitest run tests/integration",
+    "test:watch": "vitest",
+    check: "pnpm lint && pnpm typecheck && pnpm knip && pnpm test && pnpm build && pnpm test:integration && pnpm docs:check && pnpm configs:check",
+    "version-packages": "changeset version"
+  },
+  peerDependencies: {
+    eslint: "^9.0.0 || ^10.0.0",
+    valibot: "^1.0.0"
+  },
+  devDependencies: {
+    "@changesets/cli": "^2.31.0",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^24.12.0",
+    "@typescript-eslint/utils": "^8.59.4",
+    eslint: "^10.4.0",
+    "eslint-doc-generator": "^3.6.0",
+    globals: "^17.6.0",
+    knip: "^6.14.1",
+    prettier: "^3.8.3",
+    rimraf: "^6.1.3",
+    tsup: "^8.5.1",
+    tsx: "^4.22.3",
+    typescript: "^6.0.3",
+    "typescript-eslint": "^8.59.4",
+    vite: "^7.2.4",
+    vitest: "^4.1.7"
+  }
+};
+
+// src/utils/create-rule.ts
+import { ESLintUtils } from "@typescript-eslint/utils";
+var DOCS_BASE_URL = "https://github.com/nimaebrazeh/eslint-plugin-valibot/blob/main/docs/rules";
+var createRule = ESLintUtils.RuleCreator(
+  (ruleName) => `${DOCS_BASE_URL}/${ruleName}.md`
+);
+
+// src/rules/consistent-import.ts
+var STYLES = ["namespace", "named"];
+var consistentImport = createRule({
+  name: "consistent-import",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce a consistent Valibot import style using either namespace or named imports."
+    },
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          namespaceAlias: {
+            type: "string",
+            minLength: 1
+          },
+          style: {
+            type: "string",
+            enum: [...STYLES]
+          }
+        }
+      }
+    ],
+    messages: {
+      namespaceAlias: "Use '{{expectedAlias}}' as the namespace alias for Valibot imports.",
+      preferNamed: "Use named Valibot imports like `import { object, string } from 'valibot'`.",
+      preferNamespace: "Use a namespace Valibot import like `import * as {{namespaceAlias}} from 'valibot'`."
+    }
+  },
+  defaultOptions: [
+    {
+      namespaceAlias: "v",
+      style: "namespace"
+    }
+  ],
+  create(context, [options]) {
+    const resolvedOptions = resolveOptions(options);
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value !== "valibot") {
+          return;
+        }
+        if (resolvedOptions.style === "namespace") {
+          verifyNamespaceImport(context, node, resolvedOptions);
+          return;
+        }
+        verifyNamedImport(context, node);
+      }
+    };
+  }
+});
+function resolveOptions(options) {
+  return {
+    namespaceAlias: options?.namespaceAlias ?? "v",
+    style: options?.style ?? "namespace"
+  };
+}
+function verifyNamespaceImport(context, node, options) {
+  const namespaceSpecifier = node.specifiers.find(
+    (specifier) => specifier.type === "ImportNamespaceSpecifier"
+  );
+  const hasOnlyNamespaceSpecifier = node.specifiers.length === 1 && Boolean(namespaceSpecifier);
+  if (!namespaceSpecifier || !hasOnlyNamespaceSpecifier) {
+    context.report({
+      node,
+      messageId: "preferNamespace",
+      data: {
+        namespaceAlias: options.namespaceAlias
+      }
+    });
+    return;
+  }
+  if (namespaceSpecifier.local.name !== options.namespaceAlias) {
+    context.report({
+      node: namespaceSpecifier.local,
+      messageId: "namespaceAlias",
+      data: {
+        expectedAlias: options.namespaceAlias
+      }
+    });
+  }
+}
+function verifyNamedImport(context, node) {
+  const hasNamespaceSpecifier = node.specifiers.some(
+    (specifier) => specifier.type === "ImportNamespaceSpecifier"
+  );
+  const hasDefaultSpecifier = node.specifiers.some(
+    (specifier) => specifier.type === "ImportDefaultSpecifier"
+  );
+  const hasNamedSpecifiers = node.specifiers.some(
+    (specifier) => specifier.type === "ImportSpecifier"
+  );
+  if (!hasNamedSpecifiers || hasNamespaceSpecifier || hasDefaultSpecifier) {
+    context.report({
+      node,
+      messageId: "preferNamed"
+    });
+  }
+}
+
+// src/utils/collect-valibot-imports.ts
+var VALIBOT_MODULE_NAME = "valibot";
+function createEmptyValibotImports() {
+  return {
+    namespaces: /* @__PURE__ */ new Set(),
+    importedNames: /* @__PURE__ */ new Map()
+  };
+}
+function hasValibotImports(imports) {
+  return imports.namespaces.size > 0 || imports.importedNames.size > 0;
+}
+function collectValibotImports(program) {
+  const imports = createEmptyValibotImports();
+  for (const statement of program.body) {
+    if (statement.type === "ImportDeclaration" && statement.source.value === VALIBOT_MODULE_NAME) {
+      for (const specifier of statement.specifiers) {
+        if (specifier.type === "ImportNamespaceSpecifier") {
+          imports.namespaces.add(specifier.local.name);
+          continue;
+        }
+        if (specifier.type === "ImportSpecifier") {
+          const importedName = specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value);
+          imports.importedNames.set(specifier.local.name, importedName);
+        }
+      }
+      continue;
+    }
+    if (statement.type !== "VariableDeclaration") {
+      continue;
+    }
+    for (const declaration of statement.declarations) {
+      if (!declaration.init || declaration.init.type !== "CallExpression") {
+        continue;
+      }
+      if (!isRequireFromValibot(declaration.init)) {
+        continue;
+      }
+      if (declaration.id.type === "Identifier") {
+        imports.namespaces.add(declaration.id.name);
+        continue;
+      }
+      if (declaration.id.type !== "ObjectPattern") {
+        continue;
+      }
+      for (const property of declaration.id.properties) {
+        if (property.type !== "Property") {
+          continue;
+        }
+        if (property.key.type !== "Identifier") {
+          continue;
+        }
+        if (property.value.type !== "Identifier") {
+          continue;
+        }
+        imports.importedNames.set(property.value.name, property.key.name);
+      }
+    }
+  }
+  return imports;
+}
+function isRequireFromValibot(node) {
+  return node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0]?.type === "Literal" && node.arguments[0].value === VALIBOT_MODULE_NAME;
+}
+
+// src/utils/is-valibot-call.ts
+function getValibotCallName(node, imports) {
+  if (node.callee.type === "Identifier") {
+    return imports.importedNames.get(node.callee.name) ?? null;
+  }
+  if (node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.object.type === "Identifier" && node.callee.property.type === "Identifier" && imports.namespaces.has(node.callee.object.name)) {
+    return node.callee.property.name;
+  }
+  return null;
+}
+function isValibotCall(node, imports, functionName) {
+  return getValibotCallName(node, imports) === functionName;
+}
+
+// src/utils/is-schema-expression.ts
+var SCHEMA_CALL_NAMES = /* @__PURE__ */ new Set([
+  "any",
+  "array",
+  "bigint",
+  "blob",
+  "boolean",
+  "custom",
+  "date",
+  "enum",
+  "exactOptional",
+  "fallback",
+  "file",
+  "function",
+  "instance",
+  "intersect",
+  "lazy",
+  "literal",
+  "looseObject",
+  "looseTuple",
+  "map",
+  "message",
+  "nan",
+  "never",
+  "nonNullable",
+  "nonNullish",
+  "nonOptional",
+  "null",
+  "nullable",
+  "nullish",
+  "number",
+  "object",
+  "objectWithRest",
+  "omit",
+  "optional",
+  "partial",
+  "pick",
+  "picklist",
+  "pipe",
+  "promise",
+  "readonly",
+  "record",
+  "required",
+  "set",
+  "strictObject",
+  "strictTuple",
+  "string",
+  "symbol",
+  "tuple",
+  "tupleWithRest",
+  "undefined",
+  "undefinedable",
+  "union",
+  "unknown",
+  "unwrap",
+  "variant",
+  "void"
+]);
+function isValibotSchemaExpression(node, imports) {
+  return node?.type === "CallExpression" && isValibotSchemaCall(node, imports);
+}
+function isValibotSchemaCall(node, imports) {
+  const callName = getValibotCallName(node, imports);
+  return callName !== null && SCHEMA_CALL_NAMES.has(callName);
+}
+
+// src/utils/schema-identifiers.ts
+function getSchemaBindingName(node, imports) {
+  if (node.id.type !== "Identifier" || !isValibotSchemaExpression(node.init, imports)) {
+    return null;
+  }
+  return node.id.name;
+}
+
+// src/rules/consistent-schema-convention.ts
+var CONVENTIONS = ["same-name", "suffix"];
+var SCOPES = ["exported", "all"];
+var INFER_TYPE_NAMES = {
+  InferInput: "input",
+  InferOutput: "output"
+};
+var consistentSchemaConvention = createRule({
+  name: "consistent-schema-convention",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce a consistent Valibot schema naming convention for exported schemas and inferred types."
+    },
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          allowDataSuffix: {
+            type: "boolean"
+          },
+          convention: {
+            type: "string",
+            enum: [...CONVENTIONS]
+          },
+          dataSuffix: {
+            type: "string",
+            minLength: 1
+          },
+          inputSuffix: {
+            type: "string",
+            minLength: 1
+          },
+          outputSuffix: {
+            type: "string",
+            minLength: 1
+          },
+          schemaSuffix: {
+            type: "string",
+            minLength: 1
+          },
+          scope: {
+            type: "string",
+            enum: [...SCOPES]
+          }
+        }
+      }
+    ],
+    messages: {
+      schemaNameConvention: "Rename this schema binding to '{{expectedName}}' to follow the '{{convention}}' naming convention.",
+      typeNameConvention: "Rename this inferred type alias to '{{expectedName}}' to follow the '{{convention}}' naming convention."
+    }
+  },
+  defaultOptions: [
+    {
+      allowDataSuffix: true,
+      convention: "suffix",
+      dataSuffix: "Data",
+      inputSuffix: "Input",
+      outputSuffix: "Output",
+      schemaSuffix: "Schema",
+      scope: "exported"
+    }
+  ],
+  create(context, [options]) {
+    let imports = createEmptyValibotImports();
+    const exportedTypeBindings = /* @__PURE__ */ new Set();
+    const exportedValueBindings = /* @__PURE__ */ new Set();
+    const inferTypeAliases = [];
+    const resolvedOptions = resolveOptions2(options);
+    const schemaBindings = /* @__PURE__ */ new Map();
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+        exportedTypeBindings.clear();
+        exportedValueBindings.clear();
+        inferTypeAliases.length = 0;
+        schemaBindings.clear();
+        collectExportedBindings(
+          node,
+          exportedValueBindings,
+          exportedTypeBindings
+        );
+      },
+      VariableDeclarator(node) {
+        if (!hasValibotImports(imports)) {
+          return;
+        }
+        const bindingName = getSchemaBindingName(node, imports);
+        if (!bindingName || !shouldCheckSchemaBinding(
+          node,
+          resolvedOptions,
+          exportedValueBindings
+        )) {
+          return;
+        }
+        if (node.id.type !== "Identifier") {
+          return;
+        }
+        schemaBindings.set(bindingName, {
+          name: bindingName,
+          node: node.id
+        });
+      },
+      TSTypeAliasDeclaration(node) {
+        if (!hasValibotImports(imports)) {
+          return;
+        }
+        const inferTypeAlias = getInferTypeAliasInfo(node, imports);
+        if (!inferTypeAlias || !shouldCheckTypeAlias(node, resolvedOptions, exportedTypeBindings)) {
+          return;
+        }
+        inferTypeAliases.push(inferTypeAlias);
+      },
+      "Program:exit"() {
+        if (!hasValibotImports(imports)) {
+          return;
+        }
+        for (const binding of schemaBindings.values()) {
+          const expectedName = getExpectedSchemaName(
+            binding.name,
+            resolvedOptions
+          );
+          if (binding.name === expectedName) {
+            continue;
+          }
+          context.report({
+            node: binding.node,
+            messageId: "schemaNameConvention",
+            data: {
+              convention: resolvedOptions.convention,
+              expectedName
+            }
+          });
+        }
+        for (const typeAlias of inferTypeAliases) {
+          if (!schemaBindings.has(typeAlias.schemaName)) {
+            continue;
+          }
+          const expectedName = getExpectedTypeAliasName(
+            typeAlias.schemaName,
+            typeAlias.inferKind,
+            resolvedOptions
+          );
+          if (typeAlias.aliasName === expectedName || isAllowedDataAliasName(
+            typeAlias.aliasName,
+            typeAlias.schemaName,
+            resolvedOptions
+          )) {
+            continue;
+          }
+          context.report({
+            node: typeAlias.node,
+            messageId: "typeNameConvention",
+            data: {
+              convention: resolvedOptions.convention,
+              expectedName
+            }
+          });
+        }
+      }
+    };
+  }
+});
+function resolveOptions2(options) {
+  return {
+    allowDataSuffix: options?.allowDataSuffix ?? true,
+    convention: options?.convention ?? "suffix",
+    dataSuffix: options?.dataSuffix ?? "Data",
+    inputSuffix: options?.inputSuffix ?? "Input",
+    outputSuffix: options?.outputSuffix ?? "Output",
+    schemaSuffix: options?.schemaSuffix ?? "Schema",
+    scope: options?.scope ?? "exported"
+  };
+}
+function collectExportedBindings(program, exportedValueBindings, exportedTypeBindings) {
+  for (const statement of program.body) {
+    if (statement.type === "ExportDefaultDeclaration") {
+      if (statement.declaration.type === "Identifier") {
+        exportedValueBindings.add(statement.declaration.name);
+      }
+      continue;
+    }
+    if (statement.type !== "ExportNamedDeclaration") {
+      continue;
+    }
+    if (statement.declaration) {
+      collectExportedDeclarationBindings(
+        statement.declaration,
+        exportedValueBindings,
+        exportedTypeBindings
+      );
+    }
+    for (const specifier of statement.specifiers) {
+      if (specifier.local.type !== "Identifier") {
+        continue;
+      }
+      if (statement.exportKind === "type" || specifier.exportKind === "type") {
+        exportedTypeBindings.add(specifier.local.name);
+        continue;
+      }
+      exportedValueBindings.add(specifier.local.name);
+    }
+  }
+}
+function collectExportedDeclarationBindings(declaration, exportedValueBindings, exportedTypeBindings) {
+  if (!declaration) {
+    return;
+  }
+  if (declaration.type === "VariableDeclaration") {
+    for (const declarator of declaration.declarations) {
+      if (declarator.id.type === "Identifier") {
+        exportedValueBindings.add(declarator.id.name);
+      }
+    }
+    return;
+  }
+  if (declaration.type === "TSTypeAliasDeclaration") {
+    exportedTypeBindings.add(declaration.id.name);
+  }
+}
+function shouldCheckSchemaBinding(node, options, exportedValueBindings) {
+  return options.scope === "all" || isInlineExportedVariableDeclarator(node) || node.id.type === "Identifier" && exportedValueBindings.has(node.id.name);
+}
+function shouldCheckTypeAlias(node, options, exportedTypeBindings) {
+  return options.scope === "all" || isInlineExportedTypeAlias(node) || exportedTypeBindings.has(node.id.name);
+}
+function isInlineExportedVariableDeclarator(node) {
+  return node.parent?.parent?.type === "ExportNamedDeclaration";
+}
+function isInlineExportedTypeAlias(node) {
+  return node.parent?.type === "ExportNamedDeclaration";
+}
+function getInferTypeAliasInfo(node, imports) {
+  if (node.typeAnnotation.type !== "TSTypeReference") {
+    return null;
+  }
+  const inferKind = getInferTypeKind(node.typeAnnotation, imports);
+  const typeParameter = node.typeAnnotation.typeArguments?.params[0];
+  const schemaName = typeParameter && getSchemaNameFromTypeQuery(typeParameter);
+  if (!inferKind || !schemaName) {
+    return null;
+  }
+  return {
+    aliasName: node.id.name,
+    inferKind,
+    node: node.id,
+    schemaName
+  };
+}
+function getInferTypeKind(node, imports) {
+  if (node.typeName.type === "Identifier") {
+    return INFER_TYPE_NAMES[imports.importedNames.get(node.typeName.name) ?? ""] ?? null;
+  }
+  if (node.typeName.type !== "TSQualifiedName") {
+    return null;
+  }
+  return node.typeName.left.type === "Identifier" && imports.namespaces.has(node.typeName.left.name) ? INFER_TYPE_NAMES[node.typeName.right.name] ?? null : null;
+}
+function getSchemaNameFromTypeQuery(node) {
+  return node.type === "TSTypeQuery" && node.exprName.type === "Identifier" ? node.exprName.name : null;
+}
+function getExpectedSchemaName(actualName, options) {
+  const baseName = getNormalizedBaseName(actualName, options);
+  return options.convention === "same-name" ? baseName : `${baseName}${options.schemaSuffix}`;
+}
+function getExpectedTypeAliasName(schemaName, inferKind, options) {
+  const baseName = getNormalizedBaseName(schemaName, options);
+  if (options.convention === "same-name") {
+    return baseName;
+  }
+  return `${baseName}${inferKind === "input" ? options.inputSuffix : options.outputSuffix}`;
+}
+function isAllowedDataAliasName(aliasName, schemaName, options) {
+  return options.convention === "suffix" && options.allowDataSuffix && aliasName === `${getNormalizedBaseName(schemaName, options)}${options.dataSuffix}`;
+}
+function getNormalizedBaseName(value, options) {
+  const strippedValue = stripKnownSuffix(value, options);
+  return isPascalCaseLike(strippedValue) ? strippedValue : toPascalCase(strippedValue);
+}
+function stripKnownSuffix(value, options) {
+  const suffixes = [
+    options.schemaSuffix,
+    options.inputSuffix,
+    options.outputSuffix,
+    ...options.allowDataSuffix ? [options.dataSuffix] : []
+  ].sort((left, right) => right.length - left.length);
+  for (const suffix of suffixes) {
+    if (value.endsWith(suffix) && value.length > suffix.length) {
+      return value.slice(0, -suffix.length);
+    }
+  }
+  return value;
+}
+function isPascalCaseLike(value) {
+  return /^[A-Z][A-Za-z0-9]*$/.test(value);
+}
+function toPascalCase(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part[0]?.toUpperCase() + part.slice(1)).join("");
+}
+
+// src/utils/pipe-analysis.ts
+function getPipeActionDescriptors(pipeCall, imports, sourceCode) {
+  if (!isValibotCall(pipeCall, imports, "pipe") || pipeCall.arguments.length < 2) {
+    return [];
+  }
+  return pipeCall.arguments.flatMap((argument, actionIndex) => {
+    if (actionIndex === 0 || argument.type !== "CallExpression") {
+      return [];
+    }
+    const name = getValibotCallName(argument, imports);
+    if (!name) {
+      return [];
+    }
+    return [
+      {
+        actionIndex,
+        fingerprint: sourceCode.getText(argument),
+        name,
+        node: argument
+      }
+    ];
+  });
+}
+
+// src/rules/no-duplicate-pipe-actions.ts
+var noDuplicatePipeActions = createRule({
+  name: "no-duplicate-pipe-actions",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow duplicate Valibot actions inside the same pipe() call."
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      duplicatePipeAction: "This pipe action duplicates an earlier {{actionName}}() call in the same pipe."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    const sourceCode = context.sourceCode;
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      CallExpression(node) {
+        if (!hasValibotImports(imports) || !isValibotCall(node, imports, "pipe")) {
+          return;
+        }
+        const seenActions = /* @__PURE__ */ new Map();
+        for (const action of getPipeActionDescriptors(
+          node,
+          imports,
+          sourceCode
+        )) {
+          const firstAction = seenActions.get(action.fingerprint);
+          if (!firstAction) {
+            seenActions.set(action.fingerprint, action.node);
+            continue;
+          }
+          context.report({
+            node: action.node,
+            messageId: "duplicatePipeAction",
+            data: {
+              actionName: action.name
+            },
+            fix: canSafelyRemoveDuplicateAction(
+              node,
+              action.actionIndex,
+              sourceCode
+            ) ? (fixer) => {
+              const removalRange = getDuplicateActionRemovalRange(
+                node,
+                action.actionIndex
+              );
+              return fixer.removeRange(removalRange);
+            } : null
+          });
+        }
+      }
+    };
+  }
+});
+function canSafelyRemoveDuplicateAction(pipeCall, actionIndex, sourceCode) {
+  const currentAction = pipeCall.arguments[actionIndex];
+  if (!currentAction) {
+    return false;
+  }
+  if (sourceCode.getCommentsBefore(currentAction).length > 0 || sourceCode.getCommentsAfter(currentAction).length > 0) {
+    return false;
+  }
+  return true;
+}
+function getDuplicateActionRemovalRange(pipeCall, actionIndex) {
+  const currentAction = pipeCall.arguments[actionIndex];
+  if (!currentAction) {
+    return [pipeCall.range[0], pipeCall.range[0]];
+  }
+  const nextAction = pipeCall.arguments[actionIndex + 1];
+  if (nextAction) {
+    return [currentAction.range[0], nextAction.range[0]];
+  }
+  const previousAction = pipeCall.arguments[actionIndex - 1];
+  if (!previousAction) {
+    return currentAction.range;
+  }
+  return [previousAction.range[1], currentAction.range[1]];
+}
+
+// src/rules/no-recreated-schemas.ts
+var noRecreatedSchemas = createRule({
+  name: "no-recreated-schemas",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow recreating static Valibot schemas inside function scope."
+    },
+    schema: [],
+    messages: {
+      noRecreatedSchema: "This schema is recreated on every call. Hoist it to module scope unless it truly depends on runtime inputs."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      VariableDeclarator(node) {
+        if (node.id.type !== "Identifier" || !isStaticSchemaRecreation(node.init, imports)) {
+          return;
+        }
+        context.report({
+          node: node.id,
+          messageId: "noRecreatedSchema"
+        });
+      },
+      ReturnStatement(node) {
+        if (!isStaticSchemaRecreation(node.argument, imports)) {
+          return;
+        }
+        context.report({
+          node: node.argument,
+          messageId: "noRecreatedSchema"
+        });
+      },
+      ArrowFunctionExpression(node) {
+        if (node.body.type === "BlockStatement" || !isStaticSchemaRecreation(node.body, imports)) {
+          return;
+        }
+        context.report({
+          node: node.body,
+          messageId: "noRecreatedSchema"
+        });
+      }
+    };
+  }
+});
+function isStaticSchemaRecreation(node, imports) {
+  return hasValibotImports(imports) && isValibotSchemaExpression(node, imports) && findEnclosingFunction(node) !== null && !containsNestedFunction(node) && !hasDynamicSchemaInputs(node, imports);
+}
+function findEnclosingFunction(node) {
+  let current = node.parent;
+  while (current) {
+    if (isFunctionLike(current)) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+function containsNestedFunction(node) {
+  return traverseNode(
+    node,
+    (childNode) => childNode !== node && isFunctionLike(childNode)
+  );
+}
+function hasDynamicSchemaInputs(node, imports) {
+  return traverseNode(node, (childNode, parentNode) => {
+    if (childNode === node || childNode.type !== "Identifier") {
+      return false;
+    }
+    if (imports.importedNames.has(childNode.name) || imports.namespaces.has(childNode.name)) {
+      return false;
+    }
+    if (parentNode?.type === "MemberExpression" && parentNode.property === childNode && !parentNode.computed) {
+      return false;
+    }
+    if (parentNode?.type === "Property" && parentNode.key === childNode && !parentNode.computed) {
+      return false;
+    }
+    return true;
+  });
+}
+function isFunctionLike(node) {
+  return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
+}
+function traverseNode(node, predicate, parent) {
+  if (predicate(node, parent)) {
+    return true;
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "parent" || value === null || value === void 0) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (isNode(item) && traverseNode(item, predicate, node)) {
+          return true;
+        }
+      }
+      continue;
+    }
+    if (isNode(value) && traverseNode(value, predicate, node)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isNode(value) {
+  return typeof value === "object" && value !== null && "type" in value;
+}
+
+// src/rules/no-schema-as-type.ts
+var ALLOWED_INFER_TYPE_NAMES = /* @__PURE__ */ new Set(["InferInput", "InferOutput"]);
+var noSchemaAsType = createRule({
+  name: "no-schema-as-type",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow using a Valibot schema value itself as a TypeScript type."
+    },
+    schema: [],
+    messages: {
+      noSchemaAsType: "Use InferInput<typeof {{schemaName}}> or InferOutput<typeof {{schemaName}}> instead of typeof {{schemaName}}."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    const schemaBindings = /* @__PURE__ */ new Set();
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      VariableDeclarator(node) {
+        if (!hasValibotImports(imports)) {
+          return;
+        }
+        const schemaBindingName = getSchemaBindingName(node, imports);
+        if (schemaBindingName) {
+          schemaBindings.add(schemaBindingName);
+        }
+      },
+      TSTypeQuery(node) {
+        if (!hasValibotImports(imports) || isAllowedSchemaTypeQuery(node, imports)) {
+          return;
+        }
+        const schemaName = getSchemaTypeQueryName(node);
+        if (!schemaName || !schemaBindings.has(schemaName)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "noSchemaAsType",
+          data: {
+            schemaName
+          }
+        });
+      }
+    };
+  }
+});
+function getSchemaTypeQueryName(node) {
+  return node.exprName.type === "Identifier" ? node.exprName.name : null;
+}
+function isAllowedSchemaTypeQuery(node, imports) {
+  const parent = node.parent;
+  if (!parent || parent.type !== "TSTypeParameterInstantiation") {
+    return false;
+  }
+  const typeReference = parent.parent;
+  if (!typeReference || typeReference.type !== "TSTypeReference") {
+    return false;
+  }
+  return isAllowedInferReference(typeReference.typeName, imports);
+}
+function isAllowedInferReference(typeName, imports) {
+  if (typeName.type === "Identifier") {
+    return ALLOWED_INFER_TYPE_NAMES.has(
+      imports.importedNames.get(typeName.name) ?? ""
+    );
+  }
+  if (typeName.type !== "TSQualifiedName") {
+    return false;
+  }
+  return typeName.left.type === "Identifier" && imports.namespaces.has(typeName.left.name) && ALLOWED_INFER_TYPE_NAMES.has(typeName.right.name);
+}
+
+// src/rules/prefer-picklist.ts
+var preferPicklist = createRule({
+  name: "prefer-picklist",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer picklist() over union() when the union only contains literal string schemas."
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      preferPicklist: "Prefer picklist([...]) instead of union([...]) for literal string options."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    const sourceCode = context.sourceCode;
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      CallExpression(node) {
+        if (!hasValibotImports(imports) || !isValibotCall(node, imports, "union")) {
+          return;
+        }
+        const optionsArg = node.arguments[0];
+        if (optionsArg?.type !== "ArrayExpression") {
+          return;
+        }
+        const literalOptionTexts = getLiteralOptionTexts(
+          optionsArg,
+          imports,
+          sourceCode
+        );
+        if (!literalOptionTexts) {
+          return;
+        }
+        const preferredCalleeText = getPreferredCalleeText(node, imports);
+        context.report({
+          node,
+          messageId: "preferPicklist",
+          fix: preferredCalleeText && (node.arguments.length === 1 || node.arguments.length === 2) ? (fixer) => fixer.replaceText(
+            node,
+            buildPicklistCallText(
+              node,
+              preferredCalleeText,
+              literalOptionTexts,
+              sourceCode
+            )
+          ) : null
+        });
+      }
+    };
+  }
+});
+function getLiteralOptionTexts(optionsArray, imports, sourceCode) {
+  if (optionsArray.elements.length < 2) {
+    return null;
+  }
+  const literalTexts = [];
+  for (const element of optionsArray.elements) {
+    if (!element || element.type === "SpreadElement") {
+      return null;
+    }
+    if (element.type !== "CallExpression") {
+      return null;
+    }
+    if (!isValibotCall(element, imports, "literal") || element.arguments.length !== 1) {
+      return null;
+    }
+    const literalArg = element.arguments[0];
+    if (!literalArg || literalArg.type !== "Literal" || typeof literalArg.value !== "string") {
+      return null;
+    }
+    literalTexts.push(sourceCode.getText(literalArg));
+  }
+  return literalTexts;
+}
+function getPreferredCalleeText(call, imports) {
+  if (call.callee.type === "MemberExpression") {
+    return `${sourceTextForMemberNamespace(call)}.picklist`;
+  }
+  const localPicklistName = getLocalImportName(imports, "picklist");
+  return localPicklistName ?? null;
+}
+function sourceTextForMemberNamespace(call) {
+  if (call.callee.type === "MemberExpression" && call.callee.object.type === "Identifier") {
+    return call.callee.object.name;
+  }
+  return "v";
+}
+function getLocalImportName(imports, importedName) {
+  for (const [localName, importedValue] of imports.importedNames) {
+    if (importedValue === importedName) {
+      return localName;
+    }
+  }
+  return void 0;
+}
+function buildPicklistCallText(unionCall, calleeText, literalOptionTexts, sourceCode) {
+  const valuesText = `[${literalOptionTexts.join(", ")}]`;
+  const messageArg = unionCall.arguments[1];
+  if (messageArg) {
+    return `${calleeText}(${valuesText}, ${sourceCode.getText(messageArg)})`;
+  }
+  return `${calleeText}(${valuesText})`;
+}
+
+// src/rules/prefer-nullable-over-union-null.ts
+var OBJECT_SCHEMA_NAMES = [
+  "object",
+  "objectAsync",
+  "strictObject",
+  "strictObjectAsync",
+  "looseObject",
+  "looseObjectAsync",
+  "objectWithRest",
+  "objectWithRestAsync"
+];
+var preferNullableOverUnionNull = createRule({
+  name: "prefer-nullable-over-union-null",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer nullable() over union([schema, null()]) when they are equivalent."
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      preferNullable: "Prefer nullable() instead of union([schema, null()]) when the schema only needs to accept null."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    const sourceCode = context.sourceCode;
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      CallExpression(node) {
+        if (!hasValibotImports(imports) || !isValibotCall(node, imports, "union")) {
+          return;
+        }
+        const matchedSchema = getMatchedSchema(node, imports);
+        if (!matchedSchema || isWithinObjectSchemaEntry(node, imports)) {
+          return;
+        }
+        const preferredCalleeText = getPreferredCalleeText2(node, imports);
+        context.report({
+          node,
+          messageId: "preferNullable",
+          fix: preferredCalleeText ? (fixer) => fixer.replaceText(
+            node,
+            `${preferredCalleeText}(${sourceCode.getText(matchedSchema)})`
+          ) : null
+        });
+      }
+    };
+  }
+});
+function getMatchedSchema(call, imports) {
+  if (call.arguments.length !== 1) {
+    return null;
+  }
+  const options = call.arguments[0];
+  if (options?.type !== "ArrayExpression" || options.elements.length !== 2) {
+    return null;
+  }
+  const [firstOption, secondOption] = options.elements;
+  if (!isSchemaOption(firstOption) || !isSchemaOption(secondOption)) {
+    return null;
+  }
+  if (isNullSchemaCall(firstOption, imports)) {
+    return secondOption;
+  }
+  if (isNullSchemaCall(secondOption, imports)) {
+    return firstOption;
+  }
+  return null;
+}
+function isSchemaOption(node) {
+  return node !== null && node.type !== "SpreadElement";
+}
+function isNullSchemaCall(node, imports) {
+  return node.type === "CallExpression" && node.arguments.length === 0 && isValibotCall(node, imports, "null");
+}
+function isWithinObjectSchemaEntry(node, imports) {
+  let current = node;
+  while (current?.parent) {
+    const parent = current.parent;
+    if (parent.type === "Property" && parent.value === current) {
+      const objectLiteral = parent.parent;
+      if (!objectLiteral || objectLiteral.type !== "ObjectExpression") {
+        return false;
+      }
+      const schemaCall = objectLiteral.parent;
+      if (!schemaCall || schemaCall.type !== "CallExpression" || schemaCall.arguments[0] !== objectLiteral) {
+        return false;
+      }
+      return OBJECT_SCHEMA_NAMES.some(
+        (schemaName) => isValibotCall(schemaCall, imports, schemaName)
+      );
+    }
+    current = parent;
+  }
+  return false;
+}
+function getPreferredCalleeText2(call, imports) {
+  if (call.callee.type === "MemberExpression") {
+    return `${sourceTextForMemberNamespace2(call)}.nullable`;
+  }
+  const localNullableName = getLocalImportName2(imports, "nullable");
+  return localNullableName ?? null;
+}
+function sourceTextForMemberNamespace2(call) {
+  if (call.callee.type === "MemberExpression" && call.callee.object.type === "Identifier") {
+    return call.callee.object.name;
+  }
+  return "v";
+}
+function getLocalImportName2(imports, importedName) {
+  for (const [localName, importedValue] of imports.importedNames) {
+    if (importedValue === importedName) {
+      return localName;
+    }
+  }
+  return void 0;
+}
+
+// src/rules/prefer-optional-over-union-undefined.ts
+var OBJECT_SCHEMA_NAMES2 = [
+  "object",
+  "objectAsync",
+  "strictObject",
+  "strictObjectAsync",
+  "looseObject",
+  "looseObjectAsync",
+  "objectWithRest",
+  "objectWithRestAsync"
+];
+var preferOptionalOverUnionUndefined = createRule(
+  {
+    name: "prefer-optional-over-union-undefined",
+    meta: {
+      type: "suggestion",
+      docs: {
+        description: "Prefer optional() over union([schema, undefined()]) when they are equivalent."
+      },
+      fixable: "code",
+      schema: [],
+      messages: {
+        preferOptional: "Prefer optional() instead of union([schema, undefined()]) when the schema only needs to accept undefined."
+      }
+    },
+    defaultOptions: [],
+    create(context) {
+      let imports = createEmptyValibotImports();
+      const sourceCode = context.sourceCode;
+      return {
+        Program(node) {
+          imports = collectValibotImports(node);
+        },
+        CallExpression(node) {
+          if (!hasValibotImports(imports) || !isValibotCall(node, imports, "union")) {
+            return;
+          }
+          const matchedSchema = getMatchedSchema2(node, imports);
+          if (!matchedSchema || isWithinObjectSchemaEntry2(node, imports)) {
+            return;
+          }
+          const preferredCalleeText = getPreferredCalleeText3(node, imports);
+          context.report({
+            node,
+            messageId: "preferOptional",
+            fix: preferredCalleeText ? (fixer) => fixer.replaceText(
+              node,
+              `${preferredCalleeText}(${sourceCode.getText(matchedSchema)})`
+            ) : null
+          });
+        }
+      };
+    }
+  }
+);
+function getMatchedSchema2(call, imports) {
+  if (call.arguments.length !== 1) {
+    return null;
+  }
+  const options = call.arguments[0];
+  if (options?.type !== "ArrayExpression" || options.elements.length !== 2) {
+    return null;
+  }
+  const [firstOption, secondOption] = options.elements;
+  if (!isSchemaOption2(firstOption) || !isSchemaOption2(secondOption)) {
+    return null;
+  }
+  if (isUndefinedSchemaCall(firstOption, imports)) {
+    return secondOption;
+  }
+  if (isUndefinedSchemaCall(secondOption, imports)) {
+    return firstOption;
+  }
+  return null;
+}
+function isSchemaOption2(node) {
+  return node !== null && node.type !== "SpreadElement";
+}
+function isUndefinedSchemaCall(node, imports) {
+  return node.type === "CallExpression" && node.arguments.length === 0 && isValibotCall(node, imports, "undefined");
+}
+function isWithinObjectSchemaEntry2(node, imports) {
+  let current = node;
+  while (current?.parent) {
+    const parent = current.parent;
+    if (parent.type === "Property" && parent.value === current) {
+      const objectLiteral = parent.parent;
+      if (!objectLiteral || objectLiteral.type !== "ObjectExpression") {
+        return false;
+      }
+      const schemaCall = objectLiteral.parent;
+      if (!schemaCall || schemaCall.type !== "CallExpression" || schemaCall.arguments[0] !== objectLiteral) {
+        return false;
+      }
+      return OBJECT_SCHEMA_NAMES2.some(
+        (schemaName) => isValibotCall(schemaCall, imports, schemaName)
+      );
+    }
+    current = parent;
+  }
+  return false;
+}
+function getPreferredCalleeText3(call, imports) {
+  if (call.callee.type === "MemberExpression") {
+    return `${sourceTextForMemberNamespace3(call)}.optional`;
+  }
+  const localOptionalName = getLocalImportName3(imports, "optional");
+  return localOptionalName ?? null;
+}
+function sourceTextForMemberNamespace3(call) {
+  if (call.callee.type === "MemberExpression" && call.callee.object.type === "Identifier") {
+    return call.callee.object.name;
+  }
+  return "v";
+}
+function getLocalImportName3(imports, importedName) {
+  for (const [localName, importedValue] of imports.importedNames) {
+    if (importedValue === importedName) {
+      return localName;
+    }
+  }
+  return void 0;
+}
+
+// src/rules/prefer-variant.ts
+var OBJECT_SCHEMA_NAMES3 = [
+  "object",
+  "strictObject",
+  "looseObject",
+  "objectWithRest"
+];
+var preferVariant = createRule({
+  name: "prefer-variant",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer variant() over union() when object schemas share an obvious discriminant key."
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      preferVariant: "Prefer variant('{{key}}', [...]) over union([...]) for discriminated object schemas."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    const sourceCode = context.sourceCode;
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      CallExpression(node) {
+        if (!hasValibotImports(imports) || !isValibotCall(node, imports, "union")) {
+          return;
+        }
+        const optionsArray = node.arguments[0];
+        if (optionsArray?.type !== "ArrayExpression") {
+          return;
+        }
+        const optionCalls = getOptionObjectSchemaCalls(optionsArray, imports);
+        if (!optionCalls) {
+          return;
+        }
+        const discriminantKey = getCommonDiscriminantKey(optionCalls, imports);
+        if (!discriminantKey) {
+          return;
+        }
+        const preferredCalleeText = getPreferredCalleeText4(node, imports);
+        context.report({
+          node,
+          messageId: "preferVariant",
+          data: {
+            key: discriminantKey
+          },
+          fix: preferredCalleeText && node.arguments.length === 1 ? (fixer) => fixer.replaceText(
+            node,
+            `${preferredCalleeText}(${toSingleQuotedString(discriminantKey)}, ${sourceCode.getText(optionsArray)})`
+          ) : null
+        });
+      }
+    };
+  }
+});
+function getOptionObjectSchemaCalls(optionsArray, imports) {
+  if (optionsArray.elements.length < 2) {
+    return null;
+  }
+  const optionCalls = [];
+  for (const element of optionsArray.elements) {
+    if (!element || element.type === "SpreadElement") {
+      return null;
+    }
+    if (element.type !== "CallExpression") {
+      return null;
+    }
+    if (!OBJECT_SCHEMA_NAMES3.some((name) => isValibotCall(element, imports, name))) {
+      return null;
+    }
+    optionCalls.push(element);
+  }
+  return optionCalls;
+}
+function getCommonDiscriminantKey(objectSchemaCalls, imports) {
+  const literalKeyMaps = objectSchemaCalls.map(
+    (schemaCall) => getLiteralDiscriminantKeyMap(schemaCall, imports)
+  );
+  if (literalKeyMaps.some((map) => map.size === 0)) {
+    return null;
+  }
+  const firstMap = literalKeyMaps[0];
+  for (const [keyName, firstLiteral] of firstMap) {
+    let isCommon = true;
+    const literalValues = /* @__PURE__ */ new Set([firstLiteral]);
+    for (let index = 1; index < literalKeyMaps.length; index += 1) {
+      const literalValue = literalKeyMaps[index].get(keyName);
+      if (!literalValue) {
+        isCommon = false;
+        break;
+      }
+      literalValues.add(literalValue);
+    }
+    if (isCommon && literalValues.size > 1) {
+      return keyName;
+    }
+  }
+  return null;
+}
+function getLiteralDiscriminantKeyMap(objectSchemaCall, imports) {
+  const entriesArg = objectSchemaCall.arguments[0];
+  if (!entriesArg || entriesArg.type !== "ObjectExpression") {
+    return /* @__PURE__ */ new Map();
+  }
+  const keyMap = /* @__PURE__ */ new Map();
+  for (const property of entriesArg.properties) {
+    if (property.type !== "Property" || property.computed) {
+      continue;
+    }
+    const keyName = getPropertyKeyName(property.key);
+    if (!keyName) {
+      continue;
+    }
+    const literalValue = getLiteralSchemaValue(property.value, imports);
+    if (!literalValue) {
+      continue;
+    }
+    keyMap.set(keyName, literalValue);
+  }
+  return keyMap;
+}
+function getPropertyKeyName(key) {
+  if (key.type === "Identifier") {
+    return key.name;
+  }
+  if (key.type === "Literal" && typeof key.value === "string") {
+    return key.value;
+  }
+  return null;
+}
+function getLiteralSchemaValue(value, imports) {
+  if (value.type !== "CallExpression") {
+    return null;
+  }
+  if (!isValibotCall(value, imports, "literal") || value.arguments.length !== 1) {
+    return null;
+  }
+  const literalArg = value.arguments[0];
+  if (!literalArg || literalArg.type !== "Literal") {
+    return null;
+  }
+  return String(literalArg.value);
+}
+function getPreferredCalleeText4(call, imports) {
+  if (call.callee.type === "MemberExpression") {
+    return `${sourceTextForMemberNamespace4(call)}.variant`;
+  }
+  const localVariantName = getLocalImportName4(imports, "variant");
+  return localVariantName ?? null;
+}
+function sourceTextForMemberNamespace4(call) {
+  if (call.callee.type === "MemberExpression" && call.callee.object.type === "Identifier") {
+    return call.callee.object.name;
+  }
+  return "v";
+}
+function getLocalImportName4(imports, importedName) {
+  for (const [localName, importedValue] of imports.importedNames) {
+    if (importedValue === importedName) {
+      return localName;
+    }
+  }
+  return void 0;
+}
+function toSingleQuotedString(value) {
+  return `'${value.replaceAll("'", "\\'")}'`;
+}
+
+// src/rules/prefer-nullish.ts
+var WRAPPER_PAIRS = [
+  ["optional", "nullable"],
+  ["nullable", "optional"]
+];
+var preferNullish = createRule({
+  name: "prefer-nullish",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer nullish() over nested optional() and nullable() wrappers."
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      preferNullish: "Prefer nullish() instead of nesting optional() and nullable()."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    const sourceCode = context.sourceCode;
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      CallExpression(node) {
+        if (!hasValibotImports(imports) || node.arguments.length !== 1) {
+          return;
+        }
+        const innerCall = node.arguments[0];
+        if (innerCall?.type !== "CallExpression" || innerCall.arguments.length !== 1) {
+          return;
+        }
+        const innerSchema = innerCall.arguments[0];
+        if (!innerSchema) {
+          return;
+        }
+        const pair = getWrapperPair(node, innerCall, imports);
+        if (!pair) {
+          return;
+        }
+        const preferredCalleeText = getPreferredCalleeText5(node, imports);
+        context.report({
+          node,
+          messageId: "preferNullish",
+          fix: preferredCalleeText ? (fixer) => fixer.replaceText(
+            node,
+            `${preferredCalleeText}(${sourceCode.getText(innerSchema)})`
+          ) : null
+        });
+      }
+    };
+  }
+});
+function getWrapperPair(outerCall, innerCall, imports) {
+  for (const pair of WRAPPER_PAIRS) {
+    if (isValibotCall(outerCall, imports, pair[0]) && isValibotCall(innerCall, imports, pair[1])) {
+      return pair;
+    }
+  }
+  return null;
+}
+function getPreferredCalleeText5(call, imports) {
+  if (call.callee.type === "MemberExpression") {
+    return `${sourceTextForMemberNamespace5(call)}.nullish`;
+  }
+  const localNullishName = getLocalImportName5(imports, "nullish");
+  return localNullishName ?? null;
+}
+function sourceTextForMemberNamespace5(call) {
+  if (call.callee.type === "MemberExpression" && call.callee.object.type === "Identifier") {
+    return call.callee.object.name;
+  }
+  return "v";
+}
+function getLocalImportName5(imports, importedName) {
+  for (const [localName, importedValue] of imports.importedNames) {
+    if (importedValue === importedName) {
+      return localName;
+    }
+  }
+  return void 0;
+}
+
+// src/rules/no-unguarded-parse.ts
+var GUARDED_PARSER_NAMES = ["parse", "assert"];
+var noUnguardedParse = createRule({
+  name: "no-unguarded-parse",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require Valibot parse() and assert() calls to be wrapped in try/catch."
+    },
+    schema: [],
+    messages: {
+      unguardedParserCall: "Wrap Valibot {{functionName}}() in a try/catch block or switch to safeParse() for recoverable validation."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      CallExpression(node) {
+        if (!hasValibotImports(imports)) {
+          return;
+        }
+        const parserName = getGuardedParserName(node, imports);
+        if (!parserName || isInsideTryBlock(node)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "unguardedParserCall",
+          data: {
+            functionName: parserName
+          }
+        });
+      }
+    };
+  }
+});
+function getGuardedParserName(call, imports) {
+  for (const functionName of GUARDED_PARSER_NAMES) {
+    if (isValibotCall(call, imports, functionName)) {
+      return functionName;
+    }
+  }
+  return null;
+}
+function isInsideTryBlock(node) {
+  let current = node;
+  while (current?.parent) {
+    const parent = current.parent;
+    if (parent.type === "TryStatement" && parent.block === current) {
+      return true;
+    }
+    current = parent;
+  }
+  return false;
+}
+
+// src/rules/no-redundant-schema-wrappers.ts
+var DUPLICATE_WRAPPER_NAMES = /* @__PURE__ */ new Set([
+  "optional",
+  "nullable",
+  "nullish",
+  "nonOptional",
+  "nonNullable",
+  "nonNullish"
+]);
+var noRedundantSchemaWrappers = createRule({
+  name: "no-redundant-schema-wrappers",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow redundant nested Valibot schema wrappers."
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      redundantWrapper: "This Valibot wrapper is applied redundantly. Remove the outer wrapper."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    const sourceCode = context.sourceCode;
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      CallExpression(node) {
+        if (!hasValibotImports(imports)) {
+          return;
+        }
+        if (node.arguments.length !== 1) {
+          return;
+        }
+        const innerCall = node.arguments[0];
+        if (innerCall.type !== "CallExpression" || innerCall.arguments.length !== 1) {
+          return;
+        }
+        const duplicatedWrapperName = getDuplicatedWrapperName(
+          node,
+          innerCall,
+          imports
+        );
+        if (!duplicatedWrapperName) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "redundantWrapper",
+          fix(fixer) {
+            return fixer.replaceText(node, sourceCode.getText(innerCall));
+          }
+        });
+      }
+    };
+  }
+});
+function getDuplicatedWrapperName(outerCall, innerCall, imports) {
+  for (const wrapperName of DUPLICATE_WRAPPER_NAMES) {
+    if (isValibotCall(outerCall, imports, wrapperName) && isValibotCall(innerCall, imports, wrapperName)) {
+      return wrapperName;
+    }
+  }
+  return null;
+}
+
+// src/rules/no-any-schema.ts
+var noAnySchema = createRule({
+  name: "no-any-schema",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow Valibot any() schemas."
+    },
+    schema: [],
+    messages: {
+      avoidAnySchema: "Avoid Valibot any() schemas. Prefer unknown() or a more precise schema."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      CallExpression(node) {
+        if (!hasValibotImports(imports)) {
+          return;
+        }
+        if (!isValibotCall(node, imports, "any")) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "avoidAnySchema"
+        });
+      }
+    };
+  }
+});
+
+// src/rules/no-loose-object.ts
+var OBJECT_SCHEMA_TYPES = ["object", "looseObject", "strictObject"];
+var DEFAULT_ALLOWED_OBJECT_SCHEMA_TYPES = ["object", "strictObject"];
+var noLooseObject = createRule({
+  name: "no-loose-object",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow disallowed Valibot object schema constructors such as looseObject()."
+    },
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          allow: {
+            type: "array",
+            items: {
+              type: "string",
+              enum: [...OBJECT_SCHEMA_TYPES]
+            },
+            uniqueItems: true,
+            minItems: 1
+          }
+        }
+      }
+    ],
+    messages: {
+      disallowedObjectSchemaType: "Avoid Valibot {{disallowedType}}() here. Allowed object schema constructors: {{allowedTypes}}."
+    }
+  },
+  defaultOptions: [
+    {
+      allow: [...DEFAULT_ALLOWED_OBJECT_SCHEMA_TYPES]
+    }
+  ],
+  create(context, [options]) {
+    let imports = createEmptyValibotImports();
+    const allowedTypes = new Set(
+      options.allow ?? DEFAULT_ALLOWED_OBJECT_SCHEMA_TYPES
+    );
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      CallExpression(node) {
+        if (!hasValibotImports(imports)) {
+          return;
+        }
+        const callName = getValibotCallName(node, imports);
+        if (!isObjectSchemaType(callName) || allowedTypes.has(callName)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "disallowedObjectSchemaType",
+          data: {
+            disallowedType: callName,
+            allowedTypes: formatAllowedTypes(options.allow)
+          }
+        });
+      }
+    };
+  }
+});
+function isObjectSchemaType(value) {
+  return value !== null && OBJECT_SCHEMA_TYPES.includes(value);
+}
+function formatAllowedTypes(allow) {
+  const allowedTypes = allow ?? [...DEFAULT_ALLOWED_OBJECT_SCHEMA_TYPES];
+  return allowedTypes.map((type) => `${type}()`).join(", ");
+}
+
+// src/rules/no-unknown-schema.ts
+var noUnknownSchema = createRule({
+  name: "no-unknown-schema",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow Valibot unknown() schemas."
+    },
+    schema: [],
+    messages: {
+      avoidUnknownSchema: "Avoid Valibot unknown() schemas. Prefer a more precise schema."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      CallExpression(node) {
+        if (!hasValibotImports(imports)) {
+          return;
+        }
+        if (!isValibotCall(node, imports, "unknown")) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "avoidUnknownSchema"
+        });
+      }
+    };
+  }
+});
+
+// src/rules/no-instanceof-builtins.ts
+var BUILTIN_CONSTRUCTORS = /* @__PURE__ */ new Map([
+  ["Date", "date"],
+  ["Array", "array"],
+  ["Function", "function"],
+  ["Promise", "promise"],
+  ["Map", "map"],
+  ["Set", "set"],
+  ["String", "string"],
+  ["Number", "number"],
+  ["Boolean", "boolean"],
+  ["Symbol", "symbol"],
+  ["BigInt", "bigint"],
+  ["Blob", "blob"]
+]);
+var noInstanceofBuiltins = createRule({
+  name: "no-instanceof-builtins",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer primitive schema functions over instance(Constructor) for built-in types."
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      noInstanceofBuiltins: "Prefer the native Valibot schema {{preferred}}() instead of instance({{constructor}})."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      CallExpression(node) {
+        if (!hasValibotImports(imports)) {
+          return;
+        }
+        if (!isValibotCall(node, imports, "instance") || node.arguments.length !== 1) {
+          return;
+        }
+        const arg = node.arguments[0];
+        if (arg.type !== "Identifier") {
+          return;
+        }
+        const constructorName = arg.name;
+        const preferredSchema = BUILTIN_CONSTRUCTORS.get(constructorName);
+        if (!preferredSchema) {
+          return;
+        }
+        const preferredCalleeText = getPreferredCalleeText6(node, preferredSchema, imports);
+        context.report({
+          node,
+          messageId: "noInstanceofBuiltins",
+          data: {
+            preferred: preferredSchema,
+            constructor: constructorName
+          },
+          fix(fixer) {
+            return fixer.replaceText(node, `${preferredCalleeText}()`);
+          }
+        });
+      }
+    };
+  }
+});
+function getPreferredCalleeText6(call, targetName, imports) {
+  if (call.callee.type === "MemberExpression") {
+    return `${sourceTextForMemberNamespace6(call)}.${targetName}`;
+  }
+  const localName = getLocalImportName6(imports, targetName);
+  return localName ?? targetName;
+}
+function sourceTextForMemberNamespace6(call) {
+  if (call.callee.type === "MemberExpression" && call.callee.object.type === "Identifier") {
+    return call.callee.object.name;
+  }
+  return "v";
+}
+function getLocalImportName6(imports, importedName) {
+  for (const [localName, importedValue] of imports.importedNames) {
+    if (importedValue === importedName) {
+      return localName;
+    }
+  }
+  return void 0;
+}
+
+// src/rules/no-empty-pipe.ts
+var noEmptyPipe = createRule({
+  name: "no-empty-pipe",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow empty pipe() calls or pipe() calls with a single argument."
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      emptyPipe: "Avoid calling pipe() with no arguments.",
+      redundantPipe: "Avoid calling pipe() with only a single schema. Remove the pipe() wrapper."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    const sourceCode = context.sourceCode;
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      CallExpression(node) {
+        if (!hasValibotImports(imports)) {
+          return;
+        }
+        if (!isValibotCall(node, imports, "pipe")) {
+          return;
+        }
+        if (node.arguments.length === 0) {
+          context.report({
+            node,
+            messageId: "emptyPipe"
+          });
+          return;
+        }
+        if (node.arguments.length === 1) {
+          const singleArg = node.arguments[0];
+          context.report({
+            node,
+            messageId: "redundantPipe",
+            fix(fixer) {
+              return fixer.replaceText(node, sourceCode.getText(singleArg));
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-transform-in-record-key.ts
+var EXPLICIT_KEY_MUTATION_ACTION_NAMES = /* @__PURE__ */ new Set([
+  "normalize",
+  "rawTransform",
+  "transform",
+  "trim",
+  "trimEnd",
+  "trimStart"
+]);
+var noTransformInRecordKey = createRule({
+  name: "no-transform-in-record-key",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow transforms in record() key schemas, which can silently mutate keys and cause collisions."
+    },
+    schema: [],
+    messages: {
+      transformInRecordKey: "Avoid using '{{actionName}}()' in a record() key schema. Transformed record keys can change silently and collide during parsing."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    const sourceCode = context.sourceCode;
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      CallExpression(node) {
+        if (!hasValibotImports(imports) || !isValibotCall(node, imports, "record")) {
+          return;
+        }
+        for (const action of getTransformingKeyActions(
+          node.arguments[0],
+          imports,
+          sourceCode
+        )) {
+          context.report({
+            node: action.node,
+            messageId: "transformInRecordKey",
+            data: {
+              actionName: action.name
+            }
+          });
+        }
+      }
+    };
+  }
+});
+function getTransformingKeyActions(node, imports, sourceCode, visitedNodes = /* @__PURE__ */ new Set()) {
+  if (!node || visitedNodes.has(node)) {
+    return [];
+  }
+  visitedNodes.add(node);
+  if (node.type === "Identifier") {
+    const resolvedExpression = resolveIdentifierExpression(node, sourceCode);
+    return resolvedExpression ? getTransformingKeyActions(
+      resolvedExpression,
+      imports,
+      sourceCode,
+      visitedNodes
+    ) : [];
+  }
+  if (node.type !== "CallExpression") {
+    return [];
+  }
+  const transformingActions = isValibotCall(node, imports, "pipe") ? getPipeActionDescriptors(node, imports, sourceCode).filter(
+    (action) => isTransformingKeyActionName(action.name)
+  ) : [];
+  return [
+    ...transformingActions,
+    ...node.arguments.flatMap(
+      (argument) => getTransformingKeyActions(argument, imports, sourceCode, visitedNodes)
+    )
+  ];
+}
+function resolveIdentifierExpression(node, sourceCode) {
+  let scope = sourceCode.getScope(node);
+  while (scope) {
+    const definition = scope.set.get(node.name)?.defs[0];
+    if (definition?.node.type === "VariableDeclarator") {
+      return definition.node.init ?? null;
+    }
+    scope = scope.upper;
+  }
+  return null;
+}
+function isTransformingKeyActionName(name) {
+  return EXPLICIT_KEY_MUTATION_ACTION_NAMES.has(name) || /^to[A-Z]/u.test(name);
+}
+
+// src/utils/issue-message-signatures.ts
+var ISSUE_MESSAGE_PARAMETER_INDEX_ZERO = /* @__PURE__ */ new Set([
+  "base64",
+  "bic",
+  "bigint",
+  "blob",
+  "boolean",
+  "creditCard",
+  "cuid2",
+  "date",
+  "decimal",
+  "digits",
+  "domain",
+  "email",
+  "emoji",
+  "empty",
+  "file",
+  "finite",
+  "function",
+  "hexadecimal",
+  "hexColor",
+  "imei",
+  "integer",
+  "ip",
+  "ipv4",
+  "ipv6",
+  "isbn",
+  "isoDate",
+  "isoDateTime",
+  "isoDateTimeSecond",
+  "isoTime",
+  "isoTimeSecond",
+  "isoTimestamp",
+  "isoWeek",
+  "isrc",
+  "jwsCompact",
+  "mac",
+  "mac48",
+  "mac64",
+  "nan",
+  "nanoid",
+  "never",
+  "nonEmpty",
+  "null",
+  "number",
+  "octal",
+  "promise",
+  "rfcEmail",
+  "safeInteger",
+  "slug",
+  "string",
+  "symbol",
+  "toBigint",
+  "toDate",
+  "toNumber",
+  "toString",
+  "ulid",
+  "undefined",
+  "url",
+  "uuid",
+  "void"
+]);
+var ISSUE_MESSAGE_PARAMETER_INDEX_ONE = /* @__PURE__ */ new Set([
+  "array",
+  "arrayAsync",
+  "bytes",
+  "check",
+  "checkAsync",
+  "checkItems",
+  "checkItemsAsync",
+  "custom",
+  "customAsync",
+  "endsWith",
+  "entries",
+  "enum",
+  "everyItem",
+  "excludes",
+  "graphemes",
+  "gtValue",
+  "guard",
+  "hash",
+  "includes",
+  "instance",
+  "intersect",
+  "intersectAsync",
+  "keyof",
+  "length",
+  "literal",
+  "looseObject",
+  "looseObjectAsync",
+  "looseTuple",
+  "looseTupleAsync",
+  "ltValue",
+  "maxBytes",
+  "maxEntries",
+  "maxGraphemes",
+  "maxLength",
+  "maxSize",
+  "maxValue",
+  "mimeType",
+  "minBytes",
+  "minEntries",
+  "minGraphemes",
+  "minLength",
+  "minSize",
+  "minValue",
+  "multipleOf",
+  "nonNullable",
+  "nonNullableAsync",
+  "nonNullish",
+  "nonNullishAsync",
+  "nonOptional",
+  "nonOptionalAsync",
+  "notBytes",
+  "notEntries",
+  "notGraphemes",
+  "notLength",
+  "notSize",
+  "notValue",
+  "notValues",
+  "object",
+  "objectAsync",
+  "parseBoolean",
+  "parseJson",
+  "picklist",
+  "regex",
+  "required",
+  "requiredAsync",
+  "set",
+  "setAsync",
+  "size",
+  "someItem",
+  "startsWith",
+  "strictObject",
+  "strictObjectAsync",
+  "strictTuple",
+  "strictTupleAsync",
+  "stringifyJson",
+  "tuple",
+  "tupleAsync",
+  "union",
+  "unionAsync",
+  "value",
+  "values"
+]);
+var ISSUE_MESSAGE_PARAMETER_INDEX_TWO = /* @__PURE__ */ new Set([
+  "map",
+  "mapAsync",
+  "maxWords",
+  "minWords",
+  "notWords",
+  "objectWithRest",
+  "objectWithRestAsync",
+  "partialCheck",
+  "partialCheckAsync",
+  "record",
+  "recordAsync",
+  "tupleWithRest",
+  "tupleWithRestAsync",
+  "variant",
+  "variantAsync",
+  "words"
+]);
+function getIssueMessageParameterIndex(name) {
+  if (ISSUE_MESSAGE_PARAMETER_INDEX_ZERO.has(name)) {
+    return 0;
+  }
+  if (ISSUE_MESSAGE_PARAMETER_INDEX_ONE.has(name)) {
+    return 1;
+  }
+  if (ISSUE_MESSAGE_PARAMETER_INDEX_TWO.has(name)) {
+    return 2;
+  }
+  return null;
+}
+
+// src/rules/require-issue-messages.ts
+var requireIssueMessages = createRule({
+  name: "require-issue-messages",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require explicit custom issue messages on Valibot schemas and issue-producing actions."
+    },
+    schema: [],
+    messages: {
+      missingIssueMessage: "Provide a custom issue message for '{{name}}()' using its message argument or a direct message() wrapper."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let imports = createEmptyValibotImports();
+    return {
+      Program(node) {
+        imports = collectValibotImports(node);
+      },
+      CallExpression(node) {
+        if (!hasValibotImports(imports)) {
+          return;
+        }
+        const callName = getValibotCallName(node, imports);
+        if (!callName) {
+          return;
+        }
+        const messageParameterIndex = getIssueMessageParameterIndex(callName);
+        if (messageParameterIndex === null) {
+          return;
+        }
+        if (hasInlineIssueMessage(node, messageParameterIndex) || isWrappedByDirectMessageCall(node, imports)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "missingIssueMessage",
+          data: {
+            name: callName
+          }
+        });
+      }
+    };
+  }
+});
+function hasInlineIssueMessage(node, messageParameterIndex) {
+  const messageArgument = node.arguments[messageParameterIndex];
+  return Boolean(messageArgument) && !isMissingMessageExpression(messageArgument);
+}
+function isWrappedByDirectMessageCall(node, imports) {
+  const parent = node.parent;
+  return parent?.type === "CallExpression" && parent.arguments[0] === node && isValibotCall(parent, imports, "message") && Boolean(parent.arguments[1]) && !isMissingMessageExpression(parent.arguments[1]);
+}
+function isMissingMessageExpression(node) {
+  return node.type === "Identifier" && node.name === "undefined" || node.type === "Literal" && (node.value === null || node.value === void 0) || node.type === "UnaryExpression" && node.operator === "void";
+}
+
+// src/rules/registry.ts
+var ruleRegistry = [
+  {
+    name: "no-any-schema",
+    rule: noAnySchema,
+    configs: {
+      strict: "warn"
+    }
+  },
+  {
+    name: "no-unknown-schema",
+    rule: noUnknownSchema,
+    configs: {
+      strict: "warn"
+    }
+  },
+  {
+    name: "no-unguarded-parse",
+    rule: noUnguardedParse,
+    configs: {
+      recommended: "error",
+      strict: "error"
+    }
+  },
+  {
+    name: "no-redundant-schema-wrappers",
+    rule: noRedundantSchemaWrappers,
+    configs: {
+      recommended: "error",
+      strict: "error"
+    }
+  },
+  {
+    name: "prefer-nullish",
+    rule: preferNullish,
+    configs: {
+      recommended: "warn",
+      strict: "warn"
+    }
+  },
+  {
+    name: "prefer-nullable-over-union-null",
+    rule: preferNullableOverUnionNull,
+    configs: {
+      recommended: "warn",
+      strict: "warn"
+    }
+  },
+  {
+    name: "prefer-optional-over-union-undefined",
+    rule: preferOptionalOverUnionUndefined,
+    configs: {
+      recommended: "warn",
+      strict: "warn"
+    }
+  },
+  {
+    name: "no-duplicate-pipe-actions",
+    rule: noDuplicatePipeActions,
+    configs: {
+      recommended: "warn",
+      strict: "warn"
+    }
+  },
+  {
+    name: "require-issue-messages",
+    rule: requireIssueMessages,
+    configs: {
+      strict: "warn"
+    }
+  },
+  {
+    name: "no-recreated-schemas",
+    rule: noRecreatedSchemas,
+    configs: {
+      strict: "warn"
+    }
+  },
+  {
+    name: "no-schema-as-type",
+    rule: noSchemaAsType,
+    configs: {
+      strict: "error"
+    },
+    typeScriptOnly: true
+  },
+  {
+    name: "consistent-import",
+    rule: consistentImport,
+    configs: {
+      stylistic: "warn"
+    }
+  },
+  {
+    name: "consistent-schema-convention",
+    rule: consistentSchemaConvention,
+    configs: {
+      stylistic: "warn"
+    }
+  },
+  {
+    name: "prefer-variant",
+    rule: preferVariant,
+    configs: {
+      stylistic: "warn"
+    }
+  },
+  {
+    name: "prefer-picklist",
+    rule: preferPicklist,
+    configs: {
+      stylistic: "warn"
+    }
+  },
+  {
+    name: "no-loose-object",
+    rule: noLooseObject,
+    configs: {
+      strict: "warn"
+    }
+  },
+  {
+    name: "no-instanceof-builtins",
+    rule: noInstanceofBuiltins,
+    configs: {
+      recommended: "error",
+      strict: "error"
+    }
+  },
+  {
+    name: "no-empty-pipe",
+    rule: noEmptyPipe,
+    configs: {
+      recommended: "error",
+      strict: "error"
+    }
+  },
+  {
+    name: "no-transform-in-record-key",
+    rule: noTransformInRecordKey,
+    configs: {
+      recommended: "error",
+      strict: "error"
+    }
+  }
+];
+var rules = Object.fromEntries(
+  ruleRegistry.map(({ name, rule }) => [name, rule])
+);
+function getRulesForConfig(configName) {
+  return Object.fromEntries(
+    ruleRegistry.flatMap(({ name, configs: configs2 }) => {
+      const entry = configs2[configName];
+      return entry ? [[`valibot/${name}`, entry]] : [];
+    })
+  );
+}
+function getRuleNamesForConfig(configName) {
+  return ruleRegistry.filter(({ configs: configs2 }) => configName in configs2).map(({ name }) => name).sort();
+}
+
+// src/configs/flat/recommended.ts
+function createRecommendedConfig(plugin2) {
+  return [
+    {
+      name: "valibot/recommended",
+      plugins: {
+        valibot: plugin2
+      },
+      rules: getRulesForConfig("recommended")
+    }
+  ];
+}
+
+// src/configs/flat/strict.ts
+function createStrictConfig(plugin2) {
+  return [
+    {
+      name: "valibot/strict",
+      plugins: {
+        valibot: plugin2
+      },
+      rules: getRulesForConfig("strict")
+    }
+  ];
+}
+
+// src/configs/flat/stylistic.ts
+function createStylisticConfig(plugin2) {
+  return [
+    {
+      name: "valibot/stylistic",
+      plugins: {
+        valibot: plugin2
+      },
+      rules: getRulesForConfig("stylistic")
+    }
+  ];
+}
+
+// src/configs/flat/index.ts
+function createFlatConfigs(plugin2) {
+  return {
+    recommended: createRecommendedConfig(plugin2),
+    strict: createStrictConfig(plugin2),
+    stylistic: createStylisticConfig(plugin2)
+  };
+}
+
+// src/configs/legacy/recommended.ts
+var recommended = {
+  plugins: ["valibot"],
+  rules: getRulesForConfig("recommended")
+};
+
+// src/configs/legacy/strict.ts
+var strict = {
+  plugins: ["valibot"],
+  rules: getRulesForConfig("strict")
+};
+
+// src/configs/legacy/stylistic.ts
+var stylistic = {
+  plugins: ["valibot"],
+  rules: getRulesForConfig("stylistic")
+};
+
+// src/configs/legacy/index.ts
+var legacyConfigs = {
+  recommended,
+  strict,
+  stylistic
+};
+
+// src/plugin.ts
+var basePlugin = {
+  meta: {
+    name: "eslint-plugin-valibot",
+    version: package_default.version
+  },
+  rules,
+  configs: legacyConfigs
+};
+var flatConfigs = createFlatConfigs(basePlugin);
+var configs = legacyConfigs;
+var plugin = {
+  ...basePlugin,
+  flatConfigs
+};
+var plugin_default = plugin;
+export {
+  configs,
+  consistentImport,
+  consistentSchemaConvention,
+  plugin_default as default,
+  flatConfigs,
+  getRuleNamesForConfig,
+  getRulesForConfig,
+  noAnySchema,
+  noDuplicatePipeActions,
+  noLooseObject,
+  noRecreatedSchemas,
+  noRedundantSchemaWrappers,
+  noSchemaAsType,
+  noTransformInRecordKey,
+  noUnguardedParse,
+  noUnknownSchema,
+  preferNullableOverUnionNull,
+  preferNullish,
+  preferOptionalOverUnionUndefined,
+  preferPicklist,
+  preferVariant,
+  ruleRegistry,
+  rules
+};
+//# sourceMappingURL=index.mjs.map