eslint-plugin-zod 4.12.0 → 4.13.0

package/README.md

@@ -44,7 +44,9 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 | [no-coerce-boolean](docs/rules/no-coerce-boolean.md)                                             | Disallow `z.coerce.boolean()` because it treats any non-empty string as `true`.                                                | ✅  |     | 💡  |     |
 | [no-conflicting-checks](docs/rules/no-conflicting-checks.md)                                     | Disallow check combinations that can never match, are redundant, or do not apply to the schema type                            |     |     |     |     |
 | [no-duplicate-schema-methods](docs/rules/no-duplicate-schema-methods.md)                         | Disallow calling the same schema method more than once in a single chain                                                       | ✅  |     |     |     |
+| [no-dynamic-schema-value](docs/rules/no-dynamic-schema-value.md)                                 | Disallow non-static values passed as arguments in a Zod schema expression                                                      |     |     |     |     |
 | [no-empty-custom-schema](docs/rules/no-empty-custom-schema.md)                                   | Disallow usage of `z.custom()` without arguments                                                                               | ✅  |     |     |     |
+| [no-function-scoped-schema](docs/rules/no-function-scoped-schema.md)                             | Disallow constructing a Zod schema inside a function body                                                                      |     |     |     |     |
 | [no-native-enum](docs/rules/no-native-enum.md)                                                   | Disallow deprecated `z.nativeEnum()` in favor of `z.enum()`.                                                                   | ✅  | 🔧  |     |     |
 | [no-number-schema-with-finite](docs/rules/no-number-schema-with-finite.md)                       | Disallow deprecated `z.number().finite()`. In Zod 4+ number schemas do not allow infinite values by default, so it is a no-op. | ✅  | 🔧  |     |     |
 | [no-number-schema-with-int](docs/rules/no-number-schema-with-int.md)                             | Disallow usage of `z.number().int()` as it is considered legacy                                                                | ✅  | 🔧  |     |     |
@@ -73,6 +75,7 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 | [prefer-top-level-string-formats](docs/rules/prefer-top-level-string-formats.md)                 | Prefer top-level string format schemas over deprecated `z.string().<format>()` methods                                         | ✅  | 🔧  |     |     |
 | [prefer-trim-before-string-length-checks](docs/rules/prefer-trim-before-string-length-checks.md) | Enforce `.trim()` is called before string length checks to ensure accurate validation                                          | ✅  | 🔧  |     |     |
 | [prefer-tuple-over-array-length](docs/rules/prefer-tuple-over-array-length.md)                   | Prefer `z.tuple()` over a length-constrained `z.array()` so the length is preserved in the inferred type.                      |     | 🔧  |     |     |
+| [prefer-validate](docs/rules/prefer-validate.md)                                                 | Prefer boolean validation when only the success of parsing is used                                                             |     |     | 💡  |     |
 | [require-brand-type-parameter](docs/rules/require-brand-type-parameter.md)                       | Require type parameter on `.brand()` functions                                                                                 | ✅  |     | 💡  |     |
 | [require-error-message](docs/rules/require-error-message.md)                                     | Enforce that custom refinements include an error message                                                                       | ✅  | 🔧  |     |     |
 | [schema-error-property-style](docs/rules/schema-error-property-style.md)                         | Enforce consistent style for error messages in Zod schema validation (using ESQuery patterns)                                  |     |     |     |     |

package/dist/index.cjs

@@ -9,7 +9,9 @@ const require_no_any_schema = require("./rules/no-any-schema.cjs");
 const require_no_coerce_boolean = require("./rules/no-coerce-boolean.cjs");
 const require_no_conflicting_checks = require("./rules/no-conflicting-checks.cjs");
 const require_no_duplicate_schema_methods = require("./rules/no-duplicate-schema-methods.cjs");
+const require_no_dynamic_schema_value = require("./rules/no-dynamic-schema-value.cjs");
 const require_no_empty_custom_schema = require("./rules/no-empty-custom-schema.cjs");
+const require_no_function_scoped_schema = require("./rules/no-function-scoped-schema.cjs");
 const require_no_native_enum = require("./rules/no-native-enum.cjs");
 const require_no_number_schema_with_finite = require("./rules/no-number-schema-with-finite.cjs");
 const require_no_number_schema_with_int = require("./rules/no-number-schema-with-int.cjs");
@@ -38,6 +40,7 @@ const require_prefer_string_schema_with_trim = require("./rules/prefer-string-sc
 const require_prefer_top_level_string_formats = require("./rules/prefer-top-level-string-formats.cjs");
 const require_prefer_trim_before_string_length_checks = require("./rules/prefer-trim-before-string-length-checks.cjs");
 const require_prefer_tuple_over_array_length = require("./rules/prefer-tuple-over-array-length.cjs");
+const require_prefer_validate = require("./rules/prefer-validate.cjs");
 const require_require_brand_type_parameter = require("./rules/require-brand-type-parameter.cjs");
 const require_require_error_message = require("./rules/require-error-message.cjs");
 const require_schema_error_property_style = require("./rules/schema-error-property-style.cjs");
@@ -58,7 +61,9 @@ const eslintPluginZod = {
 		"no-coerce-boolean": require_no_coerce_boolean.noCoerceBoolean,
 		"no-conflicting-checks": require_no_conflicting_checks.noConflictingChecks,
 		"no-duplicate-schema-methods": require_no_duplicate_schema_methods.noDuplicateSchemaMethods,
+		"no-dynamic-schema-value": require_no_dynamic_schema_value.noDynamicSchemaValue,
 		"no-empty-custom-schema": require_no_empty_custom_schema.noEmptyCustomSchema,
+		"no-function-scoped-schema": require_no_function_scoped_schema.noFunctionScopedSchema,
 		"no-native-enum": require_no_native_enum.noNativeEnum,
 		"no-number-schema-with-finite": require_no_number_schema_with_finite.noNumberSchemaWithFinite,
 		"no-number-schema-with-int": require_no_number_schema_with_int.noNumberSchemaWithInt,
@@ -87,6 +92,7 @@ const eslintPluginZod = {
 		"prefer-string-schema-with-trim": require_prefer_string_schema_with_trim.preferStringSchemaWithTrim,
 		"prefer-trim-before-string-length-checks": require_prefer_trim_before_string_length_checks.preferTrimBeforeStringLengthChecks,
 		"prefer-tuple-over-array-length": require_prefer_tuple_over_array_length.preferTupleOverArrayLength,
+		"prefer-validate": require_prefer_validate.preferValidate,
 		"require-brand-type-parameter": require_require_brand_type_parameter.requireBrandTypeParameter,
 		"require-error-message": require_require_error_message.requireErrorMessage,
 		"schema-error-property-style": require_schema_error_property_style.schemaErrorPropertyStyle

package/dist/index.mjs

@@ -9,7 +9,9 @@ import { noAnySchema } from "./rules/no-any-schema.mjs";
 import { noCoerceBoolean } from "./rules/no-coerce-boolean.mjs";
 import { noConflictingChecks } from "./rules/no-conflicting-checks.mjs";
 import { noDuplicateSchemaMethods } from "./rules/no-duplicate-schema-methods.mjs";
+import { noDynamicSchemaValue } from "./rules/no-dynamic-schema-value.mjs";
 import { noEmptyCustomSchema } from "./rules/no-empty-custom-schema.mjs";
+import { noFunctionScopedSchema } from "./rules/no-function-scoped-schema.mjs";
 import { noNativeEnum } from "./rules/no-native-enum.mjs";
 import { noNumberSchemaWithFinite } from "./rules/no-number-schema-with-finite.mjs";
 import { noNumberSchemaWithInt } from "./rules/no-number-schema-with-int.mjs";
@@ -38,6 +40,7 @@ import { preferStringSchemaWithTrim } from "./rules/prefer-string-schema-with-tr
 import { preferTopLevelStringFormats } from "./rules/prefer-top-level-string-formats.mjs";
 import { preferTrimBeforeStringLengthChecks } from "./rules/prefer-trim-before-string-length-checks.mjs";
 import { preferTupleOverArrayLength } from "./rules/prefer-tuple-over-array-length.mjs";
+import { preferValidate } from "./rules/prefer-validate.mjs";
 import { requireBrandTypeParameter } from "./rules/require-brand-type-parameter.mjs";
 import { requireErrorMessage } from "./rules/require-error-message.mjs";
 import { schemaErrorPropertyStyle } from "./rules/schema-error-property-style.mjs";
@@ -58,7 +61,9 @@ const eslintPluginZod = {
 		"no-coerce-boolean": noCoerceBoolean,
 		"no-conflicting-checks": noConflictingChecks,
 		"no-duplicate-schema-methods": noDuplicateSchemaMethods,
+		"no-dynamic-schema-value": noDynamicSchemaValue,
 		"no-empty-custom-schema": noEmptyCustomSchema,
+		"no-function-scoped-schema": noFunctionScopedSchema,
 		"no-native-enum": noNativeEnum,
 		"no-number-schema-with-finite": noNumberSchemaWithFinite,
 		"no-number-schema-with-int": noNumberSchemaWithInt,
@@ -87,6 +92,7 @@ const eslintPluginZod = {
 		"prefer-string-schema-with-trim": preferStringSchemaWithTrim,
 		"prefer-trim-before-string-length-checks": preferTrimBeforeStringLengthChecks,
 		"prefer-tuple-over-array-length": preferTupleOverArrayLength,
+		"prefer-validate": preferValidate,
 		"require-brand-type-parameter": requireBrandTypeParameter,
 		"require-error-message": requireErrorMessage,
 		"schema-error-property-style": schemaErrorPropertyStyle

package/dist/rules/array-style.cjs

@@ -1,5 +1,7 @@
 const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+const require_has_zod_runtime_import_root = require("../utils/has-zod-runtime-import-root.cjs");
 let _eslint_zod_utils = require("@eslint-zod/utils");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
 const arrayStyle = require_create_plugin_rule.createZodPluginRule({
 	name: "array-style",
 	meta: {
@@ -23,8 +25,9 @@ const arrayStyle = require_create_plugin_rule.createZodPluginRule({
 	defaultOptions: [{ style: "function" }],
 	create(context, [{ style }]) {
 		const { sourceCode } = context;
-		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({ onSchema(node, zodSchemaMeta) {
+			if (!require_has_zod_runtime_import_root.hasZodRuntimeImportRoot(node, sourceCode)) return;
 			const { schemaDecl, schemaType } = zodSchemaMeta;
 			if (style === "method") {
 				if (schemaType === "array") {
@@ -34,9 +37,10 @@ const arrayStyle = require_create_plugin_rule.createZodPluginRule({
 							messageId: "useMethod",
 							fix(fixer) {
 								const arrayCall = collectZodChainMethods(node).find((c) => c.name === "array");
-								if (!arrayCall) return null;
-								const arg = arrayCall.node.arguments.at(0);
-								if (!arg) return null;
+								if (arrayCall?.node.arguments.length !== 1 || arrayCall.node.typeArguments || arrayCall.node.optional || arrayCall.node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && arrayCall.node.callee.optional) return null;
+								const [arg] = arrayCall.node.arguments;
+								if (arg.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier && arg.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && arg.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return null;
+								if (sourceCode.getCommentsInside(arrayCall.node).some((comment) => comment.range[0] < arg.range[0] || comment.range[1] > arg.range[1])) return null;
 								const argText = sourceCode.getText(arg);
 								return fixer.replaceText(arrayCall.node, `${argText}.array()`);
 							}

package/dist/rules/array-style.mjs

@@ -1,5 +1,7 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { hasZodRuntimeImportRoot } from "../utils/has-zod-runtime-import-root.mjs";
 import { zodImportScope } from "@eslint-zod/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 const arrayStyle = createZodPluginRule({
 	name: "array-style",
 	meta: {
@@ -23,8 +25,9 @@ const arrayStyle = createZodPluginRule({
 	defaultOptions: [{ style: "function" }],
 	create(context, [{ style }]) {
 		const { sourceCode } = context;
-		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({ onSchema(node, zodSchemaMeta) {
+			if (!hasZodRuntimeImportRoot(node, sourceCode)) return;
 			const { schemaDecl, schemaType } = zodSchemaMeta;
 			if (style === "method") {
 				if (schemaType === "array") {
@@ -34,9 +37,10 @@ const arrayStyle = createZodPluginRule({
 							messageId: "useMethod",
 							fix(fixer) {
 								const arrayCall = collectZodChainMethods(node).find((c) => c.name === "array");
-								if (!arrayCall) return null;
-								const arg = arrayCall.node.arguments.at(0);
-								if (!arg) return null;
+								if (arrayCall?.node.arguments.length !== 1 || arrayCall.node.typeArguments || arrayCall.node.optional || arrayCall.node.callee.type === AST_NODE_TYPES.MemberExpression && arrayCall.node.callee.optional) return null;
+								const [arg] = arrayCall.node.arguments;
+								if (arg.type !== AST_NODE_TYPES.Identifier && arg.type !== AST_NODE_TYPES.MemberExpression && arg.type !== AST_NODE_TYPES.CallExpression) return null;
+								if (sourceCode.getCommentsInside(arrayCall.node).some((comment) => comment.range[0] < arg.range[0] || comment.range[1] > arg.range[1])) return null;
 								const argText = sourceCode.getText(arg);
 								return fixer.replaceText(arrayCall.node, `${argText}.array()`);
 							}

package/dist/rules/no-dynamic-schema-value.cjs

@@ -0,0 +1,17 @@
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _eslint_zod_utils_rule_builders_no_dynamic_schema_value = require("@eslint-zod/utils/rule-builders/no-dynamic-schema-value");
+//#region src/rules/no-dynamic-schema-value.ts
+const noDynamicSchemaValue = require_create_plugin_rule.createZodPluginRule({
+	name: "no-dynamic-schema-value",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow non-static values passed as arguments in a Zod schema expression" },
+		messages: { dynamicValue: "This value must be a literal or an imported binding to be hoistable by tools like `zod-compiler`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (0, _eslint_zod_utils_rule_builders_no_dynamic_schema_value.buildNoDynamicSchemaValueCreate)(_eslint_zod_utils.zodImportScope)
+});
+//#endregion
+exports.noDynamicSchemaValue = noDynamicSchemaValue;

package/dist/rules/no-dynamic-schema-value.mjs

@@ -0,0 +1,17 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { zodImportScope } from "@eslint-zod/utils";
+import { buildNoDynamicSchemaValueCreate } from "@eslint-zod/utils/rule-builders/no-dynamic-schema-value";
+//#region src/rules/no-dynamic-schema-value.ts
+const noDynamicSchemaValue = createZodPluginRule({
+	name: "no-dynamic-schema-value",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow non-static values passed as arguments in a Zod schema expression" },
+		messages: { dynamicValue: "This value must be a literal or an imported binding to be hoistable by tools like `zod-compiler`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: buildNoDynamicSchemaValueCreate(zodImportScope)
+});
+//#endregion
+export { noDynamicSchemaValue };

package/dist/rules/no-function-scoped-schema.cjs

@@ -0,0 +1,17 @@
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _eslint_zod_utils_rule_builders_no_function_scoped_schema = require("@eslint-zod/utils/rule-builders/no-function-scoped-schema");
+//#region src/rules/no-function-scoped-schema.ts
+const noFunctionScopedSchema = require_create_plugin_rule.createZodPluginRule({
+	name: "no-function-scoped-schema",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow constructing a Zod schema inside a function body" },
+		messages: { functionScopedSchema: "This schema is constructed inside a function and rebuilt on every call. Declare it once at module scope instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (0, _eslint_zod_utils_rule_builders_no_function_scoped_schema.buildNoFunctionScopedSchemaCreate)(_eslint_zod_utils.zodImportScope)
+});
+//#endregion
+exports.noFunctionScopedSchema = noFunctionScopedSchema;

package/dist/rules/no-function-scoped-schema.mjs

@@ -0,0 +1,17 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { zodImportScope } from "@eslint-zod/utils";
+import { buildNoFunctionScopedSchemaCreate } from "@eslint-zod/utils/rule-builders/no-function-scoped-schema";
+//#region src/rules/no-function-scoped-schema.ts
+const noFunctionScopedSchema = createZodPluginRule({
+	name: "no-function-scoped-schema",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow constructing a Zod schema inside a function body" },
+		messages: { functionScopedSchema: "This schema is constructed inside a function and rebuilt on every call. Declare it once at module scope instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: buildNoFunctionScopedSchemaCreate(zodImportScope)
+});
+//#endregion
+export { noFunctionScopedSchema };

package/dist/rules/no-number-schema-with-finite.cjs

@@ -12,7 +12,7 @@ const noNumberSchemaWithFinite = require_create_plugin_rule.createZodPluginRule(
 	},
 	defaultOptions: [],
 	create(context) {
-		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({
 			schemaType: "number",
 			onSchema(node, zodSchemaMeta) {

package/dist/rules/no-number-schema-with-finite.mjs

@@ -12,7 +12,7 @@ const noNumberSchemaWithFinite = createZodPluginRule({
 	},
 	defaultOptions: [],
 	create(context) {
-		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({
 			schemaType: "number",
 			onSchema(node, zodSchemaMeta) {

package/dist/rules/no-number-schema-with-step.cjs

@@ -12,7 +12,7 @@ const noNumberSchemaWithStep = require_create_plugin_rule.createZodPluginRule({
 	},
 	defaultOptions: [],
 	create(context) {
-		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({
 			schemaType: "number",
 			onSchema(node, zodSchemaMeta) {

package/dist/rules/no-number-schema-with-step.mjs

@@ -12,7 +12,7 @@ const noNumberSchemaWithStep = createZodPluginRule({
 	},
 	defaultOptions: [],
 	create(context) {
-		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({
 			schemaType: "number",
 			onSchema(node, zodSchemaMeta) {

package/dist/rules/no-optional-and-default-together.cjs

@@ -30,7 +30,7 @@ const noOptionalAndDefaultTogether = require_create_plugin_rule.createZodPluginR
 	defaultOptions: [defaultOptions],
 	create(context, [{ preferredMethod }]) {
 		const { sourceCode } = context;
-		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({ onSchema(node) {
 			const methods = collectZodChainMethods(node);
 			if (methods.length === 0) return;

package/dist/rules/no-optional-and-default-together.mjs

@@ -30,7 +30,7 @@ const noOptionalAndDefaultTogether = createZodPluginRule({
 	defaultOptions: [defaultOptions],
 	create(context, [{ preferredMethod }]) {
 		const { sourceCode } = context;
-		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({ onSchema(node) {
 			const methods = collectZodChainMethods(node);
 			if (methods.length === 0) return;

package/dist/rules/no-transform-in-record-key.cjs

@@ -1,6 +1,5 @@
 const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
 let _eslint_zod_utils = require("@eslint-zod/utils");
-let _typescript_eslint_utils = require("@typescript-eslint/utils");
 let _eslint_zod_utils_rule_builders_no_transform_in_record_key = require("@eslint-zod/utils/rule-builders/no-transform-in-record-key");
 //#region src/rules/no-transform-in-record-key.ts
 const TRANSFORM_METHODS = [
@@ -17,10 +16,7 @@ const noTransformInRecordKey = require_create_plugin_rule.createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create: (0, _eslint_zod_utils_rule_builders_no_transform_in_record_key.buildNoTransformInRecordKeyCreate)(_eslint_zod_utils.zodImportScope, { findTransformNode(keySchema, { collectZodChainMethods }) {
-		if (keySchema.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return null;
-		return collectZodChainMethods(keySchema).some((method) => TRANSFORM_METHODS.includes(method.name)) ? keySchema : null;
-	} })
+	create: (0, _eslint_zod_utils_rule_builders_no_transform_in_record_key.buildNoTransformInRecordKeyCreate)(_eslint_zod_utils.zodImportScope, TRANSFORM_METHODS)
 });
 //#endregion
 exports.noTransformInRecordKey = noTransformInRecordKey;

package/dist/rules/no-transform-in-record-key.mjs

@@ -1,6 +1,5 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
 import { ZOD_MUTATING_CHECK_NAMES, zodImportScope } from "@eslint-zod/utils";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 import { buildNoTransformInRecordKeyCreate } from "@eslint-zod/utils/rule-builders/no-transform-in-record-key";
 //#region src/rules/no-transform-in-record-key.ts
 const TRANSFORM_METHODS = [
@@ -17,10 +16,7 @@ const noTransformInRecordKey = createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create: buildNoTransformInRecordKeyCreate(zodImportScope, { findTransformNode(keySchema, { collectZodChainMethods }) {
-		if (keySchema.type !== AST_NODE_TYPES.CallExpression) return null;
-		return collectZodChainMethods(keySchema).some((method) => TRANSFORM_METHODS.includes(method.name)) ? keySchema : null;
-	} })
+	create: buildNoTransformInRecordKeyCreate(zodImportScope, TRANSFORM_METHODS)
 });
 //#endregion
 export { noTransformInRecordKey };

package/dist/rules/prefer-meta-last.cjs

@@ -12,7 +12,7 @@ const preferMetaLast = require_create_plugin_rule.createZodPluginRule({
 	},
 	defaultOptions: [],
 	create(context) {
-		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({ onSchema(node) {
 			const chain = collectZodChainMethods(node);
 			const metaIndex = chain.findIndex((c) => c.name === "meta");

package/dist/rules/prefer-meta-last.mjs

@@ -12,7 +12,7 @@ const preferMetaLast = createZodPluginRule({
 	},
 	defaultOptions: [],
 	create(context) {
-		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({ onSchema(node) {
 			const chain = collectZodChainMethods(node);
 			const metaIndex = chain.findIndex((c) => c.name === "meta");

package/dist/rules/prefer-meta.cjs

@@ -12,7 +12,7 @@ const preferMeta = require_create_plugin_rule.createZodPluginRule({
 	},
 	defaultOptions: [],
 	create(context) {
-		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({ onSchema(node) {
 			const describe = collectZodChainMethods(node).find((it) => it.name === "describe");
 			if (!describe) return;

package/dist/rules/prefer-meta.mjs

@@ -12,7 +12,7 @@ const preferMeta = createZodPluginRule({
 	},
 	defaultOptions: [],
 	create(context) {
-		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({ onSchema(node) {
 			const describe = collectZodChainMethods(node).find((it) => it.name === "describe");
 			if (!describe) return;

package/dist/rules/prefer-string-schema-with-trim.cjs

@@ -12,7 +12,7 @@ const preferStringSchemaWithTrim = require_create_plugin_rule.createZodPluginRul
 	},
 	defaultOptions: [],
 	create(context) {
-		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({
 			schemaType: "string",
 			onSchema(node, zodSchemaMeta) {

package/dist/rules/prefer-string-schema-with-trim.mjs

@@ -12,7 +12,7 @@ const preferStringSchemaWithTrim = createZodPluginRule({
 	},
 	defaultOptions: [],
 	create(context) {
-		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({
 			schemaType: "string",
 			onSchema(node, zodSchemaMeta) {

package/dist/rules/prefer-trim-before-string-length-checks.cjs

@@ -17,7 +17,7 @@ const preferTrimBeforeStringLengthChecks = require_create_plugin_rule.createZodP
 	},
 	defaultOptions: [],
 	create(context) {
-		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({
 			schemaType: "string",
 			onSchema(node, zodSchemaMeta) {

package/dist/rules/prefer-trim-before-string-length-checks.mjs

@@ -17,7 +17,7 @@ const preferTrimBeforeStringLengthChecks = createZodPluginRule({
 	},
 	defaultOptions: [],
 	create(context) {
-		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
+		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({
 			schemaType: "string",
 			onSchema(node, zodSchemaMeta) {

package/dist/rules/prefer-validate.cjs

@@ -0,0 +1,21 @@
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _eslint_zod_utils_rule_builders_prefer_validate = require("@eslint-zod/utils/rule-builders/prefer-validate");
+//#region src/rules/prefer-validate.ts
+const preferValidate = require_create_plugin_rule.createZodPluginRule({
+	name: "prefer-validate",
+	meta: {
+		type: "suggestion",
+		hasSuggestions: true,
+		docs: { description: "Prefer boolean validation when only the success of parsing is used" },
+		messages: {
+			preferValidate: "Prefer `{{method}}` when only parse success is used.",
+			useValidate: "Replace success-only parsing with `{{method}}`."
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create: (0, _eslint_zod_utils_rule_builders_prefer_validate.buildPreferValidateCreate)(_eslint_zod_utils.zodImportScope, "schema-method")
+});
+//#endregion
+exports.preferValidate = preferValidate;

package/dist/rules/prefer-validate.mjs

@@ -0,0 +1,21 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { zodImportScope } from "@eslint-zod/utils";
+import { buildPreferValidateCreate } from "@eslint-zod/utils/rule-builders/prefer-validate";
+//#region src/rules/prefer-validate.ts
+const preferValidate = createZodPluginRule({
+	name: "prefer-validate",
+	meta: {
+		type: "suggestion",
+		hasSuggestions: true,
+		docs: { description: "Prefer boolean validation when only the success of parsing is used" },
+		messages: {
+			preferValidate: "Prefer `{{method}}` when only parse success is used.",
+			useValidate: "Replace success-only parsing with `{{method}}`."
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create: buildPreferValidateCreate(zodImportScope, "schema-method")
+});
+//#endregion
+export { preferValidate };

package/dist/utils/has-zod-runtime-import-root.cjs

@@ -0,0 +1,21 @@
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/utils/has-zod-runtime-import-root.ts
+/**
+* Whether the identifier a chain starts from resolves to a runtime zod import.
+* Bails on a root that is shadowed, re-assigned, type-only, or imported from another source —
+* every case where a fix would rewrite code that is not zod, or reference a binding erased at runtime.
+*/
+function hasZodRuntimeImportRoot(node, sourceCode) {
+	let root = node;
+	while (root.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression || root.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) root = root.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression ? root.callee : root.object;
+	if (root.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return false;
+	const variable = _typescript_eslint_utils.ASTUtils.findVariable(sourceCode.getScope(root), root);
+	if (variable?.defs.length !== 1) return false;
+	const [definition] = variable.defs;
+	if (definition.type !== _typescript_eslint_utils.TSESLint.Scope.DefinitionType.ImportBinding || definition.parent.type !== _typescript_eslint_utils.AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type" || !_eslint_zod_utils.zodImportScope.isAllowed(definition.parent.source.value)) return false;
+	const specifier = definition.node;
+	return specifier.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type";
+}
+//#endregion
+exports.hasZodRuntimeImportRoot = hasZodRuntimeImportRoot;

package/dist/utils/has-zod-runtime-import-root.mjs

@@ -0,0 +1,21 @@
+import { zodImportScope } from "@eslint-zod/utils";
+import { ASTUtils, AST_NODE_TYPES, TSESLint } from "@typescript-eslint/utils";
+//#region src/utils/has-zod-runtime-import-root.ts
+/**
+* Whether the identifier a chain starts from resolves to a runtime zod import.
+* Bails on a root that is shadowed, re-assigned, type-only, or imported from another source —
+* every case where a fix would rewrite code that is not zod, or reference a binding erased at runtime.
+*/
+function hasZodRuntimeImportRoot(node, sourceCode) {
+	let root = node;
+	while (root.type === AST_NODE_TYPES.CallExpression || root.type === AST_NODE_TYPES.MemberExpression) root = root.type === AST_NODE_TYPES.CallExpression ? root.callee : root.object;
+	if (root.type !== AST_NODE_TYPES.Identifier) return false;
+	const variable = ASTUtils.findVariable(sourceCode.getScope(root), root);
+	if (variable?.defs.length !== 1) return false;
+	const [definition] = variable.defs;
+	if (definition.type !== TSESLint.Scope.DefinitionType.ImportBinding || definition.parent.type !== AST_NODE_TYPES.ImportDeclaration || definition.parent.importKind === "type" || !zodImportScope.isAllowed(definition.parent.source.value)) return false;
+	const specifier = definition.node;
+	return specifier.type === AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type";
+}
+//#endregion
+export { hasZodRuntimeImportRoot };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-zod",
-  "version": "4.12.0",
+  "version": "4.13.0",
   "description": "ESLint plugin that adds custom linting rules to enforce best practices when using Zod",
   "keywords": [
     "eslint",
@@ -38,15 +38,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "^8.67.0",
-    "@eslint-zod/utils": "3.3.0"
+    "@typescript-eslint/utils": "^8.70.0",
+    "@eslint-zod/utils": "5.0.0"
   },
   "devDependencies": {
-    "@typescript-eslint/rule-tester": "8.67.0",
+    "@arethetypeswrong/cli": "0.18.5",
+    "@typescript-eslint/rule-tester": "8.70.0",
     "dedent": "1.7.2",
-    "eslint-doc-generator": "3.7.0",
-    "tsdown": "0.22.14",
-    "vitest": "4.1.11",
+    "eslint-doc-generator": "3.7.1",
+    "tsdown": "0.23.0",
+    "vitest": "5.0.0",
     "@eslint-zod/tooling": "0.0.0"
   },
   "peerDependencies": {
@@ -70,6 +71,7 @@
   },
   "scripts": {
     "build": "tsdown",
+    "lint:publish": "attw --pack .",
     "build:docs": "pnpm run build && eslint-doc-generator",
     "lint:docs": "eslint-doc-generator --check",
     "test": "vitest"