oxlint-plugin-react-doctor 0.2.0-beta.4 → 0.2.0-beta.5

package/dist/index.js

@@ -47,6 +47,25 @@ const MUTATING_HTTP_METHODS = new Set([
 	"DELETE",
 	"PATCH"
 ]);
+const SAFE_MUTABLE_CONSTRUCTOR_NAMES = new Set([
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"Headers",
+	"URLSearchParams",
+	"FormData",
+	"Response",
+	"NextResponse"
+]);
+const RESPONSE_FACTORY_OBJECTS = new Set(["Response", "NextResponse"]);
+const RESPONSE_FACTORY_METHODS = new Set([
+	"json",
+	"redirect",
+	"next",
+	"rewrite",
+	"error"
+]);
 //#endregion
 //#region src/plugin/constants/dom.ts
 const PASSIVE_EVENT_NAMES = new Set([
@@ -472,22 +491,238 @@ const asyncAwaitInLoop = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/performance/async-defer-await.ts
-const collectIdentifierNames = (node, into) => {
+//#region src/plugin/utils/collect-pattern-names.ts
+const collectPatternNames = (pattern, into) => {
+	if (!pattern) return;
+	if (isNodeOfType(pattern, "Identifier")) {
+		into.add(pattern.name);
+		return;
+	}
+	if (isNodeOfType(pattern, "AssignmentPattern")) {
+		collectPatternNames(pattern.left, into);
+		return;
+	}
+	if (isNodeOfType(pattern, "RestElement")) {
+		collectPatternNames(pattern.argument, into);
+		return;
+	}
+	if (isNodeOfType(pattern, "ArrayPattern")) {
+		for (const element of pattern.elements ?? []) collectPatternNames(element, into);
+		return;
+	}
+	if (isNodeOfType(pattern, "ObjectPattern")) for (const property of pattern.properties ?? []) {
+		if (isNodeOfType(property, "RestElement")) {
+			collectPatternNames(property.argument, into);
+			continue;
+		}
+		if (isNodeOfType(property, "Property")) collectPatternNames(property.value, into);
+	}
+};
+//#endregion
+//#region src/plugin/utils/collect-reference-identifier-names.ts
+const TYPE_POSITION_KEYS = new Set([
+	"typeAnnotation",
+	"typeParameters",
+	"typeArguments",
+	"returnType",
+	"superTypeArguments",
+	"superTypeParameters"
+]);
+const collectScopedReferencesInPattern = (pattern, into, shadowed) => {
+	if (!pattern) return;
+	if (isNodeOfType(pattern, "Identifier")) return;
+	if (isNodeOfType(pattern, "AssignmentPattern")) {
+		collectScopedReferenceIdentifierNames(pattern.right, into, shadowed);
+		collectScopedReferencesInPattern(pattern.left, into, shadowed);
+		return;
+	}
+	if (isNodeOfType(pattern, "RestElement")) {
+		collectScopedReferencesInPattern(pattern.argument, into, shadowed);
+		return;
+	}
+	if (isNodeOfType(pattern, "ArrayPattern")) {
+		for (const element of pattern.elements ?? []) collectScopedReferencesInPattern(element, into, shadowed);
+		return;
+	}
+	if (isNodeOfType(pattern, "ObjectPattern")) for (const property of pattern.properties ?? []) {
+		if (isNodeOfType(property, "RestElement")) {
+			collectScopedReferencesInPattern(property.argument, into, shadowed);
+			continue;
+		}
+		if (!isNodeOfType(property, "Property")) continue;
+		if (property.computed) collectScopedReferenceIdentifierNames(property.key, into, shadowed);
+		collectScopedReferencesInPattern(property.value, into, shadowed);
+	}
+};
+const collectFromFunction = (functionNode, into, shadowed) => {
+	if (!isNodeOfType(functionNode, "FunctionDeclaration") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "ArrowFunctionExpression")) return;
+	const innerShadowed = new Set(shadowed);
+	for (const param of functionNode.params ?? []) collectPatternNames(param, innerShadowed);
+	for (const param of functionNode.params ?? []) collectScopedReferencesInPattern(param, into, innerShadowed);
+	collectScopedReferenceIdentifierNames(functionNode.body, into, innerShadowed);
+};
+const collectScopedReferenceIdentifierNames = (node, into, shadowed) => {
 	if (!node) return;
+	if (isNodeOfType(node, "Identifier")) {
+		if (!shadowed.has(node.name)) into.add(node.name);
+		return;
+	}
+	if (isNodeOfType(node, "MemberExpression")) {
+		collectScopedReferenceIdentifierNames(node.object, into, shadowed);
+		if (node.computed) collectScopedReferenceIdentifierNames(node.property, into, shadowed);
+		return;
+	}
+	if (isNodeOfType(node, "Property")) {
+		if (node.computed) collectScopedReferenceIdentifierNames(node.key, into, shadowed);
+		collectScopedReferenceIdentifierNames(node.value, into, shadowed);
+		return;
+	}
+	if (isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression")) {
+		collectFromFunction(node, into, shadowed);
+		return;
+	}
+	if (isNodeOfType(node, "TSAsExpression") || isNodeOfType(node, "TSSatisfiesExpression") || isNodeOfType(node, "TSTypeAssertion") || isNodeOfType(node, "TSNonNullExpression") || isNodeOfType(node, "TSInstantiationExpression")) {
+		collectScopedReferenceIdentifierNames(node.expression, into, shadowed);
+		return;
+	}
+	if (typeof node.type === "string" && node.type.startsWith("TS")) return;
+	for (const [key, child] of Object.entries(node)) {
+		if (key === "parent") continue;
+		if (TYPE_POSITION_KEYS.has(key)) continue;
+		if (Array.isArray(child)) {
+			for (const item of child) if (isAstNode(item)) collectScopedReferenceIdentifierNames(item, into, shadowed);
+		} else if (isAstNode(child)) collectScopedReferenceIdentifierNames(child, into, shadowed);
+	}
+};
+const collectReferenceIdentifierNames = (node, into) => collectScopedReferenceIdentifierNames(node, into, /* @__PURE__ */ new Set());
+//#endregion
+//#region src/plugin/utils/collect-pattern-default-reference-names.ts
+const collectPatternDefaultReferenceNames = (pattern, into) => {
+	if (!pattern) return;
+	if (isNodeOfType(pattern, "AssignmentPattern")) {
+		collectReferenceIdentifierNames(pattern.right, into);
+		collectPatternDefaultReferenceNames(pattern.left, into);
+		return;
+	}
+	if (isNodeOfType(pattern, "RestElement")) {
+		collectPatternDefaultReferenceNames(pattern.argument, into);
+		return;
+	}
+	if (isNodeOfType(pattern, "ArrayPattern")) {
+		for (const element of pattern.elements ?? []) collectPatternDefaultReferenceNames(element, into);
+		return;
+	}
+	if (isNodeOfType(pattern, "ObjectPattern")) {
+		for (const property of pattern.properties ?? []) if (isNodeOfType(property, "RestElement")) collectPatternDefaultReferenceNames(property.argument, into);
+		else if (isNodeOfType(property, "Property")) {
+			if (property.computed) collectReferenceIdentifierNames(property.key, into);
+			collectPatternDefaultReferenceNames(property.value, into);
+		}
+	}
+};
+//#endregion
+//#region src/plugin/utils/contains-direct-await.ts
+const containsDirectAwait = (node) => {
+	if (!node) return false;
+	let foundAwait = false;
 	walkAst(node, (child) => {
-		if (isNodeOfType(child, "Identifier")) into.add(child.name);
+		if (foundAwait) return false;
+		if (isNodeOfType(child, "FunctionDeclaration") || isNodeOfType(child, "FunctionExpression") || isNodeOfType(child, "ArrowFunctionExpression")) return false;
+		if (isNodeOfType(child, "AwaitExpression")) {
+			foundAwait = true;
+			return false;
+		}
 	});
+	return foundAwait;
+};
+//#endregion
+//#region src/plugin/utils/is-bare-await-expression-statement.ts
+const isBareAwaitExpressionStatement = (statement) => {
+	if (!isNodeOfType(statement, "ExpressionStatement")) return false;
+	return isNodeOfType(statement.expression, "AwaitExpression");
 };
-const isEarlyReturnIfStatement = (statement) => {
+//#endregion
+//#region src/plugin/utils/is-early-exit-if-statement.ts
+const isEarlyExitStatement = (statement) => isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement") || isNodeOfType(statement, "ContinueStatement") || isNodeOfType(statement, "BreakStatement");
+const isEarlyExitIfStatement = (statement) => {
 	if (!isNodeOfType(statement, "IfStatement")) return false;
 	const consequent = statement.consequent;
 	if (!consequent) return false;
-	if (isNodeOfType(consequent, "ReturnStatement")) return true;
+	if (isEarlyExitStatement(consequent)) return true;
 	if (!isNodeOfType(consequent, "BlockStatement")) return false;
-	for (const inner of consequent.body ?? []) if (isNodeOfType(inner, "ReturnStatement")) return true;
+	for (const inner of consequent.body ?? []) if (isEarlyExitStatement(inner)) return true;
+	return false;
+};
+//#endregion
+//#region src/plugin/rules/performance/async-defer-await.ts
+const hasAnyIdentifierName = (identifierNames, candidateNames) => {
+	for (const candidateName of candidateNames) if (identifierNames.has(candidateName)) return true;
 	return false;
 };
+const collectDeclaratorDependencyIdentifierNames = (declarator, into) => {
+	if (!isNodeOfType(declarator, "VariableDeclarator")) return;
+	collectReferenceIdentifierNames(declarator.init, into);
+	collectPatternDefaultReferenceNames(declarator.id, into);
+};
+const processVariableDeclaration = (declaration, awaitedBindingNames) => {
+	if (!isNodeOfType(declaration, "VariableDeclaration")) return {
+		didIntroduceAwait: false,
+		didGrowBindings: false
+	};
+	let didIntroduceAwait = false;
+	const sizeBeforeAll = awaitedBindingNames.size;
+	let hasChanged = true;
+	while (hasChanged) {
+		hasChanged = false;
+		for (const declarator of declaration.declarations ?? []) {
+			if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
+			if (containsDirectAwait(declarator.init) || containsDirectAwait(declarator.id)) {
+				didIntroduceAwait = true;
+				const sizeBefore = awaitedBindingNames.size;
+				collectPatternNames(declarator.id, awaitedBindingNames);
+				if (awaitedBindingNames.size > sizeBefore) hasChanged = true;
+				continue;
+			}
+			const dependencyIdentifiers = /* @__PURE__ */ new Set();
+			collectDeclaratorDependencyIdentifierNames(declarator, dependencyIdentifiers);
+			if (!hasAnyIdentifierName(dependencyIdentifiers, awaitedBindingNames)) continue;
+			const sizeBefore = awaitedBindingNames.size;
+			collectPatternNames(declarator.id, awaitedBindingNames);
+			if (awaitedBindingNames.size > sizeBefore) hasChanged = true;
+		}
+	}
+	const didGrowBindings = awaitedBindingNames.size > sizeBeforeAll;
+	return {
+		didIntroduceAwait,
+		didGrowBindings
+	};
+};
+const collectAwaitWindow = (statements, startIndex) => {
+	const firstStatement = statements[startIndex];
+	const awaitedBindingNames = /* @__PURE__ */ new Set();
+	let isAwaitingStatement = false;
+	if (isNodeOfType(firstStatement, "VariableDeclaration")) {
+		if (processVariableDeclaration(firstStatement, awaitedBindingNames).didIntroduceAwait) isAwaitingStatement = true;
+	} else if (isBareAwaitExpressionStatement(firstStatement)) isAwaitingStatement = true;
+	if (!isAwaitingStatement) return null;
+	let cursor = startIndex + 1;
+	while (cursor < statements.length) {
+		const candidate = statements[cursor];
+		if (isBareAwaitExpressionStatement(candidate)) {
+			cursor++;
+			continue;
+		}
+		if (!isNodeOfType(candidate, "VariableDeclaration")) break;
+		const result = processVariableDeclaration(candidate, awaitedBindingNames);
+		if (!result.didIntroduceAwait && !result.didGrowBindings) break;
+		cursor++;
+	}
+	return {
+		firstAwaitStatement: firstStatement,
+		awaitedBindingNames,
+		guardCandidateIndex: cursor
+	};
+};
 const asyncDeferAwait = defineRule({
 	id: "async-defer-await",
 	severity: "warn",
@@ -495,38 +730,44 @@ const asyncDeferAwait = defineRule({
 	create: (context) => {
 		const inspectStatements = (statements) => {
 			for (let statementIndex = 0; statementIndex < statements.length - 1; statementIndex++) {
-				const currentStatement = statements[statementIndex];
-				if (!isNodeOfType(currentStatement, "VariableDeclaration")) continue;
-				const awaitedBindingNames = /* @__PURE__ */ new Set();
-				let didAwait = false;
-				for (const declarator of currentStatement.declarations ?? []) if (isNodeOfType(declarator.init, "AwaitExpression")) {
-					didAwait = true;
-					if (isNodeOfType(declarator.id, "Identifier")) awaitedBindingNames.add(declarator.id.name);
-					else if (isNodeOfType(declarator.id, "ObjectPattern")) {
-						for (const property of declarator.id.properties ?? []) if (isNodeOfType(property, "Property") && isNodeOfType(property.value, "Identifier")) awaitedBindingNames.add(property.value.name);
-					}
+				const window = collectAwaitWindow(statements, statementIndex);
+				if (!window) continue;
+				if (window.guardCandidateIndex >= statements.length) continue;
+				const guardStatement = statements[window.guardCandidateIndex];
+				if (!isEarlyExitIfStatement(guardStatement)) continue;
+				if (!isNodeOfType(guardStatement, "IfStatement")) continue;
+				const testIdentifierNames = /* @__PURE__ */ new Set();
+				collectReferenceIdentifierNames(guardStatement.test, testIdentifierNames);
+				if (hasAnyIdentifierName(testIdentifierNames, window.awaitedBindingNames)) {
+					statementIndex = window.guardCandidateIndex - 1;
+					continue;
+				}
+				const consequentIdentifierNames = /* @__PURE__ */ new Set();
+				collectReferenceIdentifierNames(guardStatement.consequent, consequentIdentifierNames);
+				if (hasAnyIdentifierName(consequentIdentifierNames, window.awaitedBindingNames)) {
+					statementIndex = window.guardCandidateIndex - 1;
+					continue;
 				}
-				if (!didAwait) continue;
-				const nextStatement = statements[statementIndex + 1];
-				if (!isEarlyReturnIfStatement(nextStatement)) continue;
-				if (!isNodeOfType(nextStatement, "IfStatement")) continue;
-				const testIdentifiers = /* @__PURE__ */ new Set();
-				collectIdentifierNames(nextStatement.test, testIdentifiers);
-				if ([...awaitedBindingNames].some((name) => testIdentifiers.has(name))) continue;
-				const consequentIdentifiers = /* @__PURE__ */ new Set();
-				collectIdentifierNames(nextStatement.consequent, consequentIdentifiers);
-				if ([...awaitedBindingNames].some((name) => consequentIdentifiers.has(name))) continue;
 				context.report({
-					node: currentStatement,
+					node: window.firstAwaitStatement,
 					message: "await blocks the function before an early-return that doesn't use the awaited value — move the await after the synchronous guard so the skip path stays fast"
 				});
+				statementIndex = window.guardCandidateIndex - 1;
 			}
 		};
+		const inspectAllStatementBlocks = (functionBody) => {
+			if (!functionBody) return;
+			walkAst(functionBody, (descendant) => {
+				if (isNodeOfType(descendant, "FunctionDeclaration") || isNodeOfType(descendant, "FunctionExpression") || isNodeOfType(descendant, "ArrowFunctionExpression")) return false;
+				if (isNodeOfType(descendant, "BlockStatement")) inspectStatements(descendant.body ?? []);
+				else if (isNodeOfType(descendant, "SwitchCase")) inspectStatements(descendant.consequent ?? []);
+			});
+		};
 		const enterFunction = (node) => {
 			if (!isNodeOfType(node, "FunctionDeclaration") && !isNodeOfType(node, "FunctionExpression") && !isNodeOfType(node, "ArrowFunctionExpression")) return;
 			if (!node.async) return;
 			if (!isNodeOfType(node.body, "BlockStatement")) return;
-			inspectStatements(node.body.body ?? []);
+			inspectAllStatementBlocks(node.body);
 		};
 		return {
 			FunctionDeclaration: enterFunction,
@@ -575,9 +816,221 @@ const CHAINABLE_ITERATION_METHODS = new Set([
 	"forEach",
 	"flatMap"
 ]);
-const TEST_FILE_PATTERN = /\.(?:test|spec|stories)\.[tj]sx?$/;
+const ITERATOR_PRODUCING_METHOD_NAMES = new Set([
+	"values",
+	"keys",
+	"entries"
+]);
+const BROWSER_TEST_FILE_PATTERN = /\.browser\.[cm]?[jt]sx?$/;
+const TEST_LIBRARY_IMPORT_SOURCES = new Set([
+	"vitest",
+	"jest",
+	"mocha",
+	"chai",
+	"sinon",
+	"expect",
+	"ava",
+	"uvu",
+	"node:test",
+	"bun:test",
+	"@testing-library/react",
+	"@testing-library/react-native",
+	"@testing-library/react-hooks",
+	"@testing-library/dom",
+	"@testing-library/user-event",
+	"@testing-library/jest-dom",
+	"@testing-library/vue",
+	"@testing-library/svelte",
+	"@testing-library/preact",
+	"@testing-library/cypress",
+	"playwright",
+	"playwright-core",
+	"@playwright/test",
+	"@playwright/experimental-ct-react",
+	"@playwright/experimental-ct-react17",
+	"cypress",
+	"@cypress/react",
+	"@cypress/react18",
+	"@storybook/test",
+	"@storybook/test-runner",
+	"@storybook/testing-library",
+	"@storybook/jest",
+	"puppeteer",
+	"puppeteer-core",
+	"webdriverio",
+	"@wdio/globals",
+	"@nuxt/test-utils"
+]);
+const TEST_LIBRARY_IMPORT_SOURCE_PREFIXES = [
+	"vitest/",
+	"@vitest/",
+	"@jest/",
+	"@testing-library/",
+	"@playwright/",
+	"@storybook/test/",
+	"@storybook/test-runner/",
+	"@storybook/testing-library/",
+	"@cypress/",
+	"@nuxt/test-utils/"
+];
+const ORDERED_UI_FLOW_CALLEE_NAMES = new Set([
+	"render",
+	"rerender",
+	"renderHook",
+	"renderToString",
+	"renderToStaticMarkup",
+	"act",
+	"click",
+	"dblClick",
+	"dblclick",
+	"tripleClick",
+	"tap",
+	"press",
+	"longPress",
+	"type",
+	"clear",
+	"fill",
+	"focus",
+	"blur",
+	"hover",
+	"unhover",
+	"check",
+	"uncheck",
+	"selectOption",
+	"selectOptions",
+	"setChecked",
+	"setInputFiles",
+	"scrollIntoViewIfNeeded",
+	"dragTo",
+	"dragAndDrop",
+	"drop",
+	"evaluate",
+	"evaluateHandle",
+	"waitFor",
+	"waitForLoadState",
+	"waitForSelector",
+	"waitForURL",
+	"waitForResponse",
+	"waitForRequest",
+	"waitForEvent",
+	"waitForFunction",
+	"waitForElementToBeRemoved",
+	"goto",
+	"goBack",
+	"goForward",
+	"reload",
+	"screenshot",
+	"snapshot",
+	"toMatchSnapshot",
+	"toMatchInlineSnapshot",
+	"expect",
+	"expectTypeOf",
+	"step",
+	"describe",
+	"test",
+	"it",
+	"beforeAll",
+	"beforeEach",
+	"afterAll",
+	"afterEach",
+	"play",
+	"userEvent",
+	"screen",
+	"within"
+]);
+const ORDERED_UI_FLOW_CALLEE_PREFIXES = ["findBy", "findAllBy"];
+const INTENTIONAL_SEQUENCING_CALLEE_NAMES = new Set([
+	"sleep",
+	"delay",
+	"wait",
+	"pause",
+	"throttle",
+	"debounce",
+	"tick",
+	"nextTick",
+	"advanceTimersByTime",
+	"advanceTimersByTimeAsync",
+	"runAllTimers",
+	"runAllTimersAsync",
+	"runOnlyPendingTimers",
+	"runOnlyPendingTimersAsync",
+	"setTimeout",
+	"setInterval",
+	"requestAnimationFrame",
+	"requestIdleCallback",
+	"animate",
+	"transition",
+	"spring",
+	"tween",
+	"stagger",
+	"sequence",
+	"timeline",
+	"scrub"
+]);
+//#endregion
+//#region src/plugin/utils/get-callee-identifier-trail.ts
+const getCalleeIdentifierTrail = (call) => {
+	let entry = call;
+	while (isNodeOfType(entry, "ChainExpression")) entry = entry.expression;
+	if (!isNodeOfType(entry, "CallExpression") && !isNodeOfType(entry, "NewExpression")) return [];
+	const trail = [];
+	let cursor = entry.callee;
+	while (cursor) {
+		if (isNodeOfType(cursor, "ChainExpression")) {
+			cursor = cursor.expression;
+			continue;
+		}
+		if (isNodeOfType(cursor, "MemberExpression")) {
+			if (isNodeOfType(cursor.property, "Identifier")) trail.push(cursor.property.name);
+			cursor = cursor.object;
+			continue;
+		}
+		if (isNodeOfType(cursor, "CallExpression")) {
+			cursor = cursor.callee;
+			continue;
+		}
+		if (isNodeOfType(cursor, "Identifier")) trail.push(cursor.name);
+		break;
+	}
+	return trail;
+};
+//#endregion
+//#region src/plugin/utils/is-test-library-import-source.ts
+const isTestLibraryImportSource = (source) => {
+	if (typeof source !== "string" || source.length === 0) return false;
+	if (TEST_LIBRARY_IMPORT_SOURCES.has(source)) return true;
+	return TEST_LIBRARY_IMPORT_SOURCE_PREFIXES.some((prefix) => source.startsWith(prefix));
+};
 //#endregion
 //#region src/plugin/rules/js-performance/async-parallel.ts
+const getAwaitedCall = (statement) => {
+	if (isNodeOfType(statement, "VariableDeclaration")) {
+		const declarator = statement.declarations?.[0];
+		if (declarator && isNodeOfType(declarator.init, "AwaitExpression")) return declarator.init.argument ?? null;
+	}
+	if (isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "AwaitExpression")) return statement.expression.argument ?? null;
+	return null;
+};
+const isOrderedUiFlowName = (name) => {
+	if (ORDERED_UI_FLOW_CALLEE_NAMES.has(name)) return true;
+	return ORDERED_UI_FLOW_CALLEE_PREFIXES.some((prefix) => name.startsWith(prefix));
+};
+const isOrderedUiFlowAwait = (awaitedCall) => {
+	if (!awaitedCall) return false;
+	return getCalleeIdentifierTrail(awaitedCall).some(isOrderedUiFlowName);
+};
+const isIntentionalSequencingAwait = (awaitedCall) => {
+	if (!awaitedCall) return false;
+	return getCalleeIdentifierTrail(awaitedCall).some((name) => INTENTIONAL_SEQUENCING_CALLEE_NAMES.has(name));
+};
+const sequenceContainsSerializationSignal = (statements) => {
+	for (const statement of statements) {
+		const awaitedCall = getAwaitedCall(statement);
+		if (isOrderedUiFlowAwait(awaitedCall)) return true;
+		if (isIntentionalSequencingAwait(awaitedCall)) return true;
+	}
+	return false;
+};
 const reportIfIndependent = (statements, context) => {
 	const declaredNames = /* @__PURE__ */ new Set();
 	for (const statement of statements) {
@@ -599,22 +1052,33 @@ const reportIfIndependent = (statements, context) => {
 };
 const asyncParallel = defineRule({
 	id: "async-parallel",
+	tags: ["test-noise"],
 	severity: "warn",
 	recommendation: "Use `const [a, b] = await Promise.all([fetchA(), fetchB()])` to run independent operations concurrently",
 	create: (context) => {
 		const filename = context.getFilename?.() ?? "";
-		const isTestFile = TEST_FILE_PATTERN.test(filename);
-		return { BlockStatement(node) {
-			if (isTestFile) return;
-			const consecutiveAwaitStatements = [];
-			const flushConsecutiveAwaits = () => {
-				if (consecutiveAwaitStatements.length >= 3) reportIfIndependent(consecutiveAwaitStatements, context);
-				consecutiveAwaitStatements.length = 0;
-			};
-			for (const statement of node.body ?? []) if (isNodeOfType(statement, "VariableDeclaration") && statement.declarations?.length === 1 && isNodeOfType(statement.declarations[0].init, "AwaitExpression") || isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "AwaitExpression")) consecutiveAwaitStatements.push(statement);
-			else flushConsecutiveAwaits();
-			flushConsecutiveAwaits();
-		} };
+		const isBrowserTestFile = BROWSER_TEST_FILE_PATTERN.test(filename);
+		let hasTestLibraryImport = false;
+		const shouldSkipFile = () => isBrowserTestFile || hasTestLibraryImport;
+		return {
+			ImportDeclaration(node) {
+				if (hasTestLibraryImport) return;
+				if (isTestLibraryImportSource(node.source?.value)) hasTestLibraryImport = true;
+			},
+			BlockStatement(node) {
+				if (shouldSkipFile()) return;
+				const consecutiveAwaitStatements = [];
+				const flushConsecutiveAwaits = () => {
+					if (consecutiveAwaitStatements.length >= 3) {
+						if (!sequenceContainsSerializationSignal(consecutiveAwaitStatements)) reportIfIndependent(consecutiveAwaitStatements, context);
+					}
+					consecutiveAwaitStatements.length = 0;
+				};
+				for (const statement of node.body ?? []) if (isNodeOfType(statement, "VariableDeclaration") && statement.declarations?.length === 1 && isNodeOfType(statement.declarations[0].init, "AwaitExpression") || isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "AwaitExpression")) consecutiveAwaitStatements.push(statement);
+				else flushConsecutiveAwaits();
+				flushConsecutiveAwaits();
+			}
+		};
 	}
 });
 //#endregion
@@ -1323,27 +1787,80 @@ const jsCacheStorage = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/js-performance/js-combine-iterations.ts
+const isIteratorProducingCall = (callExpression, generatorNamesInFile) => {
+	const callee = callExpression.callee;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "Iterator" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "from") return true;
+	if (isNodeOfType(callee, "Identifier") && generatorNamesInFile.has(callee.name)) return true;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && ITERATOR_PRODUCING_METHOD_NAMES.has(callee.property.name)) {
+		const receiver = callee.object;
+		if (isNodeOfType(receiver, "Identifier") && receiver.name === "Object") return false;
+		return true;
+	}
+	return false;
+};
+const isChainPassThroughCall = (callExpression) => {
+	const callee = callExpression.callee;
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	if (!isNodeOfType(callee.property, "Identifier")) return false;
+	return CHAINABLE_ITERATION_METHODS.has(callee.property.name);
+};
+const isReceiverChainIteratorRooted = (receiverNode, generatorNamesInFile) => {
+	let cursor = receiverNode;
+	while (cursor) {
+		if (isNodeOfType(cursor, "ChainExpression")) {
+			cursor = cursor.expression;
+			continue;
+		}
+		if (!isNodeOfType(cursor, "CallExpression")) return false;
+		if (isIteratorProducingCall(cursor, generatorNamesInFile)) return true;
+		if (!isChainPassThroughCall(cursor)) return false;
+		const nextCallee = cursor.callee;
+		if (!isNodeOfType(nextCallee, "MemberExpression")) return false;
+		cursor = nextCallee.object;
+	}
+	return false;
+};
+const collectGeneratorNames = (programNode) => {
+	const generatorNames = /* @__PURE__ */ new Set();
+	walkAst(programNode, (child) => {
+		if (isNodeOfType(child, "FunctionDeclaration") && child.generator === true && isNodeOfType(child.id, "Identifier")) {
+			generatorNames.add(child.id.name);
+			return;
+		}
+		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier") && isNodeOfType(child.init, "FunctionExpression") && child.init.generator === true) generatorNames.add(child.id.name);
+	});
+	return generatorNames;
+};
 const jsCombineIterations = defineRule({
 	id: "js-combine-iterations",
 	severity: "warn",
 	recommendation: "Combine `.map().filter()` (or similar chains) into a single pass with `.reduce()` or a `for...of` loop to avoid iterating the array twice",
-	create: (context) => ({ CallExpression(node) {
-		if (!isNodeOfType(node.callee, "MemberExpression") || !isNodeOfType(node.callee.property, "Identifier")) return;
-		const outerMethod = node.callee.property.name;
-		if (!CHAINABLE_ITERATION_METHODS.has(outerMethod)) return;
-		const innerCall = node.callee.object;
-		if (!isNodeOfType(innerCall, "CallExpression") || !isNodeOfType(innerCall.callee, "MemberExpression") || !isNodeOfType(innerCall.callee.property, "Identifier")) return;
-		const innerMethod = innerCall.callee.property.name;
-		if (!CHAINABLE_ITERATION_METHODS.has(innerMethod)) return;
-		if (innerMethod === "map" && outerMethod === "filter") {
-			const filterArgument = node.arguments?.[0];
-			if (isNodeOfType(filterArgument, "Identifier") && filterArgument.name === "Boolean" || isNodeOfType(filterArgument, "ArrowFunctionExpression") && filterArgument.params?.length === 1 && isNodeOfType(filterArgument.body, "Identifier") && isNodeOfType(filterArgument.params[0], "Identifier") && filterArgument.body.name === filterArgument.params[0].name) return;
-		}
-		context.report({
-			node,
-			message: `.${innerMethod}().${outerMethod}() iterates the array twice — combine into a single loop with .reduce() or for...of`
-		});
-	} })
+	create: (context) => {
+		let generatorNamesInFile = /* @__PURE__ */ new Set();
+		return {
+			Program(programNode) {
+				generatorNamesInFile = collectGeneratorNames(programNode);
+			},
+			CallExpression(node) {
+				if (!isNodeOfType(node.callee, "MemberExpression") || !isNodeOfType(node.callee.property, "Identifier")) return;
+				const outerMethod = node.callee.property.name;
+				if (!CHAINABLE_ITERATION_METHODS.has(outerMethod)) return;
+				const innerCall = node.callee.object;
+				if (!isNodeOfType(innerCall, "CallExpression") || !isNodeOfType(innerCall.callee, "MemberExpression") || !isNodeOfType(innerCall.callee.property, "Identifier")) return;
+				const innerMethod = innerCall.callee.property.name;
+				if (!CHAINABLE_ITERATION_METHODS.has(innerMethod)) return;
+				if (innerMethod === "map" && outerMethod === "filter") {
+					const filterArgument = node.arguments?.[0];
+					if (isNodeOfType(filterArgument, "Identifier") && filterArgument.name === "Boolean" || isNodeOfType(filterArgument, "ArrowFunctionExpression") && filterArgument.params?.length === 1 && isNodeOfType(filterArgument.body, "Identifier") && isNodeOfType(filterArgument.params[0], "Identifier") && filterArgument.body.name === filterArgument.params[0].name) return;
+				}
+				if (isReceiverChainIteratorRooted(innerCall.callee.object, generatorNamesInFile)) return;
+				context.report({
+					node,
+					message: `.${innerMethod}().${outerMethod}() iterates the array twice — combine into a single loop with .reduce() or for...of`
+				});
+			}
+		};
+	}
 });
 //#endregion
 //#region src/plugin/rules/js-performance/js-early-exit.ts
@@ -1479,7 +1996,80 @@ const jsIndexMaps = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/are-expressions-structurally-equal.ts
+const areExpressionsStructurallyEqual = (a, b) => {
+	if (!a || !b) return a === b;
+	if (a.type !== b.type) return false;
+	if (isNodeOfType(a, "Identifier") && isNodeOfType(b, "Identifier")) return a.name === b.name;
+	if (isNodeOfType(a, "Literal") && isNodeOfType(b, "Literal")) return a.value === b.value;
+	if (isNodeOfType(a, "MemberExpression") && isNodeOfType(b, "MemberExpression")) {
+		if (a.computed !== b.computed) return false;
+		return areExpressionsStructurallyEqual(a.object, b.object) && areExpressionsStructurallyEqual(a.property, b.property);
+	}
+	if (isNodeOfType(a, "CallExpression") && isNodeOfType(b, "CallExpression")) {
+		if (!areExpressionsStructurallyEqual(a.callee, b.callee)) return false;
+		const argumentsA = a.arguments ?? [];
+		const argumentsB = b.arguments ?? [];
+		if (argumentsA.length !== argumentsB.length) return false;
+		return argumentsA.every((argument, index) => areExpressionsStructurallyEqual(argument, argumentsB[index]));
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/flatten-logical-and-chain.ts
+const flattenLogicalAndChain = (node) => {
+	if (isNodeOfType(node, "LogicalExpression") && node.operator === "&&") return [...flattenLogicalAndChain(node.left), ...flattenLogicalAndChain(node.right)];
+	return [node];
+};
+//#endregion
+//#region src/plugin/utils/collect-earlier-and-guard-operands.ts
+const collectEarlierAndGuardOperands = (node) => {
+	const earlierOperands = [];
+	let currentNode = node;
+	let parentNode = currentNode.parent ?? null;
+	while (parentNode) {
+		if (isNodeOfType(parentNode, "LogicalExpression")) {
+			if (parentNode.operator === "&&" && parentNode.right === currentNode) earlierOperands.push(...flattenLogicalAndChain(parentNode.left));
+			currentNode = parentNode;
+			parentNode = currentNode.parent ?? null;
+			continue;
+		}
+		if (isNodeOfType(parentNode, "ChainExpression")) {
+			currentNode = parentNode;
+			parentNode = currentNode.parent ?? null;
+			continue;
+		}
+		break;
+	}
+	return earlierOperands;
+};
+//#endregion
 //#region src/plugin/rules/js-performance/js-length-check-first.ts
+const findIndexedArrayObject = (callbackBody, indexParameterName) => {
+	let indexedArrayObject = null;
+	walkAst(callbackBody, (child) => {
+		if (indexedArrayObject) return;
+		if (isNodeOfType(child, "MemberExpression") && child.computed && isNodeOfType(child.property, "Identifier") && child.property.name === indexParameterName) indexedArrayObject = child.object;
+	});
+	return indexedArrayObject;
+};
+const unwrapChainExpression$1 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
+const isMatchingLengthEqualityGuard = (guardOperand, receiverArray, indexedArray) => {
+	const binaryGuard = unwrapChainExpression$1(guardOperand);
+	if (!isNodeOfType(binaryGuard, "BinaryExpression")) return false;
+	if (binaryGuard.operator !== "===" && binaryGuard.operator !== "==") return false;
+	const leftSide = unwrapChainExpression$1(binaryGuard.left);
+	const rightSide = unwrapChainExpression$1(binaryGuard.right);
+	if (!isMemberProperty(leftSide, "length")) return false;
+	if (!isMemberProperty(rightSide, "length")) return false;
+	const leftLengthObject = unwrapChainExpression$1(leftSide.object);
+	const rightLengthObject = unwrapChainExpression$1(rightSide.object);
+	const normalizedReceiver = unwrapChainExpression$1(receiverArray);
+	const normalizedIndexed = unwrapChainExpression$1(indexedArray);
+	const matchesReceiverThenIndexed = areExpressionsStructurallyEqual(leftLengthObject, normalizedReceiver) && areExpressionsStructurallyEqual(rightLengthObject, normalizedIndexed);
+	const matchesIndexedThenReceiver = areExpressionsStructurallyEqual(leftLengthObject, normalizedIndexed) && areExpressionsStructurallyEqual(rightLengthObject, normalizedReceiver);
+	return matchesReceiverThenIndexed || matchesIndexedThenReceiver;
+};
 const jsLengthCheckFirst = defineRule({
 	id: "js-length-check-first",
 	severity: "warn",
@@ -1490,20 +2080,14 @@ const jsLengthCheckFirst = defineRule({
 		if (node.callee.property.name !== "every") return;
 		const callback = node.arguments?.[0];
 		if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return;
-		const params = callback.params ?? [];
-		if (params.length < 2) return;
-		let referencesOtherArrayByIndex = false;
-		walkAst(callback.body, (child) => {
-			if (referencesOtherArrayByIndex) return;
-			if (isNodeOfType(child, "MemberExpression") && child.computed && isNodeOfType(child.property, "Identifier") && isNodeOfType(params[1], "Identifier") && child.property.name === params[1].name) referencesOtherArrayByIndex = true;
-		});
-		if (!referencesOtherArrayByIndex) return;
-		let guard = node.parent ?? null;
-		while (guard && !isNodeOfType(guard, "LogicalExpression") && !isNodeOfType(guard, "IfStatement")) guard = guard.parent ?? null;
-		if (isNodeOfType(guard, "LogicalExpression") && guard.operator === "&&") {
-			const left = guard.left;
-			if (isNodeOfType(left, "BinaryExpression") && left.operator === "===" && (isMemberProperty(left.left, "length") || isMemberProperty(left.right, "length"))) return;
-		}
+		const callbackParameters = callback.params ?? [];
+		if (callbackParameters.length < 2) return;
+		const indexParameter = callbackParameters[1];
+		if (!isNodeOfType(indexParameter, "Identifier")) return;
+		const indexedArrayObject = findIndexedArrayObject(callback.body, indexParameter.name);
+		if (!indexedArrayObject) return;
+		const receiverArrayObject = node.callee.object;
+		if (collectEarlierAndGuardOperands(node).some((guardOperand) => isMatchingLengthEqualityGuard(guardOperand, receiverArrayObject, indexedArrayObject))) return;
 		context.report({
 			node,
 			message: ".every() over an array compared to another array — short-circuit with `a.length === b.length && a.every(...)` so unequal-length arrays exit immediately"
@@ -1795,6 +2379,7 @@ const GOOGLE_FONTS_PATTERN = /fonts\.googleapis\.com/;
 const POLYFILL_SCRIPT_PATTERN = /polyfill\.io|polyfill\.min\.js|cdn\.polyfill/;
 const APP_DIRECTORY_PATTERN = /\/app\//;
 const ROUTE_HANDLER_FILE_PATTERN = /\/route\.(tsx?|jsx?)$/;
+const CRON_ROUTE_PATTERN = /\/(?:cron|jobs\/cron)(?:\/|$)/i;
 const MUTATING_ROUTE_SEGMENTS = new Set([
 	"logout",
 	"log-out",
@@ -2069,19 +2654,116 @@ const nextjsNoRedirectInTryCatch = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/is-cookies-call.ts
+const isCookiesCall = (node) => isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "cookies";
+//#endregion
+//#region src/plugin/utils/is-cookies-or-awaited-cookies-call.ts
+const isCookiesOrAwaitedCookiesCall = (node) => {
+	if (isCookiesCall(node)) return true;
+	if (isNodeOfType(node, "AwaitExpression") && node.argument) return isCookiesCall(node.argument);
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/collect-locally-scoped-cookie-bindings.ts
+const collectLocallyScopedCookieBindings = (handlerBody) => {
+	const cookieBindingNames = /* @__PURE__ */ new Set();
+	walkInsideStatementBlocks(handlerBody, (node) => {
+		if (!isNodeOfType(node, "VariableDeclarator")) return;
+		if (!node.init) return;
+		if (!isCookiesOrAwaitedCookiesCall(node.init)) return;
+		collectPatternNames(node.id, cookieBindingNames);
+	});
+	return cookieBindingNames;
+};
+//#endregion
+//#region src/plugin/utils/is-safe-mutable-receiver-source.ts
+const SAFE_INTRINSIC_PROPERTY_NAMES = new Set(["headers", "searchParams"]);
+const unwrapAwait = (node) => isNodeOfType(node, "AwaitExpression") && node.argument ? node.argument : node;
+const isSafeConstructorNew = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && SAFE_MUTABLE_CONSTRUCTOR_NAMES.has(node.callee.name);
+const isResponseFactoryCall = (node) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
+	if (!isNodeOfType(node.callee.object, "Identifier")) return false;
+	if (!isNodeOfType(node.callee.property, "Identifier")) return false;
+	return RESPONSE_FACTORY_OBJECTS.has(node.callee.object.name) && RESPONSE_FACTORY_METHODS.has(node.callee.property.name);
+};
+const isHeadersFunctionCall = (node) => isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "headers";
+const isSafeIntrinsicMemberAccess = (node) => isNodeOfType(node, "MemberExpression") && isNodeOfType(node.property, "Identifier") && SAFE_INTRINSIC_PROPERTY_NAMES.has(node.property.name);
+const isSafeMutableReceiverSource = (initNode) => {
+	const unwrapped = unwrapAwait(initNode);
+	if (isSafeConstructorNew(unwrapped)) return true;
+	if (isResponseFactoryCall(unwrapped)) return true;
+	if (isSafeIntrinsicMemberAccess(unwrapped)) return true;
+	if (isHeadersFunctionCall(unwrapped)) return true;
+	return false;
+};
+const isSafeReceiverChainNode = (node, locallyScopedSafeBindings) => {
+	if (isSafeConstructorNew(node)) return true;
+	if (isResponseFactoryCall(node)) return true;
+	if (isSafeIntrinsicMemberAccess(node)) return true;
+	if (isHeadersFunctionCall(node)) return true;
+	if (isNodeOfType(node, "Identifier") && locallyScopedSafeBindings.has(node.name)) return true;
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/collect-locally-scoped-safe-bindings.ts
+const collectLocallyScopedSafeBindings = (handlerBody) => {
+	const safeBindingNames = /* @__PURE__ */ new Set();
+	walkInsideStatementBlocks(handlerBody, (node) => {
+		if (!isNodeOfType(node, "VariableDeclarator")) return;
+		if (!node.init) return;
+		if (!isSafeMutableReceiverSource(node.init)) return;
+		collectPatternNames(node.id, safeBindingNames);
+	});
+	return safeBindingNames;
+};
+//#endregion
+//#region src/plugin/utils/is-safe-receiver-chain.ts
+const isSafeReceiverChain = (receiverNode, locallyScopedSafeBindings) => {
+	let current = receiverNode;
+	while (current) {
+		if (isSafeReceiverChainNode(current, locallyScopedSafeBindings)) return true;
+		if (isNodeOfType(current, "MemberExpression")) {
+			current = current.object;
+			continue;
+		}
+		if (isNodeOfType(current, "ChainExpression")) {
+			current = current.expression;
+			continue;
+		}
+		if (isNodeOfType(current, "AwaitExpression")) {
+			current = current.argument;
+			continue;
+		}
+		if (isNodeOfType(current, "TSNonNullExpression") || isNodeOfType(current, "TSAsExpression")) {
+			current = current.expression;
+			continue;
+		}
+		return false;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/utils/find-side-effect.ts
+const EMPTY_BINDING_SET = /* @__PURE__ */ new Set();
+const COOKIE_MUTATION_METHOD_NAMES = new Set([
+	"set",
+	"append",
+	"delete"
+]);
 const isMutatingMethodProperty = (property) => isNodeOfType(property, "Property") && isNodeOfType(property.key, "Identifier") && property.key.name === "method" && isNodeOfType(property.value, "Literal") && typeof property.value.value === "string" && MUTATING_HTTP_METHODS.has(property.value.value.toUpperCase());
-const isCookiesOrHeadersCall = (node, methodName) => {
-	if (!isNodeOfType(node, "CallExpression") || !isNodeOfType(node.callee, "MemberExpression")) return false;
-	const { object, property } = node.callee;
-	if (!isNodeOfType(property, "Identifier") || !MUTATION_METHOD_NAMES.has(property.name)) return false;
-	if (!isNodeOfType(object, "CallExpression") || !isNodeOfType(object.callee, "Identifier")) return false;
-	return object.callee.name === methodName;
+const isCookieReceiver = (receiverNode, locallyScopedCookieBindings) => {
+	if (isCookiesOrAwaitedCookiesCall(receiverNode)) return true;
+	if (isNodeOfType(receiverNode, "Identifier")) return locallyScopedCookieBindings.has(receiverNode.name);
+	return false;
 };
-const isMutatingDbCall = (node) => {
-	if (!isNodeOfType(node, "CallExpression") || !isNodeOfType(node.callee, "MemberExpression")) return false;
-	const { property } = node.callee;
-	return isNodeOfType(property, "Identifier") && MUTATION_METHOD_NAMES.has(property.name);
+const getCookieMutationMethodName = (node, locallyScopedCookieBindings) => {
+	if (!isNodeOfType(node, "CallExpression")) return null;
+	if (!isNodeOfType(node.callee, "MemberExpression")) return null;
+	if (!isNodeOfType(node.callee.property, "Identifier")) return null;
+	if (!COOKIE_MUTATION_METHOD_NAMES.has(node.callee.property.name)) return null;
+	if (!isCookieReceiver(node.callee.object, locallyScopedCookieBindings)) return null;
+	return node.callee.property.name;
 };
 const isMutatingFetchCall = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
@@ -2090,25 +2772,30 @@ const isMutatingFetchCall = (node) => {
 	if (!optionsArgument || !isNodeOfType(optionsArgument, "ObjectExpression")) return false;
 	return Boolean(optionsArgument.properties?.some(isMutatingMethodProperty));
 };
-const getCookiesOrHeadersMethodName = (child, apiName) => {
-	if (!isCookiesOrHeadersCall(child, apiName)) return null;
-	if (!isNodeOfType(child, "CallExpression")) return null;
-	if (!isNodeOfType(child.callee, "MemberExpression")) return null;
-	if (!isNodeOfType(child.callee.property, "Identifier")) return null;
-	return child.callee.property.name;
+const isMutatingDbCall = (node, locallyScopedSafeBindings) => {
+	if (!isNodeOfType(node, "CallExpression") || !isNodeOfType(node.callee, "MemberExpression")) return false;
+	const { property, object } = node.callee;
+	if (!isNodeOfType(property, "Identifier") || !MUTATION_METHOD_NAMES.has(property.name)) return false;
+	if (isSafeReceiverChain(object, locallyScopedSafeBindings)) return false;
+	return true;
 };
-const findSideEffect = (node) => {
+const getDbCallDescription = (node) => {
+	if (!isNodeOfType(node, "CallExpression")) return ".unknown()";
+	if (!isNodeOfType(node.callee, "MemberExpression")) return ".unknown()";
+	if (!isNodeOfType(node.callee.property, "Identifier")) return ".unknown()";
+	const methodName = node.callee.property.name;
+	const rootObjectName = isNodeOfType(node.callee.object, "Identifier") ? node.callee.object.name : null;
+	return rootObjectName ? `${rootObjectName}.${methodName}()` : `.${methodName}()`;
+};
+const findSideEffect = (node, options = {}) => {
+	const locallyScopedSafeBindings = options.locallyScopedSafeBindings ?? EMPTY_BINDING_SET;
+	const locallyScopedCookieBindings = options.locallyScopedCookieBindings ?? EMPTY_BINDING_SET;
 	let sideEffectDescription = null;
 	walkAst(node, (child) => {
 		if (sideEffectDescription) return;
-		const cookiesMethodName = getCookiesOrHeadersMethodName(child, "cookies");
-		if (cookiesMethodName) {
-			sideEffectDescription = `cookies().${cookiesMethodName}()`;
-			return;
-		}
-		const headersMethodName = getCookiesOrHeadersMethodName(child, "headers");
-		if (headersMethodName) {
-			sideEffectDescription = `headers().${headersMethodName}()`;
+		const cookieMethodName = getCookieMutationMethodName(child, locallyScopedCookieBindings);
+		if (cookieMethodName) {
+			sideEffectDescription = `cookies().${cookieMethodName}()`;
 			return;
 		}
 		if (isMutatingFetchCall(child) && isNodeOfType(child, "CallExpression")) {
@@ -2117,13 +2804,9 @@ const findSideEffect = (node) => {
 			const methodProperty = optionsArgument.properties.find(isMutatingMethodProperty);
 			if (!methodProperty || !isNodeOfType(methodProperty, "Property") || !isNodeOfType(methodProperty.value, "Literal")) return;
 			sideEffectDescription = `fetch() with method ${methodProperty.value.value}`;
-		} else if (isMutatingDbCall(child) && isNodeOfType(child, "CallExpression")) {
-			if (!isNodeOfType(child.callee, "MemberExpression")) return;
-			if (!isNodeOfType(child.callee.property, "Identifier")) return;
-			const methodName = child.callee.property.name;
-			const objectName = isNodeOfType(child.callee.object, "Identifier") ? child.callee.object.name : null;
-			sideEffectDescription = objectName ? `${objectName}.${methodName}()` : `.${methodName}()`;
+			return;
 		}
+		if (isMutatingDbCall(child, locallyScopedSafeBindings)) sideEffectDescription = getDbCallDescription(child);
 	});
 	return sideEffectDescription;
 };
@@ -2137,41 +2820,141 @@ const extractMutatingRouteSegment = (filename) => {
 	}
 	return null;
 };
-const getExportedGetHandlerBody = (node) => {
-	if (!isNodeOfType(node, "ExportNamedDeclaration")) return null;
+const buildProgramBindingLookup = (programNode) => {
+	const topLevelBindings = /* @__PURE__ */ new Map();
+	if (!isNodeOfType(programNode, "Program")) return () => null;
+	const collectFromStatements = (statements) => {
+		for (const statement of statements) {
+			if (isNodeOfType(statement, "VariableDeclaration")) {
+				for (const declarator of statement.declarations ?? []) {
+					if (!isNodeOfType(declarator.id, "Identifier")) continue;
+					if (!declarator.init) continue;
+					topLevelBindings.set(declarator.id.name, declarator.init);
+				}
+				continue;
+			}
+			if (isNodeOfType(statement, "FunctionDeclaration") && isNodeOfType(statement.id, "Identifier") && statement.body) {
+				topLevelBindings.set(statement.id.name, statement);
+				continue;
+			}
+			if (isNodeOfType(statement, "ExportNamedDeclaration") && statement.declaration) collectFromStatements([statement.declaration]);
+		}
+	};
+	collectFromStatements(programNode.body ?? []);
+	return (identifierName) => topLevelBindings.get(identifierName) ?? null;
+};
+const isExportedGetHandler = (node) => {
+	if (!isNodeOfType(node, "ExportNamedDeclaration")) return false;
 	const declaration = node.declaration;
-	if (!declaration) return null;
-	if (isNodeOfType(declaration, "FunctionDeclaration") && declaration.id?.name === "GET") return declaration.body;
+	if (!declaration) return false;
+	if (isNodeOfType(declaration, "FunctionDeclaration") && declaration.id?.name === "GET") return true;
 	if (isNodeOfType(declaration, "VariableDeclaration")) {
-		for (const declarator of declaration.declarations ?? []) if (isNodeOfType(declarator?.id, "Identifier") && declarator.id.name === "GET" && declarator.init && (isNodeOfType(declarator.init, "ArrowFunctionExpression") || isNodeOfType(declarator.init, "FunctionExpression"))) return declarator.init.body;
+		for (const declarator of declaration.declarations ?? []) if (isNodeOfType(declarator?.id, "Identifier") && declarator.id.name === "GET") return true;
 	}
+	return false;
+};
+const isGetMethodCall = (callExpression) => isNodeOfType(callExpression, "CallExpression") && isNodeOfType(callExpression.callee, "MemberExpression") && isNodeOfType(callExpression.callee.property, "Identifier") && callExpression.callee.property.name === "get";
+const isStringLikeNode = (node) => isNodeOfType(node, "Literal") && typeof node.value === "string" || isNodeOfType(node, "TemplateLiteral");
+const getHandlerCallbackBody = (callExpression) => {
+	const callArguments = callExpression.arguments ?? [];
+	if (callArguments.length < 2) return null;
+	const routePatternArgument = callArguments[0];
+	if (!isStringLikeNode(routePatternArgument)) return null;
+	const handlerArgument = callArguments[callArguments.length - 1];
+	if ((isNodeOfType(handlerArgument, "ArrowFunctionExpression") || isNodeOfType(handlerArgument, "FunctionExpression")) && handlerArgument.body) return handlerArgument.body;
 	return null;
 };
+const collectChainedGetHandlerBodies = (initNode) => {
+	const chainedBodies = [];
+	let cursor = initNode;
+	while (cursor && isNodeOfType(cursor, "CallExpression")) {
+		if (isGetMethodCall(cursor)) {
+			const body = getHandlerCallbackBody(cursor);
+			if (body) chainedBodies.push(body);
+		}
+		cursor = isNodeOfType(cursor.callee, "MemberExpression") ? cursor.callee.object : null;
+	}
+	return chainedBodies;
+};
+const resolveBodiesFromExpression = (expression, resolveBinding, remainingDepth) => {
+	if (remainingDepth <= 0) return [];
+	if (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression") || isNodeOfType(expression, "FunctionDeclaration")) return expression.body ? [expression.body] : [];
+	if (isNodeOfType(expression, "CallExpression")) {
+		for (const callArgument of expression.arguments ?? []) {
+			if (isNodeOfType(callArgument, "ArrowFunctionExpression") || isNodeOfType(callArgument, "FunctionExpression")) {
+				if (callArgument.body) return [callArgument.body];
+			}
+			if (!isNodeOfType(callArgument, "Identifier")) continue;
+			const argumentInit = resolveBinding(callArgument.name);
+			if (!argumentInit) continue;
+			const resolvedBodies = resolveBodiesFromExpression(argumentInit, resolveBinding, remainingDepth - 1);
+			if (resolvedBodies.length > 0) return resolvedBodies;
+			const chainedBodies = collectChainedGetHandlerBodies(argumentInit);
+			if (chainedBodies.length > 0) return chainedBodies;
+		}
+		return [];
+	}
+	if (isNodeOfType(expression, "Identifier")) {
+		const boundInit = resolveBinding(expression.name);
+		if (!boundInit) return [];
+		return resolveBodiesFromExpression(boundInit, resolveBinding, remainingDepth - 1);
+	}
+	return [];
+};
+const resolveGetHandlerBodies = (exportNode, resolveBinding) => {
+	if (!isNodeOfType(exportNode, "ExportNamedDeclaration")) return [];
+	const declaration = exportNode.declaration;
+	if (!declaration) return [];
+	if (isNodeOfType(declaration, "FunctionDeclaration") && declaration.id?.name === "GET") return declaration.body ? [declaration.body] : [];
+	if (!isNodeOfType(declaration, "VariableDeclaration")) return [];
+	for (const declarator of declaration.declarations ?? []) {
+		if (!isNodeOfType(declarator.id, "Identifier") || declarator.id.name !== "GET") continue;
+		if (!declarator.init) return [];
+		return resolveBodiesFromExpression(declarator.init, resolveBinding, 3);
+	}
+	return [];
+};
 const nextjsNoSideEffectInGetHandler = defineRule({
 	id: "nextjs-no-side-effect-in-get-handler",
 	requires: ["nextjs"],
 	severity: "error",
 	category: "Security",
 	recommendation: "Move the side effect to a POST handler and use a <form> or fetch with method POST — GET requests can be triggered by prefetching and are vulnerable to CSRF",
-	create: (context) => ({ ExportNamedDeclaration(node) {
-		const filename = context.getFilename?.() ?? "";
-		if (!ROUTE_HANDLER_FILE_PATTERN.test(filename)) return;
-		const handlerBody = getExportedGetHandlerBody(node);
-		if (!handlerBody) return;
-		const mutatingSegment = extractMutatingRouteSegment(filename);
-		if (mutatingSegment) {
-			context.report({
-				node,
-				message: `GET handler on "/${mutatingSegment}" route — use POST to prevent CSRF and unintended prefetch triggers`
-			});
-			return;
-		}
-		const sideEffect = findSideEffect(handlerBody);
-		if (sideEffect) context.report({
-			node,
-			message: `GET handler has side effects (${sideEffect}) — use POST to prevent CSRF and unintended prefetch triggers`
-		});
-	} })
+	create: (context) => {
+		let resolveBinding = () => null;
+		return {
+			Program(node) {
+				resolveBinding = buildProgramBindingLookup(node);
+			},
+			ExportNamedDeclaration(node) {
+				const filename = context.getFilename?.() ?? "";
+				if (!ROUTE_HANDLER_FILE_PATTERN.test(filename)) return;
+				if (CRON_ROUTE_PATTERN.test(filename)) return;
+				if (!isExportedGetHandler(node)) return;
+				const mutatingSegment = extractMutatingRouteSegment(filename);
+				if (mutatingSegment) {
+					context.report({
+						node,
+						message: `GET handler on "/${mutatingSegment}" route — use POST to prevent CSRF and unintended prefetch triggers`
+					});
+					return;
+				}
+				const handlerBodies = resolveGetHandlerBodies(node, resolveBinding);
+				for (const handlerBody of handlerBodies) {
+					const sideEffect = findSideEffect(handlerBody, {
+						locallyScopedSafeBindings: collectLocallyScopedSafeBindings(handlerBody),
+						locallyScopedCookieBindings: collectLocallyScopedCookieBindings(handlerBody)
+					});
+					if (!sideEffect) continue;
+					context.report({
+						node,
+						message: `GET handler has side effects (${sideEffect}) — use POST to prevent CSRF and unintended prefetch triggers`
+					});
+					return;
+				}
+			}
+		};
+	}
 });
 //#endregion
 //#region src/plugin/utils/get-imported-name.ts
@@ -2946,44 +3729,16 @@ const noDerivedStateEffect = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/collect-pattern-names.ts
-const collectPatternNames = (pattern, into) => {
-	if (!pattern) return;
-	if (isNodeOfType(pattern, "Identifier")) {
-		into.add(pattern.name);
-		return;
-	}
-	if (isNodeOfType(pattern, "AssignmentPattern")) {
-		collectPatternNames(pattern.left, into);
-		return;
-	}
-	if (isNodeOfType(pattern, "RestElement")) {
-		collectPatternNames(pattern.argument, into);
-		return;
-	}
-	if (isNodeOfType(pattern, "ArrayPattern")) {
-		for (const element of pattern.elements ?? []) collectPatternNames(element, into);
-		return;
-	}
-	if (isNodeOfType(pattern, "ObjectPattern")) for (const property of pattern.properties ?? []) {
-		if (isNodeOfType(property, "RestElement")) {
-			collectPatternNames(property.argument, into);
-			continue;
-		}
-		if (isNodeOfType(property, "Property")) collectPatternNames(property.value, into);
-	}
-};
-//#endregion
 //#region src/plugin/utils/create-component-prop-stack-tracker.ts
 const extractDestructuredPropNames = (params) => {
 	const propNames = /* @__PURE__ */ new Set();
 	for (const param of params) collectPatternNames(param, propNames);
 	return propNames;
 };
-const isFunctionNode = (node) => Boolean(node) && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression"));
+const isFunctionNode$1 = (node) => Boolean(node) && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression"));
 const getInlineFunctionNode = (node) => {
 	if (!node) return null;
-	if (isFunctionNode(node)) return node;
+	if (isFunctionNode$1(node)) return node;
 	if (!isNodeOfType(node, "CallExpression")) return null;
 	for (const argument of node.arguments ?? []) {
 		const inlineFunctionNode = getInlineFunctionNode(argument);
@@ -2994,7 +3749,7 @@ const getInlineFunctionNode = (node) => {
 const getNearestComponentFunction = (node) => {
 	let cursor = node.parent ?? null;
 	while (cursor) {
-		if (isFunctionNode(cursor)) return cursor;
+		if (isFunctionNode$1(cursor)) return cursor;
 		cursor = cursor.parent ?? null;
 	}
 	return null;
@@ -3172,11 +3927,11 @@ const collectFunctionLocalBindings = (functionNode) => {
 	}
 	return localBindings;
 };
-const isFunctionLikeNode = (node) => isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression");
+const isFunctionLikeNode$1 = (node) => isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression");
 const walkComponentRespectingShadows = (node, shadowedStateNames, visit) => {
 	if (!node || typeof node !== "object") return;
 	let nextShadowedStateNames = shadowedStateNames;
-	if (isFunctionLikeNode(node)) {
+	if (isFunctionLikeNode$1(node)) {
 		const localBindings = collectFunctionLocalBindings(node);
 		if (localBindings.size > 0) {
 			const merged = new Set(shadowedStateNames);
@@ -3472,26 +4227,6 @@ const noEffectChain = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/are-expressions-structurally-equal.ts
-const areExpressionsStructurallyEqual = (a, b) => {
-	if (!a || !b) return a === b;
-	if (a.type !== b.type) return false;
-	if (isNodeOfType(a, "Identifier") && isNodeOfType(b, "Identifier")) return a.name === b.name;
-	if (isNodeOfType(a, "Literal") && isNodeOfType(b, "Literal")) return a.value === b.value;
-	if (isNodeOfType(a, "MemberExpression") && isNodeOfType(b, "MemberExpression")) {
-		if (a.computed !== b.computed) return false;
-		return areExpressionsStructurallyEqual(a.object, b.object) && areExpressionsStructurallyEqual(a.property, b.property);
-	}
-	if (isNodeOfType(a, "CallExpression") && isNodeOfType(b, "CallExpression")) {
-		if (!areExpressionsStructurallyEqual(a.callee, b.callee)) return false;
-		const argumentsA = a.arguments ?? [];
-		const argumentsB = b.arguments ?? [];
-		if (argumentsA.length !== argumentsB.length) return false;
-		return argumentsA.every((argument, index) => areExpressionsStructurallyEqual(argument, argumentsB[index]));
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/find-triggered-side-effect-callee-name.ts
 const findTriggeredSideEffectCalleeName = (consequentNode) => {
 	let foundCalleeName = null;
@@ -5425,8 +6160,44 @@ const noPolymorphicChildren = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/get-react-doctor-setting.ts
+const readReactDoctorSettingsBag = (settings) => {
+	const reactDoctorSettings = settings?.["react-doctor"];
+	if (typeof reactDoctorSettings !== "object" || reactDoctorSettings === null || Array.isArray(reactDoctorSettings)) return null;
+	return reactDoctorSettings;
+};
+const readOwnPropertyValue = (bag, settingName) => Object.getOwnPropertyDescriptor(bag, settingName)?.value;
+const getReactDoctorStringSetting = (settings, settingName) => {
+	const bag = readReactDoctorSettingsBag(settings);
+	if (!bag) return void 0;
+	const settingValue = readOwnPropertyValue(bag, settingName);
+	return typeof settingValue === "string" ? settingValue : void 0;
+};
+const getReactDoctorStringArraySetting = (settings, settingName) => {
+	const bag = readReactDoctorSettingsBag(settings);
+	if (!bag) return [];
+	const settingValue = readOwnPropertyValue(bag, settingName);
+	if (!Array.isArray(settingValue)) return [];
+	return settingValue.filter((entry) => typeof entry === "string" && entry.length > 0);
+};
+//#endregion
 //#region src/plugin/rules/correctness/no-prevent-default.ts
 const PREVENT_DEFAULT_ELEMENTS = new Map([["form", ["onSubmit"]], ["a", ["onClick"]]]);
+const SERVER_CAPABLE_FRAMEWORKS = new Set([
+	"nextjs",
+	"tanstack-start",
+	"remix"
+]);
+const CLIENT_ONLY_FRAMEWORKS = new Set([
+	"vite",
+	"cra",
+	"gatsby",
+	"react-native",
+	"expo"
+]);
+const FORM_MESSAGE_SERVER_CAPABLE = "preventDefault() on <form> onSubmit — form won't work without JavaScript. Use a server action (`<form action={serverAction}>`) for progressive enhancement";
+const FORM_MESSAGE_GENERIC = "preventDefault() on <form> onSubmit — form won't work without JavaScript. Consider a form action for progressive enhancement";
+const ANCHOR_MESSAGE = "preventDefault() on <a> onClick — use a <button> or routing component instead";
 const containsPreventDefaultCall = (node) => {
 	let didFindPreventDefault = false;
 	walkAst(node, (child) => {
@@ -5435,32 +6206,35 @@ const containsPreventDefaultCall = (node) => {
 	});
 	return didFindPreventDefault;
 };
-const buildPreventDefaultMessage = (elementName) => {
-	if (elementName === "form") return "preventDefault() on <form> onSubmit — form won't work without JavaScript. Consider using a server action for progressive enhancement";
-	return "preventDefault() on <a> onClick — use a <button> or routing component instead";
-};
+const selectFormMessage = (framework) => framework !== void 0 && SERVER_CAPABLE_FRAMEWORKS.has(framework) ? FORM_MESSAGE_SERVER_CAPABLE : FORM_MESSAGE_GENERIC;
 const noPreventDefault = defineRule({
 	id: "no-prevent-default",
 	severity: "warn",
-	recommendation: "Use `<form action={serverAction}>` (works without JS) or `<button>` instead of `<a>` with preventDefault",
-	create: (context) => ({ JSXOpeningElement(node) {
-		const elementName = isNodeOfType(node.name, "JSXIdentifier") ? node.name.name : null;
-		if (!elementName) return;
-		const targetEventProps = PREVENT_DEFAULT_ELEMENTS.get(elementName);
-		if (!targetEventProps) return;
-		for (const targetEventProp of targetEventProps) {
-			const eventAttribute = findJsxAttribute(node.attributes ?? [], targetEventProp);
-			if (!eventAttribute?.value || !isNodeOfType(eventAttribute.value, "JSXExpressionContainer")) continue;
-			const expression = eventAttribute.value.expression;
-			if (!isNodeOfType(expression, "ArrowFunctionExpression") && !isNodeOfType(expression, "FunctionExpression")) continue;
-			if (!containsPreventDefaultCall(expression)) continue;
-			context.report({
-				node,
-				message: buildPreventDefaultMessage(elementName)
-			});
-			return;
-		}
-	} })
+	recommendation: "Use `<form action>` (works without JS) where your framework supports it, or use a `<button>` instead of `<a>` with preventDefault",
+	create: (context) => {
+		const framework = getReactDoctorStringSetting(context.settings, "framework");
+		const isClientOnlyFramework = framework !== void 0 && CLIENT_ONLY_FRAMEWORKS.has(framework);
+		const formMessage = selectFormMessage(framework);
+		return { JSXOpeningElement(node) {
+			const elementName = isNodeOfType(node.name, "JSXIdentifier") ? node.name.name : null;
+			if (!elementName) return;
+			const targetEventProps = PREVENT_DEFAULT_ELEMENTS.get(elementName);
+			if (!targetEventProps) return;
+			if (elementName === "form" && isClientOnlyFramework) return;
+			for (const targetEventProp of targetEventProps) {
+				const eventAttribute = findJsxAttribute(node.attributes ?? [], targetEventProp);
+				if (!eventAttribute?.value || !isNodeOfType(eventAttribute.value, "JSXExpressionContainer")) continue;
+				const expression = eventAttribute.value.expression;
+				if (!isNodeOfType(expression, "ArrowFunctionExpression") && !isNodeOfType(expression, "FunctionExpression")) continue;
+				if (!containsPreventDefaultCall(expression)) continue;
+				context.report({
+					node,
+					message: elementName === "form" ? formMessage : ANCHOR_MESSAGE
+				});
+				return;
+			}
+		} };
+	}
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-prop-callback-in-effect.ts
@@ -5713,6 +6487,8 @@ const AUTH_FUNCTION_NAMES = new Set([
 	"getAuth",
 	"validateSession"
 ]);
+const GENERIC_AUTH_METHOD_NAMES = new Set(["getUser"]);
+const AUTH_OBJECT_PATTERN = /(?:^|[._])(?:auth|authn|authz|clerk|session|jwt|firebase|supabase|nextauth|kinde|workos|stytch|descope|cognito|propelauth|lucia)/i;
 const SECRET_PATTERNS = [
 	/^sk_live_/,
 	/^sk_test_/,
@@ -5725,6 +6501,63 @@ const SECRET_PATTERNS = [
 	/^sk-[a-zA-Z0-9]{32,}$/
 ];
 const SECRET_VARIABLE_PATTERN = /(?:api_?key|secret|token|password|credential|auth)/i;
+const SECRET_TOOLING_FILE_PATTERN = /(?:^|\/)[^/]+\.config\.[cm]?[jt]s$/;
+const SECRET_TOOLING_RC_FILE_PATTERN = /(?:^|\/)(?:\.[a-z-]+rc|[a-z-]+\.rc)\.[cm]?[jt]s$/;
+const SECRET_TEST_FILE_PATTERN = /(?:^|\/)[^/]+\.(?:test|spec|stories|story|fixture|fixtures)\.[cm]?[jt]sx?$/;
+const SECRET_SERVER_FILE_SUFFIX_PATTERN = /(?:^|\/)[^/]+\.server\.[cm]?[jt]sx?$/;
+const SECRET_SERVER_ENTRY_FILE_PATTERN = /(?:^|\/)(?:middleware|route)\.[cm]?[jt]sx?$/;
+const SECRET_NEXT_PAGES_API_FILE_PATTERN = /(?:^|\/)pages\/api\/.+\.[cm]?[jt]sx?$/;
+const SECRET_CLIENT_FILE_SUFFIX_PATTERN = /(?:^|\/)[^/]+\.(?:client|browser|web)\.[cm]?[jt]sx?$/;
+const SECRET_CLIENT_ENTRY_FILE_PATTERN = /(?:^|\/)(?:src\/)?(?:main|index|[Aa]pp|client)\.[cm]?[jt]sx?$/;
+const SECRET_SERVER_DIRECTORY_NAMES = new Set([
+	"backend",
+	"functions",
+	"lambdas",
+	"lambda",
+	"middleware",
+	"server",
+	"servers"
+]);
+const SECRET_SERVER_SOURCE_ROOT_OWNER_NAMES = new Set([
+	"api",
+	"backend",
+	"edge",
+	"function",
+	"functions",
+	"lambda",
+	"lambdas",
+	"server",
+	"servers",
+	"worker",
+	"workers"
+]);
+const SECRET_TEST_DIRECTORY_NAMES = new Set([
+	"__fixtures__",
+	"__mocks__",
+	"__tests__",
+	"fixtures",
+	"mocks",
+	"test",
+	"tests"
+]);
+const SECRET_TOOLING_DIRECTORY_NAMES = new Set([
+	"bin",
+	"config",
+	"configs",
+	"script",
+	"scripts",
+	"tooling",
+	"tools"
+]);
+const SECRET_CLIENT_SOURCE_DIRECTORY_NAMES = new Set([
+	"components",
+	"features",
+	"hooks",
+	"pages",
+	"ui",
+	"views",
+	"widgets"
+]);
 const SECRET_FALSE_POSITIVE_SUFFIXES = new Set([
 	"modal",
 	"label",
@@ -5732,7 +6565,6 @@ const SECRET_FALSE_POSITIVE_SUFFIXES = new Set([
 	"title",
 	"name",
 	"id",
-	"key",
 	"url",
 	"path",
 	"route",
@@ -5742,6 +6574,7 @@ const SECRET_FALSE_POSITIVE_SUFFIXES = new Set([
 	"column",
 	"header",
 	"placeholder",
+	"prefix",
 	"description",
 	"type",
 	"icon",
@@ -5786,93 +6619,280 @@ const SECRET_FALSE_POSITIVE_SUFFIXES = new Set([
 	"constant"
 ]);
 //#endregion
-//#region src/plugin/rules/security/no-secrets-in-client-code.ts
-const noSecretsInClientCode = defineRule({
-	id: "no-secrets-in-client-code",
-	severity: "warn",
-	recommendation: "Move to server-side `process.env.SECRET_NAME`. Only `NEXT_PUBLIC_*` vars are safe for the client (and should not contain secrets)",
-	create: (context) => ({ VariableDeclarator(node) {
-		if (!isNodeOfType(node.id, "Identifier")) return;
-		if (!isNodeOfType(node.init, "Literal") || typeof node.init.value !== "string") return;
-		const variableName = node.id.name;
-		const literalValue = node.init.value;
-		const trailingSuffix = variableName.split("_").pop()?.toLowerCase() ?? "";
-		const isUiConstant = SECRET_FALSE_POSITIVE_SUFFIXES.has(trailingSuffix);
-		if (SECRET_VARIABLE_PATTERN.test(variableName) && !isUiConstant && literalValue.length > 24) {
-			context.report({
-				node,
-				message: `Possible hardcoded secret in "${variableName}" — use environment variables instead`
-			});
-			return;
-		}
-		if (SECRET_PATTERNS.some((pattern) => pattern.test(literalValue))) context.report({
-			node,
-			message: "Hardcoded secret detected — use environment variables instead"
-		});
-	} })
-});
-//#endregion
-//#region src/plugin/rules/state-and-effects/no-set-state-in-render.ts
-const isUnconditionalSetterCallStatement = (statement, setterNames) => {
-	if (!isNodeOfType(statement, "ExpressionStatement")) return null;
-	const expression = statement.expression;
-	if (!isNodeOfType(expression, "CallExpression")) return null;
-	const callee = expression.callee;
-	if (!isNodeOfType(callee, "Identifier")) return null;
-	if (!setterNames.has(callee.name)) return null;
-	return expression;
+//#region src/plugin/utils/classify-secret-file-exposure.ts
+const SOURCE_FILE_EXTENSION_PATTERN = /\.[cm]?[jt]sx?$/;
+const CLIENT_SOURCE_FILE_EXTENSION_PATTERN = /\.[cm]?[jt]sx$/;
+const CLIENT_APP_DIRECTORY_FRAMEWORKS = new Set([
+	"cra",
+	"expo",
+	"gatsby",
+	"vite"
+]);
+const isInsideDirectory = (pathSegments, directoryNames) => pathSegments.some((pathSegment) => directoryNames.has(pathSegment));
+const normalizeFilename = (filename) => filename.replaceAll("\\", "/");
+const normalizeDirectory = (directory) => normalizeFilename(directory).replace(/\/+$/, "");
+const getProjectRelativeFilename = (filename, rootDirectory) => {
+	const normalizedFilename = normalizeFilename(filename);
+	if (!rootDirectory) return normalizedFilename;
+	const rootDirectoryPrefix = `${normalizeDirectory(rootDirectory)}/`;
+	if (!normalizedFilename.startsWith(rootDirectoryPrefix)) return normalizedFilename;
+	return normalizedFilename.slice(rootDirectoryPrefix.length);
+};
+const getClassifiablePathSegments = (pathSegments) => {
+	const srcIndex = pathSegments.lastIndexOf("src");
+	if (srcIndex === -1) return pathSegments;
+	return pathSegments.slice(srcIndex + 1);
+};
+const isClientSourceFile = (normalizedFilename, pathSegments, classifiablePathSegments, options) => {
+	if (!SOURCE_FILE_EXTENSION_PATTERN.test(normalizedFilename)) return false;
+	if (!pathSegments.includes("src")) return false;
+	if (classifiablePathSegments[0] === "app" && !CLIENT_APP_DIRECTORY_FRAMEWORKS.has(options.framework ?? "")) return false;
+	if (CLIENT_SOURCE_FILE_EXTENSION_PATTERN.test(normalizedFilename)) return true;
+	return classifiablePathSegments.some((pathSegment) => SECRET_CLIENT_SOURCE_DIRECTORY_NAMES.has(pathSegment));
+};
+const getSourceRootOwner = (pathSegments) => {
+	const srcIndex = pathSegments.lastIndexOf("src");
+	if (srcIndex <= 0) return null;
+	return pathSegments[srcIndex - 1];
+};
+const isAppDirectoryClientSourceFile = (normalizedFilename, classifiablePathSegments, options) => {
+	if (!SOURCE_FILE_EXTENSION_PATTERN.test(normalizedFilename)) return false;
+	if (!CLIENT_APP_DIRECTORY_FRAMEWORKS.has(options.framework ?? "")) return false;
+	return classifiablePathSegments.includes("app");
+};
+const isNextJsFramework = (options) => options.framework === "nextjs";
+const classifySecretFileExposure = (filename, options = {}) => {
+	if (filename.length === 0) return "unknown";
+	const normalizedFilename = getProjectRelativeFilename(filename, options.rootDirectory);
+	const pathSegments = normalizedFilename.split("/");
+	const classifiablePathSegments = getClassifiablePathSegments(pathSegments);
+	const sourceRootOwner = getSourceRootOwner(pathSegments);
+	if (SECRET_TEST_FILE_PATTERN.test(normalizedFilename)) return "test";
+	if (isInsideDirectory(classifiablePathSegments, SECRET_TEST_DIRECTORY_NAMES)) return "test";
+	if (SECRET_TOOLING_FILE_PATTERN.test(normalizedFilename)) return "tooling";
+	if (SECRET_TOOLING_RC_FILE_PATTERN.test(normalizedFilename)) return "tooling";
+	if (sourceRootOwner && SECRET_TOOLING_DIRECTORY_NAMES.has(sourceRootOwner)) return "tooling";
+	if (isInsideDirectory(classifiablePathSegments, SECRET_TOOLING_DIRECTORY_NAMES)) return "tooling";
+	if (SECRET_SERVER_FILE_SUFFIX_PATTERN.test(normalizedFilename)) return "server";
+	if (options.hasUseServerDirective === true) return "server";
+	if (options.hasUseClientDirective === true) return "client";
+	if (SECRET_CLIENT_FILE_SUFFIX_PATTERN.test(normalizedFilename)) return "client";
+	if (isNextJsFramework(options) && SECRET_SERVER_ENTRY_FILE_PATTERN.test(normalizedFilename)) return "server";
+	if (isNextJsFramework(options) && SECRET_NEXT_PAGES_API_FILE_PATTERN.test(normalizedFilename)) return "server";
+	if (sourceRootOwner && SECRET_SERVER_SOURCE_ROOT_OWNER_NAMES.has(sourceRootOwner)) return "server";
+	if (isInsideDirectory(classifiablePathSegments, SECRET_SERVER_DIRECTORY_NAMES)) return "server";
+	if (SECRET_CLIENT_ENTRY_FILE_PATTERN.test(normalizedFilename)) return "client";
+	if (isAppDirectoryClientSourceFile(normalizedFilename, classifiablePathSegments, options)) return "client";
+	if (isClientSourceFile(normalizedFilename, pathSegments, classifiablePathSegments, options)) return "client";
+	return "unknown";
+};
+//#endregion
+//#region src/plugin/utils/get-identifier-trailing-word.ts
+const getIdentifierTrailingWord = (identifierName) => {
+	return identifierName.match(/[A-Z]+(?=[A-Z][a-z]|\b)|[A-Z]?[a-z]+|\d+/g)?.at(-1)?.toLowerCase() ?? identifierName.toLowerCase();
 };
-const noSetStateInRender = defineRule({
-	id: "no-set-state-in-render",
-	severity: "warn",
-	recommendation: "Move the setter call into a `useEffect`, an event handler, or replace the state with a value computed during render. Calling a setter at render time triggers another render, which calls the setter again — an infinite loop",
-	create: (context) => {
-		const checkComponent = (componentBody) => {
-			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const setterNames = new Set(collectUseStateBindings(componentBody).map((binding) => binding.setterName));
-			if (setterNames.size === 0) return;
-			for (const statement of componentBody.body ?? []) {
-				const setterCall = isUnconditionalSetterCallStatement(statement, setterNames);
-				if (!setterCall) continue;
-				if (!isNodeOfType(setterCall, "CallExpression")) continue;
-				if (!isNodeOfType(setterCall.callee, "Identifier")) continue;
-				const setterIdentifierName = setterCall.callee.name;
-				context.report({
-					node: setterCall,
-					message: `${setterIdentifierName}() called unconditionally at the top of render — causes an infinite re-render loop. Move into a useEffect or an event handler. (To derive state from props, guard the call: \`if (prev !== prop) ${setterIdentifierName}(prop)\`)`
-				});
-			}
-		};
-		return {
-			FunctionDeclaration(node) {
-				if (!node.id?.name || !isUppercaseName(node.id.name)) return;
-				checkComponent(node.body);
-			},
-			VariableDeclarator(node) {
-				if (!isComponentAssignment(node)) return;
-				if (!isNodeOfType(node.init, "ArrowFunctionExpression") && !isNodeOfType(node.init, "FunctionExpression")) return;
-				checkComponent(node.init.body);
-			}
-		};
-	}
-});
 //#endregion
-//#region src/plugin/rules/design/no-side-tab-border.ts
-const isNeutralBorderColor = (value) => {
-	const trimmed = value.trim().toLowerCase();
-	if ([
-		"gray",
-		"grey",
-		"silver",
-		"white",
-		"black",
-		"transparent",
-		"currentcolor"
-	].includes(trimmed)) return true;
-	const parsed = parseColorToRgb(trimmed);
-	if (parsed) return !hasColorChroma(parsed);
-	return false;
-};
+//#region src/plugin/constants/tanstack.ts
+const TANSTACK_ROUTE_FILE_PATTERN = /\/routes\//;
+const TANSTACK_ROOT_ROUTE_FILE_PATTERN = /__root\.(tsx?|jsx?)$/;
+const TANSTACK_ROUTE_PROPERTY_ORDER = [
+	"params",
+	"validateSearch",
+	"loaderDeps",
+	"search.middlewares",
+	"ssr",
+	"context",
+	"beforeLoad",
+	"loader",
+	"onEnter",
+	"onStay",
+	"onLeave",
+	"head",
+	"scripts",
+	"headers",
+	"remountDeps"
+];
+const TANSTACK_ROUTE_CREATION_FUNCTIONS = new Set([
+	"createFileRoute",
+	"createRoute",
+	"createRootRoute",
+	"createRootRouteWithContext"
+]);
+const TANSTACK_SERVER_FN_NAMES = new Set(["createServerFn"]);
+const TANSTACK_MIDDLEWARE_METHOD_ORDER = [
+	"middleware",
+	"inputValidator",
+	"client",
+	"server",
+	"handler"
+];
+const TANSTACK_REDIRECT_FUNCTIONS = new Set(["redirect", "notFound"]);
+const TANSTACK_SERVER_FN_FILE_PATTERN = /\.functions(\.[jt]sx?)?$/;
+const TANSTACK_QUERY_HOOKS = new Set([
+	"useQuery",
+	"useInfiniteQuery",
+	"useSuspenseQuery",
+	"useSuspenseInfiniteQuery"
+]);
+const TANSTACK_MUTATION_HOOKS = new Set(["useMutation"]);
+const QUERY_CACHE_UPDATE_METHODS = new Set([
+	"invalidateQueries",
+	"setQueryData",
+	"setQueriesData",
+	"resetQueries",
+	"refetchQueries",
+	"removeQueries",
+	"cancelQueries",
+	"clear"
+]);
+//#endregion
+//#region src/plugin/utils/has-use-server-directive.ts
+const hasUseServerDirective = (node) => {
+	if (!isNodeOfType(node, "FunctionDeclaration") && !isNodeOfType(node, "FunctionExpression") && !isNodeOfType(node, "ArrowFunctionExpression")) return false;
+	if (!isNodeOfType(node.body, "BlockStatement")) return false;
+	return Boolean(node.body.body?.some((statement) => isNodeOfType(statement, "ExpressionStatement") && statement.directive === "use server"));
+};
+//#endregion
+//#region src/plugin/utils/is-inside-server-only-scope.ts
+const isFunctionNode = (node) => isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression");
+const isTanStackServerFnHandlerCall = (node) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
+	if (!isNodeOfType(node.callee.property, "Identifier")) return false;
+	if (node.callee.property.name !== "handler") return false;
+	let currentNode = node.callee.object;
+	while (isNodeOfType(currentNode, "CallExpression")) {
+		const calleeName = getCalleeName$1(currentNode);
+		if (calleeName && TANSTACK_SERVER_FN_NAMES.has(calleeName)) return true;
+		if (!isNodeOfType(currentNode.callee, "MemberExpression")) return false;
+		currentNode = currentNode.callee.object;
+	}
+	return false;
+};
+const isTanStackServerFnHandler = (node) => {
+	const parent = node.parent;
+	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
+	if (!parent.arguments?.some((argument) => argument === node)) return false;
+	return isTanStackServerFnHandlerCall(parent);
+};
+const isInsideServerOnlyScope = (node) => {
+	let currentNode = node.parent ?? null;
+	while (currentNode) {
+		if (isFunctionNode(currentNode)) {
+			if (hasUseServerDirective(currentNode) || isTanStackServerFnHandler(currentNode)) return true;
+		}
+		currentNode = currentNode.parent ?? null;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/rules/security/no-secrets-in-client-code.ts
+const noSecretsInClientCode = defineRule({
+	id: "no-secrets-in-client-code",
+	severity: "warn",
+	recommendation: "Move secrets to server-only code. Public client environment variables are bundled into browser code and must not contain secrets",
+	create: (context) => {
+		const filename = context.getFilename?.() ?? "";
+		const framework = getReactDoctorStringSetting(context.settings, "framework");
+		const rootDirectory = getReactDoctorStringSetting(context.settings, "rootDirectory");
+		let shouldUseVariableNameHeuristic = classifySecretFileExposure(filename, {
+			framework,
+			rootDirectory
+		}) === "client";
+		return {
+			Program(programNode) {
+				shouldUseVariableNameHeuristic = classifySecretFileExposure(filename, {
+					framework,
+					hasUseClientDirective: hasDirective(programNode, "use client"),
+					hasUseServerDirective: hasDirective(programNode, "use server"),
+					rootDirectory
+				}) === "client";
+			},
+			VariableDeclarator(node) {
+				if (!isNodeOfType(node.id, "Identifier")) return;
+				if (!isNodeOfType(node.init, "Literal") || typeof node.init.value !== "string") return;
+				const variableName = node.id.name;
+				const literalValue = node.init.value;
+				const isServerOnlyScope = isInsideServerOnlyScope(node);
+				const trailingSuffix = getIdentifierTrailingWord(variableName);
+				const isUiConstant = SECRET_FALSE_POSITIVE_SUFFIXES.has(trailingSuffix);
+				if (shouldUseVariableNameHeuristic && !isServerOnlyScope && SECRET_VARIABLE_PATTERN.test(variableName) && !isUiConstant && literalValue.length > 24) {
+					context.report({
+						node,
+						message: `Possible hardcoded secret in "${variableName}" — use environment variables instead`
+					});
+					return;
+				}
+				if (SECRET_PATTERNS.some((pattern) => pattern.test(literalValue))) context.report({
+					node,
+					message: "Hardcoded secret detected — use environment variables instead"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/state-and-effects/no-set-state-in-render.ts
+const isUnconditionalSetterCallStatement = (statement, setterNames) => {
+	if (!isNodeOfType(statement, "ExpressionStatement")) return null;
+	const expression = statement.expression;
+	if (!isNodeOfType(expression, "CallExpression")) return null;
+	const callee = expression.callee;
+	if (!isNodeOfType(callee, "Identifier")) return null;
+	if (!setterNames.has(callee.name)) return null;
+	return expression;
+};
+const noSetStateInRender = defineRule({
+	id: "no-set-state-in-render",
+	severity: "warn",
+	recommendation: "Move the setter call into a `useEffect`, an event handler, or replace the state with a value computed during render. Calling a setter at render time triggers another render, which calls the setter again — an infinite loop",
+	create: (context) => {
+		const checkComponent = (componentBody) => {
+			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
+			const setterNames = new Set(collectUseStateBindings(componentBody).map((binding) => binding.setterName));
+			if (setterNames.size === 0) return;
+			for (const statement of componentBody.body ?? []) {
+				const setterCall = isUnconditionalSetterCallStatement(statement, setterNames);
+				if (!setterCall) continue;
+				if (!isNodeOfType(setterCall, "CallExpression")) continue;
+				if (!isNodeOfType(setterCall.callee, "Identifier")) continue;
+				const setterIdentifierName = setterCall.callee.name;
+				context.report({
+					node: setterCall,
+					message: `${setterIdentifierName}() called unconditionally at the top of render — causes an infinite re-render loop. Move into a useEffect or an event handler. (To derive state from props, guard the call: \`if (prev !== prop) ${setterIdentifierName}(prop)\`)`
+				});
+			}
+		};
+		return {
+			FunctionDeclaration(node) {
+				if (!node.id?.name || !isUppercaseName(node.id.name)) return;
+				checkComponent(node.body);
+			},
+			VariableDeclarator(node) {
+				if (!isComponentAssignment(node)) return;
+				if (!isNodeOfType(node.init, "ArrowFunctionExpression") && !isNodeOfType(node.init, "FunctionExpression")) return;
+				checkComponent(node.init.body);
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/design/no-side-tab-border.ts
+const isNeutralBorderColor = (value) => {
+	const trimmed = value.trim().toLowerCase();
+	if ([
+		"gray",
+		"grey",
+		"silver",
+		"white",
+		"black",
+		"transparent",
+		"currentcolor"
+	].includes(trimmed)) return true;
+	const parsed = parseColorToRgb(trimmed);
+	if (parsed) return !hasColorChroma(parsed);
+	return false;
+};
 const extractBorderColorFromShorthand = (shorthandValue) => {
 	const afterSolid = shorthandValue.match(/solid\s+(.+)$/i);
 	if (!afterSolid) return null;
@@ -6557,60 +7577,6 @@ const preferUseReducer = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/constants/tanstack.ts
-const TANSTACK_ROUTE_FILE_PATTERN = /\/routes\//;
-const TANSTACK_ROOT_ROUTE_FILE_PATTERN = /__root\.(tsx?|jsx?)$/;
-const TANSTACK_ROUTE_PROPERTY_ORDER = [
-	"params",
-	"validateSearch",
-	"loaderDeps",
-	"search.middlewares",
-	"ssr",
-	"context",
-	"beforeLoad",
-	"loader",
-	"onEnter",
-	"onStay",
-	"onLeave",
-	"head",
-	"scripts",
-	"headers",
-	"remountDeps"
-];
-const TANSTACK_ROUTE_CREATION_FUNCTIONS = new Set([
-	"createFileRoute",
-	"createRoute",
-	"createRootRoute",
-	"createRootRouteWithContext"
-]);
-const TANSTACK_SERVER_FN_NAMES = new Set(["createServerFn"]);
-const TANSTACK_MIDDLEWARE_METHOD_ORDER = [
-	"middleware",
-	"inputValidator",
-	"client",
-	"server",
-	"handler"
-];
-const TANSTACK_REDIRECT_FUNCTIONS = new Set(["redirect", "notFound"]);
-const TANSTACK_SERVER_FN_FILE_PATTERN = /\.functions(\.[jt]sx?)?$/;
-const TANSTACK_QUERY_HOOKS = new Set([
-	"useQuery",
-	"useInfiniteQuery",
-	"useSuspenseQuery",
-	"useSuspenseInfiniteQuery"
-]);
-const TANSTACK_MUTATION_HOOKS = new Set(["useMutation"]);
-const QUERY_CACHE_UPDATE_METHODS = new Set([
-	"invalidateQueries",
-	"setQueryData",
-	"setQueriesData",
-	"resetQueries",
-	"refetchQueries",
-	"removeQueries",
-	"cancelQueries",
-	"clear"
-]);
-//#endregion
 //#region src/plugin/rules/tanstack-query/query-mutation-missing-invalidation.ts
 const queryMutationMissingInvalidation = defineRule({
 	id: "query-mutation-missing-invalidation",
@@ -8130,6 +9096,118 @@ const rnNoNonNativeNavigator = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/is-inside-platform-os-web-branch.ts
+const unwrapAccessor = (node) => {
+	let current = node;
+	while (current) {
+		if (isNodeOfType(current, "TSNonNullExpression")) {
+			current = current.expression;
+			continue;
+		}
+		if (isNodeOfType(current, "ChainExpression")) {
+			current = current.expression;
+			continue;
+		}
+		if (isNodeOfType(current, "TSAsExpression") || isNodeOfType(current, "TSSatisfiesExpression")) {
+			current = current.expression;
+			continue;
+		}
+		return current;
+	}
+	return null;
+};
+const isPlatformOsMemberExpression = (node) => {
+	const unwrapped = unwrapAccessor(node);
+	if (!unwrapped || !isNodeOfType(unwrapped, "MemberExpression")) return false;
+	if (unwrapped.computed) return false;
+	const objectExpression = unwrapAccessor(unwrapped.object);
+	if (!objectExpression || !isNodeOfType(objectExpression, "Identifier")) return false;
+	if (objectExpression.name !== "Platform") return false;
+	if (!isNodeOfType(unwrapped.property, "Identifier") || unwrapped.property.name !== "OS") return false;
+	return true;
+};
+const isPlatformSelectCallee = (callee) => {
+	const unwrapped = unwrapAccessor(callee);
+	if (!unwrapped || !isNodeOfType(unwrapped, "MemberExpression")) return false;
+	if (unwrapped.computed) return false;
+	const objectExpression = unwrapAccessor(unwrapped.object);
+	if (!objectExpression || !isNodeOfType(objectExpression, "Identifier")) return false;
+	if (objectExpression.name !== "Platform") return false;
+	if (!isNodeOfType(unwrapped.property, "Identifier") || unwrapped.property.name !== "select") return false;
+	return true;
+};
+const isStringLiteralEqualTo = (node, expected) => {
+	if (!node) return false;
+	if (isNodeOfType(node, "Literal") && node.value === expected) return true;
+	if (isNodeOfType(node, "TemplateLiteral") && node.quasis.length === 1) return node.quasis[0]?.value?.cooked === expected;
+	return false;
+};
+const readStaticPropertyKeyName = (property) => {
+	if (!isNodeOfType(property, "Property")) return null;
+	if (property.computed) {
+		if (isStringLiteralEqualTo(property.key, "web")) return "web";
+		return null;
+	}
+	if (isNodeOfType(property.key, "Identifier")) return property.key.name;
+	if (isNodeOfType(property.key, "Literal") && typeof property.key.value === "string") return property.key.value;
+	return null;
+};
+const classifyPlatformOsBinaryTest = (testNode) => {
+	if (!testNode || !isNodeOfType(testNode, "BinaryExpression")) return {
+		isWebBranch: false,
+		isNonWebBranch: false
+	};
+	if (testNode.operator !== "===" && testNode.operator !== "!==") return {
+		isWebBranch: false,
+		isNonWebBranch: false
+	};
+	const matchesLeft = isPlatformOsMemberExpression(testNode.left) && isStringLiteralEqualTo(testNode.right, "web");
+	const matchesRight = isPlatformOsMemberExpression(testNode.right) && isStringLiteralEqualTo(testNode.left, "web");
+	if (!matchesLeft && !matchesRight) return {
+		isWebBranch: false,
+		isNonWebBranch: false
+	};
+	return {
+		isWebBranch: testNode.operator === "===",
+		isNonWebBranch: testNode.operator === "!=="
+	};
+};
+const isScopeBoundaryNode = (node) => isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "Program");
+const isInsidePlatformOsWebBranch = (node) => {
+	let child = node;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "IfStatement")) {
+			const classification = classifyPlatformOsBinaryTest(parent.test);
+			if (classification.isWebBranch && parent.consequent === child) return true;
+			if (classification.isNonWebBranch && parent.alternate === child) return true;
+		} else if (isNodeOfType(parent, "ConditionalExpression")) {
+			const classification = classifyPlatformOsBinaryTest(parent.test);
+			if (classification.isWebBranch && parent.consequent === child) return true;
+			if (classification.isNonWebBranch && parent.alternate === child) return true;
+		} else if (isNodeOfType(parent, "LogicalExpression")) {
+			const classification = classifyPlatformOsBinaryTest(parent.left);
+			if (parent.right === child) {
+				if (parent.operator === "&&" && classification.isWebBranch) return true;
+				if (parent.operator === "||" && classification.isNonWebBranch) return true;
+			}
+		} else if (isNodeOfType(parent, "SwitchCase")) {
+			const switchStatement = parent.parent;
+			if (isNodeOfType(switchStatement, "SwitchStatement") && isPlatformOsMemberExpression(switchStatement.discriminant) && isStringLiteralEqualTo(parent.test, "web") && parent.test !== child) return true;
+		} else if (isNodeOfType(parent, "Property")) {
+			const objectExpression = parent.parent;
+			if (isNodeOfType(objectExpression, "ObjectExpression")) {
+				const callExpression = objectExpression.parent;
+				if (isNodeOfType(callExpression, "CallExpression") && callExpression.arguments[0] === objectExpression && isPlatformSelectCallee(callExpression.callee) && readStaticPropertyKeyName(parent) === "web" && parent.value === child) return true;
+			}
+		}
+		if (isScopeBoundaryNode(parent)) return false;
+		child = parent;
+		parent = parent.parent ?? null;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/react-native/rn-no-raw-text.ts
 const truncateText = (text) => text.length > 30 ? `${text.slice(0, 30)}...` : text;
 const isRawTextContent = (child) => {
@@ -8152,25 +9230,22 @@ const isTextHandlingComponent = (elementName) => {
 	if (REACT_NATIVE_TEXT_COMPONENTS.has(elementName)) return true;
 	return [...REACT_NATIVE_TEXT_COMPONENT_KEYWORDS].some((keyword) => elementName.includes(keyword));
 };
-const WEB_FILE_EXTENSION_PATTERN = /\.web\.[jt]sx?$/;
 const rnNoRawText = defineRule({
 	id: "rn-no-raw-text",
 	requires: ["react-native"],
 	severity: "error",
 	recommendation: "Wrap text in a `<Text>` component: `<Text>{value}</Text>` — raw strings outside `<Text>` crash on React Native",
 	create: (context) => {
-		let isWebOnlyFile = false;
 		let isDomComponentFile = false;
 		return {
 			Program(programNode) {
 				isDomComponentFile = hasDirective(programNode, "use dom");
-				const filename = context.getFilename?.() ?? "";
-				isWebOnlyFile = WEB_FILE_EXTENSION_PATTERN.test(filename);
 			},
 			JSXElement(node) {
-				if (isDomComponentFile || isWebOnlyFile) return;
+				if (isDomComponentFile) return;
 				const elementName = resolveJsxElementName(node.openingElement);
 				if (elementName && isTextHandlingComponent(elementName)) return;
+				if (isInsidePlatformOsWebBranch(node)) return;
 				for (const child of node.children ?? []) {
 					if (!isRawTextContent(child)) continue;
 					context.report({
@@ -8504,13 +9579,6 @@ const rnStylePreferBoxShadow = defineRule({
 	})
 });
 //#endregion
-//#region src/plugin/utils/has-use-server-directive.ts
-const hasUseServerDirective = (node) => {
-	if (!isNodeOfType(node, "FunctionDeclaration") && !isNodeOfType(node, "FunctionExpression") && !isNodeOfType(node, "ArrowFunctionExpression")) return false;
-	if (!isNodeOfType(node.body, "BlockStatement")) return false;
-	return Boolean(node.body.body?.some((statement) => isNodeOfType(statement, "ExpressionStatement") && statement.directive === "use server"));
-};
-//#endregion
 //#region src/plugin/rules/server/server-after-nonblocking.ts
 const CONSOLE_DEFERRABLE_METHODS = new Set([
 	"log",
@@ -8581,38 +9649,134 @@ const serverAfterNonblocking = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/server/server-auth-actions.ts
-const containsAuthCheck = (statements) => {
+const isAsyncFunctionLikeNode = (node) => {
+	if (!node) return false;
+	if (!isNodeOfType(node, "FunctionDeclaration") && !isNodeOfType(node, "FunctionExpression") && !isNodeOfType(node, "ArrowFunctionExpression")) return false;
+	return Boolean(node.async);
+};
+const unwrapTypeWrappedCallee = (node) => {
+	let currentNode = node;
+	while (currentNode) {
+		if (isNodeOfType(currentNode, "TSAsExpression") || isNodeOfType(currentNode, "TSNonNullExpression") || isNodeOfType(currentNode, "TSTypeAssertion") || isNodeOfType(currentNode, "TSSatisfiesExpression") || isNodeOfType(currentNode, "TSInstantiationExpression")) {
+			currentNode = currentNode.expression;
+			continue;
+		}
+		if (isNodeOfType(currentNode, "ChainExpression")) {
+			currentNode = currentNode.expression;
+			continue;
+		}
+		return currentNode;
+	}
+	return null;
+};
+const buildDottedReceiverSource = (receiverNode) => {
+	const unwrapped = unwrapTypeWrappedCallee(receiverNode);
+	if (!unwrapped) return "";
+	if (isNodeOfType(unwrapped, "Identifier")) return unwrapped.name;
+	if (isNodeOfType(unwrapped, "ThisExpression")) return "this";
+	if (isNodeOfType(unwrapped, "MemberExpression")) {
+		const objectSource = buildDottedReceiverSource(unwrapped.object);
+		const propertyName = isNodeOfType(unwrapped.property, "Identifier") ? unwrapped.property.name : "";
+		if (!propertyName) return objectSource;
+		return objectSource ? `${objectSource}.${propertyName}` : propertyName;
+	}
+	return "";
+};
+const isMemberCallAuthRelated = (receiverNode, methodName, genericMethodNames) => {
+	if (!genericMethodNames.has(methodName)) return true;
+	const receiverSource = buildDottedReceiverSource(receiverNode);
+	return AUTH_OBJECT_PATTERN.test(receiverSource);
+};
+const getAuthCallName = (callExpression, allowedFunctionNames, genericMethodNames) => {
+	const calleeNode = unwrapTypeWrappedCallee(callExpression.callee);
+	if (!calleeNode) return null;
+	if (isNodeOfType(calleeNode, "Identifier")) return allowedFunctionNames.has(calleeNode.name) ? calleeNode.name : null;
+	if (isNodeOfType(calleeNode, "MemberExpression") && isNodeOfType(calleeNode.property, "Identifier")) {
+		const methodName = calleeNode.property.name;
+		if (!allowedFunctionNames.has(methodName)) return null;
+		if (!isMemberCallAuthRelated(calleeNode.object, methodName, genericMethodNames)) return null;
+		return methodName;
+	}
+	return null;
+};
+const isFunctionLikeNode = (node) => isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression");
+const containsAuthCheck = (rootNodes, allowedFunctionNames, genericMethodNames) => {
 	let foundAuthCall = false;
-	for (const statement of statements) walkAst(statement, (child) => {
+	for (const rootNode of rootNodes) walkAst(rootNode, (child) => {
 		if (foundAuthCall) return;
-		let callNode = null;
-		if (isNodeOfType(child, "CallExpression")) callNode = child;
-		else if (isNodeOfType(child, "AwaitExpression") && isNodeOfType(child.argument, "CallExpression")) callNode = child.argument;
-		if (isNodeOfType(callNode?.callee, "Identifier") && AUTH_FUNCTION_NAMES.has(callNode.callee.name)) foundAuthCall = true;
+		if (isFunctionLikeNode(child)) return false;
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (getAuthCallName(child, allowedFunctionNames, genericMethodNames)) foundAuthCall = true;
 	});
 	return foundAuthCall;
 };
+const getAuthScanRoots = (functionNode) => {
+	const bodyNode = functionNode.body;
+	if (!bodyNode) return [];
+	if (isNodeOfType(bodyNode, "BlockStatement")) return (bodyNode.body ?? []).slice(0, 10);
+	return [bodyNode];
+};
+const inspectServerAction = (candidate, fileHasUseServerDirective, allowedFunctionNames, context) => {
+	if (!(fileHasUseServerDirective || hasUseServerDirective(candidate.functionNode))) return;
+	if (containsAuthCheck(getAuthScanRoots(candidate.functionNode), allowedFunctionNames, GENERIC_AUTH_METHOD_NAMES)) return;
+	context.report({
+		node: candidate.reportNode,
+		message: `Server action "${candidate.displayName}" — add auth check (auth(), getSession(), etc.) at the top`
+	});
+};
+const collectCandidatesFromVariableDeclaration = (variableDeclaration) => {
+	const candidates = [];
+	for (const declarator of variableDeclaration.declarations ?? []) {
+		if (!isAsyncFunctionLikeNode(declarator.init)) continue;
+		const bindingNode = isNodeOfType(declarator.id, "Identifier") ? declarator.id : null;
+		candidates.push({
+			functionNode: declarator.init,
+			displayName: bindingNode?.name ?? "anonymous",
+			reportNode: bindingNode ?? declarator
+		});
+	}
+	return candidates;
+};
+const getCandidateFromDefaultDeclaration = (node) => {
+	const declaration = node.declaration;
+	if (!isAsyncFunctionLikeNode(declaration)) return null;
+	const functionId = (isNodeOfType(declaration, "FunctionDeclaration") || isNodeOfType(declaration, "FunctionExpression")) && declaration.id ? declaration.id : null;
+	return {
+		functionNode: declaration,
+		displayName: functionId?.name ?? "default",
+		reportNode: functionId ?? node
+	};
+};
 const serverAuthActions = defineRule({
 	id: "server-auth-actions",
 	severity: "error",
 	recommendation: "Add `const session = await auth()` at the top and throw/redirect if unauthorized before any data access",
 	create: (context) => {
 		let fileHasUseServerDirective = false;
+		const customAuthFunctionNames = getReactDoctorStringArraySetting(context.settings, "serverAuthFunctionNames");
+		const allowedFunctionNames = customAuthFunctionNames.length > 0 ? new Set([...AUTH_FUNCTION_NAMES, ...customAuthFunctionNames]) : AUTH_FUNCTION_NAMES;
+		const inspect = (candidate) => inspectServerAction(candidate, fileHasUseServerDirective, allowedFunctionNames, context);
 		return {
 			Program(programNode) {
 				fileHasUseServerDirective = hasDirective(programNode, "use server");
 			},
 			ExportNamedDeclaration(node) {
 				const declaration = node.declaration;
-				if (!isNodeOfType(declaration, "FunctionDeclaration") || !declaration?.async) return;
-				if (!(fileHasUseServerDirective || hasUseServerDirective(declaration))) return;
-				if (!containsAuthCheck((declaration.body?.body ?? []).slice(0, 10))) {
-					const functionName = declaration.id?.name ?? "anonymous";
-					context.report({
-						node: declaration.id ?? node,
-						message: `Server action "${functionName}" — add auth check (auth(), getSession(), etc.) at the top`
+				if (!declaration) return;
+				if (isAsyncFunctionLikeNode(declaration)) {
+					if (!isNodeOfType(declaration, "FunctionDeclaration")) return;
+					inspect({
+						functionNode: declaration,
+						displayName: declaration.id?.name ?? "anonymous",
+						reportNode: declaration.id ?? node
 					});
+					return;
 				}
+				if (isNodeOfType(declaration, "VariableDeclaration")) for (const candidate of collectCandidatesFromVariableDeclaration(declaration)) inspect(candidate);
+			},
+			ExportDefaultDeclaration(node) {
+				const candidate = getCandidateFromDefaultDeclaration(node);
+				if (candidate) inspect(candidate);
 			}
 		};
 	}
@@ -9005,7 +10169,13 @@ const tanstackStartGetMutation = defineRule({
 		if (chainInfo.specifiedMethod && MUTATING_HTTP_METHODS.has(chainInfo.specifiedMethod.toUpperCase())) return;
 		const handlerFunction = node.arguments?.[0];
 		if (!handlerFunction) return;
-		const sideEffect = findSideEffect(handlerFunction);
+		if (!isNodeOfType(handlerFunction, "ArrowFunctionExpression") && !isNodeOfType(handlerFunction, "FunctionExpression")) return;
+		const handlerBody = handlerFunction.body;
+		if (!handlerBody) return;
+		const sideEffect = findSideEffect(handlerBody, {
+			locallyScopedSafeBindings: collectLocallyScopedSafeBindings(handlerBody),
+			locallyScopedCookieBindings: collectLocallyScopedCookieBindings(handlerBody)
+		});
 		if (sideEffect) context.report({
 			node,
 			message: `GET server function has side effects (${sideEffect}) — use createServerFn({ method: 'POST' }) for mutations`
@@ -9447,906 +10617,1065 @@ const useLazyMotion = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rule-registry.ts
+const ruleRegistry = {
+	"advanced-event-handler-refs": {
+		...advancedEventHandlerRefs,
+		framework: "global",
+		category: "Performance"
+	},
+	"async-await-in-loop": {
+		...asyncAwaitInLoop,
+		framework: "global",
+		category: "Performance"
+	},
+	"async-defer-await": {
+		...asyncDeferAwait,
+		framework: "global",
+		category: "Performance"
+	},
+	"async-parallel": {
+		...asyncParallel,
+		framework: "global",
+		category: "Performance"
+	},
+	"client-localstorage-no-version": {
+		...clientLocalstorageNoVersion,
+		framework: "global",
+		category: "Correctness"
+	},
+	"client-passive-event-listeners": {
+		...clientPassiveEventListeners,
+		framework: "global",
+		category: "Performance"
+	},
+	"design-no-bold-heading": {
+		...noBoldHeading,
+		framework: "global",
+		category: "Architecture"
+	},
+	"design-no-default-tailwind-palette": {
+		...noDefaultTailwindPalette,
+		framework: "global",
+		category: "Architecture"
+	},
+	"design-no-em-dash-in-jsx-text": {
+		...noEmDashInJsxText,
+		framework: "global",
+		category: "Architecture"
+	},
+	"design-no-redundant-padding-axes": {
+		...noRedundantPaddingAxes,
+		framework: "global",
+		category: "Architecture"
+	},
+	"design-no-redundant-size-axes": {
+		...noRedundantSizeAxes,
+		framework: "global",
+		category: "Architecture"
+	},
+	"design-no-space-on-flex-children": {
+		...noSpaceOnFlexChildren,
+		framework: "global",
+		category: "Architecture"
+	},
+	"design-no-three-period-ellipsis": {
+		...noThreePeriodEllipsis,
+		framework: "global",
+		category: "Architecture"
+	},
+	"design-no-vague-button-label": {
+		...noVagueButtonLabel,
+		framework: "global",
+		category: "Accessibility"
+	},
+	"effect-needs-cleanup": {
+		...effectNeedsCleanup,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"js-batch-dom-css": {
+		...jsBatchDomCss,
+		framework: "global",
+		category: "Performance"
+	},
+	"js-cache-property-access": {
+		...jsCachePropertyAccess,
+		framework: "global",
+		category: "Performance"
+	},
+	"js-cache-storage": {
+		...jsCacheStorage,
+		framework: "global",
+		category: "Performance"
+	},
+	"js-combine-iterations": {
+		...jsCombineIterations,
+		framework: "global",
+		category: "Performance"
+	},
+	"js-early-exit": {
+		...jsEarlyExit,
+		framework: "global",
+		category: "Performance"
+	},
+	"js-flatmap-filter": {
+		...jsFlatmapFilter,
+		framework: "global",
+		category: "Performance"
+	},
+	"js-hoist-intl": {
+		...jsHoistIntl,
+		framework: "global",
+		category: "Performance"
+	},
+	"js-hoist-regexp": {
+		...jsHoistRegexp,
+		framework: "global",
+		category: "Performance"
+	},
+	"js-index-maps": {
+		...jsIndexMaps,
+		framework: "global",
+		category: "Performance"
+	},
+	"js-length-check-first": {
+		...jsLengthCheckFirst,
+		framework: "global",
+		category: "Performance"
+	},
+	"js-min-max-loop": {
+		...jsMinMaxLoop,
+		framework: "global",
+		category: "Performance"
+	},
+	"js-set-map-lookups": {
+		...jsSetMapLookups,
+		framework: "global",
+		category: "Performance"
+	},
+	"js-tosorted-immutable": {
+		...jsTosortedImmutable,
+		framework: "global",
+		category: "Performance"
+	},
+	"nextjs-async-client-component": {
+		...nextjsAsyncClientComponent,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"nextjs-image-missing-sizes": {
+		...nextjsImageMissingSizes,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"nextjs-inline-script-missing-id": {
+		...nextjsInlineScriptMissingId,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"nextjs-missing-metadata": {
+		...nextjsMissingMetadata,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"nextjs-no-a-element": {
+		...nextjsNoAElement,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"nextjs-no-client-fetch-for-server-data": {
+		...nextjsNoClientFetchForServerData,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"nextjs-no-client-side-redirect": {
+		...nextjsNoClientSideRedirect,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"nextjs-no-css-link": {
+		...nextjsNoCssLink,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"nextjs-no-font-link": {
+		...nextjsNoFontLink,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"nextjs-no-head-import": {
+		...nextjsNoHeadImport,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"nextjs-no-img-element": {
+		...nextjsNoImgElement,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"nextjs-no-native-script": {
+		...nextjsNoNativeScript,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"nextjs-no-polyfill-script": {
+		...nextjsNoPolyfillScript,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"nextjs-no-redirect-in-try-catch": {
+		...nextjsNoRedirectInTryCatch,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"nextjs-no-side-effect-in-get-handler": {
+		...nextjsNoSideEffectInGetHandler,
+		framework: "nextjs",
+		category: "Security"
+	},
+	"nextjs-no-use-search-params-without-suspense": {
+		...nextjsNoUseSearchParamsWithoutSuspense,
+		framework: "nextjs",
+		category: "Next.js"
+	},
+	"no-array-index-as-key": {
+		...noArrayIndexAsKey,
+		framework: "global",
+		category: "Correctness"
+	},
+	"no-barrel-import": {
+		...noBarrelImport,
+		framework: "global",
+		category: "Bundle Size"
+	},
+	"no-cascading-set-state": {
+		...noCascadingSetState,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"no-dark-mode-glow": {
+		...noDarkModeGlow,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-default-props": {
+		...noDefaultProps,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-derived-state-effect": {
+		...noDerivedStateEffect,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"no-derived-useState": {
+		...noDerivedUseState,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"no-direct-state-mutation": {
+		...noDirectStateMutation,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"no-disabled-zoom": {
+		...noDisabledZoom,
+		framework: "global",
+		category: "Accessibility"
+	},
+	"no-document-start-view-transition": {
+		...noDocumentStartViewTransition,
+		framework: "global",
+		category: "Correctness"
+	},
+	"no-dynamic-import-path": {
+		...noDynamicImportPath,
+		framework: "global",
+		category: "Bundle Size"
+	},
+	"no-effect-chain": {
+		...noEffectChain,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"no-effect-event-handler": {
+		...noEffectEventHandler,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"no-effect-event-in-deps": {
+		...noEffectEventInDeps,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"no-eval": {
+		...noEval,
+		framework: "global",
+		category: "Security"
+	},
+	"no-event-trigger-state": {
+		...noEventTriggerState,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"no-fetch-in-effect": {
+		...noFetchInEffect,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"no-flush-sync": {
+		...noFlushSync,
+		framework: "global",
+		category: "Performance"
+	},
+	"no-full-lodash-import": {
+		...noFullLodashImport,
+		framework: "global",
+		category: "Bundle Size"
+	},
+	"no-generic-handler-names": {
+		...noGenericHandlerNames,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-giant-component": {
+		...noGiantComponent,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-global-css-variable-animation": {
+		...noGlobalCssVariableAnimation,
+		framework: "global",
+		category: "Performance"
+	},
+	"no-gradient-text": {
+		...noGradientText,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-gray-on-colored-background": {
+		...noGrayOnColoredBackground,
+		framework: "global",
+		category: "Accessibility"
+	},
+	"no-inline-bounce-easing": {
+		...noInlineBounceEasing,
+		framework: "global",
+		category: "Performance"
+	},
+	"no-inline-exhaustive-style": {
+		...noInlineExhaustiveStyle,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-inline-prop-on-memo-component": {
+		...noInlinePropOnMemoComponent,
+		framework: "global",
+		category: "Performance"
+	},
+	"no-justified-text": {
+		...noJustifiedText,
+		framework: "global",
+		category: "Accessibility"
+	},
+	"no-large-animated-blur": {
+		...noLargeAnimatedBlur,
+		framework: "global",
+		category: "Performance"
+	},
+	"no-layout-property-animation": {
+		...noLayoutPropertyAnimation,
+		framework: "global",
+		category: "Performance"
+	},
+	"no-layout-transition-inline": {
+		...noLayoutTransitionInline,
+		framework: "global",
+		category: "Performance"
+	},
+	"no-legacy-class-lifecycles": {
+		...noLegacyClassLifecycles,
+		framework: "global",
+		category: "Correctness"
+	},
+	"no-legacy-context-api": {
+		...noLegacyContextApi,
+		framework: "global",
+		category: "Correctness"
+	},
+	"no-long-transition-duration": {
+		...noLongTransitionDuration,
+		framework: "global",
+		category: "Performance"
+	},
+	"no-many-boolean-props": {
+		...noManyBooleanProps,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-mirror-prop-effect": {
+		...noMirrorPropEffect,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"no-moment": {
+		...noMoment,
+		framework: "global",
+		category: "Bundle Size"
+	},
+	"no-mutable-in-deps": {
+		...noMutableInDeps,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"no-nested-component-definition": {
+		...noNestedComponentDefinition,
+		framework: "global",
+		category: "Correctness"
+	},
+	"no-outline-none": {
+		...noOutlineNone,
+		framework: "global",
+		category: "Accessibility"
+	},
+	"no-permanent-will-change": {
+		...noPermanentWillChange,
+		framework: "global",
+		category: "Performance"
+	},
+	"no-polymorphic-children": {
+		...noPolymorphicChildren,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-prevent-default": {
+		...noPreventDefault,
+		framework: "global",
+		category: "Correctness"
+	},
+	"no-prop-callback-in-effect": {
+		...noPropCallbackInEffect,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"no-pure-black-background": {
+		...noPureBlackBackground,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-react-dom-deprecated-apis": {
+		...noReactDomDeprecatedApis,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-react19-deprecated-apis": {
+		...noReact19DeprecatedApis,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-render-in-render": {
+		...noRenderInRender,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-render-prop-children": {
+		...noRenderPropChildren,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-scale-from-zero": {
+		...noScaleFromZero,
+		framework: "global",
+		category: "Performance"
+	},
+	"no-secrets-in-client-code": {
+		...noSecretsInClientCode,
+		framework: "global",
+		category: "Security"
+	},
+	"no-set-state-in-render": {
+		...noSetStateInRender,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"no-side-tab-border": {
+		...noSideTabBorder,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-tiny-text": {
+		...noTinyText,
+		framework: "global",
+		category: "Accessibility"
+	},
+	"no-transition-all": {
+		...noTransitionAll,
+		framework: "global",
+		category: "Performance"
+	},
+	"no-uncontrolled-input": {
+		...noUncontrolledInput,
+		framework: "global",
+		category: "Correctness"
+	},
+	"no-undeferred-third-party": {
+		...noUndeferredThirdParty,
+		framework: "global",
+		category: "Bundle Size"
+	},
+	"no-usememo-simple-expression": {
+		...noUsememoSimpleExpression,
+		framework: "global",
+		category: "Performance"
+	},
+	"no-wide-letter-spacing": {
+		...noWideLetterSpacing,
+		framework: "global",
+		category: "Architecture"
+	},
+	"no-z-index-9999": {
+		...noZIndex9999,
+		framework: "global",
+		category: "Architecture"
+	},
+	"prefer-dynamic-import": {
+		...preferDynamicImport,
+		framework: "global",
+		category: "Bundle Size"
+	},
+	"prefer-use-effect-event": {
+		...preferUseEffectEvent,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"prefer-use-sync-external-store": {
+		...preferUseSyncExternalStore,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"prefer-useReducer": {
+		...preferUseReducer,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"query-mutation-missing-invalidation": {
+		...queryMutationMissingInvalidation,
+		framework: "tanstack-query",
+		category: "TanStack Query"
+	},
+	"query-no-query-in-effect": {
+		...queryNoQueryInEffect,
+		framework: "tanstack-query",
+		category: "TanStack Query"
+	},
+	"query-no-rest-destructuring": {
+		...queryNoRestDestructuring,
+		framework: "tanstack-query",
+		category: "TanStack Query"
+	},
+	"query-no-usequery-for-mutation": {
+		...queryNoUseQueryForMutation,
+		framework: "tanstack-query",
+		category: "TanStack Query"
+	},
+	"query-no-void-query-fn": {
+		...queryNoVoidQueryFn,
+		framework: "tanstack-query",
+		category: "TanStack Query"
+	},
+	"query-stable-query-client": {
+		...queryStableQueryClient,
+		framework: "tanstack-query",
+		category: "TanStack Query"
+	},
+	"react-compiler-destructure-method": {
+		...reactCompilerDestructureMethod,
+		framework: "global",
+		category: "Architecture"
+	},
+	"rendering-animate-svg-wrapper": {
+		...renderingAnimateSvgWrapper,
+		framework: "global",
+		category: "Performance"
+	},
+	"rendering-conditional-render": {
+		...renderingConditionalRender,
+		framework: "global",
+		category: "Correctness"
+	},
+	"rendering-hoist-jsx": {
+		...renderingHoistJsx,
+		framework: "global",
+		category: "Performance"
+	},
+	"rendering-hydration-mismatch-time": {
+		...renderingHydrationMismatchTime,
+		framework: "global",
+		category: "Correctness"
+	},
+	"rendering-hydration-no-flicker": {
+		...renderingHydrationNoFlicker,
+		framework: "global",
+		category: "Performance"
+	},
+	"rendering-script-defer-async": {
+		...renderingScriptDeferAsync,
+		framework: "global",
+		category: "Performance"
+	},
+	"rendering-svg-precision": {
+		...renderingSvgPrecision,
+		framework: "global",
+		category: "Performance"
+	},
+	"rendering-usetransition-loading": {
+		...renderingUsetransitionLoading,
+		framework: "global",
+		category: "Performance"
+	},
+	"rerender-defer-reads-hook": {
+		...rerenderDeferReadsHook,
+		framework: "global",
+		category: "Performance"
+	},
+	"rerender-dependencies": {
+		...rerenderDependencies,
+		framework: "global",
+		category: "State & Effects"
+	},
+	"rerender-derived-state-from-hook": {
+		...rerenderDerivedStateFromHook,
+		framework: "global",
+		category: "Performance"
+	},
+	"rerender-functional-setstate": {
+		...rerenderFunctionalSetstate,
+		framework: "global",
+		category: "Performance"
+	},
+	"rerender-lazy-state-init": {
+		...rerenderLazyStateInit,
+		framework: "global",
+		category: "Performance"
+	},
+	"rerender-memo-before-early-return": {
+		...rerenderMemoBeforeEarlyReturn,
+		framework: "global",
+		category: "Performance"
+	},
+	"rerender-memo-with-default-value": {
+		...rerenderMemoWithDefaultValue,
+		framework: "global",
+		category: "Performance"
+	},
+	"rerender-state-only-in-handlers": {
+		...rerenderStateOnlyInHandlers,
+		framework: "global",
+		category: "Performance"
+	},
+	"rerender-transitions-scroll": {
+		...rerenderTransitionsScroll,
+		framework: "global",
+		category: "Performance"
+	},
+	"rn-animate-layout-property": {
+		...rnAnimateLayoutProperty,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-animation-reaction-as-derived": {
+		...rnAnimationReactionAsDerived,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-bottom-sheet-prefer-native": {
+		...rnBottomSheetPreferNative,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-list-callback-per-row": {
+		...rnListCallbackPerRow,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-list-data-mapped": {
+		...rnListDataMapped,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-list-recyclable-without-types": {
+		...rnListRecyclableWithoutTypes,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-no-deprecated-modules": {
+		...rnNoDeprecatedModules,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-no-dimensions-get": {
+		...rnNoDimensionsGet,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-no-inline-flatlist-renderitem": {
+		...rnNoInlineFlatlistRenderitem,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-no-inline-object-in-list-item": {
+		...rnNoInlineObjectInListItem,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-no-legacy-expo-packages": {
+		...rnNoLegacyExpoPackages,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-no-legacy-shadow-styles": {
+		...rnNoLegacyShadowStyles,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-no-non-native-navigator": {
+		...rnNoNonNativeNavigator,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-no-raw-text": {
+		...rnNoRawText,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-no-scroll-state": {
+		...rnNoScrollState,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-no-scrollview-mapped-list": {
+		...rnNoScrollviewMappedList,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-no-single-element-style-array": {
+		...rnNoSingleElementStyleArray,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-prefer-content-inset-adjustment": {
+		...rnPreferContentInsetAdjustment,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-prefer-expo-image": {
+		...rnPreferExpoImage,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-prefer-pressable": {
+		...rnPreferPressable,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-prefer-reanimated": {
+		...rnPreferReanimated,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-pressable-shared-value-mutation": {
+		...rnPressableSharedValueMutation,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-scrollview-dynamic-padding": {
+		...rnScrollviewDynamicPadding,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"rn-style-prefer-boxshadow": {
+		...rnStylePreferBoxShadow,
+		framework: "react-native",
+		category: "React Native"
+	},
+	"server-after-nonblocking": {
+		...serverAfterNonblocking,
+		framework: "global",
+		category: "Server"
+	},
+	"server-auth-actions": {
+		...serverAuthActions,
+		framework: "global",
+		category: "Server"
+	},
+	"server-cache-with-object-literal": {
+		...serverCacheWithObjectLiteral,
+		framework: "global",
+		category: "Server"
+	},
+	"server-dedup-props": {
+		...serverDedupProps,
+		framework: "global",
+		category: "Server"
+	},
+	"server-fetch-without-revalidate": {
+		...serverFetchWithoutRevalidate,
+		framework: "global",
+		category: "Server"
+	},
+	"server-hoist-static-io": {
+		...serverHoistStaticIo,
+		framework: "global",
+		category: "Server"
+	},
+	"server-no-mutable-module-state": {
+		...serverNoMutableModuleState,
+		framework: "global",
+		category: "Server"
+	},
+	"server-sequential-independent-await": {
+		...serverSequentialIndependentAwait,
+		framework: "global",
+		category: "Server"
+	},
+	"tanstack-start-get-mutation": {
+		...tanstackStartGetMutation,
+		framework: "tanstack-start",
+		category: "Security"
+	},
+	"tanstack-start-loader-parallel-fetch": {
+		...tanstackStartLoaderParallelFetch,
+		framework: "tanstack-start",
+		category: "Performance"
+	},
+	"tanstack-start-missing-head-content": {
+		...tanstackStartMissingHeadContent,
+		framework: "tanstack-start",
+		category: "TanStack Start"
+	},
+	"tanstack-start-no-anchor-element": {
+		...tanstackStartNoAnchorElement,
+		framework: "tanstack-start",
+		category: "TanStack Start"
+	},
+	"tanstack-start-no-direct-fetch-in-loader": {
+		...tanstackStartNoDirectFetchInLoader,
+		framework: "tanstack-start",
+		category: "TanStack Start"
+	},
+	"tanstack-start-no-dynamic-server-fn-import": {
+		...tanstackStartNoDynamicServerFnImport,
+		framework: "tanstack-start",
+		category: "TanStack Start"
+	},
+	"tanstack-start-no-navigate-in-render": {
+		...tanstackStartNoNavigateInRender,
+		framework: "tanstack-start",
+		category: "TanStack Start"
+	},
+	"tanstack-start-no-secrets-in-loader": {
+		...tanstackStartNoSecretsInLoader,
+		framework: "tanstack-start",
+		category: "Security"
+	},
+	"tanstack-start-no-use-server-in-handler": {
+		...tanstackStartNoUseServerInHandler,
+		framework: "tanstack-start",
+		category: "TanStack Start"
+	},
+	"tanstack-start-no-useeffect-fetch": {
+		...tanstackStartNoUseEffectFetch,
+		framework: "tanstack-start",
+		category: "TanStack Start"
+	},
+	"tanstack-start-redirect-in-try-catch": {
+		...tanstackStartRedirectInTryCatch,
+		framework: "tanstack-start",
+		category: "TanStack Start"
+	},
+	"tanstack-start-route-property-order": {
+		...tanstackStartRoutePropertyOrder,
+		framework: "tanstack-start",
+		category: "TanStack Start"
+	},
+	"tanstack-start-server-fn-method-order": {
+		...tanstackStartServerFnMethodOrder,
+		framework: "tanstack-start",
+		category: "TanStack Start"
+	},
+	"tanstack-start-server-fn-validate-input": {
+		...tanstackStartServerFnValidateInput,
+		framework: "tanstack-start",
+		category: "TanStack Start"
+	},
+	"use-lazy-motion": {
+		...useLazyMotion,
+		framework: "global",
+		category: "Bundle Size"
+	}
+};
+//#endregion
+//#region ../types/dist/index.js
+const REACT_NATIVE_DEPENDENCY_NAMES = new Set([
+	"react-native",
+	"react-native-tvos",
+	"expo",
+	"expo-router",
+	"@expo/cli",
+	"@expo/metro-config",
+	"@expo/metro-runtime",
+	"react-native-windows",
+	"react-native-macos"
+]);
+const REACT_NATIVE_DEPENDENCY_PREFIXES = ["@react-native/", "@react-native-"];
+const isReactNativeDependencyName = (dependencyName) => {
+	if (REACT_NATIVE_DEPENDENCY_NAMES.has(dependencyName)) return true;
+	for (const prefix of REACT_NATIVE_DEPENDENCY_PREFIXES) if (dependencyName.startsWith(prefix)) return true;
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/classify-package-platform.ts
+const WEB_FRAMEWORK_DEPENDENCY_NAMES = new Set([
+	"next",
+	"vite",
+	"react-scripts",
+	"gatsby",
+	"@remix-run/react",
+	"@remix-run/node",
+	"@docusaurus/core",
+	"@docusaurus/preset-classic",
+	"@storybook/react",
+	"@storybook/react-vite",
+	"@storybook/react-webpack5",
+	"@storybook/nextjs",
+	"@storybook/web-components",
+	"storybook",
+	"react-dom",
+	"@vitejs/plugin-react",
+	"@vitejs/plugin-react-swc"
+]);
+const cachedPlatformByPackageDirectory = /* @__PURE__ */ new Map();
+const cachedPackageDirectoryByFilename = /* @__PURE__ */ new Map();
+const findNearestPackageDirectory = (filename) => {
+	if (!filename) return null;
+	const fromCache = cachedPackageDirectoryByFilename.get(filename);
+	if (fromCache !== void 0) return fromCache;
+	let currentDirectory = path.dirname(filename);
+	while (true) {
+		const candidatePackageJsonPath = path.join(currentDirectory, "package.json");
+		let hasPackageJson = false;
+		try {
+			hasPackageJson = fs.statSync(candidatePackageJsonPath).isFile();
+		} catch {
+			hasPackageJson = false;
+		}
+		if (hasPackageJson) {
+			cachedPackageDirectoryByFilename.set(filename, currentDirectory);
+			return currentDirectory;
+		}
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) {
+			cachedPackageDirectoryByFilename.set(filename, null);
+			return null;
+		}
+		currentDirectory = parentDirectory;
+	}
+};
+const readPackageJsonSafe = (packageJsonPath) => {
+	let rawContents;
+	try {
+		rawContents = fs.readFileSync(packageJsonPath, "utf-8");
+	} catch {
+		return null;
+	}
+	try {
+		const parsed = JSON.parse(rawContents);
+		if (typeof parsed === "object" && parsed !== null) return parsed;
+		return null;
+	} catch {
+		return null;
+	}
+};
+const DEPENDENCY_SECTION_NAMES = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+const iterateDependencyNames = function* (packageJson) {
+	for (const sectionName of DEPENDENCY_SECTION_NAMES) {
+		const section = packageJson[sectionName];
+		if (!section) continue;
+		for (const dependencyName of Object.keys(section)) yield dependencyName;
+	}
+};
+const isReactNativeAware = (packageJson) => {
+	if (typeof packageJson["react-native"] === "string") return true;
+	for (const dependencyName of iterateDependencyNames(packageJson)) if (isReactNativeDependencyName(dependencyName)) return true;
+	return false;
+};
+const isWebFrameworkOnly = (packageJson) => {
+	for (const dependencyName of iterateDependencyNames(packageJson)) if (WEB_FRAMEWORK_DEPENDENCY_NAMES.has(dependencyName)) return true;
+	return false;
+};
+const classifyPackagePlatform = (filename) => {
+	const packageDirectory = findNearestPackageDirectory(filename);
+	if (!packageDirectory) return "unknown";
+	const cached = cachedPlatformByPackageDirectory.get(packageDirectory);
+	if (cached !== void 0) return cached;
+	const packageJson = readPackageJsonSafe(path.join(packageDirectory, "package.json"));
+	if (!packageJson) {
+		cachedPlatformByPackageDirectory.set(packageDirectory, "unknown");
+		return "unknown";
+	}
+	let result;
+	if (isReactNativeAware(packageJson)) result = "react-native";
+	else if (isWebFrameworkOnly(packageJson)) result = "web";
+	else result = "unknown";
+	cachedPlatformByPackageDirectory.set(packageDirectory, result);
+	return result;
+};
+//#endregion
+//#region src/plugin/utils/is-react-native-file.ts
+const WEB_FILE_EXTENSION_PATTERN = /\.web\.[cm]?[jt]sx?$/;
+const NATIVE_FILE_EXTENSION_PATTERN = /\.(?:ios|android|native)\.[cm]?[jt]sx?$/;
+const isReactNativeFileActive = (context) => {
+	const filename = context.getFilename?.();
+	if (!filename) return true;
+	if (NATIVE_FILE_EXTENSION_PATTERN.test(filename)) return true;
+	if (WEB_FILE_EXTENSION_PATTERN.test(filename)) return false;
+	const packagePlatform = classifyPackagePlatform(filename);
+	if (packagePlatform === "web") return false;
+	if (packagePlatform === "react-native") return true;
+	const framework = getReactDoctorStringSetting(context.settings, "framework");
+	if (framework === "react-native" || framework === "expo") return true;
+	if (framework === "nextjs" || framework === "vite" || framework === "cra" || framework === "remix" || framework === "gatsby" || framework === "tanstack-start") return false;
+	return true;
+};
+//#endregion
+//#region src/plugin/utils/wrap-react-native-rule.ts
+const EMPTY_VISITORS = {};
+const wrapReactNativeRule = (rule) => {
+	const innerCreate = rule.create.bind(rule);
+	return {
+		...rule,
+		create: (context) => {
+			if (!isReactNativeFileActive(context)) return EMPTY_VISITORS;
+			return innerCreate(context);
+		}
+	};
+};
+//#endregion
 //#region src/plugin/react-doctor-plugin.ts
+const applyFrameworkRuleWrappers = (registry) => {
+	const wrapped = {};
+	for (const [ruleId, rule] of Object.entries(registry)) wrapped[ruleId] = rule.framework === "react-native" ? wrapReactNativeRule(rule) : rule;
+	return wrapped;
+};
 const plugin = {
 	meta: { name: "react-doctor" },
-	rules: {
-		"advanced-event-handler-refs": {
-			...advancedEventHandlerRefs,
-			framework: "global",
-			category: "Performance"
-		},
-		"async-await-in-loop": {
-			...asyncAwaitInLoop,
-			framework: "global",
-			category: "Performance"
-		},
-		"async-defer-await": {
-			...asyncDeferAwait,
-			framework: "global",
-			category: "Performance"
-		},
-		"async-parallel": {
-			...asyncParallel,
-			framework: "global",
-			category: "Performance"
-		},
-		"client-localstorage-no-version": {
-			...clientLocalstorageNoVersion,
-			framework: "global",
-			category: "Correctness"
-		},
-		"client-passive-event-listeners": {
-			...clientPassiveEventListeners,
-			framework: "global",
-			category: "Performance"
-		},
-		"design-no-bold-heading": {
-			...noBoldHeading,
-			framework: "global",
-			category: "Architecture"
-		},
-		"design-no-default-tailwind-palette": {
-			...noDefaultTailwindPalette,
-			framework: "global",
-			category: "Architecture"
-		},
-		"design-no-em-dash-in-jsx-text": {
-			...noEmDashInJsxText,
-			framework: "global",
-			category: "Architecture"
-		},
-		"design-no-redundant-padding-axes": {
-			...noRedundantPaddingAxes,
-			framework: "global",
-			category: "Architecture"
-		},
-		"design-no-redundant-size-axes": {
-			...noRedundantSizeAxes,
-			framework: "global",
-			category: "Architecture"
-		},
-		"design-no-space-on-flex-children": {
-			...noSpaceOnFlexChildren,
-			framework: "global",
-			category: "Architecture"
-		},
-		"design-no-three-period-ellipsis": {
-			...noThreePeriodEllipsis,
-			framework: "global",
-			category: "Architecture"
-		},
-		"design-no-vague-button-label": {
-			...noVagueButtonLabel,
-			framework: "global",
-			category: "Accessibility"
-		},
-		"effect-needs-cleanup": {
-			...effectNeedsCleanup,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"js-batch-dom-css": {
-			...jsBatchDomCss,
-			framework: "global",
-			category: "Performance"
-		},
-		"js-cache-property-access": {
-			...jsCachePropertyAccess,
-			framework: "global",
-			category: "Performance"
-		},
-		"js-cache-storage": {
-			...jsCacheStorage,
-			framework: "global",
-			category: "Performance"
-		},
-		"js-combine-iterations": {
-			...jsCombineIterations,
-			framework: "global",
-			category: "Performance"
-		},
-		"js-early-exit": {
-			...jsEarlyExit,
-			framework: "global",
-			category: "Performance"
-		},
-		"js-flatmap-filter": {
-			...jsFlatmapFilter,
-			framework: "global",
-			category: "Performance"
-		},
-		"js-hoist-intl": {
-			...jsHoistIntl,
-			framework: "global",
-			category: "Performance"
-		},
-		"js-hoist-regexp": {
-			...jsHoistRegexp,
-			framework: "global",
-			category: "Performance"
-		},
-		"js-index-maps": {
-			...jsIndexMaps,
-			framework: "global",
-			category: "Performance"
-		},
-		"js-length-check-first": {
-			...jsLengthCheckFirst,
-			framework: "global",
-			category: "Performance"
-		},
-		"js-min-max-loop": {
-			...jsMinMaxLoop,
-			framework: "global",
-			category: "Performance"
-		},
-		"js-set-map-lookups": {
-			...jsSetMapLookups,
-			framework: "global",
-			category: "Performance"
-		},
-		"js-tosorted-immutable": {
-			...jsTosortedImmutable,
-			framework: "global",
-			category: "Performance"
-		},
-		"nextjs-async-client-component": {
-			...nextjsAsyncClientComponent,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"nextjs-image-missing-sizes": {
-			...nextjsImageMissingSizes,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"nextjs-inline-script-missing-id": {
-			...nextjsInlineScriptMissingId,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"nextjs-missing-metadata": {
-			...nextjsMissingMetadata,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"nextjs-no-a-element": {
-			...nextjsNoAElement,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"nextjs-no-client-fetch-for-server-data": {
-			...nextjsNoClientFetchForServerData,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"nextjs-no-client-side-redirect": {
-			...nextjsNoClientSideRedirect,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"nextjs-no-css-link": {
-			...nextjsNoCssLink,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"nextjs-no-font-link": {
-			...nextjsNoFontLink,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"nextjs-no-head-import": {
-			...nextjsNoHeadImport,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"nextjs-no-img-element": {
-			...nextjsNoImgElement,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"nextjs-no-native-script": {
-			...nextjsNoNativeScript,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"nextjs-no-polyfill-script": {
-			...nextjsNoPolyfillScript,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"nextjs-no-redirect-in-try-catch": {
-			...nextjsNoRedirectInTryCatch,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"nextjs-no-side-effect-in-get-handler": {
-			...nextjsNoSideEffectInGetHandler,
-			framework: "nextjs",
-			category: "Security"
-		},
-		"nextjs-no-use-search-params-without-suspense": {
-			...nextjsNoUseSearchParamsWithoutSuspense,
-			framework: "nextjs",
-			category: "Next.js"
-		},
-		"no-array-index-as-key": {
-			...noArrayIndexAsKey,
-			framework: "global",
-			category: "Correctness"
-		},
-		"no-barrel-import": {
-			...noBarrelImport,
-			framework: "global",
-			category: "Bundle Size"
-		},
-		"no-cascading-set-state": {
-			...noCascadingSetState,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"no-dark-mode-glow": {
-			...noDarkModeGlow,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-default-props": {
-			...noDefaultProps,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-derived-state-effect": {
-			...noDerivedStateEffect,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"no-derived-useState": {
-			...noDerivedUseState,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"no-direct-state-mutation": {
-			...noDirectStateMutation,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"no-disabled-zoom": {
-			...noDisabledZoom,
-			framework: "global",
-			category: "Accessibility"
-		},
-		"no-document-start-view-transition": {
-			...noDocumentStartViewTransition,
-			framework: "global",
-			category: "Correctness"
-		},
-		"no-dynamic-import-path": {
-			...noDynamicImportPath,
-			framework: "global",
-			category: "Bundle Size"
-		},
-		"no-effect-chain": {
-			...noEffectChain,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"no-effect-event-handler": {
-			...noEffectEventHandler,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"no-effect-event-in-deps": {
-			...noEffectEventInDeps,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"no-eval": {
-			...noEval,
-			framework: "global",
-			category: "Security"
-		},
-		"no-event-trigger-state": {
-			...noEventTriggerState,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"no-fetch-in-effect": {
-			...noFetchInEffect,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"no-flush-sync": {
-			...noFlushSync,
-			framework: "global",
-			category: "Performance"
-		},
-		"no-full-lodash-import": {
-			...noFullLodashImport,
-			framework: "global",
-			category: "Bundle Size"
-		},
-		"no-generic-handler-names": {
-			...noGenericHandlerNames,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-giant-component": {
-			...noGiantComponent,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-global-css-variable-animation": {
-			...noGlobalCssVariableAnimation,
-			framework: "global",
-			category: "Performance"
-		},
-		"no-gradient-text": {
-			...noGradientText,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-gray-on-colored-background": {
-			...noGrayOnColoredBackground,
-			framework: "global",
-			category: "Accessibility"
-		},
-		"no-inline-bounce-easing": {
-			...noInlineBounceEasing,
-			framework: "global",
-			category: "Performance"
-		},
-		"no-inline-exhaustive-style": {
-			...noInlineExhaustiveStyle,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-inline-prop-on-memo-component": {
-			...noInlinePropOnMemoComponent,
-			framework: "global",
-			category: "Performance"
-		},
-		"no-justified-text": {
-			...noJustifiedText,
-			framework: "global",
-			category: "Accessibility"
-		},
-		"no-large-animated-blur": {
-			...noLargeAnimatedBlur,
-			framework: "global",
-			category: "Performance"
-		},
-		"no-layout-property-animation": {
-			...noLayoutPropertyAnimation,
-			framework: "global",
-			category: "Performance"
-		},
-		"no-layout-transition-inline": {
-			...noLayoutTransitionInline,
-			framework: "global",
-			category: "Performance"
-		},
-		"no-legacy-class-lifecycles": {
-			...noLegacyClassLifecycles,
-			framework: "global",
-			category: "Correctness"
-		},
-		"no-legacy-context-api": {
-			...noLegacyContextApi,
-			framework: "global",
-			category: "Correctness"
-		},
-		"no-long-transition-duration": {
-			...noLongTransitionDuration,
-			framework: "global",
-			category: "Performance"
-		},
-		"no-many-boolean-props": {
-			...noManyBooleanProps,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-mirror-prop-effect": {
-			...noMirrorPropEffect,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"no-moment": {
-			...noMoment,
-			framework: "global",
-			category: "Bundle Size"
-		},
-		"no-mutable-in-deps": {
-			...noMutableInDeps,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"no-nested-component-definition": {
-			...noNestedComponentDefinition,
-			framework: "global",
-			category: "Correctness"
-		},
-		"no-outline-none": {
-			...noOutlineNone,
-			framework: "global",
-			category: "Accessibility"
-		},
-		"no-permanent-will-change": {
-			...noPermanentWillChange,
-			framework: "global",
-			category: "Performance"
-		},
-		"no-polymorphic-children": {
-			...noPolymorphicChildren,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-prevent-default": {
-			...noPreventDefault,
-			framework: "global",
-			category: "Correctness"
-		},
-		"no-prop-callback-in-effect": {
-			...noPropCallbackInEffect,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"no-pure-black-background": {
-			...noPureBlackBackground,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-react-dom-deprecated-apis": {
-			...noReactDomDeprecatedApis,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-react19-deprecated-apis": {
-			...noReact19DeprecatedApis,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-render-in-render": {
-			...noRenderInRender,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-render-prop-children": {
-			...noRenderPropChildren,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-scale-from-zero": {
-			...noScaleFromZero,
-			framework: "global",
-			category: "Performance"
-		},
-		"no-secrets-in-client-code": {
-			...noSecretsInClientCode,
-			framework: "global",
-			category: "Security"
-		},
-		"no-set-state-in-render": {
-			...noSetStateInRender,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"no-side-tab-border": {
-			...noSideTabBorder,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-tiny-text": {
-			...noTinyText,
-			framework: "global",
-			category: "Accessibility"
-		},
-		"no-transition-all": {
-			...noTransitionAll,
-			framework: "global",
-			category: "Performance"
-		},
-		"no-uncontrolled-input": {
-			...noUncontrolledInput,
-			framework: "global",
-			category: "Correctness"
-		},
-		"no-undeferred-third-party": {
-			...noUndeferredThirdParty,
-			framework: "global",
-			category: "Bundle Size"
-		},
-		"no-usememo-simple-expression": {
-			...noUsememoSimpleExpression,
-			framework: "global",
-			category: "Performance"
-		},
-		"no-wide-letter-spacing": {
-			...noWideLetterSpacing,
-			framework: "global",
-			category: "Architecture"
-		},
-		"no-z-index-9999": {
-			...noZIndex9999,
-			framework: "global",
-			category: "Architecture"
-		},
-		"prefer-dynamic-import": {
-			...preferDynamicImport,
-			framework: "global",
-			category: "Bundle Size"
-		},
-		"prefer-use-effect-event": {
-			...preferUseEffectEvent,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"prefer-use-sync-external-store": {
-			...preferUseSyncExternalStore,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"prefer-useReducer": {
-			...preferUseReducer,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"query-mutation-missing-invalidation": {
-			...queryMutationMissingInvalidation,
-			framework: "tanstack-query",
-			category: "TanStack Query"
-		},
-		"query-no-query-in-effect": {
-			...queryNoQueryInEffect,
-			framework: "tanstack-query",
-			category: "TanStack Query"
-		},
-		"query-no-rest-destructuring": {
-			...queryNoRestDestructuring,
-			framework: "tanstack-query",
-			category: "TanStack Query"
-		},
-		"query-no-usequery-for-mutation": {
-			...queryNoUseQueryForMutation,
-			framework: "tanstack-query",
-			category: "TanStack Query"
-		},
-		"query-no-void-query-fn": {
-			...queryNoVoidQueryFn,
-			framework: "tanstack-query",
-			category: "TanStack Query"
-		},
-		"query-stable-query-client": {
-			...queryStableQueryClient,
-			framework: "tanstack-query",
-			category: "TanStack Query"
-		},
-		"react-compiler-destructure-method": {
-			...reactCompilerDestructureMethod,
-			framework: "global",
-			category: "Architecture"
-		},
-		"rendering-animate-svg-wrapper": {
-			...renderingAnimateSvgWrapper,
-			framework: "global",
-			category: "Performance"
-		},
-		"rendering-conditional-render": {
-			...renderingConditionalRender,
-			framework: "global",
-			category: "Correctness"
-		},
-		"rendering-hoist-jsx": {
-			...renderingHoistJsx,
-			framework: "global",
-			category: "Performance"
-		},
-		"rendering-hydration-mismatch-time": {
-			...renderingHydrationMismatchTime,
-			framework: "global",
-			category: "Correctness"
-		},
-		"rendering-hydration-no-flicker": {
-			...renderingHydrationNoFlicker,
-			framework: "global",
-			category: "Performance"
-		},
-		"rendering-script-defer-async": {
-			...renderingScriptDeferAsync,
-			framework: "global",
-			category: "Performance"
-		},
-		"rendering-svg-precision": {
-			...renderingSvgPrecision,
-			framework: "global",
-			category: "Performance"
-		},
-		"rendering-usetransition-loading": {
-			...renderingUsetransitionLoading,
-			framework: "global",
-			category: "Performance"
-		},
-		"rerender-defer-reads-hook": {
-			...rerenderDeferReadsHook,
-			framework: "global",
-			category: "Performance"
-		},
-		"rerender-dependencies": {
-			...rerenderDependencies,
-			framework: "global",
-			category: "State & Effects"
-		},
-		"rerender-derived-state-from-hook": {
-			...rerenderDerivedStateFromHook,
-			framework: "global",
-			category: "Performance"
-		},
-		"rerender-functional-setstate": {
-			...rerenderFunctionalSetstate,
-			framework: "global",
-			category: "Performance"
-		},
-		"rerender-lazy-state-init": {
-			...rerenderLazyStateInit,
-			framework: "global",
-			category: "Performance"
-		},
-		"rerender-memo-before-early-return": {
-			...rerenderMemoBeforeEarlyReturn,
-			framework: "global",
-			category: "Performance"
-		},
-		"rerender-memo-with-default-value": {
-			...rerenderMemoWithDefaultValue,
-			framework: "global",
-			category: "Performance"
-		},
-		"rerender-state-only-in-handlers": {
-			...rerenderStateOnlyInHandlers,
-			framework: "global",
-			category: "Performance"
-		},
-		"rerender-transitions-scroll": {
-			...rerenderTransitionsScroll,
-			framework: "global",
-			category: "Performance"
-		},
-		"rn-animate-layout-property": {
-			...rnAnimateLayoutProperty,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-animation-reaction-as-derived": {
-			...rnAnimationReactionAsDerived,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-bottom-sheet-prefer-native": {
-			...rnBottomSheetPreferNative,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-list-callback-per-row": {
-			...rnListCallbackPerRow,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-list-data-mapped": {
-			...rnListDataMapped,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-list-recyclable-without-types": {
-			...rnListRecyclableWithoutTypes,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-no-deprecated-modules": {
-			...rnNoDeprecatedModules,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-no-dimensions-get": {
-			...rnNoDimensionsGet,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-no-inline-flatlist-renderitem": {
-			...rnNoInlineFlatlistRenderitem,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-no-inline-object-in-list-item": {
-			...rnNoInlineObjectInListItem,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-no-legacy-expo-packages": {
-			...rnNoLegacyExpoPackages,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-no-legacy-shadow-styles": {
-			...rnNoLegacyShadowStyles,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-no-non-native-navigator": {
-			...rnNoNonNativeNavigator,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-no-raw-text": {
-			...rnNoRawText,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-no-scroll-state": {
-			...rnNoScrollState,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-no-scrollview-mapped-list": {
-			...rnNoScrollviewMappedList,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-no-single-element-style-array": {
-			...rnNoSingleElementStyleArray,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-prefer-content-inset-adjustment": {
-			...rnPreferContentInsetAdjustment,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-prefer-expo-image": {
-			...rnPreferExpoImage,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-prefer-pressable": {
-			...rnPreferPressable,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-prefer-reanimated": {
-			...rnPreferReanimated,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-pressable-shared-value-mutation": {
-			...rnPressableSharedValueMutation,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-scrollview-dynamic-padding": {
-			...rnScrollviewDynamicPadding,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"rn-style-prefer-boxshadow": {
-			...rnStylePreferBoxShadow,
-			framework: "react-native",
-			category: "React Native"
-		},
-		"server-after-nonblocking": {
-			...serverAfterNonblocking,
-			framework: "global",
-			category: "Server"
-		},
-		"server-auth-actions": {
-			...serverAuthActions,
-			framework: "global",
-			category: "Server"
-		},
-		"server-cache-with-object-literal": {
-			...serverCacheWithObjectLiteral,
-			framework: "global",
-			category: "Server"
-		},
-		"server-dedup-props": {
-			...serverDedupProps,
-			framework: "global",
-			category: "Server"
-		},
-		"server-fetch-without-revalidate": {
-			...serverFetchWithoutRevalidate,
-			framework: "global",
-			category: "Server"
-		},
-		"server-hoist-static-io": {
-			...serverHoistStaticIo,
-			framework: "global",
-			category: "Server"
-		},
-		"server-no-mutable-module-state": {
-			...serverNoMutableModuleState,
-			framework: "global",
-			category: "Server"
-		},
-		"server-sequential-independent-await": {
-			...serverSequentialIndependentAwait,
-			framework: "global",
-			category: "Server"
-		},
-		"tanstack-start-get-mutation": {
-			...tanstackStartGetMutation,
-			framework: "tanstack-start",
-			category: "Security"
-		},
-		"tanstack-start-loader-parallel-fetch": {
-			...tanstackStartLoaderParallelFetch,
-			framework: "tanstack-start",
-			category: "Performance"
-		},
-		"tanstack-start-missing-head-content": {
-			...tanstackStartMissingHeadContent,
-			framework: "tanstack-start",
-			category: "TanStack Start"
-		},
-		"tanstack-start-no-anchor-element": {
-			...tanstackStartNoAnchorElement,
-			framework: "tanstack-start",
-			category: "TanStack Start"
-		},
-		"tanstack-start-no-direct-fetch-in-loader": {
-			...tanstackStartNoDirectFetchInLoader,
-			framework: "tanstack-start",
-			category: "TanStack Start"
-		},
-		"tanstack-start-no-dynamic-server-fn-import": {
-			...tanstackStartNoDynamicServerFnImport,
-			framework: "tanstack-start",
-			category: "TanStack Start"
-		},
-		"tanstack-start-no-navigate-in-render": {
-			...tanstackStartNoNavigateInRender,
-			framework: "tanstack-start",
-			category: "TanStack Start"
-		},
-		"tanstack-start-no-secrets-in-loader": {
-			...tanstackStartNoSecretsInLoader,
-			framework: "tanstack-start",
-			category: "Security"
-		},
-		"tanstack-start-no-use-server-in-handler": {
-			...tanstackStartNoUseServerInHandler,
-			framework: "tanstack-start",
-			category: "TanStack Start"
-		},
-		"tanstack-start-no-useeffect-fetch": {
-			...tanstackStartNoUseEffectFetch,
-			framework: "tanstack-start",
-			category: "TanStack Start"
-		},
-		"tanstack-start-redirect-in-try-catch": {
-			...tanstackStartRedirectInTryCatch,
-			framework: "tanstack-start",
-			category: "TanStack Start"
-		},
-		"tanstack-start-route-property-order": {
-			...tanstackStartRoutePropertyOrder,
-			framework: "tanstack-start",
-			category: "TanStack Start"
-		},
-		"tanstack-start-server-fn-method-order": {
-			...tanstackStartServerFnMethodOrder,
-			framework: "tanstack-start",
-			category: "TanStack Start"
-		},
-		"tanstack-start-server-fn-validate-input": {
-			...tanstackStartServerFnValidateInput,
-			framework: "tanstack-start",
-			category: "TanStack Start"
-		},
-		"use-lazy-motion": {
-			...useLazyMotion,
-			framework: "global",
-			category: "Bundle Size"
-		}
-	}
+	rules: applyFrameworkRuleWrappers(ruleRegistry)
 };
 //#endregion
 //#region src/rules-by-framework.ts