oxlint-plugin-react-doctor 0.7.7-dev.30b7eeb → 0.7.7-dev.4190897

package/dist/index.js

@@ -4573,6 +4573,23 @@ const hasPossibleStaticPropertyWrite = (identifier, propertyName, scopes) => {
 		return writtenPropertyName === null || writtenPropertyName === propertyName;
 	}));
 };
+const canExecuteBefore = (candidateNode, referenceNode, scopes) => {
+	const candidateBoundary = findExecutionBoundary(candidateNode);
+	const referenceBoundary = findExecutionBoundary(referenceNode);
+	if (!candidateBoundary || !referenceBoundary) return true;
+	if (candidateBoundary === referenceBoundary) return candidateNode.range[0] < referenceNode.range[0];
+	if (!isFunctionLike$1(candidateBoundary)) return true;
+	return isFunctionSynchronouslyInvokedBefore(candidateBoundary, referenceNode, scopes);
+};
+const hasPossibleStaticPropertyWriteBefore = (identifier, propertyName, referenceNode, scopes) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	return getPotentiallyAliasedSymbols(identifier, scopes).some((symbol) => symbol.references.some((reference) => {
+		const writeTarget = getMemberWriteTarget(reference.identifier);
+		if (!writeTarget || !canExecuteBefore(writeTarget, referenceNode, scopes)) return false;
+		const writtenPropertyName = getResolvedStaticPropertyName(writeTarget, scopes);
+		return writtenPropertyName === null || writtenPropertyName === propertyName;
+	}));
+};
 const hasPossibleStaticPropertyMutationOrEscape = (identifier, propertyName, scopes) => {
 	if (!isNodeOfType(identifier, "Identifier")) return false;
 	if (hasPossibleStaticPropertyWrite(identifier, propertyName, scopes)) return true;
@@ -10558,7 +10575,7 @@ const getAssignedName = (node) => {
 	}
 	return null;
 };
-const isModuleExportsAssignment = (node) => {
+const isModuleExportsAssignment$1 = (node) => {
 	const parent = node.parent;
 	if (!parent || !isNodeOfType(parent, "AssignmentExpression")) return false;
 	const left = parent.left;
@@ -10717,7 +10734,7 @@ const displayName = defineRule({
 				}
 				const assignedName = getAssignedName(node);
 				if (assignedName && isReactComponentName(assignedName) && ignoreNamed) return;
-				if (isModuleExportsAssignment(node) && !node.id) {
+				if (isModuleExportsAssignment$1(node) && !node.id) {
 					reportAt(node);
 					return;
 				}
@@ -10739,7 +10756,7 @@ const displayName = defineRule({
 						reportAt(node);
 						return;
 					}
-					if (isModuleExportsAssignment(node)) {
+					if (isModuleExportsAssignment$1(node)) {
 						reportAt(node);
 						return;
 					}
@@ -11673,6 +11690,25 @@ const getFunctionBindingName$1 = (functionNode) => getFunctionBindingIdentifier(
 //#region src/plugin/utils/is-event-handler-attribute.ts
 const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && /^on[A-Z]/.test(node.name.name);
 //#endregion
+//#region src/plugin/utils/is-ast-descendant.ts
+/**
+* True when `inner` is `outer` itself or any descendant in the AST
+* `parent` chain. Walks `inner.parent` upward and stops at either a
+* match (`true`) or the chain's root (`false`).
+*
+* Was duplicated byte-identical in:
+* - exhaustive-deps-symbol-stability.ts
+* - semantic/closure-captures.ts
+*/
+const isAstDescendant = (inner, outer) => {
+	let current = inner;
+	while (current) {
+		if (current === outer) return true;
+		current = current.parent ?? null;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/utils/react-ref-origin.ts
 const resolveReactRefSymbol = (memberExpression, scopes) => {
 	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
@@ -12322,26 +12358,39 @@ const callbackReturnsCleanupForUsage = (callback, usage, context) => {
 	});
 	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingCleanupReturns, context);
 };
+const findDirectHandleGuardForRelease = (releaseCall, owner, usage, context) => {
+	if (usage.handleKey === null) return null;
+	const doesTestRequireLiveHandle = (test) => {
+		if (resolveExpressionKey(test, context) === usage.handleKey) return true;
+		const unwrappedTest = stripParenExpression(test);
+		if (!isNodeOfType(unwrappedTest, "BinaryExpression") || unwrappedTest.operator !== "!=" && unwrappedTest.operator !== "!==") return false;
+		const isNullishOperand = (operand) => {
+			const unwrappedOperand = stripParenExpression(operand);
+			return isNodeOfType(unwrappedOperand, "Literal") && unwrappedOperand.value === null || isNodeOfType(unwrappedOperand, "Identifier") && unwrappedOperand.name === "undefined" && context.scopes.isGlobalReference(unwrappedOperand);
+		};
+		return resolveExpressionKey(unwrappedTest.left, context) === usage.handleKey && isNullishOperand(unwrappedTest.right) || resolveExpressionKey(unwrappedTest.right, context) === usage.handleKey && isNullishOperand(unwrappedTest.left);
+	};
+	let ancestor = releaseCall.parent;
+	while (ancestor && ancestor !== owner) {
+		if (isNodeOfType(ancestor, "IfStatement")) {
+			if (ancestor.alternate !== null || !doesTestRequireLiveHandle(ancestor.test) || !doMatchingNodesCoverEveryPathAfterUsage(ancestor.consequent, [releaseCall], context)) return null;
+			return ancestor;
+		}
+		ancestor = ancestor.parent;
+	}
+	return null;
+};
 const hasRerunReleaseBeforeUsage = (callback, usage, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression") || !isNodeOfType(callback.body, "BlockStatement")) return false;
 	const functionCfg = context.cfg.cfgFor(callback);
 	const usageBlock = functionCfg?.blockOf(usage.node);
 	const usageStart = getRangeStart(usage.node);
 	if (!functionCfg || !usageBlock || usageStart === null) return false;
-	const findHandleGuard = (releaseCall) => {
-		if (usage.handleKey === null) return null;
-		let ancestor = releaseCall.parent;
-		while (ancestor && ancestor !== callback.body) {
-			if (isNodeOfType(ancestor, "IfStatement")) return ancestor.alternate === null && resolveExpressionKey(ancestor.test, context) === usage.handleKey && getRangeStart(ancestor) !== null && (getRangeStart(ancestor) ?? usageStart) < usageStart ? ancestor : null;
-			ancestor = ancestor.parent;
-		}
-		return null;
-	};
 	const matchingReleaseAnchors = [];
 	walkInsideStatementBlocks(callback.body, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
 		const releaseStart = getRangeStart(child);
-		const handleGuard = findHandleGuard(child);
+		const handleGuard = findDirectHandleGuardForRelease(child, callback, usage, context);
 		if (releaseStart === null || releaseStart >= usageStart || functionCfg.blockOf(child) !== usageBlock && !handleGuard) return;
 		if (doesReleaseCallMatchUsage(child, usage, context)) {
 			matchingReleaseAnchors.push(handleGuard ?? child);
@@ -12371,12 +12420,12 @@ const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
 	return didFindUnmountCleanup;
 };
 const hasSplitLifecycleCleanup = (callback, usage, context) => usage.handleKey !== null && hasRerunReleaseBeforeUsage(callback, usage, context) && hasStableUnmountCleanupForUsage(callback, usage, context);
-const collectBlockingBooleanStates = (expression, blockedExpressionValue, context) => {
+const collectBlockingBooleanStates = (expression, blockedExpressionValue, guardNode, context) => {
 	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return collectBlockingBooleanStates(unwrappedExpression.argument, !blockedExpressionValue, context);
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return collectBlockingBooleanStates(unwrappedExpression.argument, !blockedExpressionValue, guardNode, context);
 	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
 		if (!(unwrappedExpression.operator === "||" && blockedExpressionValue || unwrappedExpression.operator === "&&" && !blockedExpressionValue)) return [];
-		return [...collectBlockingBooleanStates(unwrappedExpression.left, blockedExpressionValue, context), ...collectBlockingBooleanStates(unwrappedExpression.right, blockedExpressionValue, context)];
+		return [...collectBlockingBooleanStates(unwrappedExpression.left, blockedExpressionValue, guardNode, context), ...collectBlockingBooleanStates(unwrappedExpression.right, blockedExpressionValue, guardNode, context)];
 	}
 	if (isNodeOfType(unwrappedExpression, "BinaryExpression") && [
 		"===",
@@ -12387,35 +12436,59 @@ const collectBlockingBooleanStates = (expression, blockedExpressionValue, contex
 		const leftValue = readStaticBoolean(unwrappedExpression.left);
 		const rightValue = readStaticBoolean(unwrappedExpression.right);
 		const booleanValue = leftValue ?? rightValue;
-		const comparedKey = resolveExpressionKey(leftValue === null ? unwrappedExpression.left : unwrappedExpression.right, context);
+		const comparedExpression = leftValue === null ? unwrappedExpression.left : unwrappedExpression.right;
+		const comparedKey = resolveExpressionKey(comparedExpression, context);
 		if (booleanValue === null || comparedKey === null) return [];
+		const isEquality = unwrappedExpression.operator === "===" || unwrappedExpression.operator === "==";
 		return [{
+			bindingIdentifier: isNodeOfType(comparedExpression, "Identifier") ? context.scopes.symbolFor(comparedExpression)?.bindingIdentifier ?? null : null,
+			guardNode,
 			key: comparedKey,
-			value: (unwrappedExpression.operator === "===" || unwrappedExpression.operator === "==") === blockedExpressionValue ? booleanValue : !booleanValue
+			value: isEquality === blockedExpressionValue ? booleanValue : !booleanValue
 		}];
 	}
 	const expressionKey = resolveExpressionKey(unwrappedExpression, context);
 	return expressionKey === null ? [] : [{
+		bindingIdentifier: isNodeOfType(unwrappedExpression, "Identifier") ? context.scopes.symbolFor(unwrappedExpression)?.bindingIdentifier ?? null : null,
+		guardNode,
 		key: expressionKey,
 		value: blockedExpressionValue
 	}];
 };
-const isDirectEarlyReturnConsequent = (ifStatement) => {
-	if (!isNodeOfType(ifStatement, "IfStatement") || ifStatement.alternate) return false;
-	if (isNodeOfType(ifStatement.consequent, "ReturnStatement")) return true;
-	return isNodeOfType(ifStatement.consequent, "BlockStatement") && ifStatement.consequent.body.length === 1 && isNodeOfType(ifStatement.consequent.body[0], "ReturnStatement");
+const canNodeReachLaterNodeWithinFunction = (sourceNode, targetNode, owner, context) => {
+	const functionCfg = context.cfg.cfgFor(owner);
+	const sourceBlock = functionCfg?.blockOf(sourceNode);
+	const targetBlock = functionCfg?.blockOf(targetNode);
+	const sourceStart = getRangeStart(sourceNode);
+	const targetStart = getRangeStart(targetNode);
+	if (!functionCfg || !sourceBlock || !targetBlock || sourceStart === null || targetStart === null) return true;
+	if (!isNodeReachableWithinFunction(sourceNode, context)) return false;
+	if (sourceBlock === targetBlock) return sourceStart < targetStart;
+	const visitedBlocks = new Set([sourceBlock]);
+	const pendingBlocks = [sourceBlock];
+	while (pendingBlocks.length > 0) {
+		const currentBlock = pendingBlocks.pop();
+		if (!currentBlock) break;
+		for (const edge of currentBlock.successors) {
+			if (edge.to === targetBlock) return true;
+			if (visitedBlocks.has(edge.to)) continue;
+			visitedBlocks.add(edge.to);
+			pendingBlocks.push(edge.to);
+		}
+	}
+	return false;
 };
 const collectDeferredUsageGuardStates = (callback, usageNode, context) => {
 	if (!isFunctionLike$1(callback) || callback.async) return [];
 	const guardStates = [];
 	walkAst(callback.body, (child) => {
 		if (child !== callback.body && isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "IfStatement") && isDirectEarlyReturnConsequent(child) && doMatchingNodesCoverEveryPathBeforeUsage(usageNode, [child], callback, context)) guardStates.push(...collectBlockingBooleanStates(child.test, true, context));
+		if (isNodeOfType(child, "IfStatement") && !child.alternate && !canNodeReachLaterNodeWithinFunction(child.consequent, usageNode, callback, context) && doMatchingNodesCoverEveryPathBeforeUsage(usageNode, [child], callback, context)) guardStates.push(...collectBlockingBooleanStates(child.test, true, child, context));
 	});
 	let descendant = usageNode;
 	let ancestor = descendant.parent;
 	while (ancestor && ancestor !== callback) {
-		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant) guardStates.push(...collectBlockingBooleanStates(ancestor.test, false, context));
+		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant) guardStates.push(...collectBlockingBooleanStates(ancestor.test, false, ancestor, context));
 		descendant = ancestor;
 		ancestor = ancestor.parent;
 	}
@@ -12424,7 +12497,7 @@ const collectDeferredUsageGuardStates = (callback, usageNode, context) => {
 const cleanupReturnInvalidatesGuard = (cleanupReturn, guardState, context) => {
 	if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return false;
 	const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
-	if (!cleanupFunction || !isFunctionLike$1(cleanupFunction) || cleanupFunction.async) return false;
+	if (!cleanupFunction || !isFunctionLike$1(cleanupFunction) || cleanupFunction.async || cleanupFunction.generator) return false;
 	let didInvalidateGuard = false;
 	walkAst(cleanupFunction.body, (child) => {
 		if (didInvalidateGuard) return false;
@@ -12453,11 +12526,110 @@ const deferredUsageWritesGuardBeforeUsage = (callback, usageNode, guardState, co
 	});
 	return didWriteGuard;
 };
+const canInterruptionReachUsageThroughCatch = (interruptionNode, usageNode, owner, context) => {
+	let descendant = interruptionNode;
+	let ancestor = descendant.parent;
+	while (ancestor && ancestor !== owner) {
+		if (isNodeOfType(ancestor, "TryStatement") && ancestor.block === descendant && ancestor.handler && canNodeReachLaterNodeWithinFunction(ancestor.handler.body, usageNode, owner, context)) return true;
+		descendant = ancestor;
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const isEffectLocalLifecycleGuard = (callback, guardState, cleanupFunctions, context) => {
+	if (!guardState.bindingIdentifier) return false;
+	const guardSymbol = context.scopes.symbolFor(guardState.bindingIdentifier);
+	if (!guardSymbol || guardSymbol.kind !== "let" && guardSymbol.kind !== "var" || !isNodeOfType(guardSymbol.declarationNode, "VariableDeclarator") || findEnclosingFunction$1(guardSymbol.declarationNode) !== callback) return false;
+	return guardSymbol.references.every((reference) => {
+		if (!isWithinAssignmentTarget(reference.identifier)) return true;
+		const assignmentTarget = findTransparentExpressionRoot(reference.identifier);
+		const assignment = assignmentTarget.parent;
+		return isNodeOfType(assignment, "AssignmentExpression") && assignment.operator === "=" && assignment.left === assignmentTarget && readStaticBoolean(assignment.right) === guardState.value && cleanupFunctions.includes(findEnclosingFunction$1(assignment) ?? assignment);
+	});
+};
+const hasPotentialInterruptionAfterGuard = (callback, guardState, usageNode, context) => {
+	if (!isFunctionLike$1(callback)) return true;
+	const guardStart = getRangeStart(guardState.guardNode);
+	const usageStart = getRangeStart(usageNode);
+	if (guardStart === null || usageStart === null) return true;
+	let hasPotentialInterruption = false;
+	walkAst(callback.body, (child) => {
+		if (hasPotentialInterruption) return false;
+		if (child !== callback.body && isFunctionLike$1(child)) return false;
+		const childStart = getRangeStart(child);
+		if (childStart === null || childStart <= guardStart || childStart >= usageStart) return;
+		if (isNodeOfType(child, "CallExpression") || isNodeOfType(child, "AwaitExpression") || isNodeOfType(child, "YieldExpression")) {
+			if (canNodeReachLaterNodeWithinFunction(child, usageNode, callback, context) || canInterruptionReachUsageThroughCatch(child, usageNode, callback, context)) {
+				hasPotentialInterruption = true;
+				return false;
+			}
+		}
+	});
+	return hasPotentialInterruption;
+};
 const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) => {
 	const usageFunction = findEnclosingFunction$1(usage.node);
 	const promiseChainCall = usageFunction ? getPromiseChainCallForCallback(usageFunction) : null;
-	if (usage.handleKey === null || !usageFunction || usageFunction === callback || !promiseChainCall || !collectEffectInvokedFunctions(callback).has(usageFunction) || !doMatchingNodesCoverEveryPathAfterUsage(promiseChainCall, cleanupReturns, context)) return false;
-	return collectDeferredUsageGuardStates(usageFunction, usage.node, context).some((guardState) => !deferredUsageWritesGuardBeforeUsage(usageFunction, usage.node, guardState, context) && cleanupReturns.every((cleanupReturn) => cleanupReturnInvalidatesGuard(cleanupReturn, guardState, context)));
+	if (usage.kind !== "timer" || usage.handleKey === null || !usageFunction || !isFunctionLike$1(usageFunction) || usageFunction === callback || usageFunction.async || usageFunction.generator || !isNodeOfType(usage.node, "CallExpression") || !isNodeOfType(usage.node.callee, "Identifier") || !context.scopes.isGlobalReference(usage.node.callee) || !promiseChainCall || !collectEffectInvokedFunctions(callback).has(usageFunction) || !doMatchingNodesCoverEveryPathAfterUsage(promiseChainCall, cleanupReturns, context)) return false;
+	const usageExpression = findTransparentExpressionRoot(usage.node);
+	const usageAssignment = usageExpression.parent;
+	if (!isNodeOfType(usageAssignment, "AssignmentExpression") || usageAssignment.operator !== "=" || usageAssignment.right !== usageExpression || !isNodeOfType(usageAssignment.left, "Identifier")) return false;
+	const handleSymbol = context.scopes.symbolFor(usageAssignment.left);
+	if (!handleSymbol || handleSymbol.kind !== "let" && handleSymbol.kind !== "var" || !isNodeOfType(handleSymbol.declarationNode, "VariableDeclarator") || findEnclosingFunction$1(handleSymbol.declarationNode) !== callback) return false;
+	const cleanupFunctions = cleanupReturns.flatMap((cleanupReturn) => {
+		if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return [];
+		const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
+		return cleanupFunction && isFunctionLike$1(cleanupFunction) ? [cleanupFunction] : [];
+	});
+	if (cleanupFunctions.length !== cleanupReturns.length) return false;
+	const globalReleaseProofsByCleanup = /* @__PURE__ */ new Map();
+	for (const cleanupFunction of cleanupFunctions) {
+		if (!isFunctionLike$1(cleanupFunction)) return false;
+		const globalReleaseProofs = [];
+		walkAst(cleanupFunction.body, (child) => {
+			if (child !== cleanupFunction.body && isFunctionLike$1(child)) return false;
+			if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && context.scopes.isGlobalReference(child.callee) && doesReleaseCallMatchUsage(child, usage, context)) {
+				const handleGuard = findDirectHandleGuardForRelease(child, cleanupFunction, usage, context);
+				globalReleaseProofs.push({
+					anchor: handleGuard ?? child,
+					call: child,
+					handleGuard
+				});
+			}
+		});
+		if (!doMatchingNodesCoverEveryPathFromFunctionEntry(cleanupFunction, globalReleaseProofs.map((releaseProof) => releaseProof.anchor), context)) return false;
+		globalReleaseProofsByCleanup.set(cleanupFunction, globalReleaseProofs);
+	}
+	const handleAssignments = handleSymbol.references.filter((reference) => isWithinAssignmentTarget(reference.identifier));
+	const hasUsageAssignment = handleAssignments.some((handleAssignment) => findTransparentExpressionRoot(handleAssignment.identifier).parent === usageAssignment);
+	const hasUnsafeHandleAssignment = handleAssignments.some((handleAssignment) => {
+		const assignmentTarget = findTransparentExpressionRoot(handleAssignment.identifier);
+		const assignment = assignmentTarget.parent;
+		if (assignment === usageAssignment) return false;
+		if (!isNodeOfType(assignment, "AssignmentExpression") || assignment.operator !== "=" || assignment.left !== assignmentTarget) return true;
+		const assignedValue = stripParenExpression(assignment.right);
+		if (!(isNodeOfType(assignedValue, "Literal") && assignedValue.value === null || isNodeOfType(assignedValue, "Identifier") && assignedValue.name === "undefined" && context.scopes.isGlobalReference(assignedValue))) return true;
+		const cleanupFunction = findEnclosingFunction$1(assignment);
+		const globalReleaseProofs = cleanupFunction ? globalReleaseProofsByCleanup.get(cleanupFunction) : void 0;
+		return !(cleanupFunction && globalReleaseProofs && doMatchingNodesCoverEveryPathBeforeUsage(assignment, globalReleaseProofs.map((releaseProof) => releaseProof.handleGuard && isAstDescendant(assignment, releaseProof.handleGuard.consequent) ? releaseProof.call : releaseProof.anchor), cleanupFunction, context));
+	});
+	if (!hasUsageAssignment || hasUnsafeHandleAssignment) return false;
+	let usageAncestor = usage.node.parent;
+	while (usageAncestor && usageAncestor !== usageFunction) {
+		if (isNodeOfType(usageAncestor, "ForStatement") || isNodeOfType(usageAncestor, "ForInStatement") || isNodeOfType(usageAncestor, "ForOfStatement") || isNodeOfType(usageAncestor, "WhileStatement") || isNodeOfType(usageAncestor, "DoWhileStatement")) return false;
+		usageAncestor = usageAncestor.parent;
+	}
+	let hasPotentialInterruption = false;
+	for (const argument of usage.node.arguments ?? []) walkAst(argument, (argumentChild) => {
+		if (hasPotentialInterruption) return false;
+		if (isFunctionLike$1(argumentChild)) return false;
+		if (isNodeOfType(argumentChild, "CallExpression") || isNodeOfType(argumentChild, "AwaitExpression") || isNodeOfType(argumentChild, "YieldExpression")) {
+			hasPotentialInterruption = true;
+			return false;
+		}
+	});
+	if (hasPotentialInterruption) return false;
+	return collectDeferredUsageGuardStates(usageFunction, usage.node, context).some((guardState) => isEffectLocalLifecycleGuard(callback, guardState, cleanupFunctions, context) && !hasPotentialInterruptionAfterGuard(usageFunction, guardState, usage.node, context) && !deferredUsageWritesGuardBeforeUsage(usageFunction, usage.node, guardState, context) && cleanupReturns.every((cleanupReturn) => cleanupReturnInvalidatesGuard(cleanupReturn, guardState, context)));
 };
 const effectHasCleanupForUsage = (callback, usage, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
@@ -13023,7 +13195,7 @@ const effectNeedsCleanup = defineRule({
 				const hookName = getCalleeName$2(node) ?? "effect";
 				context.report({
 					node,
-					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in ${hookName} without returning cleanup. Return a cleanup function so it does not leak after unmount.`
+					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in ${hookName} without guaranteed cleanup. Return a cleanup function that owns every allocation so it does not leak after unmount.`
 				});
 			},
 			FunctionDeclaration(node) {
@@ -14368,6 +14540,22 @@ const isReactHocCallbackArgument = (functionNode) => {
 	return calleeName !== null && REACT_HOC_NAMES.has(calleeName);
 };
 //#endregion
+//#region src/plugin/utils/is-outside-all-functions.ts
+const FUNCTION_SCOPE_KINDS = new Set([
+	"function",
+	"arrow-function",
+	"method"
+]);
+const isOutsideAllFunctions = (symbol) => {
+	let scope = symbol.scope;
+	while (scope) {
+		if (FUNCTION_SCOPE_KINDS.has(scope.kind)) return false;
+		if (scope.kind === "module") return true;
+		scope = scope.parent;
+	}
+	return true;
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-low-level.ts
 /**
 * Lowest-level helpers consumed by both the main `exhaustive-deps`
@@ -14420,25 +14608,6 @@ const getHookName = (callee, scopes) => {
 	if (isNodeOfType(strippedCallee, "MemberExpression") && !strippedCallee.computed && isNodeOfType(strippedCallee.property, "Identifier")) return strippedCallee.property.name;
 	return null;
 };
-const FUNCTION_SCOPE_KINDS = new Set([
-	"function",
-	"arrow-function",
-	"method"
-]);
-/**
-* True for symbols declared at module scope (outside any function
-* scope). Module-scope bindings don't change between renders so they
-* don't need to live in dependency arrays.
-*/
-const isOutsideAllFunctions = (symbol) => {
-	let scope = symbol.scope;
-	while (scope) {
-		if (FUNCTION_SCOPE_KINDS.has(scope.kind)) return false;
-		if (scope.kind === "module") return true;
-		scope = scope.parent ?? null;
-	}
-	return true;
-};
 //#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-messages.ts
 const buildMissingDepMessage = (hookName, depName) => `\`${hookName}\` can run with a stale \`${depName}\` & show your users old data.`;
@@ -14457,7 +14626,7 @@ const buildAsyncEffectMessage = (hookName) => `\`${hookName}\` was given an asyn
 const buildUnknownCallbackMessage = (hookName) => `\`${hookName}\`'s callback is defined elsewhere, so dependencies can't be checked and stale values can slip through.`;
 const buildUnstableDepMessage = (hookName, depName) => `\`${depName}\` is rebuilt every render, so \`${hookName}\` runs every time.`;
 const buildForwardedUnstableDepMessage = (depName) => `\`${depName}\` is rebuilt every render and reaches a Hook dependency inside this custom Hook.`;
-const buildSetStateWithoutDepsMessage = (hookName, setterName) => `\`${hookName}\` calls \`${setterName}\` with no dependency array, so it can loop forever & freeze the component.`;
+const buildSetStateWithoutDepsMessage = (hookName, setterName) => `\`${hookName}\` calls \`${setterName}\` with a value that can change on every render and no dependency array, so it can keep triggering renders.`;
 const buildRefCleanupMessage = (depName) => `Your cleanup may read the wrong node since the ref \`${depName}\` can change before it runs.`;
 const buildAssignmentMessage = (name) => `Assigning to \`${name}\` inside a hook is thrown away after each render, so the next render reads the old value.`;
 //#endregion
@@ -14476,25 +14645,6 @@ const resolveExhaustiveDepsSettings = (settings) => {
 	};
 };
 //#endregion
-//#region src/plugin/utils/is-ast-descendant.ts
-/**
-* True when `inner` is `outer` itself or any descendant in the AST
-* `parent` chain. Walks `inner.parent` upward and stops at either a
-* match (`true`) or the chain's root (`false`).
-*
-* Was duplicated byte-identical in:
-* - exhaustive-deps-symbol-stability.ts
-* - semantic/closure-captures.ts
-*/
-const isAstDescendant = (inner, outer) => {
-	let current = inner;
-	while (current) {
-		if (current === outer) return true;
-		current = current.parent ?? null;
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-sole-writer-guard.ts
 const EQUALITY_BINARY_OPERATORS = new Set(["===", "!=="]);
 const getUseStateSetterSymbol = (stateSymbol, scopes) => {
@@ -15236,26 +15386,125 @@ const isExtraDepAllowedForHook = (hookName, node, scopes) => {
 };
 const hasDirectIdentifierDeclarator = (symbol) => isNodeOfType(symbol.declarationNode, "VariableDeclarator") && isNodeOfType(symbol.declarationNode.id, "Identifier") || isNodeOfType(symbol.declarationNode, "ClassDeclaration");
 const isFunctionValueSymbol = (symbol) => getFunctionValueNode(symbol) !== null;
-const isStableSetterLikeSymbol = (symbol, scopes) => {
-	if (!symbolHasStableHookOrigin(symbol, scopes)) return false;
-	return symbol.name.startsWith("set") || symbol.name.startsWith("dispatch") || symbol.name.startsWith("startTransition");
+const FRESH_STATE_CONSTRUCTOR_NAMES = new Set([
+	"Array",
+	"Date",
+	"Error",
+	"Map",
+	"Object",
+	"RegExp",
+	"Set",
+	"WeakMap",
+	"WeakSet"
+]);
+const getBindingIdentifier = (node) => {
+	if (!node) return null;
+	const candidate = isNodeOfType(node, "AssignmentPattern") ? node.left : node;
+	return isNodeOfType(candidate, "Identifier") ? candidate : null;
 };
-const isConvergingFunctionalUpdater = (node, scopes) => {
-	const updater = unwrapExpression$3(node);
-	if (!isNodeOfType(updater, "ArrowFunctionExpression") && !isNodeOfType(updater, "FunctionExpression")) return false;
-	const previousValueParameter = updater.params?.[0];
-	if (!previousValueParameter || !isNodeOfType(previousValueParameter, "Identifier")) return false;
-	let returnedExpression = updater.body;
-	if (isNodeOfType(updater.body, "BlockStatement")) {
-		returnedExpression = null;
-		for (const statement of updater.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument) {
-			returnedExpression = statement.argument;
-			break;
+const resolveStateSetterSymbol = (identifier, scopes) => {
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	let symbol = scopes.symbolFor(identifier);
+	while (symbol?.kind === "const" && isNodeOfType(symbol.declarationNode, "VariableDeclarator") && symbol.declarationNode.id === symbol.bindingIdentifier && symbol.initializer) {
+		if (visitedSymbolIds.has(symbol.id)) return null;
+		visitedSymbolIds.add(symbol.id);
+		const initializer = unwrapExpression$3(symbol.initializer);
+		if (!isNodeOfType(initializer, "Identifier")) return symbol;
+		symbol = scopes.symbolFor(initializer);
+	}
+	return symbol;
+};
+const getStateSetterDescriptor = (identifier, scopes) => {
+	const setterSymbol = resolveStateSetterSymbol(identifier, scopes);
+	if (!setterSymbol || !isNodeOfType(setterSymbol.declarationNode, "VariableDeclarator")) return null;
+	const declarator = setterSymbol.declarationNode;
+	if (!isNodeOfType(declarator.id, "ArrayPattern")) return null;
+	const setterElement = declarator.id.elements?.[1];
+	const setterBinding = isAstNode(setterElement) ? getBindingIdentifier(setterElement) : null;
+	if (!setterBinding || setterBinding !== setterSymbol.bindingIdentifier) return null;
+	const initializer = declarator.init ? unwrapExpression$3(declarator.init) : null;
+	if (!initializer || !isNodeOfType(initializer, "CallExpression") || !isReactApiCall(initializer, "useState", scopes, {
+		allowGlobalReactNamespace: true,
+		allowUnboundBareCalls: true,
+		resolveNamedAliases: true
+	})) return null;
+	const stateElement = declarator.id.elements?.[0];
+	const stateBinding = isAstNode(stateElement) ? getBindingIdentifier(stateElement) : null;
+	return {
+		setterSymbol,
+		stateSymbol: stateBinding ? scopes.symbolFor(stateBinding) : null
+	};
+};
+const expressionReadsSymbol = (node, symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!symbol) return false;
+	const candidate = unwrapExpression$3(node);
+	if (isNodeOfType(candidate, "Identifier")) {
+		const reference = scopes.referenceFor(candidate);
+		if (reference?.flag !== "write" && reference?.resolvedSymbol?.id === symbol.id) return true;
+		const candidateSymbol = reference?.resolvedSymbol;
+		if (candidateSymbol?.kind === "const" && candidateSymbol.initializer && !isOutsideAllFunctions(candidateSymbol) && !visitedSymbolIds.has(candidateSymbol.id)) {
+			const nextVisitedSymbolIds = new Set(visitedSymbolIds);
+			nextVisitedSymbolIds.add(candidateSymbol.id);
+			return expressionReadsSymbol(candidateSymbol.initializer, symbol, scopes, nextVisitedSymbolIds);
 		}
+		return false;
 	}
-	const conditional = returnedExpression ? unwrapExpression$3(returnedExpression) : null;
-	if (!conditional || !isNodeOfType(conditional, "ConditionalExpression")) return false;
-	const test = unwrapExpression$3(conditional.test);
+	const record = candidate;
+	for (const key of Object.keys(record)) {
+		if (key === "parent") continue;
+		const child = record[key];
+		if (Array.isArray(child)) {
+			if (child.some((item) => isAstNode(item) && expressionReadsSymbol(item, symbol, scopes))) return true;
+		} else if (isAstNode(child) && expressionReadsSymbol(child, symbol, scopes)) return true;
+	}
+	return false;
+};
+const isGuaranteedFreshStateValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = unwrapExpression$3(node);
+	if (isNodeOfType(candidate, "ObjectExpression") || isNodeOfType(candidate, "ArrayExpression") || isNodeOfType(candidate, "JSXElement") || isNodeOfType(candidate, "JSXFragment") || isRegExpLiteral(candidate)) return true;
+	if (isNodeOfType(candidate, "SequenceExpression")) {
+		const finalExpression = candidate.expressions.at(-1);
+		return Boolean(finalExpression && isGuaranteedFreshStateValue(finalExpression, scopes));
+	}
+	if (isNodeOfType(candidate, "ConditionalExpression")) return isGuaranteedFreshStateValue(candidate.consequent, scopes, visitedSymbolIds) && isGuaranteedFreshStateValue(candidate.alternate, scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "LogicalExpression")) return isGuaranteedFreshStateValue(candidate.left, scopes, visitedSymbolIds) && isGuaranteedFreshStateValue(candidate.right, scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "CallExpression")) {
+		const callee = unwrapExpression$3(candidate.callee);
+		return isNodeOfType(callee, "Identifier") && scopes.isGlobalReference(callee) && (callee.name === "Array" || callee.name === "Object") && (callee.name === "Array" || candidate.arguments.length === 0);
+	}
+	if (isNodeOfType(candidate, "NewExpression")) {
+		const callee = unwrapExpression$3(candidate.callee);
+		return isNodeOfType(callee, "Identifier") && scopes.isGlobalReference(callee) && FRESH_STATE_CONSTRUCTOR_NAMES.has(callee.name) && (callee.name !== "Object" || candidate.arguments.length === 0);
+	}
+	if (!isNodeOfType(candidate, "Identifier")) return false;
+	const symbol = scopes.symbolFor(candidate);
+	if (!symbol || symbol.kind !== "const" || !symbol.initializer || isOutsideAllFunctions(symbol) || visitedSymbolIds.has(symbol.id)) return false;
+	const nextVisitedSymbolIds = new Set(visitedSymbolIds);
+	nextVisitedSymbolIds.add(symbol.id);
+	return isGuaranteedFreshStateValue(symbol.initializer, scopes, nextVisitedSymbolIds);
+};
+const isNonZeroLiteral = (node) => {
+	const candidate = unwrapExpression$3(node);
+	return isNodeOfType(candidate, "Literal") && (typeof candidate.value === "number" && candidate.value !== 0 || typeof candidate.value === "bigint" && candidate.value !== 0n || typeof candidate.value === "string" && candidate.value.length > 0);
+};
+const isProvablyChangingExpression = (node, previousValueSymbol, scopes) => {
+	const candidate = unwrapExpression$3(node);
+	if (isGuaranteedFreshStateValue(candidate, scopes)) return true;
+	if (isNodeOfType(candidate, "ConditionalExpression")) {
+		const isConsequentChanging = isProvablyChangingExpression(candidate.consequent, previousValueSymbol, scopes);
+		const isAlternateChanging = isProvablyChangingExpression(candidate.alternate, previousValueSymbol, scopes);
+		return expressionReadsSymbol(candidate.test, previousValueSymbol, scopes) ? isConsequentChanging && isAlternateChanging : isConsequentChanging || isAlternateChanging;
+	}
+	if (!expressionReadsSymbol(candidate, previousValueSymbol, scopes)) return false;
+	if (isNodeOfType(candidate, "UnaryExpression")) return candidate.operator === "!";
+	if (isNodeOfType(candidate, "UpdateExpression")) return true;
+	if (!isNodeOfType(candidate, "BinaryExpression")) return false;
+	return (candidate.operator === "+" || candidate.operator === "-") && expressionReadsSymbol(candidate.left, previousValueSymbol, scopes) && isNonZeroLiteral(candidate.right);
+};
+const isFreshEqualityGuardUpdater = (node, previousValueSymbol, scopes) => {
+	const candidate = unwrapExpression$3(node);
+	if (!isNodeOfType(candidate, "ConditionalExpression")) return false;
+	const test = unwrapExpression$3(candidate.test);
 	if (!isNodeOfType(test, "BinaryExpression") || ![
 		"===",
 		"!==",
@@ -15263,38 +15512,50 @@ const isConvergingFunctionalUpdater = (node, scopes) => {
 		"!="
 	].includes(test.operator)) return false;
 	const isPreviousValue = (expression) => {
-		const candidate = unwrapExpression$3(expression);
-		return isNodeOfType(candidate, "Identifier") && candidate.name === previousValueParameter.name;
+		const expressionCandidate = unwrapExpression$3(expression);
+		return isNodeOfType(expressionCandidate, "Identifier") && scopes.symbolFor(expressionCandidate)?.id === previousValueSymbol?.id;
 	};
 	let comparedValue = null;
 	if (isPreviousValue(test.left)) comparedValue = test.right;
-	else if (isPreviousValue(test.right)) comparedValue = test.left;
-	if (!comparedValue) return false;
-	if (isPotentiallyFreshComparedValue(comparedValue, scopes)) return false;
-	const isSameComparedValue = (expression) => {
-		const candidate = unwrapExpression$3(expression);
-		const compared = unwrapExpression$3(comparedValue);
-		if (isNodeOfType(candidate, "Identifier") && isNodeOfType(compared, "Identifier")) return candidate.name === compared.name;
-		if (isNodeOfType(candidate, "Literal") && isNodeOfType(compared, "Literal")) return candidate.value === compared.value;
-		return false;
+	if (isPreviousValue(test.right)) comparedValue = test.left;
+	if (!comparedValue || !isPotentiallyFreshComparedValue(comparedValue, scopes)) return false;
+	const isComparedValue = (expression) => {
+		const expressionCandidate = unwrapExpression$3(expression);
+		const comparedCandidate = unwrapExpression$3(comparedValue);
+		if (isNodeOfType(expressionCandidate, "Identifier")) return isNodeOfType(comparedCandidate, "Identifier") && scopes.symbolFor(expressionCandidate)?.id === scopes.symbolFor(comparedCandidate)?.id;
+		return isNodeOfType(expressionCandidate, "Literal") && isNodeOfType(comparedCandidate, "Literal") && expressionCandidate.value === comparedCandidate.value;
 	};
-	return test.operator === "===" || test.operator === "==" ? isPreviousValue(conditional.consequent) && isSameComparedValue(conditional.alternate) : isSameComparedValue(conditional.consequent) && isPreviousValue(conditional.alternate);
-};
-const isGuardedStableSetterCall = (identifier, symbol, scopes) => {
-	const parent = identifier.parent;
-	if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== identifier || !isStableSetterLikeSymbol(symbol, scopes)) return false;
-	const writtenValue = parent.arguments?.[0];
-	return Boolean(writtenValue && isConvergingFunctionalUpdater(writtenValue, scopes));
+	return test.operator === "===" || test.operator === "==" ? isPreviousValue(candidate.consequent) && isComparedValue(candidate.alternate) : isComparedValue(candidate.consequent) && isPreviousValue(candidate.alternate);
 };
-const findStableSetterReference = (node, scopes) => {
+const isProvablyChangingFunctionalUpdater = (node, scopes) => {
+	const updater = unwrapExpression$3(node);
+	if (!isNodeOfType(updater, "ArrowFunctionExpression") && !isNodeOfType(updater, "FunctionExpression")) return false;
+	const previousValueParameter = updater.params?.[0];
+	if (!previousValueParameter || !isNodeOfType(previousValueParameter, "Identifier")) return false;
+	const previousValueSymbol = scopes.symbolFor(previousValueParameter);
+	if (!isNodeOfType(updater.body, "BlockStatement")) return isFreshEqualityGuardUpdater(updater.body, previousValueSymbol, scopes) || isProvablyChangingExpression(updater.body, previousValueSymbol, scopes);
+	if (updater.body.body.length !== 1) return false;
+	const soleStatement = updater.body.body[0];
+	if (!isNodeOfType(soleStatement, "ReturnStatement") || !isAstNode(soleStatement.argument)) return false;
+	return isFreshEqualityGuardUpdater(soleStatement.argument, previousValueSymbol, scopes) || isProvablyChangingExpression(soleStatement.argument, previousValueSymbol, scopes);
+};
+const isProvablyRenderChangingSetterCall = (identifier, scopes) => {
+	const setterCall = identifier.parent;
+	if (!setterCall || !isNodeOfType(setterCall, "CallExpression") || setterCall.callee !== identifier) return false;
+	const descriptor = getStateSetterDescriptor(identifier, scopes);
+	const writtenValue = setterCall.arguments?.[0];
+	if (!descriptor || !writtenValue || !isAstNode(writtenValue)) return false;
+	return isProvablyChangingFunctionalUpdater(writtenValue, scopes) ? true : isProvablyChangingExpression(writtenValue, descriptor.stateSymbol, scopes);
+};
+const findRenderChangingStateSetterName = (node, scopes) => {
 	let setterName = null;
 	const visit = (current) => {
 		if (setterName) return;
 		if (current !== node && (isNodeOfType(current, "FunctionDeclaration") || isNodeOfType(current, "FunctionExpression") || isNodeOfType(current, "ArrowFunctionExpression"))) return;
 		if (isNodeOfType(current, "Identifier")) {
-			const symbol = scopes.referenceFor(current)?.resolvedSymbol;
-			if (symbol && isStableSetterLikeSymbol(symbol, scopes) && !isGuardedStableSetterCall(current, symbol, scopes)) {
-				setterName = symbol.name;
+			const descriptor = getStateSetterDescriptor(current, scopes);
+			if (descriptor && isProvablyRenderChangingSetterCall(current, scopes)) {
+				setterName = descriptor.setterSymbol.name;
 				return;
 			}
 		}
@@ -15621,7 +15882,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 			}
 			if (!depsArgumentRaw) {
 				if (callbackToAnalyze && EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS.has(hookName)) {
-					const setterName = findStableSetterReference(callbackToAnalyze, context.scopes);
+					const setterName = findRenderChangingStateSetterName(callbackToAnalyze, context.scopes);
 					if (setterName) {
 						context.report({
 							node: callbackToAnalyze,
@@ -20014,14 +20275,14 @@ const isIndexOfResultUsedAsMembershipTest = (node) => {
 	if (isNegativeOneLiteral(otherOperand)) return true;
 	return isZeroLiteral(otherOperand) && (parent.operator === ">=" || parent.operator === "<");
 };
-const getTypeAnnotation = (node) => {
+const getTypeAnnotation$1 = (node) => {
 	if (!node || !("typeAnnotation" in node)) return null;
 	const annotation = node.typeAnnotation;
 	if (!annotation || !isNodeOfType(annotation, "TSTypeAnnotation")) return null;
 	return annotation.typeAnnotation;
 };
 const getDeclaredPropertyType = (members, propertyName) => {
-	for (const member of members) if (isNodeOfType(member, "TSPropertySignature") && isNodeOfType(member.key, "Identifier") && member.key.name === propertyName) return getTypeAnnotation(member);
+	for (const member of members) if (isNodeOfType(member, "TSPropertySignature") && isNodeOfType(member.key, "Identifier") && member.key.name === propertyName) return getTypeAnnotation$1(member);
 	return null;
 };
 const getArrayElementType = (typeNode) => {
@@ -20040,7 +20301,7 @@ const getDestructuredDeclaredType = (identifier) => {
 	const property = binding.bindingIdentifier.parent;
 	const objectPattern = property?.parent;
 	if (!isNodeOfType(property, "Property") || !isNodeOfType(property.key, "Identifier") || !isNodeOfType(objectPattern, "ObjectPattern")) return null;
-	const propsType = getTypeAnnotation(objectPattern);
+	const propsType = getTypeAnnotation$1(objectPattern);
 	if (!propsType) return null;
 	if (isNodeOfType(propsType, "TSTypeLiteral")) return getDeclaredPropertyType(propsType.members ?? [], property.key.name);
 	if (!isNodeOfType(propsType, "TSTypeReference") || !isNodeOfType(propsType.typeName, "Identifier")) return null;
@@ -20057,7 +20318,7 @@ const getIdentifierDeclaredType = (identifier, visitedBindingIdentifiers = /* @_
 	const binding = findVariableInitializer(identifier, identifier.name);
 	if (!binding || visitedBindingIdentifiers.has(binding.bindingIdentifier)) return null;
 	visitedBindingIdentifiers.add(binding.bindingIdentifier);
-	const directType = getTypeAnnotation(binding.bindingIdentifier);
+	const directType = getTypeAnnotation$1(binding.bindingIdentifier);
 	if (directType) return directType;
 	const initializer = binding.initializer;
 	if (isNodeOfType(initializer, "TSAsExpression") || isNodeOfType(initializer, "TSTypeAssertion") || isNodeOfType(initializer, "TSSatisfiesExpression")) return initializer.typeAnnotation;
@@ -27222,6 +27483,211 @@ const computeExternallyDriven = (analysis, declarator) => {
 	return hasDeferredCallSite;
 };
 //#endregion
+//#region src/plugin/rules/state-and-effects/utils/effect/is-proven-native-read-method.ts
+const ARRAY_READ_METHOD_NAMES$1 = new Set([
+	"at",
+	"concat",
+	"entries",
+	"every",
+	"filter",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"flat",
+	"flatMap",
+	"forEach",
+	"includes",
+	"indexOf",
+	"join",
+	"keys",
+	"lastIndexOf",
+	"map",
+	"reduce",
+	"reduceRight",
+	"slice",
+	"some",
+	"toLocaleString",
+	"toReversed",
+	"toSorted",
+	"toSpliced",
+	"toString",
+	"values",
+	"with"
+]);
+const MAP_READ_METHOD_NAMES = new Set([
+	"entries",
+	"forEach",
+	"get",
+	"has",
+	"keys",
+	"values"
+]);
+const SET_READ_METHOD_NAMES = new Set([
+	"difference",
+	"entries",
+	"forEach",
+	"has",
+	"intersection",
+	"isDisjointFrom",
+	"isSubsetOf",
+	"isSupersetOf",
+	"keys",
+	"symmetricDifference",
+	"union",
+	"values"
+]);
+const FUNCTION_READ_METHOD_NAMES = new Set(["bind"]);
+const PROMISE_READ_METHOD_NAMES = new Set([
+	"catch",
+	"finally",
+	"then"
+]);
+const STRING_READ_METHOD_NAMES$1 = new Set([
+	"at",
+	"charAt",
+	"charCodeAt",
+	"codePointAt",
+	"concat",
+	"endsWith",
+	"includes",
+	"indexOf",
+	"isWellFormed",
+	"lastIndexOf",
+	"localeCompare",
+	"match",
+	"matchAll",
+	"normalize",
+	"padEnd",
+	"padStart",
+	"repeat",
+	"replace",
+	"replaceAll",
+	"search",
+	"slice",
+	"split",
+	"startsWith",
+	"substring",
+	"toLocaleLowerCase",
+	"toLocaleUpperCase",
+	"toLowerCase",
+	"toString",
+	"toUpperCase",
+	"toWellFormed",
+	"trim",
+	"trimEnd",
+	"trimStart",
+	"valueOf"
+]);
+const NATIVE_TYPE_NAMES = new Set([
+	"Array",
+	"Map",
+	"Promise",
+	"PromiseLike",
+	"ReadonlyArray",
+	"ReadonlyMap",
+	"ReadonlySet",
+	"Set"
+]);
+const nativeTypeDeclarationsByProgram = /* @__PURE__ */ new WeakMap();
+const shadowedNativeTypeNamesByBinding = /* @__PURE__ */ new WeakMap();
+const isWithinNode = (node, ancestor) => {
+	let current = node;
+	while (current) {
+		if (current === ancestor) return true;
+		current = current.parent;
+	}
+	return false;
+};
+const findTypeDeclarationScope = (declaration) => {
+	let current = declaration.parent;
+	while (current) {
+		if (isNodeOfType(current, "Program") || isNodeOfType(current, "BlockStatement") || isNodeOfType(current, "TSModuleBlock") || isNodeOfType(current, "StaticBlock")) return current;
+		current = current.parent;
+	}
+	return null;
+};
+const getDeclaredTypeName = (declaration) => {
+	if (!isNodeOfType(declaration, "ClassDeclaration") && !isNodeOfType(declaration, "TSEnumDeclaration") && !isNodeOfType(declaration, "TSImportEqualsDeclaration") && !isNodeOfType(declaration, "TSInterfaceDeclaration") && !isNodeOfType(declaration, "TSModuleDeclaration") && !isNodeOfType(declaration, "TSTypeAliasDeclaration")) return null;
+	return declaration.id && isNodeOfType(declaration.id, "Identifier") ? declaration.id.name : null;
+};
+const getNativeTypeDeclarations = (program) => {
+	const cachedDeclarations = nativeTypeDeclarationsByProgram.get(program);
+	if (cachedDeclarations) return cachedDeclarations;
+	const declarations = [];
+	walkAst(program, (candidate) => {
+		if (isNodeOfType(candidate, "ImportDeclaration")) {
+			for (const specifier of candidate.specifiers) if (NATIVE_TYPE_NAMES.has(specifier.local.name)) declarations.push({
+				name: specifier.local.name,
+				scope: program
+			});
+			return;
+		}
+		const declaredTypeName = getDeclaredTypeName(candidate);
+		if (!declaredTypeName || !NATIVE_TYPE_NAMES.has(declaredTypeName)) return;
+		const declarationScope = findTypeDeclarationScope(candidate);
+		if (declarationScope) declarations.push({
+			name: declaredTypeName,
+			scope: declarationScope
+		});
+	});
+	nativeTypeDeclarationsByProgram.set(program, declarations);
+	return declarations;
+};
+const getShadowedNativeTypeNames = (binding) => {
+	const cachedNames = shadowedNativeTypeNamesByBinding.get(binding);
+	if (cachedNames) return cachedNames;
+	const shadowedNames = /* @__PURE__ */ new Set();
+	for (const typeName of NATIVE_TYPE_NAMES) if (hasEnclosingTypeParameterNamed(binding, typeName)) shadowedNames.add(typeName);
+	const program = findProgramRoot(binding);
+	if (program) {
+		for (const declaration of getNativeTypeDeclarations(program)) if (isWithinNode(binding, declaration.scope)) shadowedNames.add(declaration.name);
+	}
+	shadowedNativeTypeNamesByBinding.set(binding, shadowedNames);
+	return shadowedNames;
+};
+const getParameterBinding = (definitionName) => {
+	if (isNodeOfType(definitionName, "Identifier")) return definitionName;
+	if (!isNodeOfType(definitionName, "AssignmentPattern")) return null;
+	return isNodeOfType(definitionName.left, "Identifier") ? definitionName.left : null;
+};
+const getTypeAnnotation = (binding) => {
+	if (!isNodeOfType(binding, "Identifier")) return null;
+	const annotation = binding.typeAnnotation;
+	return annotation && isNodeOfType(annotation, "TSTypeAnnotation") ? annotation.typeAnnotation : null;
+};
+const isNullishType = (typeNode) => isNodeOfType(typeNode, "TSNullKeyword") || isNodeOfType(typeNode, "TSUndefinedKeyword");
+const isNativeReadMethod = (typeNode, methodName, shadowedTypeNames) => {
+	if (isNodeOfType(typeNode, "TSArrayType") || isNodeOfType(typeNode, "TSTupleType")) return ARRAY_READ_METHOD_NAMES$1.has(methodName);
+	if (isNodeOfType(typeNode, "TSStringKeyword")) return STRING_READ_METHOD_NAMES$1.has(methodName);
+	if (isNodeOfType(typeNode, "TSFunctionType")) return FUNCTION_READ_METHOD_NAMES.has(methodName);
+	if (isNodeOfType(typeNode, "TSLiteralType") && isNodeOfType(typeNode.literal, "Literal") && typeof typeNode.literal.value === "string") return STRING_READ_METHOD_NAMES$1.has(methodName);
+	if (isNodeOfType(typeNode, "TSTypeOperator") && typeNode.operator === "readonly" && typeNode.typeAnnotation) return isNativeReadMethod(typeNode.typeAnnotation, methodName, shadowedTypeNames);
+	if (isNodeOfType(typeNode, "TSUnionType")) {
+		let hasNonNullishMember = false;
+		for (const memberType of typeNode.types) {
+			if (isNullishType(memberType)) continue;
+			hasNonNullishMember = true;
+			if (!isNativeReadMethod(memberType, methodName, shadowedTypeNames)) return false;
+		}
+		return hasNonNullishMember;
+	}
+	if (!isNodeOfType(typeNode, "TSTypeReference") || !isNodeOfType(typeNode.typeName, "Identifier")) return false;
+	if (shadowedTypeNames.has(typeNode.typeName.name)) return false;
+	if (typeNode.typeName.name === "Array" || typeNode.typeName.name === "ReadonlyArray") return ARRAY_READ_METHOD_NAMES$1.has(methodName);
+	if (typeNode.typeName.name === "Map" || typeNode.typeName.name === "ReadonlyMap") return MAP_READ_METHOD_NAMES.has(methodName);
+	if (typeNode.typeName.name === "Set" || typeNode.typeName.name === "ReadonlySet") return SET_READ_METHOD_NAMES.has(methodName);
+	if (typeNode.typeName.name === "Promise" || typeNode.typeName.name === "PromiseLike") return PROMISE_READ_METHOD_NAMES.has(methodName);
+	return false;
+};
+const isProvenNativeReadMethod = (ref, methodName) => Boolean(ref.resolved?.defs.some((definition) => {
+	if (definition.type !== "Parameter") return false;
+	const parameterBinding = getParameterBinding(definition.name);
+	if (!parameterBinding) return false;
+	const typeAnnotation = getTypeAnnotation(parameterBinding);
+	return Boolean(typeAnnotation && isNativeReadMethod(typeAnnotation, methodName, getShadowedNativeTypeNames(parameterBinding)));
+}));
+//#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/react.ts
 const KNOWN_PURE_HOC_NAMES = new Set(["memo", "forwardRef"]);
 const startsWithUppercase = (name) => Boolean(name && name.length > 0 && name[0] >= "A" && name[0] <= "Z");
@@ -27448,7 +27914,132 @@ const isRefCurrent = (ref) => {
 const isStateSetterCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => isStateSetter(analysis, innerRef));
 const isSyncStateSetterCall = (analysis, ref, effectFn) => isStateSetterCall(analysis, ref) && isSynchronous(ref.identifier, effectFn) && !resolvesToAsyncFunction(ref);
 const HANDLER_NAMED_METHOD_PATTERN = /^(on|handle)[A-Z]/;
-const isPropCallbackInvocationRef = (analysis, ref) => {
+const SYNCHRONOUS_CALLBACK_ARGUMENT_INDEX_BY_METHOD = new Map([
+	["every", 0],
+	["filter", 0],
+	["find", 0],
+	["findIndex", 0],
+	["findLast", 0],
+	["findLastIndex", 0],
+	["flatMap", 0],
+	["forEach", 0],
+	["map", 0],
+	["reduce", 0],
+	["reduceRight", 0],
+	["replace", 1],
+	["replaceAll", 1],
+	["some", 0]
+]);
+const addSimpleBindingNames = (pattern, names) => {
+	if (isNodeOfType(pattern, "Identifier")) {
+		if (names.has(pattern.name)) return false;
+		names.add(pattern.name);
+		return true;
+	}
+	if (isNodeOfType(pattern, "AssignmentPattern")) return addSimpleBindingNames(pattern.left, names);
+	if (isNodeOfType(pattern, "RestElement")) return addSimpleBindingNames(pattern.argument, names);
+	if (isNodeOfType(pattern, "ObjectPattern")) {
+		let didAddName = false;
+		for (const property of pattern.properties) didAddName = addSimpleBindingNames(isNodeOfType(property, "Property") ? property.value : property, names) || didAddName;
+		return didAddName;
+	}
+	if (isNodeOfType(pattern, "ArrayPattern")) {
+		let didAddName = false;
+		for (const element of pattern.elements) if (element) didAddName = addSimpleBindingNames(element, names) || didAddName;
+		return didAddName;
+	}
+	return false;
+};
+const getSimpleParameterNames = (callback) => {
+	if (!isFunctionLike$1(callback)) return /* @__PURE__ */ new Set();
+	const names = /* @__PURE__ */ new Set();
+	for (const parameter of callback.params ?? []) addSimpleBindingNames(parameter, names);
+	return names;
+};
+const inlineCallbackInvokesParameter = (callback) => {
+	const parameterNames = getSimpleParameterNames(callback);
+	if (parameterNames.size === 0 || !isFunctionLike$1(callback)) return false;
+	let didAddAlias = true;
+	while (didAddAlias) {
+		didAddAlias = false;
+		walkAst(callback.body, (candidate) => {
+			if (candidate !== callback.body && isFunctionLike$1(candidate)) return false;
+			if (isNodeOfType(candidate, "AssignmentExpression") && candidate.operator === "=" && isNodeOfType(candidate.left, "Identifier")) {
+				const assignedValueRoot = getRootIdentifier$1(candidate.right);
+				if (isNodeOfType(assignedValueRoot, "Identifier") && parameterNames.has(assignedValueRoot.name) && !parameterNames.has(candidate.left.name)) {
+					parameterNames.add(candidate.left.name);
+					didAddAlias = true;
+				}
+				return;
+			}
+			if (!isNodeOfType(candidate, "VariableDeclarator") || !candidate.init) return;
+			const initializerRoot = getRootIdentifier$1(candidate.init);
+			if (!isNodeOfType(initializerRoot, "Identifier") || !parameterNames.has(initializerRoot.name)) return;
+			if (addSimpleBindingNames(candidate.id, parameterNames)) didAddAlias = true;
+		});
+	}
+	let didInvokeParameter = false;
+	walkAst(callback.body, (candidate) => {
+		if (didInvokeParameter) return false;
+		if (candidate !== callback.body && isFunctionLike$1(candidate)) return false;
+		if (!isNodeOfType(candidate, "CallExpression")) return;
+		const callee = stripParenExpression(candidate.callee);
+		if (isNodeOfType(callee, "Identifier") && parameterNames.has(callee.name)) {
+			didInvokeParameter = true;
+			return false;
+		}
+		if (isNodeOfType(callee, "MemberExpression")) {
+			const receiverRoot = getRootIdentifier$1(callee.object);
+			if (receiverRoot && parameterNames.has(receiverRoot.name)) {
+				didInvokeParameter = true;
+				return false;
+			}
+		}
+	});
+	return didInvokeParameter;
+};
+const callbackInvokesPropCallback = (analysis, callback) => {
+	if (!isFunctionLike$1(callback)) return false;
+	let didInvokePropCallback = false;
+	walkAst(callback.body, (candidate) => {
+		if (didInvokePropCallback) return false;
+		if (candidate !== callback.body && isFunctionLike$1(candidate)) return false;
+		if (!isNodeOfType(candidate, "CallExpression")) return;
+		if (getDownstreamRefs(analysis, stripParenExpression(candidate.callee)).some((reference) => isPropCallbackInvocationRef(analysis, reference))) {
+			didInvokePropCallback = true;
+			return false;
+		}
+	});
+	return didInvokePropCallback;
+};
+const isNativeMethodSuppressionSafe = (analysis, callExpression, methodName, scopes) => {
+	if (!isNodeOfType(callExpression, "CallExpression")) return false;
+	const callee = stripParenExpression(callExpression.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const receiver = stripParenExpression(callee.object);
+	if (!isNodeOfType(receiver, "Identifier")) return false;
+	const receiverSymbol = scopes.symbolFor(receiver);
+	if (!receiverSymbol || hasSymbolWriteBefore(receiverSymbol, callExpression, scopes) || hasPossibleStaticPropertyWriteBefore(receiver, methodName, callExpression, scopes)) return false;
+	let callResult = callExpression;
+	let callResultConsumer = callResult.parent;
+	while (callResultConsumer && (TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(callResultConsumer.type) && "expression" in callResultConsumer && callResultConsumer.expression === callResult || isNodeOfType(callResultConsumer, "MemberExpression") && callResultConsumer.object === callResult)) {
+		callResult = callResultConsumer;
+		callResultConsumer = callResult.parent;
+	}
+	if (isNodeOfType(callResultConsumer, "CallExpression") && callResultConsumer.callee === callResult) return false;
+	const callbackArgumentIndex = SYNCHRONOUS_CALLBACK_ARGUMENT_INDEX_BY_METHOD.get(methodName);
+	if (callbackArgumentIndex === void 0) return true;
+	const callbackArgument = callExpression.arguments?.[callbackArgumentIndex];
+	if (!callbackArgument) return true;
+	const callbackValue = stripParenExpression(callbackArgument);
+	if (isFunctionLike$1(callbackValue)) return !inlineCallbackInvokesParameter(callbackValue) && !callbackInvokesPropCallback(analysis, callbackValue);
+	if (!isNodeOfType(callbackValue, "Identifier")) return false;
+	const callbackRef = getRef(analysis, callbackValue);
+	if (!callbackRef || isPropAlias(analysis, callbackRef)) return false;
+	const callbackFunction = resolveToFunction(callbackRef);
+	return Boolean(callbackFunction && isFunctionLike$1(callbackFunction) && !inlineCallbackInvokesParameter(callbackFunction) && !callbackInvokesPropCallback(analysis, callbackFunction));
+};
+const isPropCallbackInvocationRef = (analysis, ref, options = {}) => {
 	if (!isPropAlias(analysis, ref)) return false;
 	let effectiveNode = ref.identifier;
 	let parent = effectiveNode.parent;
@@ -27461,7 +28052,9 @@ const isPropCallbackInvocationRef = (analysis, ref) => {
 	if (isNodeOfType(parent, "MemberExpression") && parent.object === effectiveNode) {
 		const memberParent = parent.parent;
 		if (isNodeOfType(memberParent, "CallExpression") && memberParent.callee === parent) {
-			if (!parent.computed && isNodeOfType(parent.property, "Identifier") && HANDLER_NAMED_METHOD_PATTERN.test(parent.property.name)) return true;
+			const propertyName = getStaticPropertyName(parent);
+			if (propertyName && HANDLER_NAMED_METHOD_PATTERN.test(propertyName)) return true;
+			if (options.nativeMethodScopes && isCustomHookParameter(ref) && propertyName && isProvenNativeReadMethod(ref, propertyName) && isNativeMethodSuppressionSafe(analysis, memberParent, propertyName, options.nativeMethodScopes)) return false;
 			return isWholePropsObjectReference(analysis, ref);
 		}
 	}
@@ -29496,7 +30089,7 @@ const isNumericForLoopCounter = (attributeNode, indexName) => {
 	if (forStatement.test && forLoopTestReadsDataLength(forStatement.test)) return false;
 	return true;
 };
-const EMPTY_NAME_SET = /* @__PURE__ */ new Set();
+const EMPTY_NAME_SET$1 = /* @__PURE__ */ new Set();
 const findIteratorItemNamesOfBinding = (binding) => {
 	const names = /* @__PURE__ */ new Set();
 	if (!binding.bindingFunction || !isFunctionLike$1(binding.bindingFunction)) return names;
@@ -29610,9 +30203,9 @@ const noArrayIndexAsKey = defineRule({
 					const jsxElement = openingElement.parent;
 					if (jsxElement && isNodeOfType(jsxElement, "JSXElement")) {
 						const isInlineTextRun = INLINE_TEXT_LEAF_TAGS.has(elementName.name);
-						const primitiveItemNames = keyTemplate ? findBareItemNamesReferencedByTemplate(keyTemplate, itemNames) : EMPTY_NAME_SET;
+						const primitiveItemNames = keyTemplate ? findBareItemNamesReferencedByTemplate(keyTemplate, itemNames) : EMPTY_NAME_SET$1;
 						if (!containsStatefulDescendant(jsxElement, {
-							memberRootNames: isInlineTextRun ? itemNames : EMPTY_NAME_SET,
+							memberRootNames: isInlineTextRun ? itemNames : EMPTY_NAME_SET$1,
 							bareIdentifierNames: primitiveItemNames.size > 0 ? new Set([...derivedNames, ...primitiveItemNames]) : derivedNames
 						})) return;
 					}
@@ -30113,6 +30706,9 @@ const findNearestPackageDirectory = (filename) => {
 const readNearestPackageManifest = (filename) => {
 	const packageDirectory = findNearestPackageDirectory(filename);
 	if (!packageDirectory) return null;
+	return readPackageManifest(packageDirectory);
+};
+const readPackageManifest = (packageDirectory) => {
 	const packageJsonPath = path.join(packageDirectory, "package.json");
 	recordContentProbe(packageJsonPath);
 	const cached = cachedManifestByPackageDirectory.get(packageDirectory);
@@ -30491,7 +31087,16 @@ const isRenderPreservingCallArgumentFunction = (node, scopes) => {
 	return parent.arguments.some((argumentNode) => argumentNode === node) && isProvenArrayMapCall(parent, scopes);
 };
 const isNestedRenderEvidenceBoundary = (node, scopes) => NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES.has(node.type) && !isRenderPreservingCallArgumentFunction(node, scopes);
-const isRenderOutputExpression = (node, scopes) => node.type === "JSXElement" || node.type === "JSXFragment" || isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS);
+const isRenderOutputExpression = (node, scopes) => node.type === "JSXElement" || node.type === "JSXFragment" || isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS) || isReactDomCreatePortalCall(node, scopes);
+const isReactDomCreatePortalCall = (node, scopes) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (isNodeOfType(callee, "Identifier")) return scopes.symbolFor(callee)?.kind === "import" && getImportedNameFromModule(callee, callee.name, "react-dom") === "createPortal";
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== "createPortal") return false;
+	const symbol = scopes.symbolFor(callee.object);
+	if (!symbol || symbol.kind !== "import") return false;
+	return isDefaultImportFromModule(callee.object, callee.object.name, "react-dom") || isNamespaceImportFromModule(callee.object, callee.object.name, "react-dom");
+};
 const containsRenderOutput$1 = (rootNode, scopes) => {
 	let hasRenderOutput = false;
 	walkAst(rootNode, (node) => {
@@ -30643,6 +31248,514 @@ const noCascadingSetState = defineRetiredRule({
 	recommendation: "Retired: React batches synchronous state updates from one effect into the same follow-up commit, so setter count does not prove repeated redraws."
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/utils/create-state-trigger-reachability.ts
+const getRefCurrentSymbol = (node, context) => {
+	const expression = stripParenExpression(node);
+	if (!isNodeOfType(expression, "MemberExpression") || getStaticMemberPropertyName(expression) !== "current" || !isNodeOfType(expression.object, "Identifier")) return null;
+	return context.scopes.symbolFor(expression.object);
+};
+const expressionReadsState = (analysis, expression) => getDownstreamRefs(analysis, expression).some((reference) => getUpstreamRefs(analysis, reference).some((upstreamReference) => isState(analysis, upstreamReference)));
+const expressionReadsProp = (analysis, expression) => getDownstreamRefs(analysis, expression).some((reference) => getUpstreamRefs(analysis, reference).some((upstreamReference) => isProp(analysis, upstreamReference)));
+const hasNonInitializerWrite = (analysis, identifier) => {
+	const reference = getRef(analysis, identifier);
+	return Boolean(reference?.resolved?.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init));
+};
+const isStableParameterDefault = (expression) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Literal")) return candidate.value === null || [
+		"bigint",
+		"boolean",
+		"number",
+		"string"
+	].includes(typeof candidate.value);
+	return Boolean(isNodeOfType(candidate, "TemplateLiteral") && (candidate.expressions ?? []).length === 0);
+};
+const isDirectComponentPropBinding = (symbol) => {
+	const parameter = symbol.declarationNode;
+	if (parameter === symbol.bindingIdentifier) return true;
+	if (isNodeOfType(parameter, "AssignmentPattern")) return parameter.left === symbol.bindingIdentifier && isStableParameterDefault(parameter.right);
+	if (!isNodeOfType(parameter, "ObjectPattern")) return false;
+	return parameter.properties.some((property) => {
+		if (!isNodeOfType(property, "Property")) return false;
+		const propertyValue = property.value;
+		if (propertyValue === symbol.bindingIdentifier) return true;
+		return Boolean(isNodeOfType(propertyValue, "AssignmentPattern") && propertyValue.left === symbol.bindingIdentifier && isStableParameterDefault(propertyValue.right));
+	});
+};
+const REFLEXIVE_TYPE_NODE_TYPES = new Set([
+	"TSBigIntKeyword",
+	"TSBooleanKeyword",
+	"TSNeverKeyword",
+	"TSNullKeyword",
+	"TSObjectKeyword",
+	"TSStringKeyword",
+	"TSSymbolKeyword",
+	"TSUndefinedKeyword"
+]);
+const PRIMITIVE_TYPE_NODE_TYPES = new Set([
+	"TSBigIntKeyword",
+	"TSBooleanKeyword",
+	"TSNeverKeyword",
+	"TSNullKeyword",
+	"TSNumberKeyword",
+	"TSStringKeyword",
+	"TSSymbolKeyword",
+	"TSUndefinedKeyword"
+]);
+const isDefinitelyReflexiveType = (typeNode) => {
+	if (REFLEXIVE_TYPE_NODE_TYPES.has(typeNode.type)) return true;
+	if (isNodeOfType(typeNode, "TSLiteralType")) return Boolean(isNodeOfType(typeNode.literal, "Literal") && (typeof typeNode.literal.value !== "number" || !Number.isNaN(typeNode.literal.value)));
+	if (isNodeOfType(typeNode, "TSUnionType")) return (typeNode.types ?? []).every((member) => isDefinitelyReflexiveType(member));
+	return false;
+};
+const isDefinitelyPrimitiveType = (typeNode) => {
+	if (PRIMITIVE_TYPE_NODE_TYPES.has(typeNode.type)) return true;
+	if (isNodeOfType(typeNode, "TSLiteralType")) return true;
+	if (isNodeOfType(typeNode, "TSUnionType")) return (typeNode.types ?? []).every((member) => isDefinitelyPrimitiveType(member));
+	return false;
+};
+const isDefinitelyPrimitiveExpression = (expression, context) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Literal")) return true;
+	if (!isNodeOfType(candidate, "Identifier")) return false;
+	const symbol = context.scopes.symbolFor(candidate);
+	const typeAnnotation = symbol ? getSymbolTypeAnnotation(symbol) : null;
+	return Boolean(typeAnnotation && isDefinitelyPrimitiveType(typeAnnotation));
+};
+const isDefinitelyReflexiveExpression = (expression, analysis, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Literal")) return typeof candidate.value !== "number" || !Number.isNaN(candidate.value);
+	if (isNodeOfType(candidate, "TemplateLiteral") || isNodeOfType(candidate, "ArrayExpression") || isNodeOfType(candidate, "ObjectExpression") || isFunctionLike$1(candidate)) return true;
+	if (isNodeOfType(candidate, "UnaryExpression")) return [
+		"!",
+		"typeof",
+		"void",
+		"~"
+	].includes(candidate.operator);
+	if (isNodeOfType(candidate, "BinaryExpression")) return [
+		"&",
+		"|",
+		"^",
+		"<<",
+		">>",
+		">>>"
+	].includes(candidate.operator);
+	if (isNodeOfType(candidate, "CallExpression")) {
+		const callee = stripParenExpression(candidate.callee);
+		return Boolean(isNodeOfType(callee, "Identifier") && ["Boolean", "String"].includes(callee.name) && context.scopes.isGlobalReference(callee));
+	}
+	if (!isNodeOfType(candidate, "Identifier")) return false;
+	if (candidate.name === "undefined" && context.scopes.isGlobalReference(candidate)) return true;
+	const symbol = context.scopes.symbolFor(candidate);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+	const typeAnnotation = getSymbolTypeAnnotation(symbol);
+	if (typeAnnotation && isDefinitelyReflexiveType(typeAnnotation)) return true;
+	if (!symbol.initializer || hasNonInitializerWrite(analysis, candidate)) return false;
+	const nextVisitedSymbolIds = new Set(visitedSymbolIds);
+	nextVisitedSymbolIds.add(symbol.id);
+	return isDefinitelyReflexiveExpression(symbol.initializer, analysis, context, nextVisitedSymbolIds);
+};
+const isSupportedPropProjection = (analysis, expression, context, visitedBindings = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Identifier")) {
+		const reference = getRef(analysis, candidate);
+		if (!reference) return false;
+		if (isProp(analysis, reference)) {
+			if (isCustomHookParameter(reference)) return false;
+			const symbol = context.scopes.symbolFor(candidate);
+			return Boolean(symbol && isDirectComponentPropBinding(symbol));
+		}
+		if (!reference.resolved || visitedBindings.has(reference.resolved)) return false;
+		if (hasNonInitializerWrite(analysis, candidate)) return false;
+		const declarator = reference.resolved.defs.map((definition) => definition.node).find((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
+		if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.id, "Identifier") || !declarator.init) return false;
+		const nextVisitedBindings = new Set(visitedBindings);
+		nextVisitedBindings.add(reference.resolved);
+		return isSupportedPropProjection(analysis, declarator.init, context, nextVisitedBindings);
+	}
+	if (isNodeOfType(candidate, "MemberExpression")) return false;
+	if (isNodeOfType(candidate, "UnaryExpression") && candidate.operator === "~") return Boolean(isDefinitelyPrimitiveExpression(candidate.argument, context) && isSupportedPropProjection(analysis, candidate.argument, context, visitedBindings));
+	if (isNodeOfType(candidate, "BinaryExpression") && [
+		"&",
+		"|",
+		"^",
+		"<<",
+		">>",
+		">>>"
+	].includes(candidate.operator)) return [candidate.left, candidate.right].every((operand) => {
+		const projectionOperand = stripParenExpression(operand);
+		return isNodeOfType(projectionOperand, "Literal") || isDefinitelyPrimitiveExpression(projectionOperand, context) && isSupportedPropProjection(analysis, projectionOperand, context, visitedBindings);
+	});
+	if (isNodeOfType(candidate, "CallExpression")) {
+		const callee = stripParenExpression(candidate.callee);
+		if (isNodeOfType(callee, "Identifier") && ["Boolean", "String"].includes(callee.name) && context.scopes.isGlobalReference(callee) && (candidate.arguments ?? []).length === 1) {
+			const argument = candidate.arguments?.[0];
+			return Boolean(argument && isDefinitelyPrimitiveExpression(argument, context) && isSupportedPropProjection(analysis, argument, context, visitedBindings));
+		}
+		return false;
+	}
+	return false;
+};
+const getStableCurrentValueKey = (analysis, expression, context) => {
+	if (expressionReadsState(analysis, expression)) return null;
+	if (!expressionReadsProp(analysis, expression)) return null;
+	if (!isSupportedPropProjection(analysis, expression, context)) return null;
+	return resolveExpressionKey$1(expression, context);
+};
+const getSnapshotShape = (analysis, expression, context) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "ArrayExpression")) {
+		const elementKeys = [];
+		for (const element of candidate.elements ?? []) {
+			if (!element || isNodeOfType(element, "SpreadElement")) return null;
+			const elementKey = getStableCurrentValueKey(analysis, element, context);
+			if (!elementKey) return null;
+			elementKeys.push(elementKey);
+		}
+		return {
+			scalarKey: null,
+			elementKeys
+		};
+	}
+	const scalarKey = getStableCurrentValueKey(analysis, candidate, context);
+	return scalarKey ? {
+		scalarKey,
+		elementKeys: null
+	} : null;
+};
+const snapshotShapesMatch = (left, right) => {
+	if (left.scalarKey !== right.scalarKey) return false;
+	if (left.elementKeys === null || right.elementKeys === null) return left.elementKeys === right.elementKeys;
+	return left.elementKeys.length === right.elementKeys.length && left.elementKeys.every((elementKey, index) => elementKey === right.elementKeys?.[index]);
+};
+const collectSnapshotEnvironment = (analysis, effectFunction, context) => {
+	const assignmentsByRefSymbolId = /* @__PURE__ */ new Map();
+	const refSymbolsById = /* @__PURE__ */ new Map();
+	walkAst(effectFunction, (child) => {
+		if (child !== effectFunction && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "AssignmentExpression") || child.operator !== "=") return;
+		const refSymbol = getRefCurrentSymbol(child.left, context);
+		if (!refSymbol) return;
+		const assignments = assignmentsByRefSymbolId.get(refSymbol.id) ?? [];
+		assignments.push(child);
+		assignmentsByRefSymbolId.set(refSymbol.id, assignments);
+		refSymbolsById.set(refSymbol.id, refSymbol);
+	});
+	const refShapes = /* @__PURE__ */ new Map();
+	for (const [refSymbolId, assignments] of assignmentsByRefSymbolId) {
+		if (assignments.length !== 1) continue;
+		const assignment = assignments[0];
+		if (!assignment || !isNodeOfType(assignment, "AssignmentExpression")) continue;
+		if (context.cfg.enclosingFunction(assignment) !== effectFunction) continue;
+		if (!context.cfg.isUnconditionalFromEntry(assignment)) continue;
+		const declarator = refSymbolsById.get(refSymbolId)?.declarationNode ?? null;
+		if (!declarator || !isGenuineReactHookDeclarator(analysis, declarator, "useRef") || !isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.init, "CallExpression")) continue;
+		const refIdentifier = isNodeOfType(declarator.id, "Identifier") ? declarator.id : null;
+		const declarationSymbol = refIdentifier ? context.scopes.symbolFor(refIdentifier) : null;
+		if (!declarationSymbol || declarationSymbol.id !== refSymbolId) continue;
+		if (declarationSymbol.references.some((reference) => {
+			const member = reference.identifier.parent;
+			if (!member || !isNodeOfType(member, "MemberExpression") || member.object !== reference.identifier || getStaticMemberPropertyName(member) !== "current") return true;
+			const parent = member.parent;
+			if (!parent) return false;
+			if (isNodeOfType(parent, "UpdateExpression")) return true;
+			if (isNodeOfType(parent, "AssignmentExpression") && parent.left === member) return parent !== assignment;
+			return false;
+		})) continue;
+		const initializer = declarator.init.arguments?.[0];
+		if (!initializer) continue;
+		const initialShape = getSnapshotShape(analysis, initializer, context);
+		const assignedShape = getSnapshotShape(analysis, assignment.right, context);
+		if (!initialShape || !assignedShape || !snapshotShapesMatch(initialShape, assignedShape)) continue;
+		refShapes.set(refSymbolId, assignedShape);
+	}
+	const previousValueKeys = /* @__PURE__ */ new Map();
+	walkAst(effectFunction, (child) => {
+		if (child !== effectFunction && isFunctionLike$1(child)) return false;
+		if (!isNodeOfType(child, "VariableDeclarator") || !child.init) return;
+		const refSymbol = getRefCurrentSymbol(child.init, context);
+		if (!refSymbol) return;
+		const snapshotShape = refShapes.get(refSymbol.id);
+		if (!snapshotShape) return;
+		if (isNodeOfType(child.id, "Identifier") && snapshotShape.scalarKey) {
+			const previousSymbol = context.scopes.symbolFor(child.id);
+			if (previousSymbol && previousSymbol.kind === "const") previousValueKeys.set(previousSymbol.id, snapshotShape.scalarKey);
+			return;
+		}
+		if (!isNodeOfType(child.id, "ArrayPattern") || !snapshotShape.elementKeys) return;
+		for (let elementIndex = 0; elementIndex < child.id.elements.length; elementIndex += 1) {
+			const element = child.id.elements[elementIndex];
+			const elementKey = snapshotShape.elementKeys[elementIndex];
+			if (!element || !elementKey || !isNodeOfType(element, "Identifier")) continue;
+			const previousSymbol = context.scopes.symbolFor(element);
+			if (previousSymbol && previousSymbol.kind === "const") previousValueKeys.set(previousSymbol.id, elementKey);
+		}
+	});
+	return {
+		refShapes,
+		previousValueKeys
+	};
+};
+const getSnapshotValueKey = (expression, environment) => {
+	const candidate = stripParenExpression(expression);
+	const refSymbol = getRefCurrentSymbol(candidate, environment.context);
+	if (refSymbol) return environment.snapshotEnvironment.refShapes.get(refSymbol.id)?.scalarKey ?? null;
+	if (!isNodeOfType(candidate, "Identifier")) return null;
+	const symbol = environment.context.scopes.symbolFor(candidate);
+	if (!symbol) return null;
+	const substitutedExpression = environment.substitutions.get(symbol.id);
+	if (substitutedExpression) return getSnapshotValueKey(substitutedExpression, environment);
+	const directKey = environment.snapshotEnvironment.previousValueKeys.get(symbol.id);
+	if (directKey) return directKey;
+	if (symbol.kind !== "const" || !symbol.initializer || environment.visitedSymbolIds.has(symbol.id)) return null;
+	const nextVisitedSymbolIds = new Set(environment.visitedSymbolIds);
+	nextVisitedSymbolIds.add(symbol.id);
+	return getSnapshotValueKey(symbol.initializer, {
+		...environment,
+		visitedSymbolIds: nextVisitedSymbolIds
+	});
+};
+const evaluateComparison = (expression, environment) => {
+	if (!isNodeOfType(expression, "BinaryExpression")) return null;
+	if (![
+		"===",
+		"!==",
+		"==",
+		"!="
+	].includes(expression.operator)) return null;
+	const resolveSubstitutedExpression = (operand) => {
+		const candidate = stripParenExpression(operand);
+		if (!isNodeOfType(candidate, "Identifier")) return candidate;
+		const symbol = environment.context.scopes.symbolFor(candidate);
+		return (symbol && environment.substitutions.get(symbol.id)) ?? candidate;
+	};
+	const leftExpression = resolveSubstitutedExpression(expression.left);
+	const rightExpression = resolveSubstitutedExpression(expression.right);
+	const leftSnapshotKey = getSnapshotValueKey(leftExpression, environment);
+	const rightSnapshotKey = getSnapshotValueKey(rightExpression, environment);
+	const leftCurrentKey = getStableCurrentValueKey(environment.analysis, leftExpression, environment.context);
+	const rightCurrentKey = getStableCurrentValueKey(environment.analysis, rightExpression, environment.context);
+	const currentExpression = leftSnapshotKey !== null && leftSnapshotKey === rightCurrentKey ? rightExpression : rightSnapshotKey !== null && rightSnapshotKey === leftCurrentKey ? leftExpression : null;
+	if (!currentExpression || !isDefinitelyReflexiveExpression(currentExpression, environment.analysis, environment.context)) return null;
+	return expression.operator === "===" || expression.operator === "==";
+};
+const hasDirectGlobalObjectIsWrite = (objectIdentifier, context) => {
+	const program = findProgramRoot(objectIdentifier);
+	if (!program) return true;
+	let didFindWrite = false;
+	walkAst(program, (candidate) => {
+		if (didFindWrite) return false;
+		let writeTarget = null;
+		if (isNodeOfType(candidate, "AssignmentExpression")) writeTarget = candidate.left;
+		else if (isNodeOfType(candidate, "UpdateExpression")) writeTarget = candidate.argument;
+		else if (isNodeOfType(candidate, "UnaryExpression") && candidate.operator === "delete") writeTarget = candidate.argument;
+		if (!writeTarget) return;
+		const target = stripParenExpression(writeTarget);
+		if (isNodeOfType(target, "Identifier")) {
+			didFindWrite = target.name === "Object" && context.scopes.isGlobalReference(target);
+			return;
+		}
+		if (isNodeOfType(target, "MemberExpression") && isNodeOfType(target.object, "Identifier") && target.object.name === "Object" && context.scopes.isGlobalReference(target.object)) {
+			const propertyName = getStaticMemberPropertyName(target);
+			didFindWrite = propertyName === null || propertyName === "is";
+		}
+	});
+	return didFindWrite;
+};
+const evaluateObjectIs = (expression, environment) => {
+	if (!isNodeOfType(expression, "CallExpression")) return null;
+	const callee = stripParenExpression(expression.callee);
+	if (!isNodeOfType(callee, "MemberExpression") || !isNodeOfType(callee.object, "Identifier") || callee.object.name !== "Object" || !environment.context.scopes.isGlobalReference(callee.object) || getStaticMemberPropertyName(callee) !== "is") return null;
+	if (hasPossibleStaticPropertyWrite(callee.object, "is", environment.context.scopes) || hasDirectGlobalObjectIsWrite(callee.object, environment.context)) return null;
+	const argumentsToCompare = expression.arguments ?? [];
+	if (argumentsToCompare.length !== 2) return null;
+	const resolveSubstitutedExpression = (operand) => {
+		const candidate = stripParenExpression(operand);
+		if (!isNodeOfType(candidate, "Identifier")) return candidate;
+		const symbol = environment.context.scopes.symbolFor(candidate);
+		return (symbol && environment.substitutions.get(symbol.id)) ?? candidate;
+	};
+	const leftExpression = resolveSubstitutedExpression(argumentsToCompare[0]);
+	const rightExpression = resolveSubstitutedExpression(argumentsToCompare[1]);
+	const leftSnapshotKey = getSnapshotValueKey(leftExpression, environment);
+	const rightSnapshotKey = getSnapshotValueKey(rightExpression, environment);
+	const leftCurrentKey = getStableCurrentValueKey(environment.analysis, leftExpression, environment.context);
+	const rightCurrentKey = getStableCurrentValueKey(environment.analysis, rightExpression, environment.context);
+	return leftSnapshotKey !== null && leftSnapshotKey === rightCurrentKey ? true : rightSnapshotKey !== null && rightSnapshotKey === leftCurrentKey ? true : null;
+};
+const getHelperReturnExpression = (functionNode) => {
+	if (!isFunctionLike$1(functionNode)) return null;
+	if (Boolean(functionNode.async) || Boolean(functionNode.generator)) return null;
+	if (!isNodeOfType(functionNode.body, "BlockStatement")) return functionNode.body;
+	const statements = functionNode.body.body ?? [];
+	if (statements.length !== 1 || !isNodeOfType(statements[0], "ReturnStatement")) return null;
+	return statements[0].argument ? statements[0].argument : null;
+};
+const evaluateBoolean = (expression, environment) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Literal") && typeof candidate.value === "boolean") return candidate.value;
+	if (isNodeOfType(candidate, "Identifier")) {
+		const symbol = environment.context.scopes.symbolFor(candidate);
+		if (!symbol) return null;
+		const substitutedExpression = environment.substitutions.get(symbol.id);
+		if (substitutedExpression) return evaluateBoolean(substitutedExpression, environment);
+		if (symbol.kind !== "const" || !symbol.initializer || environment.visitedSymbolIds.has(symbol.id)) return null;
+		const nextVisitedSymbolIds = new Set(environment.visitedSymbolIds);
+		nextVisitedSymbolIds.add(symbol.id);
+		return evaluateBoolean(symbol.initializer, {
+			...environment,
+			visitedSymbolIds: nextVisitedSymbolIds
+		});
+	}
+	if (isNodeOfType(candidate, "UnaryExpression") && candidate.operator === "!") {
+		const argumentValue = evaluateBoolean(candidate.argument, environment);
+		return argumentValue === null ? null : !argumentValue;
+	}
+	if (isNodeOfType(candidate, "LogicalExpression")) {
+		const leftValue = evaluateBoolean(candidate.left, environment);
+		if (candidate.operator === "&&") {
+			if (leftValue === false) return false;
+			const rightValue = evaluateBoolean(candidate.right, environment);
+			if (leftValue === true) return rightValue;
+			return rightValue === false ? false : null;
+		}
+		if (candidate.operator === "||") {
+			if (leftValue === true) return true;
+			const rightValue = evaluateBoolean(candidate.right, environment);
+			if (leftValue === false) return rightValue;
+			return rightValue === true ? true : null;
+		}
+		return null;
+	}
+	const objectIsValue = evaluateObjectIs(candidate, environment);
+	if (objectIsValue !== null) return objectIsValue;
+	const comparisonValue = evaluateComparison(candidate, environment);
+	if (comparisonValue !== null) return comparisonValue;
+	if (!environment.allowHelperCall || !isNodeOfType(candidate, "CallExpression")) return null;
+	const callee = stripParenExpression(candidate.callee);
+	if (!isNodeOfType(callee, "Identifier")) return null;
+	const calleeReference = getRef(environment.analysis, callee);
+	if (calleeReference?.resolved?.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init)) return null;
+	const helperFunction = calleeReference ? resolveToFunction(calleeReference) : null;
+	const returnExpression = helperFunction ? getHelperReturnExpression(helperFunction) : null;
+	if (!helperFunction || !returnExpression || !isFunctionLike$1(helperFunction)) return null;
+	const parameters = helperFunction.params ?? [];
+	const argumentsForHelper = candidate.arguments ?? [];
+	if (parameters.length !== argumentsForHelper.length) return null;
+	const substitutions = new Map(environment.substitutions);
+	for (let parameterIndex = 0; parameterIndex < parameters.length; parameterIndex += 1) {
+		const parameter = parameters[parameterIndex];
+		const argument = argumentsForHelper[parameterIndex];
+		if (!parameter || !argument || !isNodeOfType(parameter, "Identifier")) return null;
+		const parameterSymbol = environment.context.scopes.symbolFor(parameter);
+		if (!parameterSymbol) return null;
+		substitutions.set(parameterSymbol.id, argument);
+	}
+	return evaluateBoolean(returnExpression, {
+		...environment,
+		substitutions,
+		visitedSymbolIds: /* @__PURE__ */ new Set(),
+		allowHelperCall: false
+	});
+};
+const statementCanCompleteNormally = (statement, environment) => {
+	if (isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement") || isNodeOfType(statement, "BreakStatement") || isNodeOfType(statement, "ContinueStatement")) return false;
+	if (isNodeOfType(statement, "BlockStatement")) return (statement.body ?? []).every((childStatement) => statementCanCompleteNormally(childStatement, environment));
+	if (isNodeOfType(statement, "IfStatement")) {
+		const testValue = evaluateBoolean(statement.test, environment);
+		if (testValue === true) return statementCanCompleteNormally(statement.consequent, environment);
+		if (testValue === false) return statement.alternate ? statementCanCompleteNormally(statement.alternate, environment) : true;
+		const consequentCanComplete = statementCanCompleteNormally(statement.consequent, environment);
+		const alternateCanComplete = statement.alternate ? statementCanCompleteNormally(statement.alternate, environment) : true;
+		return consequentCanComplete || alternateCanComplete;
+	}
+	if (isNodeOfType(statement, "LabeledStatement")) {
+		const labelName = isNodeOfType(statement.label, "Identifier") ? statement.label.name : null;
+		if (labelName && statementCanCompleteWithBreakToLabel(statement.body, labelName, environment)) return true;
+		return statementCanCompleteNormallyForLabel(statement.body, environment);
+	}
+	return true;
+};
+const statementCanCompleteNormallyForLabel = (statement, environment) => {
+	if (isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement") || isNodeOfType(statement, "BreakStatement") || isNodeOfType(statement, "ContinueStatement")) return false;
+	if (isNodeOfType(statement, "BlockStatement")) return (statement.body ?? []).every((childStatement) => statementCanCompleteNormallyForLabel(childStatement, environment));
+	if (isNodeOfType(statement, "IfStatement")) {
+		const testValue = evaluateBoolean(statement.test, environment);
+		if (testValue === true) return statementCanCompleteNormallyForLabel(statement.consequent, environment);
+		if (testValue === false) return statement.alternate ? statementCanCompleteNormallyForLabel(statement.alternate, environment) : true;
+		const consequentCanComplete = statementCanCompleteNormallyForLabel(statement.consequent, environment);
+		const alternateCanComplete = statement.alternate ? statementCanCompleteNormallyForLabel(statement.alternate, environment) : true;
+		return consequentCanComplete || alternateCanComplete;
+	}
+	if (isNodeOfType(statement, "LabeledStatement")) return statementCanCompleteNormally(statement, environment);
+	return isNodeOfType(statement, "ExpressionStatement") || isNodeOfType(statement, "VariableDeclaration") || isNodeOfType(statement, "EmptyStatement") || isNodeOfType(statement, "DebuggerStatement");
+};
+const statementCanCompleteWithBreakToLabel = (statement, labelName, environment) => {
+	if (isNodeOfType(statement, "BreakStatement")) return Boolean(isNodeOfType(statement.label, "Identifier") && statement.label.name === labelName);
+	if (isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement") || isNodeOfType(statement, "ContinueStatement")) return false;
+	if (isNodeOfType(statement, "BlockStatement")) {
+		for (const childStatement of statement.body ?? []) {
+			if (statementCanCompleteWithBreakToLabel(childStatement, labelName, environment)) return true;
+			if (!statementCanCompleteNormallyForLabel(childStatement, environment)) return false;
+		}
+		return false;
+	}
+	if (isNodeOfType(statement, "IfStatement")) {
+		const testValue = evaluateBoolean(statement.test, environment);
+		if (testValue === true) return statementCanCompleteWithBreakToLabel(statement.consequent, labelName, environment);
+		if (testValue === false) return Boolean(statement.alternate && statementCanCompleteWithBreakToLabel(statement.alternate, labelName, environment));
+		return statementCanCompleteWithBreakToLabel(statement.consequent, labelName, environment) || Boolean(statement.alternate && statementCanCompleteWithBreakToLabel(statement.alternate, labelName, environment));
+	}
+	if (isNodeOfType(statement, "LabeledStatement")) return statementCanCompleteWithBreakToLabel(statement.body, labelName, environment);
+	return false;
+};
+const isReachableUnderSnapshotEnvironment = (target, effectFunction, environment) => {
+	if (environment.context.cfg.enclosingFunction(target) !== effectFunction) return true;
+	let current = target;
+	while (current !== effectFunction) {
+		const parent = current.parent;
+		if (!parent) return true;
+		if (isFunctionLike$1(parent) && parent !== effectFunction) return true;
+		if (isNodeOfType(parent, "IfStatement")) {
+			const testValue = evaluateBoolean(parent.test, environment);
+			if (isAstDescendant(current, parent.consequent) && testValue === false) return false;
+			if (parent.alternate && isAstDescendant(current, parent.alternate) && testValue === true) return false;
+		}
+		if (isNodeOfType(parent, "LogicalExpression") && parent.right === current) {
+			const leftValue = evaluateBoolean(parent.left, environment);
+			if (parent.operator === "&&" && leftValue === false) return false;
+			if (parent.operator === "||" && leftValue === true) return false;
+		}
+		if (isNodeOfType(parent, "ConditionalExpression")) {
+			const testValue = evaluateBoolean(parent.test, environment);
+			if (parent.consequent === current && testValue === false) return false;
+			if (parent.alternate === current && testValue === true) return false;
+		}
+		if (isNodeOfType(parent, "BlockStatement")) {
+			const containingStatementIndex = (parent.body ?? []).findIndex((statement) => isAstDescendant(current, statement));
+			if (containingStatementIndex >= 0) {
+				if ((parent.body ?? []).slice(0, containingStatementIndex).some((statement) => !statementCanCompleteNormally(statement, environment))) return false;
+			}
+		}
+		current = parent;
+	}
+	return true;
+};
+const createStateTriggerReachability = ({ analysis, context, effectFunction }) => {
+	const snapshotEnvironment = collectSnapshotEnvironment(analysis, effectFunction, context);
+	if (snapshotEnvironment.refShapes.size === 0) return () => true;
+	const environment = {
+		analysis,
+		context,
+		effectFunction,
+		snapshotEnvironment,
+		substitutions: /* @__PURE__ */ new Map(),
+		visitedSymbolIds: /* @__PURE__ */ new Set(),
+		allowHelperCall: true
+	};
+	return (target) => isReachableUnderSnapshotEnvironment(target, effectFunction, environment);
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-chain-state-updates.ts
 const getUseStateDeclarator = (ref) => (ref.resolved?.defs ?? []).map((def) => def.node).find((node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "ArrayPattern")) ?? null;
 const isDeclaredWithin = (node, container) => {
@@ -30708,11 +31821,17 @@ const noChainStateUpdates = defineRule({
 		if (stateDeps.length === 0) return;
 		if (stateDeps.every((ref) => isExternallyDrivenState(analysis, ref))) return;
 		const stateDepDeclarators = new Set(stateDeps.map((ref) => getUseStateDeclarator(ref)).filter((declarator) => declarator !== null));
+		const isReachableFromStateTrigger = createStateTriggerReachability({
+			analysis,
+			context,
+			effectFunction: effectFn
+		});
 		const domSyncedStateDeclarators = /* @__PURE__ */ new Set();
 		for (const ref of effectFnRefs) {
 			if (!isSyncStateSetterCall(analysis, ref, effectFn)) continue;
 			const callExpr = getCallExpr(ref);
 			if (!callExpr) continue;
+			if (!isReachableFromStateTrigger(callExpr)) continue;
 			if (!readsPostMountValueThroughLocals(callExpr, effectFn, { ignoreBareRefCurrent: true })) continue;
 			const declarator = getUseStateDeclarator(ref);
 			if (declarator) domSyncedStateDeclarators.add(declarator);
@@ -30721,6 +31840,7 @@ const noChainStateUpdates = defineRule({
 			if (!isSyncStateSetterCall(analysis, ref, effectFn)) continue;
 			const callExpr = getCallExpr(ref);
 			if (!callExpr) continue;
+			if (!isReachableFromStateTrigger(callExpr)) continue;
 			if (getArgsUpstreamRefs(analysis, ref).some((argRef) => isState(analysis, argRef))) continue;
 			const setterDeclarator = getUseStateDeclarator(ref);
 			if (setterDeclarator && domSyncedStateDeclarators.has(setterDeclarator)) continue;
@@ -40920,7 +42040,7 @@ const noPropCallbackInRender = defineRule({
 		if (!analysis) return;
 		const callee = stripParenExpression(node.callee);
 		if (isFunctionLike$1(callee)) return;
-		if (!getDownstreamRefs(analysis, callee).some((reference) => isPropCallbackInvocationRef(analysis, reference))) return;
+		if (!getDownstreamRefs(analysis, callee).some((reference) => isPropCallbackInvocationRef(analysis, reference, { nativeMethodScopes: context.scopes }))) return;
 		context.report({
 			node,
 			message: "This prop callback runs during render. React can replay or discard render work, so the callback can fire more than once or for UI that never commits."
@@ -41883,18 +43003,107 @@ const getNodeText$1 = (node) => {
 		return value;
 	});
 };
-const isLiteralConstantIdentifier = (analysis, identifier) => {
-	const definitions = getRef(analysis, identifier)?.resolved?.defs;
-	if (!definitions || definitions.length !== 1) return false;
-	const definition = definitions[0];
-	if (definition.type !== "Variable") return false;
-	const declarator = definition.node;
-	if (!isNodeOfType(declarator, "VariableDeclarator")) return false;
-	const declaration = declarator.parent;
-	if (!isNodeOfType(declaration, "VariableDeclaration") || declaration.kind !== "const") return false;
-	return isNodeOfType(declarator.init, "Literal");
+const normalizeAsBoolean = (identity) => ({
+	...identity,
+	booleanNormalization: identity.booleanNormalization === "identity" ? "normalized" : identity.booleanNormalization
+});
+const negateBoolean = (identity) => ({
+	...identity,
+	booleanNormalization: identity.booleanNormalization === "negated" ? "normalized" : "negated"
+});
+const getLivePropExpressionIdentity = (analysis, context, node, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "Identifier")) {
+		const reference = getRef(analysis, expression);
+		const symbol = context.scopes.symbolFor(expression);
+		if (!reference || !symbol) return null;
+		if (isProp(analysis, reference)) return {
+			propSymbolId: symbol.id,
+			memberPath: [],
+			booleanNormalization: "identity"
+		};
+		if (visitedSymbolIds.has(symbol.id) || symbol.kind !== "const") return null;
+		visitedSymbolIds.add(symbol.id);
+		const initializer = getDirectConstInitializer(symbol);
+		if (initializer) return getLivePropExpressionIdentity(analysis, context, initializer, visitedSymbolIds);
+		return getUpstreamRefs(analysis, reference).some((upstreamReference) => isProp(analysis, upstreamReference)) ? {
+			propSymbolId: symbol.id,
+			memberPath: [],
+			booleanNormalization: "identity"
+		} : null;
+	}
+	if (isNodeOfType(expression, "MemberExpression")) {
+		const propertyName = getStaticMemberPropertyName(expression);
+		if (!propertyName) return null;
+		const objectIdentity = getLivePropExpressionIdentity(analysis, context, expression.object, visitedSymbolIds);
+		if (!objectIdentity) return null;
+		return {
+			...objectIdentity,
+			memberPath: [...objectIdentity.memberPath, propertyName]
+		};
+	}
+	if (isNodeOfType(expression, "CallExpression") && isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "Boolean" && context.scopes.isGlobalReference(expression.callee) && expression.arguments?.length === 1) {
+		const argument = expression.arguments[0];
+		const argumentIdentity = getLivePropExpressionIdentity(analysis, context, argument, visitedSymbolIds);
+		return argumentIdentity ? normalizeAsBoolean(argumentIdentity) : null;
+	}
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "!") {
+		const argumentIdentity = getLivePropExpressionIdentity(analysis, context, expression.argument, visitedSymbolIds);
+		return argumentIdentity ? negateBoolean(argumentIdentity) : null;
+	}
+	return null;
+};
+const isMountSnapshotInitializer = (context, node) => {
+	if (!isReactApiCall(node, "useMemo", context.scopes, { resolveNamedAliases: true }) || !isNodeOfType(node, "CallExpression")) return false;
+	const dependencies = node.arguments?.[1];
+	return isNodeOfType(dependencies, "ArrayExpression") && dependencies.elements.length === 0;
+};
+const isMountSnapshotBinding = (context, identifier, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const symbol = context.scopes.symbolFor(identifier);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	const initializer = getDirectConstInitializer(symbol);
+	if (!initializer) return false;
+	if (isMountSnapshotInitializer(context, initializer)) return true;
+	const expression = stripParenExpression(initializer);
+	return isNodeOfType(expression, "Identifier") && isMountSnapshotBinding(context, expression, visitedSymbolIds);
 };
-const isSetStateToInitialValue = (analysis, setterRef) => {
+const isConstantBooleanExpression = (context, node, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "Literal")) return true;
+	if (isNodeOfType(expression, "Identifier")) {
+		const symbol = context.scopes.symbolFor(expression);
+		if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+		visitedSymbolIds.add(symbol.id);
+		const initializer = getDirectConstInitializer(symbol);
+		return Boolean(initializer && isConstantBooleanExpression(context, initializer, visitedSymbolIds));
+	}
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "!") return isConstantBooleanExpression(context, expression.argument, visitedSymbolIds);
+	if (isNodeOfType(expression, "CallExpression") && isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "Boolean" && context.scopes.isGlobalReference(expression.callee) && expression.arguments?.length === 1) return isConstantBooleanExpression(context, expression.arguments[0], visitedSymbolIds);
+	return false;
+};
+const isProvenLiveBinding = (analysis, context, identifier) => {
+	const reference = getRef(analysis, identifier);
+	const symbol = context.scopes.symbolFor(identifier);
+	if (!reference || !symbol || symbol.kind !== "const" || isOutsideAllFunctions(symbol)) return false;
+	const initializer = symbol.initializer;
+	if (!initializer || isMountSnapshotBinding(context, identifier)) return false;
+	if (getDownstreamRefs(analysis, initializer).some((initializerReference) => isRefCurrent(initializerReference))) return false;
+	return !isConstantBooleanExpression(context, initializer);
+};
+const areSameProvenLiveBinding = (analysis, context, left, right) => {
+	const leftExpression = stripParenExpression(left);
+	const rightExpression = stripParenExpression(right);
+	if (!isNodeOfType(leftExpression, "Identifier") || !isNodeOfType(rightExpression, "Identifier")) return false;
+	const leftSymbol = context.scopes.symbolFor(leftExpression);
+	const rightSymbol = context.scopes.symbolFor(rightExpression);
+	return Boolean(leftSymbol && leftSymbol === rightSymbol && isProvenLiveBinding(analysis, context, leftExpression));
+};
+const haveSameLivePropExpressionIdentity = (left, right) => {
+	if (left.propSymbolId !== right.propSymbolId || left.booleanNormalization !== right.booleanNormalization || left.memberPath.length !== right.memberPath.length) return false;
+	return left.memberPath.every((propertyName, index) => propertyName === right.memberPath[index]);
+};
+const isSetStateToInitialValue = (analysis, context, setterRef) => {
 	const callExpr = getCallExpr(setterRef);
 	if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) return false;
 	const setStateToValue = callExpr.arguments?.[0];
@@ -41905,7 +43114,12 @@ const isSetStateToInitialValue = (analysis, setterRef) => {
 	if (isUndefinedNode(setStateToValue) && isUndefinedNode(stateInitialValue)) return true;
 	if (setStateToValue == null && stateInitialValue == null) return true;
 	if (setStateToValue && !stateInitialValue || !setStateToValue && stateInitialValue) return false;
-	if (stateInitialValue && isNodeOfType(stateInitialValue, "Identifier") && stateInitialValue.name !== "undefined" && !isLiteralConstantIdentifier(analysis, stateInitialValue)) return false;
+	if (stateInitialValue && setStateToValue) {
+		const initialLivePropIdentity = getLivePropExpressionIdentity(analysis, context, stateInitialValue);
+		const nextLivePropIdentity = getLivePropExpressionIdentity(analysis, context, setStateToValue);
+		if (initialLivePropIdentity && nextLivePropIdentity && haveSameLivePropExpressionIdentity(initialLivePropIdentity, nextLivePropIdentity)) return false;
+		if (areSameProvenLiveBinding(analysis, context, stateInitialValue, setStateToValue)) return false;
+	}
 	return getNodeText$1(setStateToValue) === getNodeText$1(stateInitialValue);
 };
 const countUseStates = (analysis, componentNode) => {
@@ -41914,10 +43128,10 @@ const countUseStates = (analysis, componentNode) => {
 	for (const ref of getDownstreamRefs(analysis, componentNode)) if (isState(analysis, ref)) stateVariables.add(ref.resolved);
 	return stateVariables.size;
 };
-const findPropUsedToResetAllState = (analysis, effectFnRefs, depsRefs, useEffectNode, effectFn) => {
+const findPropUsedToResetAllState = (analysis, context, effectFnRefs, depsRefs, useEffectNode, effectFn) => {
 	const stateSetterRefs = effectFnRefs.filter((ref) => isSyncStateSetterCall(analysis, ref, effectFn));
 	if (stateSetterRefs.length === 0) return null;
-	if (!stateSetterRefs.every((ref) => isSetStateToInitialValue(analysis, ref))) return null;
+	if (!stateSetterRefs.every((ref) => isSetStateToInitialValue(analysis, context, ref))) return null;
 	if (stateSetterRefs.every((setterRef) => effectFnRefs.some((otherRef) => otherRef !== setterRef && otherRef.resolved === setterRef.resolved && Boolean(getCallExpr(otherRef)) && !isSyncStateSetterCall(analysis, otherRef, effectFn)))) return null;
 	const containing = findContainingNode(analysis, useEffectNode);
 	if (new Set(stateSetterRefs.map((setterRef) => setterRef.resolved)).size !== countUseStates(analysis, containing)) return null;
@@ -41941,7 +43155,7 @@ const noResetAllStateOnPropChange = defineRule({
 		if (containing && isCustomHook(containing)) return;
 		const effectFn = getEffectFn(analysis, node);
 		if (!effectFn) return;
-		if (!findPropUsedToResetAllState(analysis, effectFnRefs, depsRefs, node, effectFn)) return;
+		if (!findPropUsedToResetAllState(analysis, context, effectFnRefs, depsRefs, node, effectFn)) return;
 		context.report({
 			node,
 			message: `Your users briefly see stale state when a prop changes because this useEffect clears all state.`
@@ -45744,19 +46958,726 @@ const nosqlInjectionRisk = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/utils/export-all-adds-runtime-values.ts
+const getExportedName = (node) => {
+	if (!node) return null;
+	if (isNodeOfType(node, "Identifier")) return node.name;
+	if (isNodeOfType(node, "Literal") && typeof node.value === "string") return node.value;
+	return null;
+};
+const programHasRuntimeNamedExports = (filePath, program, visitedFilePaths) => {
+	if (!isNodeOfType(program, "Program")) return true;
+	for (const statement of program.body) {
+		if (isNodeOfType(statement, "ExportDefaultDeclaration")) continue;
+		if (isNodeOfType(statement, "ExportAllDeclaration")) {
+			if (statement.exportKind === "type") continue;
+			if (statement.exported) return true;
+			if (typeof statement.source.value !== "string") return true;
+			if (exportAllAddsRuntimeValues(filePath, statement.source.value, visitedFilePaths)) return true;
+			continue;
+		}
+		if (!isNodeOfType(statement, "ExportNamedDeclaration")) continue;
+		if (statement.exportKind === "type") continue;
+		if (statement.declaration) {
+			if (statement.declaration.type !== "TSInterfaceDeclaration" && statement.declaration.type !== "TSTypeAliasDeclaration" && statement.declaration.type !== "TSDeclareFunction") return true;
+			continue;
+		}
+		if (isEverySpecifierInlineType(statement.specifiers, "ExportSpecifier", "exportKind")) continue;
+		for (const specifier of statement.specifiers) {
+			if (!isNodeOfType(specifier, "ExportSpecifier") || specifier.exportKind === "type") continue;
+			if (getExportedName(specifier.exported) !== "default") return true;
+		}
+	}
+	return false;
+};
+const exportAllAddsRuntimeValues = (importerFilePath, source, visitedFilePaths = /* @__PURE__ */ new Set()) => {
+	const resolvedFilePath = resolveRelativeImportPath(importerFilePath, source);
+	if (!resolvedFilePath) return true;
+	if (path.extname(resolvedFilePath) === ".cjs" || resolvedFilePath.endsWith(".cts")) return true;
+	if (visitedFilePaths.has(resolvedFilePath)) return true;
+	visitedFilePaths.add(resolvedFilePath);
+	const program = parseSourceFile(resolvedFilePath);
+	if (!program) return true;
+	return programHasRuntimeNamedExports(resolvedFilePath, program, visitedFilePaths);
+};
+//#endregion
 //#region src/plugin/utils/is-framework-route-or-special-filename.ts
-const sourceFileExtensionGroup = NEXTJS_SOURCE_FILE_EXTENSION_GROUP;
-const FRAMEWORK_ROUTE_FILE_PATTERNS = [
-	new RegExp(`^(page|layout|loading|error|not-found|template|default|global-error|route|_app|_document|_error)\\.${sourceFileExtensionGroup}$`),
-	new RegExp(`^(_layout|\\+html|\\+not-found|\\+native-intent)\\.${sourceFileExtensionGroup}$`),
-	new RegExp(`(?:^__root|\\.lazy)\\.${sourceFileExtensionGroup}$`),
-	new RegExp(`^(root|entry\\.client|entry\\.server)\\.${sourceFileExtensionGroup}$`)
-];
-const isFrameworkRouteOrSpecialFilename = (rawFilename) => {
+const NEXT_APP_ROUTE_FILE_PATTERN = new RegExp(`^(page|layout|loading|error|not-found|template|default|global-error|route)\\.${NEXTJS_SOURCE_FILE_EXTENSION_GROUP}$`);
+const NEXT_PAGES_ROUTE_FILE_PATTERN = new RegExp(`^(_app|_document|_error|_meta)\\.${NEXTJS_SOURCE_FILE_EXTENSION_GROUP}$`);
+const EXPO_ROUTE_FILE_PATTERN = new RegExp(`^(_layout|\\+html|\\+not-found|\\+native-intent)\\.${NEXTJS_SOURCE_FILE_EXTENSION_GROUP}$`);
+const TANSTACK_ROUTE_FILE_PATTERN = new RegExp(`(?:^__root|\\.lazy)\\.${NEXTJS_SOURCE_FILE_EXTENSION_GROUP}$`);
+const REACT_ROUTER_FILE_PATTERN = new RegExp(`^(root|entry\\.client|entry\\.server)\\.${NEXTJS_SOURCE_FILE_EXTENSION_GROUP}$`);
+const isInNextDirectory = (context, directoryPath) => {
+	if (isInProjectDirectory(context, directoryPath)) return true;
+	const filename = normalizeFilename(context.filename ?? "");
+	if (path.isAbsolute(filename)) return false;
+	return filename.startsWith(`${directoryPath}/`) || filename.includes(`/${directoryPath}/`);
+};
+const isInExpoRouteDirectory = (context) => {
+	const filename = normalizeFilename(context.filename ?? "");
+	const configuredRootDirectory = getReactDoctorStringSetting(context.settings, "rootDirectory");
+	const packageDirectory = path.isAbsolute(filename) ? findNearestPackageDirectory(filename) : null;
+	const projectRelativeFilename = getProjectRelativeFilename(filename, configuredRootDirectory ?? packageDirectory ?? void 0);
+	const relativeFilename = projectRelativeFilename === filename && path.isAbsolute(filename) ? filename.split("/").slice(2).join("/") : projectRelativeFilename;
+	return relativeFilename.startsWith("app/") || relativeFilename.startsWith("src/app/");
+};
+const isFrameworkRouteOrSpecialFilename = (context, runtime) => {
+	const rawFilename = context.filename;
 	if (!rawFilename) return false;
-	if (isNextjsMetadataImageRouteFilename(rawFilename)) return true;
 	const basename = path.basename(rawFilename);
-	return FRAMEWORK_ROUTE_FILE_PATTERNS.some((pattern) => pattern.test(basename));
+	if (runtime === "next") return isInNextDirectory(context, "app") && (isNextjsMetadataImageRouteFilename(rawFilename) || NEXT_APP_ROUTE_FILE_PATTERN.test(basename)) || isInNextDirectory(context, "pages") && NEXT_PAGES_ROUTE_FILE_PATTERN.test(basename);
+	if (runtime === "expo") return isInExpoRouteDirectory(context) && EXPO_ROUTE_FILE_PATTERN.test(basename);
+	if (runtime === "tanstack") return TANSTACK_ROUTE_FILE_PATTERN.test(basename);
+	if (runtime === "react-router" || runtime === "remix") return REACT_ROUTER_FILE_PATTERN.test(basename);
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/function-has-react-element-return-type.ts
+const isReactNamespaceBinding = (node) => {
+	if (!isNodeOfType(node, "Identifier")) return false;
+	const binding = getImportBindingForName(node, node.name);
+	return Boolean(binding && binding.source === "react" && (binding.isNamespace || binding.exportedName === "default"));
+};
+const hasLocalJsxNamespace = (node) => {
+	const program = findProgramRoot(node);
+	if (!program || !isNodeOfType(program, "Program")) return false;
+	return program.body.some((statement) => isNodeOfType(statement, "TSModuleDeclaration") && isNodeOfType(statement.id, "Identifier") && statement.id.name === "JSX");
+};
+const isReactElementTypeReference = (node) => {
+	if (!isNodeOfType(node, "TSTypeReference")) return false;
+	const typeName = node.typeName;
+	if (isNodeOfType(typeName, "Identifier")) return getImportedNameFromModule(typeName, typeName.name, "react") === "ReactElement";
+	if (!isNodeOfType(typeName, "TSQualifiedName")) return false;
+	if (!isNodeOfType(typeName.right, "Identifier")) return false;
+	if (typeName.right.name === "ReactElement" && isReactNamespaceBinding(typeName.left)) return true;
+	if (typeName.right.name !== "Element") return false;
+	if (isNodeOfType(typeName.left, "Identifier")) {
+		if (typeName.left.name !== "JSX") return false;
+		const binding = getImportBindingForName(typeName.left, typeName.left.name);
+		if (!binding) return !hasLocalJsxNamespace(typeName.left);
+		return binding.source === "react" && binding.exportedName === "JSX";
+	}
+	return isNodeOfType(typeName.left, "TSQualifiedName") && isNodeOfType(typeName.left.right, "Identifier") && typeName.left.right.name === "JSX" && isReactNamespaceBinding(typeName.left.left);
+};
+const containsReactElementType = (node) => {
+	if (isNodeOfType(node, "TSUnionType")) return node.types.some((member) => containsReactElementType(member));
+	return isReactElementTypeReference(node);
+};
+const functionHasReactElementReturnType = (functionNode) => {
+	const returnType = Reflect.get(functionNode, "returnType");
+	if (!isNodeOfType(returnType, "TSTypeAnnotation")) return false;
+	return containsReactElementType(returnType.typeAnnotation);
+};
+//#endregion
+//#region src/plugin/constants/fast-refresh.ts
+const FAST_REFRESH_CONFIG_FILENAMES = [
+	"vite.config.ts",
+	"vite.config.mts",
+	"vite.config.cts",
+	"vite.config.js",
+	"vite.config.mjs",
+	"vite.config.cjs",
+	"webpack.config.ts",
+	"webpack.config.js",
+	"webpack.config.mjs",
+	"webpack.config.cjs",
+	"rsbuild.config.ts",
+	"rsbuild.config.js",
+	"rspack.config.ts",
+	"rspack.config.js"
+];
+const MINIMUM_FAST_REFRESH_VERSIONS = {
+	dumi: {
+		major: 2,
+		minor: 0
+	},
+	expo: {
+		major: 36,
+		minor: 0
+	},
+	gatsby: {
+		major: 2,
+		minor: 31
+	},
+	next: {
+		major: 9,
+		minor: 4
+	},
+	parcel: {
+		major: 2,
+		minor: 0
+	},
+	reactForGatsbyTwo: {
+		major: 17,
+		minor: 0
+	},
+	reactNative: {
+		major: 0,
+		minor: 61
+	},
+	reactScripts: {
+		major: 4,
+		minor: 0
+	},
+	storybookReact: {
+		major: 6,
+		minor: 1
+	}
+};
+//#endregion
+//#region src/plugin/utils/get-fast-refresh-file-status.ts
+const INTEGRATION_IMPORTS = new Map([
+	["@vitejs/plugin-react", {
+		importedNames: null,
+		requiresViteDevelopmentServer: true,
+		runtime: "generic"
+	}],
+	["@vitejs/plugin-react-swc", {
+		importedNames: null,
+		requiresViteDevelopmentServer: true,
+		runtime: "generic"
+	}],
+	["@pmmmwh/react-refresh-webpack-plugin", {
+		importedNames: null,
+		runtime: "generic"
+	}],
+	["@react-router/dev/vite", {
+		importedNames: new Set(["reactRouter"]),
+		requiresViteDevelopmentServer: true,
+		runtime: "react-router"
+	}],
+	["@remix-run/dev", {
+		importedNames: new Set(["vitePlugin"]),
+		requiresViteDevelopmentServer: true,
+		runtime: "remix"
+	}],
+	["@rsbuild/plugin-react", {
+		importedNames: new Set(["pluginReact"]),
+		runtime: "generic"
+	}],
+	["@rspack/plugin-react-refresh", {
+		importedNames: null,
+		runtime: "generic"
+	}],
+	["@rozenite/vite-plugin", {
+		importedNames: new Set(["rozenitePlugin"]),
+		requiresViteDevelopmentServer: true,
+		runtime: "generic"
+	}],
+	["@tanstack/react-start/plugin/vite", {
+		importedNames: new Set(["tanstackStart"]),
+		requiresViteDevelopmentServer: true,
+		runtime: "tanstack"
+	}]
+]);
+const REGISTERED_INTEGRATION_RUNTIME_PRECEDENCE = [
+	"tanstack",
+	"remix",
+	"react-router",
+	"generic"
+];
+const cachedLocalStatusByManifest = /* @__PURE__ */ new WeakMap();
+const cachedWorkspaceIndexByManifest = /* @__PURE__ */ new WeakMap();
+const INACTIVE_STATUS = {
+	isActive: false,
+	runtime: "generic"
+};
+const WORKSPACE_IGNORED_DIRECTORY_NAMES = new Set([
+	".git",
+	".next",
+	"build",
+	"coverage",
+	"dist",
+	"node_modules",
+	"out"
+]);
+const parseVersion = (version) => {
+	if (typeof version !== "string") return null;
+	const match = version.match(/(?:^|[^\d])(\d+)(?:\.(\d+))?/);
+	if (!match) return null;
+	return {
+		major: Number(match[1]),
+		minor: Number(match[2] ?? 0)
+	};
+};
+const isVersionAtLeast = (version, minimum) => {
+	const parsed = parseVersion(version);
+	if (!parsed) return false;
+	return parsed.major > minimum.major || parsed.major === minimum.major && parsed.minor >= minimum.minor;
+};
+const getDependencyVersion = (manifest, dependencyName) => manifest.dependencies?.[dependencyName] ?? manifest.devDependencies?.[dependencyName] ?? manifest.peerDependencies?.[dependencyName] ?? manifest.optionalDependencies?.[dependencyName];
+const getRuntimeDependencyVersion = (manifest, dependencyName) => manifest.dependencies?.[dependencyName] ?? manifest.optionalDependencies?.[dependencyName];
+const getOwnedDependencyVersion = (manifest, dependencyName, developmentCommandPattern) => {
+	const runtimeVersion = getRuntimeDependencyVersion(manifest, dependencyName);
+	if (runtimeVersion !== void 0) return runtimeVersion;
+	return Object.values(manifest.scripts ?? {}).some((script) => typeof script === "string" && developmentCommandPattern.test(script)) ? manifest.devDependencies?.[dependencyName] : void 0;
+};
+const hasParcelBrowserEntry = (manifest) => {
+	if (typeof manifest.source === "string" && manifest.source.endsWith(".html")) return true;
+	return Object.values(manifest.scripts ?? {}).some((script) => typeof script === "string" && /(?:^|\s)parcel(?:\s+serve)?\s+[^\n]*\.html(?:\s|$)/.test(script));
+};
+const hasParcelDevelopmentCommand = (manifest) => Object.values(manifest.scripts ?? {}).some((script) => typeof script === "string" && /(?:^|[\s;&|'\\"])parcel(?=\s|$)(?!\s+(?:build|help|watch|--help|--version|-h|-V)(?:\s|$))/.test(script) && !/(?:^|\s)--no-hmr(?:\s|$)/.test(script));
+const hasOwnedDevelopmentCommand = (manifest, commandPattern) => Object.values(manifest.scripts ?? {}).some((script) => typeof script === "string" && commandPattern.test(script));
+const hasViteDevelopmentCommand = (manifest) => Object.values(manifest.scripts ?? {}).some((script) => {
+	if (typeof script !== "string") return false;
+	return [...script.matchAll(/(?:^|[\s;&|'\\"])vite(?:\s+(build|preview|test)\b)?/g)].some((match) => match[1] === void 0);
+});
+const hasViteBrowserEntry = (manifest, packageDirectory) => {
+	if (typeof manifest.source === "string" && manifest.source.endsWith(".html")) return true;
+	const browserEntryPath = path.join(packageDirectory, "index.html");
+	recordExistenceProbe(browserEntryPath);
+	return fs.existsSync(browserEntryPath);
+};
+const getBuiltInStatus = (manifest) => {
+	if (isVersionAtLeast(getOwnedDependencyVersion(manifest, "next", /(?:^|\s)next\s+dev(?:\s|$)/), MINIMUM_FAST_REFRESH_VERSIONS.next)) return {
+		isActive: true,
+		runtime: "next"
+	};
+	const gatsbyDependency = getOwnedDependencyVersion(manifest, "gatsby", /(?:^|\s)gatsby\s+develop(?:\s|$)/);
+	const gatsbyVersion = parseVersion(gatsbyDependency);
+	const hasGatsbyFastRefresh = gatsbyVersion !== null && (gatsbyVersion.major >= 3 || isVersionAtLeast(gatsbyDependency, MINIMUM_FAST_REFRESH_VERSIONS.gatsby) && isVersionAtLeast(getDependencyVersion(manifest, "react"), MINIMUM_FAST_REFRESH_VERSIONS.reactForGatsbyTwo));
+	if (isVersionAtLeast(getOwnedDependencyVersion(manifest, "react-scripts", /(?:^|\s)react-scripts\s+start(?:\s|$)/), MINIMUM_FAST_REFRESH_VERSIONS.reactScripts) || hasGatsbyFastRefresh || isVersionAtLeast(getDependencyVersion(manifest, "parcel"), MINIMUM_FAST_REFRESH_VERSIONS.parcel) && declaresDependency(manifest, "react") && hasParcelDevelopmentCommand(manifest) && hasParcelBrowserEntry(manifest)) return {
+		isActive: true,
+		runtime: "generic"
+	};
+	if (isVersionAtLeast(getOwnedDependencyVersion(manifest, "expo", /(?:^|\s)expo\s+start(?:\s|$)/), MINIMUM_FAST_REFRESH_VERSIONS.expo) || isVersionAtLeast(getOwnedDependencyVersion(manifest, "react-native", /(?:^|\s)react-native\s+start(?:\s|$)/), MINIMUM_FAST_REFRESH_VERSIONS.reactNative)) return {
+		isActive: true,
+		runtime: "expo"
+	};
+	if (isVersionAtLeast(getOwnedDependencyVersion(manifest, "dumi", /(?:^|\s)dumi\s+dev(?:\s|$)/), MINIMUM_FAST_REFRESH_VERSIONS.dumi)) return {
+		isActive: true,
+		runtime: "generic"
+	};
+	return null;
+};
+const getIntegrationLocalNames = (program, scopes) => {
+	const localBindings = /* @__PURE__ */ new Map();
+	const registerLocalName = (source, importedName, localIdentifier) => {
+		const integration = INTEGRATION_IMPORTS.get(source);
+		if (!integration) return;
+		if (integration.importedNames === null ? importedName === null || importedName === "default" : importedName !== null && integration.importedNames.has(importedName)) {
+			const symbol = scopes.symbolFor(localIdentifier);
+			if (symbol) localBindings.set(symbol, integration);
+		}
+	};
+	walkAst(program, (node) => {
+		if (isNodeOfType(node, "ImportDeclaration")) {
+			const source = node.source.value;
+			if (typeof source !== "string") return;
+			for (const specifier of node.specifiers) {
+				if (isNodeOfType(specifier, "ImportDefaultSpecifier") || isNodeOfType(specifier, "ImportNamespaceSpecifier")) {
+					registerLocalName(source, null, specifier.local);
+					continue;
+				}
+				registerLocalName(source, getImportedName(specifier) ?? null, specifier.local);
+			}
+			return;
+		}
+		if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return;
+		const initializer = node.init;
+		if (!isNodeOfType(initializer, "CallExpression") || !isNodeOfType(initializer.callee, "Identifier") || initializer.callee.name !== "require") return;
+		const sourceArgument = initializer.arguments[0];
+		if (!sourceArgument || !isNodeOfType(sourceArgument, "Literal")) return;
+		const source = sourceArgument.value;
+		if (typeof source !== "string") return;
+		if (isNodeOfType(node.id, "Identifier")) {
+			registerLocalName(source, null, node.id);
+			return;
+		}
+		if (!isNodeOfType(node.id, "ObjectPattern")) return;
+		for (const property of node.id.properties) {
+			if (!isNodeOfType(property, "Property") || !isNodeOfType(property.value, "Identifier")) continue;
+			registerLocalName(source, isNodeOfType(property.key, "Identifier") ? property.key.name : isNodeOfType(property.key, "Literal") && typeof property.key.value === "string" ? property.key.value : null, property.value);
+		}
+	});
+	return localBindings;
+};
+const isModuleExportsAssignment = (node) => isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && isNodeOfType(node.left.object, "Identifier") && node.left.object.name === "module" && isNodeOfType(node.left.property, "Identifier") && node.left.property.name === "exports";
+const getExportedBindings = (program, scopes) => {
+	const exportedBindings = /* @__PURE__ */ new Set();
+	walkAst(program, (node) => {
+		let exportRoot = null;
+		if (isNodeOfType(node, "ExportDefaultDeclaration")) exportRoot = node.declaration;
+		else if (isNodeOfType(node, "AssignmentExpression") && isModuleExportsAssignment(node)) exportRoot = node.right;
+		if (!exportRoot) return;
+		if (isFunctionLike$1(exportRoot) || isNodeOfType(exportRoot, "ObjectExpression")) return;
+		walkAst(exportRoot, (exportNode) => {
+			if (isFunctionLike$1(exportNode) || isNodeOfType(exportNode, "ObjectExpression")) return false;
+			if (!isNodeOfType(exportNode, "Identifier")) return;
+			const symbol = scopes.symbolFor(exportNode);
+			if (symbol) exportedBindings.add(symbol);
+		});
+	});
+	return exportedBindings;
+};
+const isExportedConfigProperty = (property, exportedBindings, scopes) => {
+	let ancestor = property.parent;
+	let didFindContainingObject = false;
+	let didCrossNestedProperty = false;
+	let didCrossFunctionBoundary = false;
+	let containingFunction = null;
+	let containingReturn = null;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "ObjectExpression") && !didFindContainingObject) didFindContainingObject = true;
+		else if (didFindContainingObject && isNodeOfType(ancestor, "Property")) didCrossNestedProperty = true;
+		if (!containingReturn && isNodeOfType(ancestor, "ReturnStatement")) containingReturn = ancestor;
+		if (isFunctionLike$1(ancestor)) if (containingFunction) didCrossFunctionBoundary = true;
+		else containingFunction = ancestor;
+		if (isNodeOfType(ancestor, "ExportDefaultDeclaration") || isModuleExportsAssignment(ancestor)) return !didCrossNestedProperty && !didCrossFunctionBoundary && (!containingFunction || Boolean(containingReturn) || !isNodeOfType(containingFunction.body, "BlockStatement"));
+		if (isNodeOfType(ancestor, "VariableDeclarator") && isNodeOfType(ancestor.id, "Identifier")) {
+			const binding = scopes.symbolFor(ancestor.id);
+			if (binding && exportedBindings.has(binding)) return !didCrossNestedProperty && !containingFunction;
+		}
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const getExplicitConfigPaths = (packageDirectory, manifest) => {
+	const configPaths = new Set(FAST_REFRESH_CONFIG_FILENAMES.map((configFilename) => path.join(packageDirectory, configFilename)));
+	for (const script of Object.values(manifest.scripts ?? {})) {
+		if (typeof script !== "string") continue;
+		for (const match of script.matchAll(/(?:^|\s)--config(?:=|\s+)(?:"([^"]+)"|'([^']+)'|([^\s;&|]+))/g)) {
+			const relativeConfigPath = match[1] ?? match[2] ?? match[3];
+			if (!relativeConfigPath) continue;
+			const configPath = path.resolve(packageDirectory, relativeConfigPath);
+			const relativePath = path.relative(packageDirectory, configPath);
+			if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) continue;
+			configPaths.add(configPath);
+		}
+	}
+	return [...configPaths];
+};
+const getRegisteredIntegration = (packageDirectory, manifest) => {
+	for (const configPath of getExplicitConfigPaths(packageDirectory, manifest)) {
+		const program = parseSourceFile(configPath);
+		if (!program) continue;
+		const scopes = analyzeScopes(program);
+		const integrationLocalBindings = getIntegrationLocalNames(program, scopes);
+		if (integrationLocalBindings.size === 0) continue;
+		const exportedBindings = getExportedBindings(program, scopes);
+		const registeredIntegrations = [];
+		walkAst(program, (node) => {
+			if (!isNodeOfType(node, "Property")) return;
+			if (!(isNodeOfType(node.key, "Identifier") && node.key.name === "plugins" || isNodeOfType(node.key, "Literal") && node.key.value === "plugins")) return;
+			if (!isExportedConfigProperty(node, exportedBindings, scopes)) return;
+			const inspectedBindings = /* @__PURE__ */ new Set();
+			const inspectValue = (value) => {
+				walkAst(value, (valueNode) => {
+					if (isNodeOfType(valueNode, "Identifier")) {
+						const symbol = scopes.symbolFor(valueNode);
+						const initializer = symbol ? getDirectUnreassignedInitializer(symbol) : null;
+						if (symbol && initializer && !inspectedBindings.has(symbol.id)) {
+							inspectedBindings.add(symbol.id);
+							inspectValue(initializer);
+						}
+					}
+					if (!isNodeOfType(valueNode, "CallExpression") && !isNodeOfType(valueNode, "NewExpression")) return;
+					if (!isNodeOfType(valueNode.callee, "Identifier")) return;
+					const symbol = scopes.symbolFor(valueNode.callee);
+					const integration = symbol ? integrationLocalBindings.get(symbol) : null;
+					if (integration) registeredIntegrations.push(integration);
+				});
+			};
+			inspectValue(node.value);
+			return false;
+		});
+		const hasViteDevelopmentRuntime = hasViteDevelopmentCommand(manifest) || hasViteBrowserEntry(manifest, packageDirectory);
+		const registeredIntegration = REGISTERED_INTEGRATION_RUNTIME_PRECEDENCE.flatMap((runtime) => registeredIntegrations.filter((integration) => integration.runtime === runtime && (!integration.requiresViteDevelopmentServer || hasViteDevelopmentRuntime)))[0];
+		if (registeredIntegration) return {
+			isActive: true,
+			runtime: registeredIntegration.runtime
+		};
+	}
+	return null;
+};
+const hasStorybookReactViteConfig = (packageDirectory) => {
+	for (const configFilename of [
+		"main.ts",
+		"main.js",
+		"main.mjs",
+		"main.cjs"
+	]) {
+		const program = parseSourceFile(path.join(packageDirectory, ".storybook", configFilename));
+		if (!program) continue;
+		const scopes = analyzeScopes(program);
+		const exportedBindings = getExportedBindings(program, scopes);
+		let hasReactViteFramework = false;
+		walkAst(program, (node) => {
+			if (!isNodeOfType(node, "Property")) return;
+			if (!(isNodeOfType(node.key, "Identifier") && node.key.name === "framework" || isNodeOfType(node.key, "Literal") && node.key.value === "framework")) return;
+			if (!isExportedConfigProperty(node, exportedBindings, scopes)) return;
+			walkAst(node.value, (valueNode) => {
+				if (isNodeOfType(valueNode, "Literal") && valueNode.value === "@storybook/react-vite") {
+					hasReactViteFramework = true;
+					return false;
+				}
+			});
+			if (hasReactViteFramework) return false;
+		});
+		if (hasReactViteFramework) return true;
+	}
+	return false;
+};
+const resolveDirectUnreassignedValue = (value, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const unwrappedValue = stripParenExpression(value);
+	if (!isNodeOfType(unwrappedValue, "Identifier")) return unwrappedValue;
+	const symbol = scopes.symbolFor(unwrappedValue);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return unwrappedValue;
+	const initializer = getDirectUnreassignedInitializer(symbol);
+	if (!initializer) return unwrappedValue;
+	visitedSymbolIds.add(symbol.id);
+	return resolveDirectUnreassignedValue(initializer, scopes, visitedSymbolIds);
+};
+const isStaticPropertyNamed = (node, propertyName) => isNodeOfType(node, "Property") && (!node.computed && isNodeOfType(node.key, "Identifier") && node.key.name === propertyName || isNodeOfType(node.key, "Literal") && node.key.value === propertyName);
+const readLastStaticBooleanProperty = (value, propertyName, scopes) => {
+	const resolvedValue = resolveDirectUnreassignedValue(value, scopes);
+	if (!isNodeOfType(resolvedValue, "ObjectExpression")) return null;
+	let propertyValue = null;
+	for (const property of resolvedValue.properties) {
+		if (isNodeOfType(property, "SpreadElement")) {
+			propertyValue = null;
+			continue;
+		}
+		if (!isStaticPropertyNamed(property, propertyName) || !isNodeOfType(property, "Property")) continue;
+		propertyValue = readStaticBoolean(resolveDirectUnreassignedValue(property.value, scopes));
+	}
+	return propertyValue;
+};
+const isLastStaticPropertyInObject = (property, propertyName) => {
+	if (!isNodeOfType(property.parent, "ObjectExpression")) return false;
+	const propertyIndex = property.parent.properties.findIndex((objectProperty) => objectProperty === property);
+	return property.parent.properties.slice(propertyIndex + 1).every((laterProperty) => {
+		if (isNodeOfType(laterProperty, "SpreadElement")) return false;
+		return !isStaticPropertyNamed(laterProperty, propertyName);
+	});
+};
+const hasStorybookReactWebpackFastRefreshConfig = (packageDirectory) => {
+	for (const configFilename of [
+		"main.ts",
+		"main.js",
+		"main.mjs",
+		"main.cjs"
+	]) {
+		const program = parseSourceFile(path.join(packageDirectory, ".storybook", configFilename));
+		if (!program) continue;
+		const scopes = analyzeScopes(program);
+		const exportedBindings = getExportedBindings(program, scopes);
+		let hasFastRefresh = false;
+		walkAst(program, (node) => {
+			if (!isStaticPropertyNamed(node, "reactOptions") || !isNodeOfType(node, "Property")) return;
+			if (!isExportedConfigProperty(node, exportedBindings, scopes)) return;
+			if (!isLastStaticPropertyInObject(node, "reactOptions")) return;
+			if (readLastStaticBooleanProperty(node.value, "fastRefresh", scopes) === true) {
+				hasFastRefresh = true;
+				return false;
+			}
+		});
+		if (hasFastRefresh) return true;
+	}
+	return false;
+};
+const hasStorybookReactViteIntegration = (packageDirectory, manifest) => hasOwnedDevelopmentCommand(manifest, /(?:^|\s)(?:storybook\s+dev|start-storybook)(?:\s|$)/) && hasStorybookReactViteConfig(packageDirectory);
+const hasStorybookReactWebpackFastRefreshIntegration = (packageDirectory, manifest) => {
+	const developmentCommandPattern = /(?:^|\s)(?:storybook\s+dev|start-storybook)(?:\s|$)/;
+	if (!hasOwnedDevelopmentCommand(manifest, developmentCommandPattern)) return false;
+	return isVersionAtLeast(getOwnedDependencyVersion(manifest, "@storybook/react", developmentCommandPattern) ?? getOwnedDependencyVersion(manifest, "@storybook/react-webpack5", developmentCommandPattern), MINIMUM_FAST_REFRESH_VERSIONS.storybookReact) && hasStorybookReactWebpackFastRefreshConfig(packageDirectory);
+};
+const hasNxStorybookReactViteIntegration = (packageDirectory) => {
+	if (!hasStorybookReactViteConfig(packageDirectory)) return false;
+	try {
+		const project = JSON.parse(fs.readFileSync(path.join(packageDirectory, "project.json"), "utf8"));
+		if (typeof project !== "object" || project === null) return false;
+		const targets = Reflect.get(project, "targets");
+		if (typeof targets !== "object" || targets === null) return false;
+		return Object.keys(targets).some((targetName) => targetName === "storybook:serve:dev");
+	} catch {
+		return false;
+	}
+};
+const getLocalFastRefreshStatus = (packageDirectory, manifest) => {
+	const cachedStatus = cachedLocalStatusByManifest.get(manifest);
+	if (cachedStatus) return cachedStatus;
+	const status = getBuiltInStatus(manifest) ?? (hasStorybookReactViteIntegration(packageDirectory, manifest) || hasNxStorybookReactViteIntegration(packageDirectory) || hasStorybookReactWebpackFastRefreshIntegration(packageDirectory, manifest) ? {
+		isActive: true,
+		runtime: "generic"
+	} : null) ?? getRegisteredIntegration(packageDirectory, manifest) ?? INACTIVE_STATUS;
+	cachedLocalStatusByManifest.set(manifest, status);
+	return status;
+};
+const isWorkspaceRoot = (directory, manifest) => {
+	if (manifest?.workspaces !== void 0) return true;
+	return [
+		"pnpm-workspace.yaml",
+		"pnpm-workspace.yml",
+		"nx.json"
+	].some((filename) => fs.existsSync(path.join(directory, filename)));
+};
+const findWorkspaceRoot = (packageDirectory) => {
+	let currentDirectory = packageDirectory;
+	let workspaceRoot = null;
+	while (true) {
+		const manifest = readPackageManifest(currentDirectory);
+		if (isWorkspaceRoot(currentDirectory, manifest)) workspaceRoot = currentDirectory;
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) return workspaceRoot;
+		currentDirectory = parentDirectory;
+	}
+};
+const collectWorkspacePackages = (workspaceRoot) => {
+	const packages = [];
+	const pendingDirectories = [workspaceRoot];
+	while (pendingDirectories.length > 0) {
+		const directory = pendingDirectories.pop();
+		if (!directory) continue;
+		const manifest = readPackageManifest(directory);
+		if (manifest) packages.push({
+			directory,
+			manifest,
+			status: getLocalFastRefreshStatus(directory, manifest)
+		});
+		let entries;
+		try {
+			entries = fs.readdirSync(directory, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			if (entry.name.startsWith(".") || WORKSPACE_IGNORED_DIRECTORY_NAMES.has(entry.name)) continue;
+			pendingDirectories.push(path.join(directory, entry.name));
+		}
+	}
+	return packages;
+};
+const isPropertyNamed = (node, name) => isNodeOfType(node, "Property") && (isNodeOfType(node.key, "Identifier") && node.key.name === name || isNodeOfType(node.key, "Literal") && node.key.value === name);
+const normalizeAliasRoot = (configDirectory, aliasPath) => {
+	if (!aliasPath.startsWith(".") && !path.isAbsolute(aliasPath)) return null;
+	const withoutPlaceholder = aliasPath.replace(/(?:\/)?(?:\*|\$\d+).*$/, "");
+	return path.resolve(configDirectory, withoutPlaceholder);
+};
+const collectAliasRootsFromValue = (value, configDirectory, aliasRoots) => {
+	walkAst(value, (node) => {
+		if (!isPropertyNamed(node, "alias")) return;
+		if (!isNodeOfType(node, "Property")) return;
+		walkAst(node.value, (aliasNode) => {
+			if (!isNodeOfType(aliasNode, "Literal") || typeof aliasNode.value !== "string") return;
+			const aliasRoot = normalizeAliasRoot(configDirectory, aliasNode.value);
+			if (aliasRoot) aliasRoots.add(aliasRoot);
+		});
+		return false;
+	});
+};
+const getActivePackageAliasRoots = (packageDirectory, manifest) => {
+	const aliasRoots = /* @__PURE__ */ new Set();
+	const configPaths = [...getExplicitConfigPaths(packageDirectory, manifest), ...[
+		"main.ts",
+		"main.js",
+		"main.mjs",
+		"main.cjs"
+	].map((filename) => path.join(packageDirectory, ".storybook", filename))];
+	for (const configPath of configPaths) {
+		const program = parseSourceFile(configPath);
+		if (!program) continue;
+		const scopes = analyzeScopes(program);
+		const exportedBindings = getExportedBindings(program, scopes);
+		walkAst(program, (node) => {
+			if (!isPropertyNamed(node, "resolve") && !isPropertyNamed(node, "viteFinal")) return;
+			if (!isNodeOfType(node, "Property")) return;
+			if (!isExportedConfigProperty(node, exportedBindings, scopes)) return;
+			collectAliasRootsFromValue(node.value, path.dirname(configPath), aliasRoots);
+			return false;
+		});
+	}
+	return aliasRoots;
+};
+const collectStringValues = (value, values) => {
+	if (typeof value === "string") {
+		values.push(value);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const entry of value) collectStringValues(entry, values);
+		return;
+	}
+	if (typeof value !== "object" || value === null) return;
+	for (const entry of Object.values(value)) collectStringValues(entry, values);
+};
+const hasSourceRuntimeEntry = (manifest) => {
+	const entryValues = [];
+	collectStringValues(manifest.exports, entryValues);
+	collectStringValues(manifest.main, entryValues);
+	collectStringValues(manifest.module, entryValues);
+	return entryValues.some((entry) => /^\.\/?src(?:\/|\.|$)/.test(entry));
+};
+const getWorkspaceDependencyVersion = (manifest, dependencyName) => manifest.dependencies?.[dependencyName] ?? manifest.optionalDependencies?.[dependencyName];
+const buildWorkspaceFastRefreshIndex = (workspaceRoot, rootManifest) => {
+	const cached = cachedWorkspaceIndexByManifest.get(rootManifest);
+	if (cached) return cached;
+	const workspacePackages = collectWorkspacePackages(workspaceRoot);
+	const activePackages = workspacePackages.filter((workspacePackage) => workspacePackage.status.isActive);
+	const aliasOwners = [];
+	for (const activePackage of activePackages) for (const rootDirectory of getActivePackageAliasRoots(activePackage.directory, activePackage.manifest)) aliasOwners.push({
+		rootDirectory,
+		status: activePackage.status
+	});
+	const sourceEntryOwners = /* @__PURE__ */ new Map();
+	for (const producerPackage of workspacePackages) {
+		const packageName = producerPackage.manifest.name;
+		if (typeof packageName !== "string" || !hasSourceRuntimeEntry(producerPackage.manifest)) continue;
+		const owner = activePackages.find((activePackage) => {
+			const dependencyVersion = getWorkspaceDependencyVersion(activePackage.manifest, packageName);
+			return typeof dependencyVersion === "string" && dependencyVersion.startsWith("workspace:");
+		});
+		if (owner) sourceEntryOwners.set(producerPackage.directory, owner.status);
+	}
+	const index = {
+		aliasOwners,
+		sourceEntryOwners
+	};
+	cachedWorkspaceIndexByManifest.set(rootManifest, index);
+	return index;
+};
+const isPathInside = (filePath, directory) => {
+	const relativePath = path.relative(directory, filePath);
+	return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
+};
+const getWorkspaceOwnedStatus = (filename, packageDirectory) => {
+	const workspaceRoot = findWorkspaceRoot(packageDirectory);
+	if (!workspaceRoot) return null;
+	const rootManifest = readPackageManifest(workspaceRoot);
+	if (!rootManifest) return null;
+	const index = buildWorkspaceFastRefreshIndex(workspaceRoot, rootManifest);
+	const aliasOwner = index.aliasOwners.find((owner) => isPathInside(filename, owner.rootDirectory));
+	if (aliasOwner) return aliasOwner.status;
+	for (const [producerDirectory, status] of index.sourceEntryOwners) if (isPathInside(filename, producerDirectory)) return status;
+	return null;
+};
+const resolveFastRefreshFileStatus = (filename) => {
+	const manifest = readNearestPackageManifest(filename);
+	if (!manifest) return INACTIVE_STATUS;
+	const packageDirectory = findNearestPackageDirectory(filename);
+	if (!packageDirectory) return INACTIVE_STATUS;
+	const localStatus = getLocalFastRefreshStatus(packageDirectory, manifest);
+	if (localStatus.isActive) return localStatus;
+	return getWorkspaceOwnedStatus(filename, packageDirectory) ?? INACTIVE_STATUS;
+};
+const getConfiguredFallbackStatus = (context) => {
+	const framework = getReactDoctorStringSetting(context.settings, "framework");
+	return {
+		isActive: true,
+		runtime: framework === "nextjs" ? "next" : framework === "expo" || framework === "react-native" ? "expo" : framework === "remix" ? "remix" : framework === "tanstack-start" ? "tanstack" : "generic"
+	};
+};
+const getFastRefreshFileStatus = (context) => {
+	let filename = context.filename;
+	if (!filename) return getConfiguredFallbackStatus(context);
+	if (!path.isAbsolute(filename)) {
+		const absoluteFilename = path.resolve(filename);
+		if (!fs.existsSync(absoluteFilename)) return getConfiguredFallbackStatus(context);
+		filename = absoluteFilename;
+	}
+	if (!readNearestPackageManifest(filename)) return INACTIVE_STATUS;
+	return resolveFastRefreshFileStatus(filename);
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/only-export-components-tables.ts
@@ -45768,6 +47689,7 @@ const NOT_REACT_COMPONENT_EXPRESSION_TYPES = new Set([
 	"ConditionalExpression",
 	"Literal",
 	"LogicalExpression",
+	"NewExpression",
 	"ObjectExpression",
 	"TemplateLiteral",
 	"ThisExpression",
@@ -45786,124 +47708,25 @@ const NON_FAST_REFRESH_PATH_SEGMENTS = [
 	"/cypress/",
 	"/.storybook/",
 	"/stories/",
-	"/__stories__/",
-	"/playground/",
-	"/playgrounds/",
-	"/examples/",
-	"/example/",
-	"/demo/",
-	"/demos/",
-	"/sandbox/",
-	"/sandboxes/"
+	"/__stories__/"
 ];
-const ENTRY_POINT_BASENAMES = new Set([
-	"main.tsx",
-	"main.jsx",
-	"main.js",
-	"index.tsx",
-	"index.jsx",
-	"entry.tsx",
-	"entry.jsx",
-	"bootstrap.tsx",
-	"bootstrap.jsx",
-	"client.tsx",
-	"client.jsx",
-	"server.tsx",
-	"server.jsx",
-	"app.tsx",
-	"app.jsx",
-	"App.tsx",
-	"App.jsx"
-]);
-const UTILITY_FILE_BASENAMES = new Set([
-	"utils.tsx",
-	"utils.jsx",
-	"util.tsx",
-	"util.jsx",
-	"helpers.tsx",
-	"helpers.jsx",
-	"helper.tsx",
-	"helper.jsx",
-	"shared.tsx",
-	"shared.jsx",
-	"common.tsx",
-	"common.jsx",
-	"lib.tsx",
-	"lib.jsx",
-	"nodeTypes.tsx",
-	"nodeTypes.jsx",
-	"node-types.tsx",
-	"node-types.jsx",
-	"edgeTypes.tsx",
-	"edgeTypes.jsx",
-	"edge-types.tsx",
-	"edge-types.jsx",
-	"cellTypes.tsx",
-	"cellTypes.jsx",
-	"columnTypes.tsx",
-	"columnTypes.jsx",
-	"columnDefs.tsx",
-	"columnDefs.jsx",
-	"columnRenderers.tsx",
-	"columnRenderers.jsx",
-	"columns.tsx",
-	"columns.jsx",
-	"mappings.tsx",
-	"mappings.jsx",
-	"mapping.tsx",
-	"mapping.jsx",
-	"lookups.tsx",
-	"lookups.jsx",
-	"lookup.tsx",
-	"lookup.jsx",
-	"registry.tsx",
-	"registry.jsx",
-	"toast.tsx",
-	"toast.jsx",
-	"toaster.tsx",
-	"toaster.jsx",
-	"theme.tsx",
-	"theme.jsx",
-	"tokens.tsx",
-	"tokens.jsx",
-	"palette.tsx",
-	"palette.jsx",
-	"colors.tsx",
-	"colors.jsx",
-	"colours.tsx",
-	"colours.jsx",
-	"constants.tsx",
-	"constants.jsx",
-	"enums.tsx",
-	"enums.jsx",
-	"types.tsx",
-	"types.jsx",
-	"schemas.tsx",
-	"schemas.jsx",
-	"schema.tsx",
-	"schema.jsx",
-	"definitions.tsx",
-	"definitions.jsx",
-	"config.tsx",
-	"config.jsx",
-	"defaults.tsx",
-	"defaults.jsx"
-]);
-const ROUTE_FACTORY_CALLEE_NAMES = new Set([
+const TANSTACK_ROUTE_FACTORY_CALLEE_NAMES = new Set([
 	...TANSTACK_ROUTE_CREATION_FUNCTIONS,
 	"createLazyFileRoute",
 	"createLazyRoute",
 	"createAPIFileRoute",
 	"createServerFileRoute",
 	"createServerRootRoute",
-	"createServerRoute",
+	"createServerRoute"
+]);
+const REACT_ROUTER_FACTORY_CALLEE_NAMES = new Set([
 	"createBrowserRouter",
 	"createHashRouter",
 	"createMemoryRouter",
 	"createStaticRouter",
 	"createRouter"
 ]);
-const ROUTE_MODULE_ALLOWED_EXPORT_NAMES = new Set([
+const REACT_ROUTER_ALLOWED_EXPORT_NAMES = new Set([
 	"loader",
 	"clientLoader",
 	"action",
@@ -45914,7 +47737,9 @@ const ROUTE_MODULE_ALLOWED_EXPORT_NAMES = new Set([
 	"handle",
 	"shouldRevalidate",
 	"middleware",
-	"unstable_middleware",
+	"unstable_middleware"
+]);
+const NEXT_ALLOWED_EXPORT_NAMES = new Set([
 	"getServerSideProps",
 	"getStaticProps",
 	"getStaticPaths",
@@ -45934,9 +47759,9 @@ const ROUTE_MODULE_ALLOWED_EXPORT_NAMES = new Set([
 	"runtime",
 	"preferredRegion",
 	"maxDuration",
-	"experimental_ppr",
-	"unstable_settings"
+	"experimental_ppr"
 ]);
+const EXPO_ALLOWED_EXPORT_NAMES = new Set(["unstable_settings"]);
 //#endregion
 //#region src/plugin/rules/react-builtins/only-export-components.ts
 const NAMED_EXPORT_MESSAGE = "This file exports non-components, so Fast Refresh can't safely preserve component state.";
@@ -45949,6 +47774,8 @@ const DEFAULT_REACT_HOCS = [
 	"forwardRef",
 	"lazy"
 ];
+const EMPTY_NAME_SET = /* @__PURE__ */ new Set();
+const TEST_SUPPORT_FILE_PATTERN = /(?:^|\/)(?:test|spec)(?:[-_.]?(?:utils?|helpers?|setup|fixtures?))?\.(?:jsx?|tsx?)$/i;
 const resolveSettings$6 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.onlyExportComponents ?? {} : {};
@@ -45972,13 +47799,12 @@ const isReactCreateContext = (initializer) => {
 	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "createContext") return true;
 	return false;
 };
-const isRouteFactoryName = (name) => ROUTE_FACTORY_CALLEE_NAMES.has(name);
-const isRouteFactoryCall = (expression) => {
+const isRouteFactoryCall = (expression, bindings) => {
 	let currentCall = expression;
 	while (isNodeOfType(currentCall, "CallExpression")) {
 		const callee = currentCall.callee;
-		if (isNodeOfType(callee, "Identifier") && isRouteFactoryName(callee.name)) return true;
-		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && isRouteFactoryName(callee.property.name)) return true;
+		if (isNodeOfType(callee, "Identifier") && bindings.localNames.has(callee.name)) return true;
+		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && bindings.namespaceNames.has(callee.object.name) && isNodeOfType(callee.property, "Identifier") && bindings.memberNames.has(callee.property.name)) return true;
 		if (!isNodeOfType(callee, "CallExpression")) return false;
 		currentCall = callee;
 	}
@@ -46006,10 +47832,11 @@ const isHocCallee = (callee, state) => {
 const canBeReactFunctionComponent = (initializer, state) => {
 	if (!initializer) return false;
 	const expression = skipTsExpression(initializer);
-	if (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression")) return true;
+	if (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression")) return functionHasReactRenderSemantics(expression, state);
 	if (isNodeOfType(expression, "CallExpression")) return isHocCallee(expression.callee, state);
 	return false;
 };
+const functionHasReactRenderSemantics = (functionNode, state) => functionContainsReactRenderOutput(functionNode, state.scopes, state.controlFlow) || functionHasReactElementReturnType(functionNode) || functionReturnsOnlyNull(functionNode);
 const isReactComponentInitializer = (expression, state) => {
 	const stripped = skipTsExpression(expression);
 	if (isNodeOfType(stripped, "ArrowFunctionExpression")) return true;
@@ -46018,6 +47845,60 @@ const isReactComponentInitializer = (expression, state) => {
 	if (isNodeOfType(stripped, "CallExpression") && isHocCallee(stripped.callee, state) && stripped.arguments.length > 0) return true;
 	return false;
 };
+const isNextDynamicCall = (expression, nextDynamicImportSymbolIds, scopes) => {
+	const stripped = skipTsExpression(expression);
+	if (!isNodeOfType(stripped, "CallExpression")) return false;
+	const callee = skipTsExpression(stripped.callee);
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	const symbol = scopes.symbolFor(callee);
+	return symbol !== null && nextDynamicImportSymbolIds.has(symbol.id);
+};
+const functionReturnsNextDynamicComponent = (expression, nextDynamicImportSymbolIds, scopes) => {
+	const stripped = skipTsExpression(expression);
+	if (!isNodeOfType(stripped, "ArrowFunctionExpression") && !isNodeOfType(stripped, "FunctionExpression") && !isNodeOfType(stripped, "FunctionDeclaration")) return false;
+	const body = stripped.body;
+	if (!isNodeOfType(body, "BlockStatement")) return isNextDynamicCall(body, nextDynamicImportSymbolIds, scopes);
+	if (body.body.length !== 1) return false;
+	const statement = body.body[0];
+	return Boolean(statement) && isNodeOfType(statement, "ReturnStatement") && Boolean(statement.argument) && isNextDynamicCall(statement.argument, nextDynamicImportSymbolIds, scopes);
+};
+const isComponentFactoryCall = (expression, state) => {
+	const stripped = skipTsExpression(expression);
+	if (!isNodeOfType(stripped, "CallExpression")) return false;
+	const callee = skipTsExpression(stripped.callee);
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	const symbol = state.scopes.symbolFor(callee);
+	return symbol !== null && state.componentFactorySymbolIds.has(symbol.id);
+};
+const isProvenComponentValue = (expression, state, inspectedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const stripped = skipTsExpression(expression);
+	if (isNodeOfType(stripped, "Identifier")) {
+		const symbol = state.scopes.symbolFor(stripped);
+		if (!symbol) return false;
+		if (state.localComponentNames.has(stripped.name)) return symbol.references.every((reference) => reference.flag === "read");
+		if (isReactComponentName(stripped.name) && symbol.kind === "import") return true;
+		if (inspectedSymbolIds.has(symbol.id)) return false;
+		const initializer = getDirectUnreassignedInitializer(symbol);
+		if (!initializer) return false;
+		const strippedInitializer = skipTsExpression(initializer);
+		if (isNodeOfType(strippedInitializer, "ArrowFunctionExpression") || isNodeOfType(strippedInitializer, "FunctionExpression")) return false;
+		return isProvenComponentValue(initializer, state, new Set([...inspectedSymbolIds, symbol.id]));
+	}
+	if (isNodeOfType(stripped, "MemberExpression") && !stripped.computed && isNodeOfType(stripped.object, "Identifier") && isNodeOfType(stripped.property, "Identifier") && isReactComponentName(stripped.property.name)) {
+		const objectSymbol = state.scopes.symbolFor(stripped.object);
+		return objectSymbol !== null && state.importSymbolIds.has(objectSymbol.id);
+	}
+	if (isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "FunctionExpression")) return functionHasReactRenderSemantics(stripped, state);
+	if (!isNodeOfType(stripped, "CallExpression")) return false;
+	if (!isHocCallee(stripped.callee, state)) return false;
+	return stripped.arguments.some((argument) => isProvenComponentValue(argument, state));
+};
+const isDirectRefreshWrapperCall = (call, state) => {
+	const callee = skipTsExpression(call.callee);
+	if (isHocCallee(callee, state)) return call.arguments.length > 0;
+	if (!isNodeOfType(callee, "Identifier") && !isNodeOfType(callee, "MemberExpression")) return false;
+	return call.arguments.some((argument) => isProvenComponentValue(argument, state));
+};
 const objectExpressionBundlesComponents = (objectExpression, state) => {
 	for (const property of objectExpression.properties ?? []) {
 		if (!isNodeOfType(property, "Property")) continue;
@@ -46027,20 +47908,22 @@ const objectExpressionBundlesComponents = (objectExpression, state) => {
 			continue;
 		}
 		if (!(!property.computed && isNodeOfType(property.key, "Identifier") && isReactComponentName(property.key.name))) continue;
-		if ((isNodeOfType(value, "ArrowFunctionExpression") || isNodeOfType(value, "FunctionExpression")) && functionContainsReactRenderOutput(value, state.scopes, state.controlFlow)) return true;
+		if ((isNodeOfType(value, "ArrowFunctionExpression") || isNodeOfType(value, "FunctionExpression")) && functionHasReactRenderSemantics(value, state)) return true;
 		if (isNodeOfType(value, "CallExpression") && isHocCallee(value.callee, state) && value.arguments.length > 0) return true;
 	}
 	return false;
 };
 const classifyExport = (name, reportNode, isFunction, initializer, state) => {
+	if (isNodeOfType(reportNode, "Identifier") && isProvenComponentValue(reportNode, state)) return { kind: "react-component" };
 	if (initializer) {
 		const expression = skipTsExpression(initializer);
-		if (isRouteFactoryCall(expression)) return { kind: "react-component" };
+		if (isNodeOfType(expression, "CallExpression") && isReactComponentName(name) && isComponentFactoryCall(expression, state)) return { kind: "react-component" };
+		if (isRouteFactoryCall(expression, state.routeFactoryBindings)) return { kind: "react-component" };
 		if (isNodeOfType(expression, "CallExpression") && isHocCallee(expression.callee, state) && expression.arguments.length > 0 && isReactComponentName(name)) return { kind: "react-component" };
 		if (isNodeOfType(expression, "ConditionalExpression") && isReactComponentName(name) && isReactComponentInitializer(expression.consequent, state) && isReactComponentInitializer(expression.alternate, state)) return { kind: "react-component" };
 	}
 	if (state.allowExportNames.has(name)) return { kind: "allowed" };
-	if (ROUTE_MODULE_ALLOWED_EXPORT_NAMES.has(name)) return { kind: "allowed" };
+	if (state.allowedRouteExportNames.has(name)) return { kind: "allowed" };
 	if (/^use[A-Z]/.test(name)) return { kind: "allowed" };
 	if (state.allowConstantExport && initializer) {
 		const expression = skipTsExpression(initializer);
@@ -46066,42 +47949,33 @@ const classifyExport = (name, reportNode, isFunction, initializer, state) => {
 			kind: "namespace-object",
 			reportNode
 		};
+		if (isNodeOfType(stripped, "MemberExpression")) return isProvenComponentValue(stripped, state) ? { kind: "react-component" } : {
+			kind: "non-component",
+			reportNode
+		};
+		if (isNodeOfType(stripped, "Identifier")) return isProvenComponentValue(stripped, state) ? { kind: "react-component" } : {
+			kind: "non-component",
+			reportNode
+		};
 		if (NOT_REACT_COMPONENT_EXPRESSION_TYPES.has(stripped.type)) return {
 			kind: "non-component",
 			reportNode
 		};
+		if (isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "FunctionExpression")) return {
+			kind: "non-component",
+			reportNode
+		};
 	}
 	return isReactComponentName(name) ? { kind: "react-component" } : {
 		kind: "non-component",
 		reportNode
 	};
 };
-const isEntryPointFile = (filename) => {
-	const lastSlash = Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\"));
-	const basename = lastSlash === -1 ? filename : filename.slice(lastSlash + 1);
-	return ENTRY_POINT_BASENAMES.has(basename);
-};
-const ASSET_FILE_BASENAME_PATTERN = /^([A-Za-z][\w-]*[-._])?(icons?|svgs?|svg[-_]?sprites?|sprites?|emojis?|flags?|logos?|lockups?|illustrations?|glyphs?|stickers?|emotes?|avatars?|backgrounds?|patterns?|assets?|gradients?|countryVectors?|paymentVectors?|brandVectors?|brandLogos?)\.(t|j)sx?$/;
-const UTILITY_BASENAME_SUFFIX_PATTERN = /^[A-Za-z][\w-]*(Utils|Util|Helpers|Helper|Shared|Constants|Constant|Types|Type|Mappings|Mapping|Lookups|Lookup|Registry|Renderers|Renderer|NodeTypes|EdgeTypes|CellTypes|ColumnDefs|ColumnTypes|ColumnRenderers|Schemas|Schema|Definitions|Definition|Config|Configuration|Defaults|Default|Tokens|Palette|Context|Provider|Providers|Logic|Scene|Page|Layout)\.(t|j)sx?$/;
-const HOOK_FILE_BASENAME_PATTERN = /^use[A-Z][\w-]*\.(t|j)sx?$/;
-const NODE_DEFINITION_BASENAME_PATTERN = /^[A-Z][\w-]*(NodeUtil|ShapeUtil|EdgeUtil|BindingUtil|InlineNode|BlockNode|NotebookNode)\.(t|j)sx?$/;
-const isAssetOrUtilityFile = (filename) => {
-	const lastSlash = Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\"));
-	const basename = lastSlash === -1 ? filename : filename.slice(lastSlash + 1);
-	if (ASSET_FILE_BASENAME_PATTERN.test(basename)) return true;
-	if (UTILITY_FILE_BASENAMES.has(basename)) return true;
-	if (UTILITY_BASENAME_SUFFIX_PATTERN.test(basename)) return true;
-	if (HOOK_FILE_BASENAME_PATTERN.test(basename)) return true;
-	if (NODE_DEFINITION_BASENAME_PATTERN.test(basename)) return true;
-	return false;
-};
 const isFileNameAllowed = (filename, checkJS) => {
 	if (!filename) return true;
+	if (TEST_SUPPORT_FILE_PATTERN.test(filename)) return false;
 	if (filename.includes(".test.") || filename.includes(".spec.") || filename.includes(".cy.") || filename.includes(".stories.")) return false;
 	for (const segment of NON_FAST_REFRESH_PATH_SEGMENTS) if (filename.includes(segment)) return false;
-	if (isEntryPointFile(filename)) return false;
-	if (isFrameworkRouteOrSpecialFilename(filename)) return false;
-	if (isAssetOrUtilityFile(filename)) return false;
 	if (filename.endsWith(".tsx") || filename.endsWith(".jsx")) return true;
 	if (checkJS && filename.endsWith(".js")) return true;
 	return false;
@@ -46114,16 +47988,100 @@ const onlyExportComponents = defineRule({
 	category: "Architecture",
 	create: (context) => {
 		const settings = resolveSettings$6(context.settings);
-		if (!isFileNameAllowed(normalizeFilename(context.filename ?? ""), settings.checkJS)) return {};
+		const filename = normalizeFilename(context.filename ?? "");
+		const fastRefreshStatus = getFastRefreshFileStatus(context);
+		if (!fastRefreshStatus.isActive) return {};
+		if (isFrameworkRouteOrSpecialFilename(context, fastRefreshStatus.runtime)) return {};
+		if (!isFileNameAllowed(filename, settings.checkJS)) return {};
+		const allowedRouteExportNames = fastRefreshStatus.runtime === "next" ? NEXT_ALLOWED_EXPORT_NAMES : fastRefreshStatus.runtime === "expo" ? EXPO_ALLOWED_EXPORT_NAMES : fastRefreshStatus.runtime === "react-router" || fastRefreshStatus.runtime === "remix" ? REACT_ROUTER_ALLOWED_EXPORT_NAMES : EMPTY_NAME_SET;
+		const routeFactoryMemberNames = fastRefreshStatus.runtime === "tanstack" ? TANSTACK_ROUTE_FACTORY_CALLEE_NAMES : fastRefreshStatus.runtime === "react-router" || fastRefreshStatus.runtime === "remix" ? REACT_ROUTER_FACTORY_CALLEE_NAMES : EMPTY_NAME_SET;
+		const routeFactoryLocalNames = /* @__PURE__ */ new Set();
+		const routeFactoryNamespaceNames = /* @__PURE__ */ new Set();
+		const nextDynamicImportSymbolIds = /* @__PURE__ */ new Set();
+		const importSymbolIds = /* @__PURE__ */ new Set();
+		const routeFactoryBindings = {
+			localNames: routeFactoryLocalNames,
+			memberNames: routeFactoryMemberNames,
+			namespaceNames: routeFactoryNamespaceNames
+		};
 		const exportNodes = [];
 		const componentCandidates = [];
+		const createRootNames = /* @__PURE__ */ new Set();
+		const hydrateRootNames = /* @__PURE__ */ new Set();
+		const legacyRenderNames = /* @__PURE__ */ new Set();
+		const reactDomNamespaceNames = /* @__PURE__ */ new Set();
+		const rootNames = /* @__PURE__ */ new Set();
+		let hasRootMount = false;
+		const isCreateRootCall = (node) => {
+			if (!isNodeOfType(node, "CallExpression")) return false;
+			if (isNodeOfType(node.callee, "Identifier")) return createRootNames.has(node.callee.name);
+			return isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.object, "Identifier") && reactDomNamespaceNames.has(node.callee.object.name) && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "createRoot";
+		};
+		const visitImportDeclaration = (node) => {
+			if (!isNodeOfType(node, "ImportDeclaration")) return;
+			const source = node.source.value;
+			for (const specifier of node.specifiers) {
+				const symbol = context.scopes.symbolFor(specifier.local);
+				if (symbol) importSymbolIds.add(symbol.id);
+			}
+			if (typeof source === "string" && (fastRefreshStatus.runtime === "tanstack" && (source.startsWith("@tanstack/react-router") || source.startsWith("@tanstack/react-start")) || (fastRefreshStatus.runtime === "react-router" || fastRefreshStatus.runtime === "remix") && (source === "react-router" || source === "react-router-dom" || source === "@remix-run/react"))) for (const specifier of node.specifiers) {
+				if (isNodeOfType(specifier, "ImportNamespaceSpecifier")) {
+					routeFactoryNamespaceNames.add(specifier.local.name);
+					continue;
+				}
+				const importedName = getImportedName(specifier);
+				if (importedName && routeFactoryMemberNames.has(importedName)) routeFactoryLocalNames.add(specifier.local.name);
+			}
+			if (source === "next/dynamic") for (const specifier of node.specifiers) {
+				if (!isNodeOfType(specifier, "ImportDefaultSpecifier")) continue;
+				const symbol = context.scopes.symbolFor(specifier.local);
+				if (symbol) nextDynamicImportSymbolIds.add(symbol.id);
+			}
+			if (source !== "react-dom" && source !== "react-dom/client") return;
+			for (const specifier of node.specifiers) {
+				if (isNodeOfType(specifier, "ImportDefaultSpecifier") || isNodeOfType(specifier, "ImportNamespaceSpecifier")) {
+					reactDomNamespaceNames.add(specifier.local.name);
+					continue;
+				}
+				const importedName = getImportedName(specifier);
+				if (importedName === "createRoot") createRootNames.add(specifier.local.name);
+				if (importedName === "hydrateRoot") hydrateRootNames.add(specifier.local.name);
+				if (source === "react-dom" && (importedName === "render" || importedName === "hydrate")) legacyRenderNames.add(specifier.local.name);
+			}
+		};
+		const visitCallExpression = (node) => {
+			if (!isNodeOfType(node, "CallExpression")) return;
+			if (isInsideFunctionScope(node)) return;
+			if (isNodeOfType(node.callee, "Identifier")) {
+				if (hydrateRootNames.has(node.callee.name) || legacyRenderNames.has(node.callee.name)) hasRootMount = true;
+				return;
+			}
+			if (!isNodeOfType(node.callee, "MemberExpression") || !isNodeOfType(node.callee.property, "Identifier")) return;
+			const methodName = node.callee.property.name;
+			if (isNodeOfType(node.callee.object, "Identifier") && reactDomNamespaceNames.has(node.callee.object.name) && (methodName === "render" || methodName === "hydrate" || methodName === "hydrateRoot")) {
+				hasRootMount = true;
+				return;
+			}
+			if (methodName !== "render") return;
+			if (isCreateRootCall(node.callee.object)) {
+				hasRootMount = true;
+				return;
+			}
+			if (isNodeOfType(node.callee.object, "Identifier") && rootNames.has(node.callee.object.name)) hasRootMount = true;
+		};
 		const pushExportNode = (node) => {
 			exportNodes.push(node);
 		};
 		const pushComponentCandidate = (node) => {
 			componentCandidates.push(node);
+			if (isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && node.init && isCreateRootCall(node.init) && !isInsideFunctionScope(node)) rootNames.add(node.id.name);
 		};
 		return {
+			ImportDeclaration: visitImportDeclaration,
+			CallExpression: visitCallExpression,
+			AssignmentExpression(node) {
+				if (isNodeOfType(node.left, "Identifier") && rootNames.has(node.left.name)) rootNames.delete(node.left.name);
+			},
 			ExportAllDeclaration: pushExportNode,
 			ExportDefaultDeclaration: pushExportNode,
 			ExportNamedDeclaration: pushExportNode,
@@ -46131,31 +48089,53 @@ const onlyExportComponents = defineRule({
 			VariableDeclarator: pushComponentCandidate,
 			ClassDeclaration: pushComponentCandidate,
 			"Program:exit"() {
+				if (hasRootMount) return;
 				const localComponentNames = /* @__PURE__ */ new Set();
+				const componentFactorySymbolIds = /* @__PURE__ */ new Set();
+				for (const child of componentCandidates) {
+					if (isInsideFunctionScope(child)) continue;
+					if (isNodeOfType(child, "FunctionDeclaration") && child.id) {
+						if (functionReturnsNextDynamicComponent(child, nextDynamicImportSymbolIds, context.scopes)) {
+							const symbol = context.scopes.symbolFor(child.id);
+							if (symbol?.references.every((reference) => reference.flag === "read")) componentFactorySymbolIds.add(symbol.id);
+						}
+						continue;
+					}
+					if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier") && child.init && functionReturnsNextDynamicComponent(child.init, nextDynamicImportSymbolIds, context.scopes)) {
+						const symbol = context.scopes.symbolFor(child.id);
+						if (symbol?.references.every((reference) => reference.flag === "read")) componentFactorySymbolIds.add(symbol.id);
+					}
+				}
 				const state = {
 					customHocs: new Set([...DEFAULT_REACT_HOCS, ...settings.customHOCs]),
 					allowExportNames: new Set(settings.allowExportNames),
 					allowConstantExport: settings.allowConstantExport,
+					allowedRouteExportNames,
+					routeFactoryBindings,
+					componentFactorySymbolIds,
+					importSymbolIds,
 					localComponentNames,
 					scopes: context.scopes,
 					controlFlow: context.cfg
 				};
 				for (const child of componentCandidates) {
 					if (isNodeOfType(child, "FunctionDeclaration") && child.id) {
-						if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child) && functionContainsReactRenderOutput(child, context.scopes, context.cfg)) localComponentNames.add(child.id.name);
+						if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child) && functionHasReactRenderSemantics(child, state)) localComponentNames.add(child.id.name);
 					}
 					if (isNodeOfType(child, "ClassDeclaration") && child.id) {
 						if (isReactComponentName(child.id.name) && isEs6Component(child) && !isInsideFunctionScope(child)) localComponentNames.add(child.id.name);
 					}
 					if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
 						const initializer = child.init;
-						if (isReactComponentName(child.id.name) && (canBeReactFunctionComponent(initializer, state) || (initializer ? isEs6Component(skipTsExpression(initializer)) : false)) && !isInsideFunctionScope(child)) {
-							const expression = initializer ? skipTsExpression(initializer) : null;
-							if (!(expression !== null && (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression"))) || functionContainsReactRenderOutput(expression, context.scopes, context.cfg)) localComponentNames.add(child.id.name);
+						const expression = initializer ? skipTsExpression(initializer) : null;
+						const isDirectFunction = expression !== null && (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression"));
+						if (isReactComponentName(child.id.name) && (canBeReactFunctionComponent(initializer, state) || (expression ? isEs6Component(expression) : false)) && !isInsideFunctionScope(child)) {
+							if (!isDirectFunction || functionHasReactRenderSemantics(expression, state)) localComponentNames.add(child.id.name);
 						}
 					}
 				}
 				const exports = [];
+				const exportAllNodes = [];
 				let hasReactExport = false;
 				let hasAnyExports = false;
 				const isExportedNodeIds = /* @__PURE__ */ new WeakSet();
@@ -46163,10 +48143,8 @@ const onlyExportComponents = defineRule({
 					if (isNodeOfType(child, "ExportAllDeclaration")) {
 						if (child.exportKind === "type") continue;
 						hasAnyExports = true;
-						context.report({
-							node: child,
-							message: EXPORT_ALL_MESSAGE
-						});
+						const source = child.source.value;
+						if (typeof source !== "string" || exportAllAddsRuntimeValues(filename, source)) exportAllNodes.push(child);
 						continue;
 					}
 					if (isNodeOfType(child, "ExportDefaultDeclaration")) {
@@ -46174,17 +48152,24 @@ const onlyExportComponents = defineRule({
 						const declaration = child.declaration;
 						const stripped = skipTsExpression(declaration);
 						if (isNodeOfType(stripped, "FunctionDeclaration") || isNodeOfType(stripped, "FunctionExpression")) {
+							const hasRenderOutput = functionHasReactRenderSemantics(stripped, state);
 							if (stripped.id) {
 								const idNode = stripped.id;
 								isExportedNodeIds.add(stripped);
-								exports.push(classifyExport(idNode.name, idNode, true, null, state));
-							} else {
+								exports.push(hasRenderOutput ? classifyExport(idNode.name, idNode, true, null, state) : {
+									kind: "non-component",
+									reportNode: idNode
+								});
+							} else if (hasRenderOutput) {
 								context.report({
 									node: stripped,
 									message: ANONYMOUS_MESSAGE
 								});
 								hasReactExport = true;
-							}
+							} else exports.push({
+								kind: "non-component",
+								reportNode: stripped
+							});
 							continue;
 						}
 						if (isNodeOfType(stripped, "ClassDeclaration") || isNodeOfType(stripped, "ClassExpression")) {
@@ -46203,26 +48188,34 @@ const onlyExportComponents = defineRule({
 							continue;
 						}
 						if (isNodeOfType(stripped, "Identifier")) {
-							exports.push(classifyExport(stripped.name, stripped, false, null, state));
+							exports.push(isProvenComponentValue(stripped, state) ? { kind: "react-component" } : {
+								kind: "non-component",
+								reportNode: stripped
+							});
+							continue;
+						}
+						if (isNodeOfType(stripped, "MemberExpression")) {
+							if (isProvenComponentValue(stripped, state)) hasReactExport = true;
+							else exports.push({
+								kind: "non-component",
+								reportNode: stripped
+							});
 							continue;
 						}
 						if (isNodeOfType(stripped, "CallExpression")) {
-							if (isRouteFactoryCall(stripped)) {
+							if (isRouteFactoryCall(stripped, state.routeFactoryBindings)) {
 								hasReactExport = true;
 								continue;
 							}
-							const isHoc = isHocCallee(stripped.callee, state);
-							const firstArg = stripped.arguments[0];
-							const firstArgIsValid = Boolean(firstArg) && (() => {
-								if (!firstArg) return false;
-								const expression = skipTsExpression(firstArg);
-								if (isNodeOfType(expression, "Identifier")) return true;
-								if (isNodeOfType(expression, "FunctionExpression") && expression.id) return true;
-								if (isNodeOfType(expression, "CallExpression") && isHocCallee(expression.callee, state)) return true;
-								return false;
-							})();
-							if (isHoc && firstArgIsValid) hasReactExport = true;
-							else if (!isHoc && isConfigOnlyFactoryCall(stripped)) exports.push({
+							if (isReactCreateContext(stripped)) {
+								exports.push({
+									kind: "react-context",
+									reportNode: stripped
+								});
+								continue;
+							}
+							if (isDirectRefreshWrapperCall(stripped, state)) hasReactExport = true;
+							else if (isConfigOnlyFactoryCall(stripped)) exports.push({
 								kind: "non-component",
 								reportNode: stripped
 							});
@@ -46233,16 +48226,32 @@ const onlyExportComponents = defineRule({
 							continue;
 						}
 						if (isNodeOfType(stripped, "ObjectExpression")) {
-							context.report({
-								node: stripped,
-								message: objectExpressionBundlesComponents(stripped, state) ? NAMESPACE_OBJECT_MESSAGE : ANONYMOUS_MESSAGE
+							exports.push(objectExpressionBundlesComponents(stripped, state) ? {
+								kind: "namespace-object",
+								reportNode: stripped
+							} : {
+								kind: "non-component",
+								reportNode: stripped
 							});
 							continue;
 						}
-						if (isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "Literal")) {
-							context.report({
-								node: stripped,
-								message: ANONYMOUS_MESSAGE
+						if (isNodeOfType(stripped, "ArrowFunctionExpression")) {
+							if (functionHasReactRenderSemantics(stripped, state)) {
+								context.report({
+									node: stripped,
+									message: ANONYMOUS_MESSAGE
+								});
+								hasReactExport = true;
+							} else exports.push({
+								kind: "non-component",
+								reportNode: stripped
+							});
+							continue;
+						}
+						if (isNodeOfType(stripped, "Literal") || isNodeOfType(stripped, "NewExpression")) {
+							exports.push({
+								kind: "non-component",
+								reportNode: stripped
 							});
 							continue;
 						}
@@ -46259,7 +48268,10 @@ const onlyExportComponents = defineRule({
 							const declaration = child.declaration;
 							if (isNodeOfType(declaration, "FunctionDeclaration") && declaration.id) {
 								isExportedNodeIds.add(declaration);
-								exports.push(classifyExport(declaration.id.name, declaration.id, true, null, state));
+								exports.push(functionHasReactRenderSemantics(declaration, state) || localComponentNames.has(declaration.id.name) ? classifyExport(declaration.id.name, declaration.id, true, null, state) : {
+									kind: "non-component",
+									reportNode: declaration.id
+								});
 							} else if (isNodeOfType(declaration, "ClassDeclaration") && declaration.id) {
 								isExportedNodeIds.add(declaration);
 								if (isReactComponentName(declaration.id.name) && isEs6Component(declaration)) exports.push({ kind: "react-component" });
@@ -46283,6 +48295,7 @@ const onlyExportComponents = defineRule({
 						const isReExportFromSource = Boolean(child.source);
 						for (const specifier of child.specifiers ?? []) {
 							if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
+							if (specifier.exportKind === "type") continue;
 							const exported = specifier.exported;
 							const local = specifier.local;
 							let exportedName = null;
@@ -46290,8 +48303,13 @@ const onlyExportComponents = defineRule({
 							const localName = local && isNodeOfType(local, "Identifier") ? local.name : null;
 							const reportNode = specifier;
 							let entry;
-							if (exportedName === "default" && localName) entry = classifyExport(localName, reportNode, false, null, state);
-							else if (exportedName) entry = classifyExport(exportedName, reportNode, false, null, state);
+							if (localName && localComponentNames.has(localName)) entry = { kind: "react-component" };
+							else if (!isReExportFromSource && localName === exportedName && localName !== null && isReactComponentName(localName)) entry = { kind: "react-component" };
+							else if (exportedName === "default" && localName && local) entry = isProvenComponentValue(local, state) ? { kind: "react-component" } : {
+								kind: "non-component",
+								reportNode
+							};
+							else if (exportedName) entry = classifyExport(exportedName, reportNode, false, isReExportFromSource ? null : local, state);
 							else {
 								entry = {
 									kind: "non-component",
@@ -46309,15 +48327,21 @@ const onlyExportComponents = defineRule({
 					node: entry.reportNode,
 					message: NAMESPACE_OBJECT_MESSAGE
 				});
-				if (hasAnyExports && hasReactExport) for (const entry of exports) {
-					if (entry.kind === "non-component") context.report({
-						node: entry.reportNode,
-						message: NAMED_EXPORT_MESSAGE
-					});
-					if (entry.kind === "react-context") context.report({
-						node: entry.reportNode,
-						message: REACT_CONTEXT_MESSAGE
+				if (hasAnyExports && hasReactExport) {
+					for (const exportAllNode of exportAllNodes) context.report({
+						node: exportAllNode,
+						message: EXPORT_ALL_MESSAGE
 					});
+					for (const entry of exports) {
+						if (entry.kind === "non-component") context.report({
+							node: entry.reportNode,
+							message: NAMED_EXPORT_MESSAGE
+						});
+						if (entry.kind === "react-context") context.report({
+							node: entry.reportNode,
+							message: REACT_CONTEXT_MESSAGE
+						});
+					}
 				}
 			}
 		};
@@ -57980,6 +60004,78 @@ const inferDestructureSourceKey = (bindingIdentifier) => {
 	return null;
 };
 const isReactUseHook = (hookName) => hookName === "use";
+const isReactHookCapabilityValue = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		const symbol = scopes.symbolFor(unwrappedExpression);
+		if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+		visitedSymbolIds.add(symbol.id);
+		if (symbol.kind === "import") return isReactImport(symbol) && isReactHookName(getImportedName(symbol.declarationNode) ?? "");
+		if (symbol.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return false;
+		const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
+		if (destructuredPropertyName) {
+			const namespaceExpression = stripParenExpression(symbol.initializer);
+			return isReactHookName(destructuredPropertyName) && isNodeOfType(namespaceExpression, "Identifier") && isReactNamespaceImport(namespaceExpression, scopes) && !hasPossibleStaticPropertyMutationOrEscape(namespaceExpression, destructuredPropertyName, scopes);
+		}
+		if (symbol.declarationNode.id !== symbol.bindingIdentifier) return false;
+		return isReactHookCapabilityValue(symbol.initializer, scopes, visitedSymbolIds);
+	}
+	if (!isNodeOfType(unwrappedExpression, "MemberExpression")) return false;
+	const propertyName = getStaticPropertyName(unwrappedExpression);
+	if (!propertyName || !isReactHookName(propertyName)) return false;
+	const namespaceExpression = stripParenExpression(unwrappedExpression.object);
+	return isNodeOfType(namespaceExpression, "Identifier") && isReactNamespaceImport(namespaceExpression, scopes) && !hasPossibleStaticPropertyMutationOrEscape(namespaceExpression, propertyName, scopes);
+};
+const isReactHookCapabilityComparisonOperand = (expression, scopes) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isReactHookCapabilityValue(unwrappedExpression, scopes)) return true;
+	return isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "typeof" && isReactHookCapabilityValue(unwrappedExpression.argument, scopes);
+};
+const isStaticCapabilityComparisonValue = (expression, scopes) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "Literal")) return true;
+	return isNodeOfType(unwrappedExpression, "Identifier") && unwrappedExpression.name === "undefined" && scopes.isGlobalReference(unwrappedExpression);
+};
+const CAPABILITY_COMPARISON_OPERATORS = new Set([
+	"==",
+	"!=",
+	"===",
+	"!=="
+]);
+const isInvariantReactHookCapabilityCondition = (expression, scopes) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isReactHookCapabilityValue(unwrappedExpression, scopes)) return true;
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return isInvariantReactHookCapabilityCondition(unwrappedExpression.argument, scopes);
+	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) return isInvariantReactHookCapabilityCondition(unwrappedExpression.left, scopes) && isInvariantReactHookCapabilityCondition(unwrappedExpression.right, scopes);
+	if (!isNodeOfType(unwrappedExpression, "BinaryExpression") || !CAPABILITY_COMPARISON_OPERATORS.has(unwrappedExpression.operator)) return false;
+	return isReactHookCapabilityComparisonOperand(unwrappedExpression.left, scopes) && isStaticCapabilityComparisonValue(unwrappedExpression.right, scopes) || isReactHookCapabilityComparisonOperand(unwrappedExpression.right, scopes) && isStaticCapabilityComparisonValue(unwrappedExpression.left, scopes);
+};
+const statementContainsOwnAbruptCompletion = (statement) => {
+	let doesContainAbruptCompletion = false;
+	walkAst(statement, (child) => {
+		if (child !== statement && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "ReturnStatement") || isNodeOfType(child, "ThrowStatement")) {
+			doesContainAbruptCompletion = true;
+			return false;
+		}
+	});
+	return doesContainAbruptCompletion;
+};
+const isInvariantReactHookCapabilityExit = (statement, scopes) => isNodeOfType(statement, "IfStatement") && statement.alternate === null && statementAlwaysExits(statement.consequent) && isInvariantReactHookCapabilityCondition(statement.test, scopes);
+const isAfterOnlyInvariantReactHookCapabilityExits = (node, enclosingFunction, scopes) => {
+	if (!isFunctionLike$1(enclosingFunction) || !isNodeOfType(enclosingFunction.body, "BlockStatement")) return false;
+	let containingStatement = node;
+	while (containingStatement.parent && containingStatement.parent !== enclosingFunction.body) {
+		if (isFunctionLike$1(containingStatement.parent)) return false;
+		if (isNodeOfType(containingStatement.parent, "IfStatement") || isNodeOfType(containingStatement.parent, "SwitchStatement") || isNodeOfType(containingStatement.parent, "SwitchCase") || isNodeOfType(containingStatement.parent, "ConditionalExpression") || isNodeOfType(containingStatement.parent, "LogicalExpression")) return false;
+		containingStatement = containingStatement.parent;
+	}
+	if (containingStatement.parent !== enclosingFunction.body) return false;
+	const statementIndex = enclosingFunction.body.body.findIndex((statement) => statement === containingStatement);
+	if (statementIndex <= 0) return false;
+	const bypassingStatements = enclosingFunction.body.body.slice(0, statementIndex).filter((statement) => statementContainsOwnAbruptCompletion(statement));
+	return bypassingStatements.length > 0 && bypassingStatements.every((statement) => isInvariantReactHookCapabilityExit(statement, scopes));
+};
 const getCallExpressionCalleeName = (callExpression) => {
 	const callee = callExpression.callee;
 	if (isNodeOfType(callee, "Identifier")) return callee.name;
@@ -58275,7 +60371,7 @@ const rulesOfHooks = defineRule({
 					});
 					return;
 				}
-				if (!context.cfg.isUnconditionalFromEntry(node)) context.report({
+				if (!context.cfg.isUnconditionalFromEntry(node) && !isAfterOnlyInvariantReactHookCapabilityExits(node, enclosing.node, context.scopes)) context.report({
 					node: node.callee,
 					message: buildConditionalMessage(hookName)
 				});
@@ -66414,6 +68510,7 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"no-effect-with-fresh-deps",
 	"no-initialize-state",
 	"no-mutating-reducer-state",
+	"only-export-components",
 	"no-unguarded-browser-global-in-render-or-hook-init",
 	"prefer-dynamic-import",
 	"rendering-hydration-mismatch-time",
@@ -66621,7 +68718,7 @@ const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 * `CROSS_FILE_DEPENDENCY_COLLECTORS` (the core guard test enforces the
 * partition), forcing a conscious classification.
 */
-const UNBOUNDED_CROSS_FILE_RULE_IDS = /* @__PURE__ */ new Set();
+const UNBOUNDED_CROSS_FILE_RULE_IDS = new Set(["only-export-components"]);
 /**
 * Runs the collectors for `ruleIds` over one file and returns every
 * filesystem probe they made — the file's cross-file dependency set.