oxlint-plugin-react-doctor 0.2.11-dev.b5cf767 → 0.2.11-dev.b65b157

package/dist/index.d.ts

@@ -5542,6 +5542,74 @@ declare const REACT_DOCTOR_RULES: readonly [{
     readonly recommendation?: string;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/zod-v4-no-deprecated-error-apis";
+  readonly id: "zod-v4-no-deprecated-error-apis";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Architecture";
+    readonly id: string;
+    readonly severity: RuleSeverity;
+    readonly requires?: ReadonlyArray<string>;
+    readonly disabledBy?: ReadonlyArray<string>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly defaultEnabled?: boolean;
+    readonly recommendation?: string;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
+}, {
+  readonly key: "react-doctor/zod-v4-no-deprecated-error-customization";
+  readonly id: "zod-v4-no-deprecated-error-customization";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Architecture";
+    readonly id: string;
+    readonly severity: RuleSeverity;
+    readonly requires?: ReadonlyArray<string>;
+    readonly disabledBy?: ReadonlyArray<string>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly defaultEnabled?: boolean;
+    readonly recommendation?: string;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
+}, {
+  readonly key: "react-doctor/zod-v4-no-deprecated-schema-apis";
+  readonly id: "zod-v4-no-deprecated-schema-apis";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Architecture";
+    readonly id: string;
+    readonly severity: RuleSeverity;
+    readonly requires?: ReadonlyArray<string>;
+    readonly disabledBy?: ReadonlyArray<string>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly defaultEnabled?: boolean;
+    readonly recommendation?: string;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
+}, {
+  readonly key: "react-doctor/zod-v4-prefer-top-level-string-formats";
+  readonly id: "zod-v4-prefer-top-level-string-formats";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Architecture";
+    readonly id: string;
+    readonly severity: RuleSeverity;
+    readonly requires?: ReadonlyArray<string>;
+    readonly disabledBy?: ReadonlyArray<string>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly defaultEnabled?: boolean;
+    readonly recommendation?: string;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }];
 declare const EXTERNAL_RULES: readonly [{
   readonly key: "react-hooks-js/set-state-in-render";
@@ -11014,6 +11082,74 @@ declare const RULES: readonly [{
     readonly recommendation?: string;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/zod-v4-no-deprecated-error-apis";
+  readonly id: "zod-v4-no-deprecated-error-apis";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Architecture";
+    readonly id: string;
+    readonly severity: RuleSeverity;
+    readonly requires?: ReadonlyArray<string>;
+    readonly disabledBy?: ReadonlyArray<string>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly defaultEnabled?: boolean;
+    readonly recommendation?: string;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
+}, {
+  readonly key: "react-doctor/zod-v4-no-deprecated-error-customization";
+  readonly id: "zod-v4-no-deprecated-error-customization";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Architecture";
+    readonly id: string;
+    readonly severity: RuleSeverity;
+    readonly requires?: ReadonlyArray<string>;
+    readonly disabledBy?: ReadonlyArray<string>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly defaultEnabled?: boolean;
+    readonly recommendation?: string;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
+}, {
+  readonly key: "react-doctor/zod-v4-no-deprecated-schema-apis";
+  readonly id: "zod-v4-no-deprecated-schema-apis";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Architecture";
+    readonly id: string;
+    readonly severity: RuleSeverity;
+    readonly requires?: ReadonlyArray<string>;
+    readonly disabledBy?: ReadonlyArray<string>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly defaultEnabled?: boolean;
+    readonly recommendation?: string;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
+}, {
+  readonly key: "react-doctor/zod-v4-prefer-top-level-string-formats";
+  readonly id: "zod-v4-prefer-top-level-string-formats";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "Architecture";
+    readonly id: string;
+    readonly severity: RuleSeverity;
+    readonly requires?: ReadonlyArray<string>;
+    readonly disabledBy?: ReadonlyArray<string>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly defaultEnabled?: boolean;
+    readonly recommendation?: string;
+    readonly create: (context: RuleContext) => RuleVisitors;
+  };
 }, {
   readonly key: "react-hooks-js/set-state-in-render";
   readonly source: "react-compiler";

package/dist/index.js

@@ -33358,6 +33358,410 @@ const voidDomElementsNoChildren = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/rules/zod/utils/zod-ast.ts
+const ZOD_MODULE = "zod";
+const getStaticPropertyName = (member) => {
+	const property = member.property;
+	if (!member.computed && isNodeOfType(property, "Identifier")) return property.name;
+	if (member.computed && isNodeOfType(property, "Literal") && typeof property.value === "string") return property.value;
+	return null;
+};
+const getImportInfoForIdentifier = (identifier) => {
+	const specifier = findVariableInitializer(identifier, identifier.name)?.initializer;
+	if (!specifier) return null;
+	const declaration = specifier.parent;
+	if (!declaration || !isNodeOfType(declaration, "ImportDeclaration")) return null;
+	if (declaration.source?.value !== ZOD_MODULE) return null;
+	if (isNodeOfType(specifier, "ImportNamespaceSpecifier")) return {
+		imported: null,
+		isDefault: false,
+		isNamespace: true
+	};
+	if (isNodeOfType(specifier, "ImportDefaultSpecifier")) return {
+		imported: null,
+		isDefault: true,
+		isNamespace: false
+	};
+	if (isNodeOfType(specifier, "ImportSpecifier")) {
+		const imported = specifier.imported;
+		if (isNodeOfType(imported, "Identifier")) return {
+			imported: imported.name,
+			isDefault: false,
+			isNamespace: false
+		};
+		if (isNodeOfType(imported, "Literal") && typeof imported.value === "string") return {
+			imported: imported.value,
+			isDefault: false,
+			isNamespace: false
+		};
+	}
+	return null;
+};
+const isZodNamespaceIdentifier = (node) => {
+	const inner = stripParenExpression(node);
+	if (!isNodeOfType(inner, "Identifier")) return false;
+	const info = getImportInfoForIdentifier(inner);
+	return Boolean(info && (info.isNamespace || info.isDefault || info.imported === "z"));
+};
+const getZodNamedImport = (node) => {
+	const inner = stripParenExpression(node);
+	if (!isNodeOfType(inner, "Identifier")) return null;
+	const info = getImportInfoForIdentifier(inner);
+	if (!info || info.isNamespace || info.isDefault) return null;
+	return info.imported;
+};
+const getZodNamespaceMemberName = (node) => {
+	const inner = stripParenExpression(node);
+	if (!isNodeOfType(inner, "MemberExpression")) return null;
+	if (!isZodNamespaceIdentifier(inner.object)) return null;
+	return getStaticPropertyName(inner);
+};
+const isZodFactoryCall = (callExpression, factoryNames) => {
+	const factoryName = getZodFactoryCallName(callExpression);
+	return factoryName !== null && factoryNames.has(factoryName);
+};
+const getZodFactoryCallName = (callExpression) => {
+	const callee = stripParenExpression(callExpression.callee);
+	if (isNodeOfType(callee, "Identifier")) return getZodNamedImport(callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return null;
+	const memberName = getStaticPropertyName(callee);
+	if (memberName === null) return null;
+	if (!isZodNamespaceIdentifier(callee.object)) return null;
+	return memberName;
+};
+const getMethodCall = (callExpression) => {
+	const callee = stripParenExpression(callExpression.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return null;
+	const methodName = getStaticPropertyName(callee);
+	if (!methodName) return null;
+	return {
+		methodName,
+		receiver: callee.object
+	};
+};
+const isDirectMethodCallOnZodFactory = (callExpression, factoryNames, methodNames) => {
+	const methodCall = getMethodCall(callExpression);
+	if (!methodCall || !methodNames.has(methodCall.methodName)) return false;
+	const receiver = stripParenExpression(methodCall.receiver);
+	return isNodeOfType(receiver, "CallExpression") && isZodFactoryCall(receiver, factoryNames);
+};
+const isObjectExpressionWithAnyProperty = (node, propertyNames) => {
+	if (!node) return false;
+	const inner = stripParenExpression(node);
+	if (!isNodeOfType(inner, "ObjectExpression")) return false;
+	return inner.properties.some((property) => {
+		if (!isNodeOfType(property, "Property")) return false;
+		const key = property.key;
+		if (isNodeOfType(key, "Identifier")) return propertyNames.has(key.name);
+		return isNodeOfType(key, "Literal") && typeof key.value === "string" && propertyNames.has(key.value);
+	});
+};
+//#endregion
+//#region src/plugin/rules/zod/zod-v4-no-deprecated-error-apis.ts
+const DEPRECATED_ZOD_ERROR_MEMBERS = new Set([
+	"addIssue",
+	"addIssues",
+	"errors",
+	"flatten",
+	"formErrors",
+	"format"
+]);
+const ZOD_ERROR_API_MESSAGE = "Zod 4 removes or deprecates this ZodError API; use `error.issues` or the new top-level error formatting helpers.";
+const isZodErrorReference = (node) => {
+	const inner = stripParenExpression(node);
+	if (isNodeOfType(inner, "Identifier")) return getZodNamedImport(inner) === "ZodError";
+	if (!isNodeOfType(inner, "MemberExpression")) return false;
+	return getZodNamespaceMemberName(inner) === "ZodError";
+};
+const isDirectZodErrorValue = (node) => {
+	const inner = stripParenExpression(node);
+	if (isNodeOfType(inner, "NewExpression")) return isZodErrorReference(inner.callee);
+	if (!isNodeOfType(inner, "CallExpression")) return false;
+	const methodCall = getMethodCall(inner);
+	return methodCall?.methodName === "create" && isZodErrorReference(methodCall.receiver);
+};
+const isDeprecatedZodErrorMemberAccess = (node) => {
+	if (!isNodeOfType(node, "MemberExpression")) return false;
+	const memberExpression = node;
+	const propertyName = getStaticPropertyName(memberExpression);
+	return propertyName !== null && DEPRECATED_ZOD_ERROR_MEMBERS.has(propertyName) && isDirectZodErrorValue(memberExpression.object);
+};
+const isZodErrorCreateCall = (callExpression) => {
+	const methodCall = getMethodCall(callExpression);
+	return methodCall?.methodName === "create" && isZodErrorReference(methodCall.receiver);
+};
+const isReceiverOfDeprecatedZodErrorMember = (callExpression) => {
+	const parent = callExpression.parent;
+	if (!parent || !isNodeOfType(parent, "MemberExpression")) return false;
+	if (stripParenExpression(parent.object) !== callExpression) return false;
+	return isDeprecatedZodErrorMemberAccess(parent);
+};
+const zodV4NoDeprecatedErrorApis = defineRule({
+	id: "zod-v4-no-deprecated-error-apis",
+	requires: ["zod:4"],
+	tags: ["migration-hint"],
+	severity: "warn",
+	recommendation: "Replace deprecated ZodError helpers with the Zod 4 functions: `z.treeifyError()`, `z.flattenError()`, `z.prettifyError()`, or direct `error.issues` access.",
+	create: (context) => ({
+		CallExpression(node) {
+			if (isZodErrorCreateCall(node) && isReceiverOfDeprecatedZodErrorMember(node)) return;
+			if (!isZodErrorCreateCall(node) && !isDeprecatedZodErrorMemberAccess(node.callee)) return;
+			context.report({
+				node,
+				message: ZOD_ERROR_API_MESSAGE
+			});
+		},
+		MemberExpression(node) {
+			const parent = node.parent;
+			if (parent && isNodeOfType(parent, "CallExpression") && stripParenExpression(parent.callee) === node) return;
+			if (!isDeprecatedZodErrorMemberAccess(node)) return;
+			context.report({
+				node,
+				message: ZOD_ERROR_API_MESSAGE
+			});
+		}
+	})
+});
+//#endregion
+//#region src/plugin/rules/zod/zod-v4-no-deprecated-error-customization.ts
+const ZOD_FACTORIES_WITH_ERROR_PARAMS = new Set([
+	"any",
+	"array",
+	"bigint",
+	"boolean",
+	"date",
+	"enum",
+	"literal",
+	"map",
+	"nativeEnum",
+	"never",
+	"null",
+	"number",
+	"object",
+	"record",
+	"set",
+	"string",
+	"tuple",
+	"undefined",
+	"union",
+	"unknown",
+	"void"
+]);
+const DROPPED_ERROR_OPTION_PROPERTIES = new Set([
+	"errorMap",
+	"invalid_type_error",
+	"required_error"
+]);
+const FACTORIES_WITH_LEGACY_FIRST_ARG_MESSAGE = new Set([
+	"bigint",
+	"boolean",
+	"date",
+	"number",
+	"string"
+]);
+const ERROR_MAP_PROPERTY = new Set(["errorMap"]);
+const PARSE_METHODS = new Set([
+	"parse",
+	"safeParse",
+	"parseAsync",
+	"safeParseAsync"
+]);
+const firstArgumentIsMessageString = (callExpression) => {
+	const firstArgument = callExpression.arguments[0];
+	const inner = firstArgument ? stripParenExpression(firstArgument) : null;
+	return Boolean(inner && isNodeOfType(inner, "Literal") && typeof inner.value === "string");
+};
+const factoryUsesDeprecatedErrorParameter = (callExpression) => {
+	const factoryName = getZodFactoryCallName(callExpression);
+	if (factoryName === null || !ZOD_FACTORIES_WITH_ERROR_PARAMS.has(factoryName)) return false;
+	return FACTORIES_WITH_LEGACY_FIRST_ARG_MESSAGE.has(factoryName) && firstArgumentIsMessageString(callExpression) || callExpression.arguments.some((argument) => isObjectExpressionWithAnyProperty(argument, DROPPED_ERROR_OPTION_PROPERTIES));
+};
+const parseCallUsesErrorMap = (callExpression) => {
+	const methodCall = getMethodCall(callExpression);
+	if (!methodCall || !PARSE_METHODS.has(methodCall.methodName)) return false;
+	const receiver = stripParenExpression(methodCall.receiver);
+	if (!isNodeOfType(receiver, "CallExpression")) return false;
+	if (!isZodFactoryCall(receiver, ZOD_FACTORIES_WITH_ERROR_PARAMS)) return false;
+	return isObjectExpressionWithAnyProperty(callExpression.arguments[1], ERROR_MAP_PROPERTY);
+};
+const zodV4NoDeprecatedErrorCustomization = defineRule({
+	id: "zod-v4-no-deprecated-error-customization",
+	requires: ["zod:4"],
+	tags: ["migration-hint"],
+	severity: "warn",
+	recommendation: "Use Zod 4's unified `{ error }` callback/object customization instead of string message parameters, `invalid_type_error`, `required_error`, or `errorMap`.",
+	create: (context) => ({ CallExpression(node) {
+		if (!factoryUsesDeprecatedErrorParameter(node) && !parseCallUsesErrorMap(node)) return;
+		context.report({
+			node,
+			message: "Zod 4 replaces message parameters, `invalid_type_error`, `required_error`, and `errorMap` with the unified `error` API."
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/zod/zod-v4-no-deprecated-schema-apis.ts
+const OBJECT_FACTORY = new Set(["object"]);
+const OBJECT_METHODS = new Set([
+	"deepPartial",
+	"merge",
+	"nonstrict",
+	"passthrough",
+	"strict",
+	"strip"
+]);
+const NUMBER_FACTORY = new Set(["number"]);
+const NUMBER_METHODS = new Set(["safe"]);
+const FUNCTION_FACTORY = new Set(["function"]);
+const FUNCTION_CHAIN_METHODS = new Set(["args", "returns"]);
+const DEPRECATED_TOP_LEVEL_FACTORIES = new Set([
+	"nativeEnum",
+	"ostring",
+	"onumber",
+	"oboolean",
+	"oarray",
+	"promise"
+]);
+const FACTORIES_WITH_DROPPED_CREATE = new Set([
+	"any",
+	"array",
+	"bigint",
+	"boolean",
+	"date",
+	"enum",
+	"function",
+	"literal",
+	"map",
+	"nativeEnum",
+	"never",
+	"null",
+	"number",
+	"object",
+	"optional",
+	"promise",
+	"record",
+	"set",
+	"string",
+	"tuple",
+	"undefined",
+	"union",
+	"unknown",
+	"void"
+]);
+const ENUM_PROPERTY_ALIASES = new Set(["Enum", "Values"]);
+const ENUM_FACTORY = new Set(["enum"]);
+const RECORD_FACTORY = new Set(["record"]);
+const LITERAL_FACTORY = new Set(["literal"]);
+const reportSchemaMigration = (context, node) => {
+	context.report({
+		node,
+		message: "This Zod API is deprecated or changed in Zod 4; migrate to the recommended Zod 4 schema API."
+	});
+};
+const isCallToDeprecatedTopLevelFactory = (callExpression) => isZodFactoryCall(callExpression, DEPRECATED_TOP_LEVEL_FACTORIES);
+const isCallToDroppedCreateFactory = (callExpression) => {
+	const methodCall = getMethodCall(callExpression);
+	if (!methodCall || methodCall.methodName !== "create") return false;
+	const receiver = stripParenExpression(methodCall.receiver);
+	const namespaceMemberName = getZodNamespaceMemberName(receiver);
+	if (namespaceMemberName !== null) return FACTORIES_WITH_DROPPED_CREATE.has(namespaceMemberName);
+	if (!isNodeOfType(receiver, "Identifier")) return false;
+	const imported = getZodNamedImport(receiver);
+	return imported !== null && FACTORIES_WITH_DROPPED_CREATE.has(imported);
+};
+const isSingleArgumentRecordCall = (callExpression) => callExpression.arguments.length === 1 && isZodFactoryCall(callExpression, RECORD_FACTORY);
+const isDeprecatedFunctionChainCall = (callExpression) => isDirectMethodCallOnZodFactory(callExpression, FUNCTION_FACTORY, FUNCTION_CHAIN_METHODS);
+const isSymbolLiteralArgument = (node) => {
+	if (!node) return false;
+	const inner = stripParenExpression(node);
+	if (isNodeOfType(inner, "CallExpression")) {
+		const callee = stripParenExpression(inner.callee);
+		return isNodeOfType(callee, "Identifier") && callee.name === "Symbol";
+	}
+	if (!isNodeOfType(inner, "MemberExpression")) return false;
+	const object = stripParenExpression(inner.object);
+	return isNodeOfType(object, "Identifier") && object.name === "Symbol";
+};
+const isLiteralSymbolCall = (callExpression) => callExpression.arguments.length > 0 && isZodFactoryCall(callExpression, LITERAL_FACTORY) && isSymbolLiteralArgument(callExpression.arguments[0]);
+const isDroppedEnumAliasAccess = (memberExpression) => {
+	const propertyName = getStaticPropertyName(memberExpression);
+	if (propertyName === null || !ENUM_PROPERTY_ALIASES.has(propertyName)) return false;
+	const receiver = stripParenExpression(memberExpression.object);
+	return isNodeOfType(receiver, "CallExpression") && isZodFactoryCall(receiver, ENUM_FACTORY);
+};
+const isRefineSecondArgumentFunction = (callExpression) => {
+	const methodCall = getMethodCall(callExpression);
+	if (!methodCall || methodCall.methodName !== "refine") return false;
+	const receiver = stripParenExpression(methodCall.receiver);
+	if (!isNodeOfType(receiver, "CallExpression")) return false;
+	if (!isZodFactoryCall(receiver, FACTORIES_WITH_DROPPED_CREATE)) return false;
+	const secondArgument = callExpression.arguments[1];
+	return isNodeOfType(secondArgument, "FunctionExpression") || isNodeOfType(secondArgument, "ArrowFunctionExpression");
+};
+const isZodNamespaceImportMemberCreate = (memberExpression) => {
+	if (getStaticPropertyName(memberExpression) !== "create") return false;
+	const receiver = stripParenExpression(memberExpression.object);
+	if (!isNodeOfType(receiver, "MemberExpression")) return false;
+	const factoryName = getStaticPropertyName(receiver);
+	return factoryName !== null && FACTORIES_WITH_DROPPED_CREATE.has(factoryName) && isZodNamespaceIdentifier(receiver.object);
+};
+const zodV4NoDeprecatedSchemaApis = defineRule({
+	id: "zod-v4-no-deprecated-schema-apis",
+	requires: ["zod:4"],
+	tags: ["migration-hint"],
+	severity: "warn",
+	recommendation: "Migrate Zod 4 schema APIs that were deprecated, changed, or removed: use top-level factories such as `z.enum()`, object helpers such as `z.strictObject()`, the new `z.function({ input, output })` form, and explicit key/value schemas for `z.record()`.",
+	create: (context) => ({
+		CallExpression(node) {
+			if (isCallToDeprecatedTopLevelFactory(node) || isCallToDroppedCreateFactory(node) || isSingleArgumentRecordCall(node) || isLiteralSymbolCall(node) || isDeprecatedFunctionChainCall(node) || isDirectMethodCallOnZodFactory(node, OBJECT_FACTORY, OBJECT_METHODS) || isDirectMethodCallOnZodFactory(node, NUMBER_FACTORY, NUMBER_METHODS) || isRefineSecondArgumentFunction(node)) reportSchemaMigration(context, node);
+		},
+		MemberExpression(node) {
+			const parent = node.parent;
+			if (parent && isNodeOfType(parent, "CallExpression") && stripParenExpression(parent.callee) === node) return;
+			if (isDroppedEnumAliasAccess(node) || isZodNamespaceImportMemberCreate(node)) reportSchemaMigration(context, node);
+		}
+	})
+});
+//#endregion
+//#region src/plugin/rules/zod/zod-v4-prefer-top-level-string-formats.ts
+const ZOD_STRING_FACTORY = new Set(["string"]);
+const STRING_FORMAT_METHODS = new Set([
+	"base64",
+	"base64url",
+	"cidr",
+	"cidrv4",
+	"cidrv6",
+	"cuid",
+	"cuid2",
+	"date",
+	"datetime",
+	"duration",
+	"email",
+	"emoji",
+	"ip",
+	"ipv4",
+	"ipv6",
+	"jwt",
+	"nanoid",
+	"time",
+	"ulid",
+	"url",
+	"uuid"
+]);
+const zodV4PreferTopLevelStringFormats = defineRule({
+	id: "zod-v4-prefer-top-level-string-formats",
+	requires: ["zod:4"],
+	tags: ["migration-hint"],
+	severity: "warn",
+	recommendation: "Replace deprecated `z.string().<format>()` calls with Zod 4 top-level string format APIs like `z.email()`, `z.uuid()`, `z.ipv4()`, or `z.cidrv4()`.",
+	create: (context) => ({ CallExpression(node) {
+		if (!isDirectMethodCallOnZodFactory(node, ZOD_STRING_FACTORY, STRING_FORMAT_METHODS)) return;
+		context.report({
+			node,
+			message: "Zod 4 deprecates string format methods on `z.string()`; use the matching top-level Zod format API instead."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rule-registry.ts
 const reactDoctorRules = [
 	{
@@ -36894,6 +37298,50 @@ const reactDoctorRules = [
 			framework: "global",
 			category: "Correctness"
 		}
+	},
+	{
+		key: "react-doctor/zod-v4-no-deprecated-error-apis",
+		id: "zod-v4-no-deprecated-error-apis",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...zodV4NoDeprecatedErrorApis,
+			framework: "global",
+			category: "Architecture"
+		}
+	},
+	{
+		key: "react-doctor/zod-v4-no-deprecated-error-customization",
+		id: "zod-v4-no-deprecated-error-customization",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...zodV4NoDeprecatedErrorCustomization,
+			framework: "global",
+			category: "Architecture"
+		}
+	},
+	{
+		key: "react-doctor/zod-v4-no-deprecated-schema-apis",
+		id: "zod-v4-no-deprecated-schema-apis",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...zodV4NoDeprecatedSchemaApis,
+			framework: "global",
+			category: "Architecture"
+		}
+	},
+	{
+		key: "react-doctor/zod-v4-prefer-top-level-string-formats",
+		id: "zod-v4-prefer-top-level-string-formats",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...zodV4PreferTopLevelStringFormats,
+			framework: "global",
+			category: "Architecture"
+		}
 	}
 ];
 const ruleRegistry = Object.fromEntries(reactDoctorRules.map((rule) => [rule.id, rule.rule]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.2.11-dev.b5cf767",
+  "version": "0.2.11-dev.b65b157",
   "description": "oxlint plugin for React Doctor: diagnose React codebases for security, performance, correctness, accessibility, bundle-size, and architecture issues",
   "keywords": [
     "accessibility",