oxlint-plugin-react-doctor 0.2.11-dev.402c7ea → 0.2.11-dev.b2934f9

package/dist/index.d.ts

@@ -3400,6 +3400,23 @@ declare const REACT_DOCTOR_RULES: readonly [{
     readonly recommendation?: string;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/no-self-updating-effect";
+  readonly id: "no-self-updating-effect";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "State & Effects";
+    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/no-set-state";
   readonly id: "no-set-state";
@@ -5525,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";
@@ -8855,6 +8940,23 @@ declare const RULES: readonly [{
     readonly recommendation?: string;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
+}, {
+  readonly key: "react-doctor/no-self-updating-effect";
+  readonly id: "no-self-updating-effect";
+  readonly source: "react-doctor";
+  readonly originallyExternal: false;
+  readonly rule: {
+    readonly framework: "global";
+    readonly category: "State & Effects";
+    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/no-set-state";
   readonly id: "no-set-state";
@@ -10980,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

@@ -21089,6 +21089,363 @@ const noSecretsInClientCode = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/no-self-updating-effect.ts
+const doesConstructFreshReference = (node) => isNodeOfType(node, "ArrayExpression") || isNodeOfType(node, "ObjectExpression") || isNodeOfType(node, "NewExpression") || isNodeOfType(node, "Literal") && "regex" in node;
+const expressionReadsStateValue = (node, stateName) => {
+	if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression")) return false;
+	if (isNodeOfType(node, "Identifier")) return node.name === stateName;
+	if (isNodeOfType(node, "MemberExpression")) {
+		if (expressionReadsStateValue(node.object, stateName)) return true;
+		return node.computed ? expressionReadsStateValue(node.property, stateName) : false;
+	}
+	if (isNodeOfType(node, "Property")) {
+		if (node.computed && expressionReadsStateValue(node.key, stateName)) return true;
+		return expressionReadsStateValue(node.value, stateName);
+	}
+	const nodeRecord = node;
+	for (const childKey of Object.keys(nodeRecord)) {
+		if (childKey === "parent" || childKey === "type") continue;
+		const childValue = nodeRecord[childKey];
+		if (Array.isArray(childValue)) {
+			for (const childArrayItem of childValue) if (isAstNode(childArrayItem) && expressionReadsStateValue(childArrayItem, stateName)) return true;
+		} else if (isAstNode(childValue) && expressionReadsStateValue(childValue, stateName)) return true;
+	}
+	return false;
+};
+const isNonSettlingSetterArgument = (setterCall, stateName) => {
+	const firstArgument = setterCall.arguments?.[0];
+	if (!firstArgument) return false;
+	const argument = stripParenExpression(firstArgument);
+	if (isNodeOfType(argument, "Identifier") && argument.name === stateName) return false;
+	if (isNodeOfType(argument, "ArrowFunctionExpression") || isNodeOfType(argument, "FunctionExpression")) return true;
+	if (doesConstructFreshReference(argument)) return true;
+	return expressionReadsStateValue(argument, stateName);
+};
+const getUnconditionalSetterCall = (statement, setterNames) => {
+	const expression = stripParenExpression(isNodeOfType(statement, "ExpressionStatement") ? statement.expression : statement);
+	if (!isNodeOfType(expression, "CallExpression")) return null;
+	if (!isNodeOfType(expression.callee, "Identifier")) return null;
+	if (!setterNames.has(expression.callee.name)) return null;
+	return expression;
+};
+const collectDependencyStateNames = (depsNode) => {
+	const dependencyNames = /* @__PURE__ */ new Set();
+	if (!isNodeOfType(depsNode, "ArrayExpression")) return dependencyNames;
+	for (const element of depsNode.elements ?? []) if (isNodeOfType(element, "Identifier")) dependencyNames.add(element.name);
+	return dependencyNames;
+};
+const isEarlyReturnGuard = (statement) => {
+	if (!isNodeOfType(statement, "IfStatement")) return false;
+	const consequent = statement.consequent;
+	if (isNodeOfType(consequent, "ReturnStatement")) return true;
+	if (isNodeOfType(consequent, "BlockStatement")) return (consequent.body ?? []).some((inner) => isNodeOfType(inner, "ReturnStatement"));
+	return false;
+};
+const numericLiteralValue = (node) => {
+	if (isNodeOfType(node, "Literal") && typeof node.value === "number") return node.value;
+	if (isNodeOfType(node, "UnaryExpression") && node.operator === "-" && isNodeOfType(node.argument, "Literal") && typeof node.argument.value === "number") return -node.argument.value;
+	return null;
+};
+const isStateLength = (node, stateName) => {
+	const member = isNodeOfType(node, "ChainExpression") ? node.expression : node;
+	return isNodeOfType(member, "MemberExpression") && !member.computed && isNodeOfType(member.property, "Identifier") && member.property.name === "length" && expressionReadsStateValue(member.object, stateName);
+};
+const isNullishLiteral = (node) => isNodeOfType(node, "Literal") && node.value === null || isNodeOfType(node, "Identifier") && node.name === "undefined";
+const numericComparisonHolds = (operator, left, right) => {
+	switch (operator) {
+		case "<": return left < right;
+		case "<=": return left <= right;
+		case ">": return left > right;
+		case ">=": return left >= right;
+		case "===":
+		case "==": return left === right;
+		case "!==":
+		case "!=": return left !== right;
+		default: return false;
+	}
+};
+const guardExitsWhenStateEmpty = (test, stateName) => {
+	const node = isNodeOfType(test, "ChainExpression") ? test.expression : test;
+	if (isNodeOfType(node, "UnaryExpression") && node.operator === "!") return isStateLength(node.argument, stateName);
+	if (isNodeOfType(node, "LogicalExpression")) {
+		if (node.operator === "||") return guardExitsWhenStateEmpty(node.left, stateName) || guardExitsWhenStateEmpty(node.right, stateName);
+		if (node.operator === "&&") return guardExitsWhenStateEmpty(node.left, stateName) && guardExitsWhenStateEmpty(node.right, stateName);
+		return false;
+	}
+	if (isNodeOfType(node, "BinaryExpression")) {
+		const leftIsLength = isStateLength(node.left, stateName);
+		const rightIsLength = isStateLength(node.right, stateName);
+		if (leftIsLength || rightIsLength) {
+			const other = numericLiteralValue(leftIsLength ? node.right : node.left);
+			if (other === null) return false;
+			return leftIsLength ? numericComparisonHolds(node.operator, 0, other) : numericComparisonHolds(node.operator, other, 0);
+		}
+		if (node.operator === "==" || node.operator === "===") {
+			if (expressionReadsStateValue(node.left, stateName) && isNullishLiteral(node.right)) return true;
+			if (expressionReadsStateValue(node.right, stateName) && isNullishLiteral(node.left)) return true;
+		}
+		return false;
+	}
+	return false;
+};
+const isEmptyOrFalsyValue = (node) => {
+	if (isNodeOfType(node, "ArrayExpression")) return (node.elements ?? []).length === 0;
+	if (isNodeOfType(node, "ObjectExpression")) return (node.properties ?? []).length === 0;
+	if (isNodeOfType(node, "Literal")) return node.value === null || node.value === "" || node.value === 0 || node.value === false;
+	if (isNodeOfType(node, "Identifier")) return node.name === "undefined";
+	return false;
+};
+const functionReturnExpression = (fn) => {
+	if (!isNodeOfType(fn, "ArrowFunctionExpression") && !isNodeOfType(fn, "FunctionExpression")) return null;
+	if (!isNodeOfType(fn.body, "BlockStatement")) return fn.body ? stripParenExpression(fn.body) : null;
+	for (const statement of fn.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument) return stripParenExpression(statement.argument);
+	return null;
+};
+const isLengthReducingUpdater = (node) => {
+	if (!isNodeOfType(node, "ArrowFunctionExpression") && !isNodeOfType(node, "FunctionExpression")) return false;
+	const firstParameter = node.params?.[0];
+	if (!firstParameter || !isNodeOfType(firstParameter, "Identifier")) return false;
+	const returned = functionReturnExpression(node);
+	if (!returned || !isNodeOfType(returned, "CallExpression")) return false;
+	const callee = returned.callee;
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return false;
+	if (!isNodeOfType(callee.object, "Identifier") || callee.object.name !== firstParameter.name) return false;
+	if (!isNodeOfType(callee.property, "Identifier") || callee.property.name !== "slice") return false;
+	const sliceStart = numericLiteralValue(returned.arguments?.[0]);
+	return sliceStart !== null && sliceStart >= 1;
+};
+const writeProvablyConverges = (setterArgument, stateName, earlyReturnGuardTests) => {
+	if (!isEmptyOrFalsyValue(setterArgument) && !isLengthReducingUpdater(setterArgument)) return false;
+	return earlyReturnGuardTests.some((test) => guardExitsWhenStateEmpty(test, stateName));
+};
+const SYMBOLIC_DEPTH_LIMIT = 16;
+const unwrapChain = (node) => {
+	let current = node;
+	for (;;) {
+		const withoutParens = stripParenExpression(current);
+		if (withoutParens !== current) {
+			current = withoutParens;
+			continue;
+		}
+		if (isNodeOfType(current, "ChainExpression")) {
+			current = current.expression;
+			continue;
+		}
+		return current;
+	}
+};
+const isUndefinedValue = (node) => isNodeOfType(node, "Identifier") && node.name === "undefined" || isNodeOfType(node, "Literal") && node.value === null;
+const literalsEqual = (a, b) => isNodeOfType(a, "Literal") && isNodeOfType(b, "Literal") && a.value === b.value;
+const resolveValueNode = (node, writes, depth, seen) => {
+	if (depth > SYMBOLIC_DEPTH_LIMIT) return null;
+	const current = unwrapChain(node);
+	if (isNodeOfType(current, "Identifier")) {
+		if (seen.has(current.name)) return null;
+		const written = writes.get(current.name);
+		if (written) return resolveValueNode(written, writes, depth + 1, new Set(seen).add(current.name));
+		return current;
+	}
+	if (isNodeOfType(current, "Literal") || isNodeOfType(current, "ArrayExpression") || isNodeOfType(current, "ObjectExpression")) return current;
+	if (isNodeOfType(current, "MemberExpression") && !current.computed && isNodeOfType(current.property, "Identifier")) {
+		const objectValue = resolveValueNode(current.object, writes, depth + 1, seen);
+		if (objectValue && isNodeOfType(objectValue, "ObjectExpression")) {
+			const propertyKey = current.property.name;
+			const properties = objectValue.properties ?? [];
+			for (let index = properties.length - 1; index >= 0; index--) {
+				const property = properties[index];
+				if (isNodeOfType(property, "SpreadElement")) return null;
+				if (isNodeOfType(property, "Property") && !property.computed && (isNodeOfType(property.key, "Identifier") && property.key.name === propertyKey || isNodeOfType(property.key, "Literal") && property.key.value === propertyKey)) return resolveValueNode(property.value, writes, depth + 1, seen);
+			}
+		}
+		return null;
+	}
+	return null;
+};
+const resolveToNumber = (node, writes, depth, seen) => {
+	const value = resolveValueNode(node, writes, depth, seen);
+	if (value && isNodeOfType(value, "Literal") && typeof value.value === "number") return value.value;
+	const current = unwrapChain(node);
+	if (isNodeOfType(current, "MemberExpression") && !current.computed && isNodeOfType(current.property, "Identifier") && current.property.name === "length") {
+		const objectValue = resolveValueNode(current.object, writes, depth, seen);
+		if (objectValue && isNodeOfType(objectValue, "ArrayExpression")) {
+			const elements = objectValue.elements ?? [];
+			if (!elements.some((element) => element && isNodeOfType(element, "SpreadElement"))) return elements.length;
+		}
+	}
+	return null;
+};
+const provablyEqualAfterWrites = (left, right, writes, depth, seen) => {
+	const leftNumber = resolveToNumber(left, writes, depth, seen);
+	const rightNumber = resolveToNumber(right, writes, depth, seen);
+	if (leftNumber !== null && rightNumber !== null) return leftNumber === rightNumber;
+	const a = resolveValueNode(left, writes, depth, seen);
+	const b = resolveValueNode(right, writes, depth, seen);
+	if (!a || !b) return false;
+	if (literalsEqual(a, b)) return true;
+	if (isUndefinedValue(a) && isUndefinedValue(b)) return true;
+	return isNodeOfType(a, "Identifier") && isNodeOfType(b, "Identifier") && a.name === b.name;
+};
+const provablyFalsyAfterWrites = (node, writes, depth, seen) => {
+	const value = resolveValueNode(node, writes, depth, seen);
+	if (value) {
+		if (isUndefinedValue(value)) return true;
+		if (isNodeOfType(value, "Literal")) return value.value === null || value.value === 0 || value.value === false || value.value === "";
+	}
+	return resolveToNumber(node, writes, depth, seen) === 0;
+};
+const guardProvenAfterWrites = (test, writes, depth, seen) => {
+	if (depth > SYMBOLIC_DEPTH_LIMIT) return false;
+	const node = unwrapChain(test);
+	if (isNodeOfType(node, "LogicalExpression")) {
+		if (node.operator === "&&") return guardProvenAfterWrites(node.left, writes, depth + 1, seen) && guardProvenAfterWrites(node.right, writes, depth + 1, seen);
+		if (node.operator === "||") return guardProvenAfterWrites(node.left, writes, depth + 1, seen) || guardProvenAfterWrites(node.right, writes, depth + 1, seen);
+		return false;
+	}
+	if (isNodeOfType(node, "UnaryExpression") && node.operator === "!") return provablyFalsyAfterWrites(node.argument, writes, depth + 1, seen);
+	if (isNodeOfType(node, "BinaryExpression")) {
+		if (node.operator === "===" || node.operator === "==") return provablyEqualAfterWrites(node.left, node.right, writes, depth + 1, seen);
+		const leftNumber = resolveToNumber(node.left, writes, depth + 1, seen);
+		const rightNumber = resolveToNumber(node.right, writes, depth + 1, seen);
+		if (leftNumber !== null && rightNumber !== null) return numericComparisonHolds(node.operator, leftNumber, rightNumber);
+		return false;
+	}
+	const value = resolveValueNode(node, writes, depth + 1, seen);
+	if (value) {
+		if (isNodeOfType(value, "ArrayExpression") || isNodeOfType(value, "ObjectExpression")) return true;
+		if (isNodeOfType(value, "Literal")) return Boolean(value.value);
+	}
+	return false;
+};
+const collectTopLevelWrites = (statements, setterNameToStateName, setterNames) => {
+	const writes = /* @__PURE__ */ new Map();
+	const setterCallNodes = /* @__PURE__ */ new Set();
+	for (const statement of statements) {
+		const setterCall = getUnconditionalSetterCall(statement, setterNames);
+		if (!setterCall || !isNodeOfType(setterCall.callee, "Identifier")) continue;
+		setterCallNodes.add(setterCall);
+		const stateName = setterNameToStateName.get(setterCall.callee.name);
+		if (!stateName) continue;
+		const argument = setterCall.arguments?.[0];
+		if (!argument) continue;
+		const newValue = isNodeOfType(argument, "ArrowFunctionExpression") || isNodeOfType(argument, "FunctionExpression") ? functionReturnExpression(argument) : stripParenExpression(argument);
+		if (newValue) writes.set(stateName, newValue);
+	}
+	return {
+		writes,
+		setterCallNodes
+	};
+};
+const everySetterCall = (root, setterName, inspect) => {
+	let ok = true;
+	const visit = (node) => {
+		if (!ok) return;
+		if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === setterName && !inspect(node)) {
+			ok = false;
+			return;
+		}
+		const record = node;
+		for (const key of Object.keys(record)) {
+			if (key === "parent" || key === "type") continue;
+			const child = record[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isAstNode(item)) visit(item);
+			} else if (isAstNode(child)) visit(child);
+			if (!ok) return;
+		}
+	};
+	visit(root);
+	return ok;
+};
+const everyWriteToStateDrivesTowardEmpty = (callbackBody, setterName) => everySetterCall(callbackBody, setterName, (call) => {
+	const argument = call.arguments?.[0];
+	if (!argument) return true;
+	const value = stripParenExpression(argument);
+	return isEmptyOrFalsyValue(value) || isLengthReducingUpdater(value);
+});
+const everySetterCallIsTopLevel = (callbackBody, setterNames, topLevelSetterCalls) => {
+	let safe = true;
+	const visit = (node) => {
+		if (!safe) return;
+		if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && setterNames.has(node.callee.name) && !topLevelSetterCalls.has(node)) {
+			safe = false;
+			return;
+		}
+		const record = node;
+		for (const key of Object.keys(record)) {
+			if (key === "parent" || key === "type") continue;
+			const child = record[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isAstNode(item)) visit(item);
+			} else if (isAstNode(child)) visit(child);
+			if (!safe) return;
+		}
+	};
+	visit(callbackBody);
+	return safe;
+};
+const noSelfUpdatingEffect = defineRule({
+	id: "no-self-updating-effect",
+	severity: "warn",
+	tags: ["test-noise"],
+	recommendation: "Remove the feedback loop: derive the value during render, move the write into an event handler, or guard the update so it reaches a fixed point. See https://react.dev/learn/you-might-not-need-an-effect",
+	create: (context) => {
+		const checkFunctionScope = (functionBody) => {
+			if (!functionBody || !isNodeOfType(functionBody, "BlockStatement")) return;
+			const useStateBindings = collectUseStateBindings(functionBody);
+			if (useStateBindings.length === 0) return;
+			const setterNameToStateName = /* @__PURE__ */ new Map();
+			for (const binding of useStateBindings) setterNameToStateName.set(binding.setterName, binding.valueName);
+			const setterNames = new Set(setterNameToStateName.keys());
+			for (const statement of functionBody.body ?? []) {
+				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
+				const effectCall = statement.expression;
+				if (!isNodeOfType(effectCall, "CallExpression")) continue;
+				if (!isHookCall$1(effectCall, EFFECT_HOOK_NAMES$1)) continue;
+				if ((effectCall.arguments?.length ?? 0) < 2) continue;
+				const dependencyStateNames = collectDependencyStateNames(effectCall.arguments[1]);
+				if (dependencyStateNames.size === 0) continue;
+				const callback = getEffectCallback(effectCall);
+				if (!callback) continue;
+				const callbackStatements = getCallbackStatements(callback);
+				const firstWriteIndex = callbackStatements.findIndex((candidate) => getUnconditionalSetterCall(candidate, setterNames) !== null);
+				const guardCutoff = firstWriteIndex < 0 ? callbackStatements.length : firstWriteIndex;
+				const earlyReturnGuardTests = callbackStatements.slice(0, guardCutoff).filter(isEarlyReturnGuard).map((guard) => guard.test);
+				const { writes: topLevelWrites, setterCallNodes } = collectTopLevelWrites(callbackStatements, setterNameToStateName, setterNames);
+				if (everySetterCallIsTopLevel(callback, setterNames, setterCallNodes) && earlyReturnGuardTests.some((test) => guardProvenAfterWrites(test, topLevelWrites, 0, /* @__PURE__ */ new Set()))) continue;
+				const reportedStateNames = /* @__PURE__ */ new Set();
+				for (const callbackStatement of callbackStatements) {
+					const setterCall = getUnconditionalSetterCall(callbackStatement, setterNames);
+					if (!setterCall || !isNodeOfType(setterCall.callee, "Identifier")) continue;
+					const stateName = setterNameToStateName.get(setterCall.callee.name);
+					if (!stateName || !dependencyStateNames.has(stateName)) continue;
+					if (reportedStateNames.has(stateName)) continue;
+					if (!isNonSettlingSetterArgument(setterCall, stateName)) continue;
+					const firstArgument = setterCall.arguments?.[0];
+					if (firstArgument && writeProvablyConverges(stripParenExpression(firstArgument), stateName, earlyReturnGuardTests) && everyWriteToStateDrivesTowardEmpty(callback, setterCall.callee.name)) continue;
+					reportedStateNames.add(stateName);
+					context.report({
+						node: setterCall,
+						message: `${setterCall.callee.name}() runs unconditionally inside this effect, which depends on \`${stateName}\` — setting the same state the effect reacts to re-runs the effect on every commit and causes a render loop. Derive the value during render, move the write into an event handler, or guard the update so it settles.`
+					});
+				}
+			}
+		};
+		return {
+			FunctionDeclaration(node) {
+				const functionName = node.id?.name;
+				if (!functionName || !isUppercaseName(functionName) && !isReactHookName(functionName)) return;
+				checkFunctionScope(node.body);
+			},
+			VariableDeclarator(node) {
+				const isHookAssignment = isNodeOfType(node.id, "Identifier") && isReactHookName(node.id.name) && (isNodeOfType(node.init, "ArrowFunctionExpression") || isNodeOfType(node.init, "FunctionExpression"));
+				if (!isComponentAssignment(node) && !isHookAssignment) return;
+				if (!isNodeOfType(node.init, "ArrowFunctionExpression") && !isNodeOfType(node.init, "FunctionExpression")) return;
+				checkFunctionScope(node.init.body);
+			}
+		};
+	}
+});
+//#endregion
 //#region src/plugin/utils/get-parent-component.ts
 const getParentComponent = (node) => {
 	let ancestor = node.parent;
@@ -26311,6 +26668,7 @@ const REACT_NATIVE_TEXT_COMPONENT_KEYWORDS = new Set([
 	"Description",
 	"Body"
 ]);
+const REACT_NATIVE_TEXT_TRANSPARENT_COMPONENTS = new Set(["fbt", "fbs"]);
 const DEPRECATED_RN_MODULE_REPLACEMENTS = new Map([
 	["AsyncStorage", "@react-native-async-storage/async-storage"],
 	["Picker", "@react-native-picker/picker"],
@@ -27143,10 +27501,29 @@ const getRawTextDescription = (child) => {
 	}
 	return "text content";
 };
+const resolveTextBoundaryName = (openingElement) => {
+	if (isNodeOfType(openingElement.name, "JSXNamespacedName")) return openingElement.name.namespace.name;
+	return resolveJsxElementName(openingElement);
+};
 const isTextHandlingComponent = (elementName) => {
 	if (REACT_NATIVE_TEXT_COMPONENTS.has(elementName)) return true;
 	return [...REACT_NATIVE_TEXT_COMPONENT_KEYWORDS].some((keyword) => elementName.includes(keyword));
 };
+const isTransparentTextWrapper = (elementName) => elementName !== null && REACT_NATIVE_TEXT_TRANSPARENT_COMPONENTS.has(elementName);
+const isInsideTextHandlingComponent = (node) => {
+	let parentNode = node.parent;
+	while (parentNode) {
+		if (!isNodeOfType(parentNode, "JSXElement")) {
+			parentNode = parentNode.parent;
+			continue;
+		}
+		const parentName = resolveTextBoundaryName(parentNode.openingElement);
+		if (parentName && isTextHandlingComponent(parentName)) return true;
+		if (!isTransparentTextWrapper(parentName)) return false;
+		parentNode = parentNode.parent;
+	}
+	return false;
+};
 const rnNoRawText = defineRule({
 	id: "rn-no-raw-text",
 	requires: ["react-native"],
@@ -27160,9 +27537,10 @@ const rnNoRawText = defineRule({
 			},
 			JSXElement(node) {
 				if (isDomComponentFile) return;
-				const elementName = resolveJsxElementName(node.openingElement);
+				const elementName = resolveTextBoundaryName(node.openingElement);
 				if (elementName && isTextHandlingComponent(elementName)) return;
 				if (isInsidePlatformOsWebBranch(node)) return;
+				if (isTransparentTextWrapper(elementName) && isInsideTextHandlingComponent(node)) return;
 				for (const child of node.children ?? []) {
 					if (!isRawTextContent(child)) continue;
 					context.report({
@@ -33001,6 +33379,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 = [
 	{
@@ -35115,6 +35897,17 @@ const reactDoctorRules = [
 			category: "Security"
 		}
 	},
+	{
+		key: "react-doctor/no-self-updating-effect",
+		id: "no-self-updating-effect",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noSelfUpdatingEffect,
+			framework: "global",
+			category: "State & Effects"
+		}
+	},
 	{
 		key: "react-doctor/no-set-state",
 		id: "no-set-state",
@@ -36526,6 +37319,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.402c7ea",
+  "version": "0.2.11-dev.b2934f9",
   "description": "oxlint plugin for React Doctor: diagnose React codebases for security, performance, correctness, accessibility, bundle-size, and architecture issues",
   "keywords": [
     "accessibility",