oxlint-plugin-react-doctor 0.9.1-dev.54ba416 → 0.9.1-dev.5d2f66d

package/dist/index.js

@@ -14551,16 +14551,136 @@ const dangerousHtmlSink = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/get-static-logical-expression-result-branches.ts
+const deduplicateResultBranches = (branches) => {
+	const resultBranches = [];
+	const seenStatesByExpression = /* @__PURE__ */ new Map();
+	for (const branch of branches) {
+		const branchState = `${branch.truthiness}:${branch.nullishness}`;
+		const seenStates = seenStatesByExpression.get(branch.expression);
+		if (seenStates?.has(branchState)) continue;
+		if (seenStates) seenStates.add(branchState);
+		else seenStatesByExpression.set(branch.expression, new Set([branchState]));
+		resultBranches.push(branch);
+	}
+	return resultBranches;
+};
+const getAtomicExpressionResultBranch = (expression) => {
+	if (isNodeOfType(expression, "JSXElement") || isNodeOfType(expression, "JSXFragment") || isNodeOfType(expression, "ArrayExpression") || isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression") || isNodeOfType(expression, "ClassExpression") || isNodeOfType(expression, "NewExpression")) return {
+		expression,
+		truthiness: "truthy",
+		nullishness: "non-nullish"
+	};
+	if (isNodeOfType(expression, "Literal")) {
+		if (expression.value === null) return {
+			expression,
+			truthiness: "falsy",
+			nullishness: "nullish"
+		};
+		return {
+			expression,
+			truthiness: expression.value ? "truthy" : "falsy",
+			nullishness: "non-nullish"
+		};
+	}
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return {
+		expression,
+		truthiness: "falsy",
+		nullishness: "nullish"
+	};
+	return {
+		expression,
+		truthiness: "unknown",
+		nullishness: "unknown"
+	};
+};
+const getStaticExpressionResultBranches = (expression) => {
+	const finalExpression = getFinalSequenceExpressionValue(expression);
+	if (isNodeOfType(finalExpression, "ConditionalExpression")) return deduplicateResultBranches([...getStaticExpressionResultBranches(finalExpression.consequent), ...getStaticExpressionResultBranches(finalExpression.alternate)]);
+	if (!isNodeOfType(finalExpression, "LogicalExpression")) return [getAtomicExpressionResultBranch(finalExpression)];
+	const leftBranches = getStaticExpressionResultBranches(finalExpression.left);
+	const rightBranches = getStaticExpressionResultBranches(finalExpression.right);
+	const resultBranches = [];
+	for (const leftBranch of leftBranches) {
+		if (finalExpression.operator === "&&") {
+			if (leftBranch.truthiness !== "truthy") resultBranches.push(leftBranch.truthiness === "falsy" ? leftBranch : {
+				...leftBranch,
+				truthiness: "falsy"
+			});
+			if (leftBranch.truthiness !== "falsy") resultBranches.push(...rightBranches);
+			continue;
+		}
+		if (finalExpression.operator === "||") {
+			if (leftBranch.truthiness !== "falsy") resultBranches.push(leftBranch.truthiness === "truthy" ? leftBranch : {
+				...leftBranch,
+				truthiness: "truthy",
+				nullishness: "non-nullish"
+			});
+			if (leftBranch.truthiness !== "truthy") resultBranches.push(...rightBranches);
+			continue;
+		}
+		if (leftBranch.nullishness !== "nullish") resultBranches.push(leftBranch.nullishness === "non-nullish" ? leftBranch : {
+			...leftBranch,
+			nullishness: "non-nullish"
+		});
+		if (leftBranch.nullishness !== "non-nullish") resultBranches.push(...rightBranches);
+	}
+	return deduplicateResultBranches(resultBranches);
+};
+const getStaticLogicalExpressionResultBranches = (expression) => {
+	const resultExpressions = [];
+	const seenExpressions = /* @__PURE__ */ new Set();
+	for (const resultBranch of getStaticExpressionResultBranches(expression)) {
+		if (seenExpressions.has(resultBranch.expression)) continue;
+		seenExpressions.add(resultBranch.expression);
+		resultExpressions.push(resultBranch.expression);
+	}
+	return resultExpressions;
+};
+//#endregion
 //#region src/plugin/utils/get-static-jsx-descendant-opening-elements.ts
-const appendDescendants = (children, descendants) => {
-	for (const child of children) if (isNodeOfType(child, "JSXElement")) {
-		descendants.push(child.openingElement);
-		appendDescendants(child.children, descendants);
-	} else if (isNodeOfType(child, "JSXFragment")) appendDescendants(child.children, descendants);
+const appendDescendant = (node, descendants, includeStaticExpressionBranches) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "JSXElement")) {
+		descendants.push(expression.openingElement);
+		for (const child of expression.children) appendDescendant(child, descendants, includeStaticExpressionBranches);
+		return;
+	}
+	if (isNodeOfType(expression, "JSXFragment")) {
+		for (const child of expression.children) appendDescendant(child, descendants, includeStaticExpressionBranches);
+		return;
+	}
+	if (!includeStaticExpressionBranches) return;
+	if (isNodeOfType(expression, "JSXExpressionContainer")) {
+		appendDescendant(expression.expression, descendants, true);
+		return;
+	}
+	if (isNodeOfType(expression, "ConditionalExpression")) {
+		const staticTestValue = readStaticBoolean(getFinalSequenceExpressionValue(expression.test));
+		if (staticTestValue !== null) {
+			appendDescendant(staticTestValue ? expression.consequent : expression.alternate, descendants, true);
+			return;
+		}
+		appendDescendant(expression.consequent, descendants, true);
+		appendDescendant(expression.alternate, descendants, true);
+		return;
+	}
+	if (isNodeOfType(expression, "LogicalExpression")) {
+		for (const resultBranch of getStaticLogicalExpressionResultBranches(expression)) appendDescendant(resultBranch, descendants, true);
+		return;
+	}
+	if (isNodeOfType(expression, "ArrayExpression")) {
+		for (const element of expression.elements) if (element && !isNodeOfType(element, "SpreadElement")) appendDescendant(element, descendants, true);
+		return;
+	}
+	if (isNodeOfType(expression, "SequenceExpression")) {
+		if (expression.expressions.length === 0) return;
+		appendDescendant(getFinalSequenceExpressionValue(expression), descendants, true);
+	}
 };
-const getStaticJsxDescendantOpeningElements = (element) => {
+const getStaticJsxDescendantOpeningElements = (element, options = {}) => {
 	const descendants = [];
-	appendDescendants(element.children, descendants);
+	for (const child of element.children) appendDescendant(child, descendants, options.includeStaticExpressionBranches === true);
 	return descendants;
 };
 //#endregion
@@ -25376,6 +25496,27 @@ const flattenLogicalAndChain = (node) => {
 	return [node];
 };
 //#endregion
+//#region src/plugin/utils/resolve-imported-jsx-component-name.ts
+const resolveImportedJsxComponentName = (openingElement, moduleSource, scopes) => {
+	const elementName = openingElement.name;
+	if (isNodeOfType(elementName, "JSXIdentifier")) {
+		const symbol = scopes.symbolFor(elementName);
+		if (!symbol || symbol.kind !== "import") return null;
+		const importDeclaration = getImportDeclarationForSymbol(symbol);
+		if (!importDeclaration || importDeclaration.source.value !== moduleSource || isTypeOnlyImport(importDeclaration)) return null;
+		if (isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier")) return "default";
+		if (!isNodeOfType(symbol.declarationNode, "ImportSpecifier")) return null;
+		if (symbol.declarationNode.importKind === "type") return null;
+		return getImportedName(symbol.declarationNode) ?? null;
+	}
+	if (!isNodeOfType(elementName, "JSXMemberExpression") || !isNodeOfType(elementName.object, "JSXIdentifier") || !isNodeOfType(elementName.property, "JSXIdentifier")) return null;
+	const namespaceSymbol = scopes.symbolFor(elementName.object);
+	if (!namespaceSymbol || namespaceSymbol.kind !== "import" || !isNodeOfType(namespaceSymbol.declarationNode, "ImportNamespaceSpecifier")) return null;
+	const importDeclaration = getImportDeclarationForSymbol(namespaceSymbol);
+	if (!importDeclaration || importDeclaration.source.value !== moduleSource || isTypeOnlyImport(importDeclaration)) return null;
+	return elementName.property.name;
+};
+//#endregion
 //#region src/plugin/utils/resolve-ink-api-name.ts
 const resolveInkApiName = (node, scopes) => {
 	if (isNodeOfType(node, "Identifier")) {
@@ -25385,15 +25526,7 @@ const resolveInkApiName = (node, scopes) => {
 	if (isNodeOfType(node, "MemberExpression") && isNodeOfType(node.object, "Identifier") && scopes.symbolFor(node.object)?.kind === "import" && isNamespaceImportFromModule$1(node, node.object.name, "ink")) return getStaticPropertyName(node);
 	return null;
 };
-const resolveInkJsxElementName = (openingElement, scopes) => {
-	const elementName = openingElement.name;
-	if (isNodeOfType(elementName, "JSXIdentifier")) {
-		if (scopes.symbolFor(elementName)?.kind !== "import") return null;
-		return getImportedNameFromModule(openingElement, elementName.name, "ink");
-	}
-	if (isNodeOfType(elementName, "JSXMemberExpression") && isNodeOfType(elementName.object, "JSXIdentifier") && scopes.symbolFor(elementName.object)?.kind === "import" && isNamespaceImportFromModule$1(openingElement, elementName.object.name, "ink")) return elementName.property.name;
-	return null;
-};
+const resolveInkJsxElementName = (openingElement, scopes) => resolveImportedJsxComponentName(openingElement, "ink", scopes);
 //#endregion
 //#region src/plugin/utils/resolve-ink-render-calls.ts
 const getRenderedComponentName = (renderCall) => {
@@ -35937,6 +36070,7 @@ const MOBX_RULE_GATES = {
 const resolveImportSymbol = (symbol) => {
 	const importDeclaration = getImportDeclarationForSymbol(symbol);
 	if (!importDeclaration || typeof importDeclaration.source.value !== "string") return null;
+	if (importDeclaration.importKind === "type" || isNodeOfType(symbol.declarationNode, "ImportSpecifier") && symbol.declarationNode.importKind === "type") return null;
 	if (isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier")) return {
 		source: importDeclaration.source.value,
 		importedName: null,
@@ -51167,6 +51301,23 @@ const isProvenReactClassComponent = (classNode, scopes, visitedClassNodes = /* @
 	return isReactComponentClassValue(classNode.superClass, scopes, visitedClassNodes, visitedSymbolIds);
 };
 //#endregion
+//#region src/plugin/utils/unwrap-proven-react-hoc-function.ts
+const unwrapProvenReactHocFunction = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!node) return null;
+	const expression = stripParenExpression(node);
+	if (isFunctionLike$1(expression)) return expression;
+	if (isNodeOfType(expression, "Identifier")) {
+		const symbol = scopes.symbolFor(expression);
+		if (!symbol || visitedSymbolIds.has(symbol.id) || !symbol.initializer || hasSymbolWriteBefore(symbol, expression, scopes)) return null;
+		visitedSymbolIds.add(symbol.id);
+		return unwrapProvenReactHocFunction(symbol.initializer, scopes, visitedSymbolIds);
+	}
+	if (!isNodeOfType(expression, "CallExpression") || !isReactApiCall(expression, "memo", scopes, { resolveNamedAliases: true }) && !isReactApiCall(expression, "forwardRef", scopes, { resolveNamedAliases: true })) return null;
+	const componentArgument = expression.arguments[0];
+	if (!componentArgument || isNodeOfType(componentArgument, "SpreadElement")) return null;
+	return unwrapProvenReactHocFunction(componentArgument, scopes, visitedSymbolIds);
+};
+//#endregion
 //#region src/plugin/utils/is-inline-intrinsic-ref-callback.ts
 const isInlineIntrinsicRefCallback = (functionNode, scopes) => {
 	const functionExpression = findTransparentExpressionRoot(functionNode);
@@ -51279,22 +51430,6 @@ const getEnvironment = (program, filename, state) => {
 	state.environmentsByProgram.set(program, environment);
 	return environment;
 };
-const unwrapProvenReactHocFunction = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (!node) return null;
-	const current = findTransparentExpressionRoot(node);
-	if (isFunctionLike$1(current)) return current;
-	if (isNodeOfType(current, "Identifier")) {
-		const symbol = scopes.symbolFor(current);
-		if (!symbol || visitedSymbolIds.has(symbol.id) || !symbol.initializer || hasSymbolWriteBefore(symbol, current, scopes)) return null;
-		visitedSymbolIds.add(symbol.id);
-		return unwrapProvenReactHocFunction(symbol.initializer, scopes, visitedSymbolIds);
-	}
-	if (!isNodeOfType(current, "CallExpression")) return null;
-	if (!isProvenReactCall(current, "memo", scopes) && !isProvenReactCall(current, "forwardRef", scopes)) return null;
-	const firstArgument = current.arguments[0];
-	if (!firstArgument || isNodeOfType(firstArgument, "SpreadElement")) return null;
-	return unwrapProvenReactHocFunction(firstArgument, scopes, visitedSymbolIds);
-};
 const isForwardRefValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const current = findTransparentExpressionRoot(node);
 	if (isNodeOfType(current, "Identifier")) {
@@ -99790,9 +99925,9 @@ const rawSqlInjectionRisk = defineRule({
 //#endregion
 //#region src/plugin/rules/architecture/react-compiler-no-manual-memoization.ts
 const REMOVAL_MESSAGE_BY_REACT_API_NAME = new Map([
-	["useMemo", "This `useMemo` is dead weight, since React Compiler already caches every value here. Delete it."],
-	["useCallback", "This `useCallback` is dead weight, since React Compiler already caches every function here. Delete it."],
-	["memo", "This `memo()` is dead weight, since React Compiler already caches the component's output. Delete it."]
+	["useMemo", "React Compiler can cache this value automatically. Verify that removing `useMemo` preserves behavior before simplifying it."],
+	["useCallback", "React Compiler can cache this function automatically. Verify that removing `useCallback` preserves behavior before simplifying it."],
+	["memo", "React Compiler can cache this component output automatically. Verify that removing `memo()` preserves behavior before simplifying it."]
 ]);
 const resolveReactApiNameForIdentifier = (callee, context) => {
 	if (!isNodeOfType(callee, "Identifier")) return null;
@@ -99838,10 +99973,10 @@ const isCompilerInferableFunction = (functionNode) => {
 };
 const reactCompilerNoManualMemoization = defineRule({
 	id: "react-compiler-no-manual-memoization",
-	title: "Redundant manual memoization",
+	title: "Manual memoization in compiler-managed code",
 	severity: "warn",
 	requires: ["react-compiler"],
-	recommendation: "Delete the `useMemo` / `useCallback` / `memo` call and use the plain value or component. React Compiler caches it for you.",
+	recommendation: "Profile compiler-managed code and remove `useMemo`, `useCallback`, or `memo` only when the manual cache no longer carries behavioral or performance intent.",
 	create: (context) => ({ CallExpression(node) {
 		const apiName = resolveReactApiNameForCallee(node.callee, context);
 		if (!apiName) return;
@@ -106449,7 +106584,7 @@ const rnAnimateLayoutProperty = defineRetiredRule({
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-animation-reaction-as-derived.ts
-const REANIMATED_MODULE_SOURCE = "react-native-reanimated";
+const REANIMATED_MODULE_SOURCE$1 = "react-native-reanimated";
 const rnAnimationReactionAsDerived = defineRule({
 	id: "rn-animation-reaction-as-derived",
 	title: "useAnimatedReaction just copies a value",
@@ -106459,7 +106594,7 @@ const rnAnimationReactionAsDerived = defineRule({
 	recommendation: "This useAnimatedReaction just copies one value to another. Replace it with `useDerivedValue(() => ..., [deps])`, which is shorter and tracks changes for you.",
 	create: (context) => ({ CallExpression(node) {
 		if (!isNodeOfType(node.callee, "Identifier") || node.callee.name !== "useAnimatedReaction") return;
-		if (getImportSourceForName(node, node.callee.name) !== REANIMATED_MODULE_SOURCE) return;
+		if (getImportSourceForName(node, node.callee.name) !== REANIMATED_MODULE_SOURCE$1) return;
 		const reactionFn = node.arguments?.[1];
 		if (!reactionFn) return;
 		if (!isNodeOfType(reactionFn, "ArrowFunctionExpression") && !isNodeOfType(reactionFn, "FunctionExpression")) return;
@@ -106483,6 +106618,69 @@ const rnAnimationReactionAsDerived = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/react-native/rn-bottom-sheet-no-ignored-scroll-prop.ts
+const GORHOM_BOTTOM_SHEET_MODULE$2 = "@gorhom/bottom-sheet";
+const IGNORED_SCROLL_PROPERTY_NAMES = new Set([
+	"decelerationRate",
+	"onScrollBeginDrag",
+	"scrollEventThrottle"
+]);
+const rnBottomSheetNoIgnoredScrollProp = defineRule({
+	id: "rn-bottom-sheet-no-ignored-scroll-prop",
+	title: "Ignored BottomSheetScrollView prop",
+	requires: ["react-native"],
+	severity: "warn",
+	recommendation: "Remove scrollEventThrottle, decelerationRate, and onScrollBeginDrag from BottomSheetScrollView because the component ignores them.",
+	create: (context) => ({ JSXOpeningElement(node) {
+		if (resolveImportedJsxComponentName(node, GORHOM_BOTTOM_SHEET_MODULE$2, context.scopes) !== "BottomSheetScrollView") return;
+		for (const attribute of node.attributes) {
+			if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+			const propertyName = getJsxAttributeName(attribute.name);
+			if (!propertyName || !IGNORED_SCROLL_PROPERTY_NAMES.has(propertyName)) continue;
+			context.report({
+				node: attribute,
+				message: `BottomSheetScrollView ignores \`${propertyName}\`, so this prop cannot affect scrolling. Remove it or handle the behavior outside the scrollable.`
+			});
+		}
+	} })
+});
+//#endregion
+//#region src/plugin/rules/react-native/rn-bottom-sheet-no-state-in-on-animate.ts
+const GORHOM_BOTTOM_SHEET_MODULE$1 = "@gorhom/bottom-sheet";
+const BOTTOM_SHEET_CONTAINER_NAMES$1 = new Set([
+	"BottomSheet",
+	"BottomSheetModal",
+	"default"
+]);
+const rnBottomSheetNoStateInOnAnimate = defineRule({
+	id: "rn-bottom-sheet-no-state-in-on-animate",
+	title: "React state update in Bottom Sheet onAnimate",
+	requires: ["react-native"],
+	severity: "warn",
+	recommendation: "Avoid starting React renders from onAnimate. Use animatedIndex or animatedPosition for animation-coupled UI, or onChange for committed index state.",
+	create: (context) => ({ JSXOpeningElement(node) {
+		const componentName = resolveImportedJsxComponentName(node, GORHOM_BOTTOM_SHEET_MODULE$1, context.scopes);
+		if (!componentName || !BOTTOM_SHEET_CONTAINER_NAMES$1.has(componentName)) return;
+		const onAnimateAttribute = findJsxAttribute(node.attributes, "onAnimate");
+		if (!onAnimateAttribute?.value || !isNodeOfType(onAnimateAttribute.value, "JSXExpressionContainer")) return;
+		const handler = resolveExactLocalFunction(onAnimateAttribute.value.expression, context.scopes);
+		if (!handler) return;
+		let stateSetterCall = null;
+		walkOwnFunctionScope(handler, (child) => {
+			if (stateSetterCall) return false;
+			if (!isNodeOfType(child, "CallExpression") || !isNodeOfType(child.callee, "Identifier")) return;
+			if (!resolveReactUseStatePair(child.callee, context.scopes)) return;
+			stateSetterCall = child;
+			return false;
+		});
+		if (!stateSetterCall) return;
+		context.report({
+			node: stateSetterCall,
+			message: "This onAnimate handler starts a React state update as the Bottom Sheet begins moving, adding render work to the transition. Use animatedIndex or animatedPosition for animation-coupled UI."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/react-native/rn-bottom-sheet-prefer-native.ts
 const JS_BOTTOM_SHEET_PACKAGES = new Set([
 	"react-native-bottom-sheet",
@@ -106499,7 +106697,7 @@ const rnBottomSheetPreferNative = defineRule({
 	tags: ["test-noise"],
 	requires: ["react-native"],
 	severity: "warn",
-	recommendation: "On RN v7+, use `<Modal presentationStyle=\"formSheet\">` so the sheet uses platform-native gestures, detents, accessibility, and presentation behavior.",
+	recommendation: "When native presentation fits the design, use `<Modal presentationStyle=\"formSheet\">` for platform-native gestures, accessibility, and presentation behavior.",
 	create: (context) => ({ ImportDeclaration(node) {
 		const source = node.source?.value;
 		if (typeof source !== "string" || !JS_BOTTOM_SHEET_PACKAGES.has(source)) return;
@@ -106511,6 +106709,45 @@ const rnBottomSheetPreferNative = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/react-native/rn-bottom-sheet-use-integrated-scrollable.ts
+const GORHOM_BOTTOM_SHEET_MODULE = "@gorhom/bottom-sheet";
+const REACT_NATIVE_MODULE$1 = "react-native";
+const BOTTOM_SHEET_CONTAINER_NAMES = new Set([
+	"BottomSheet",
+	"BottomSheetModal",
+	"default"
+]);
+const REACT_NATIVE_SCROLLABLE_NAMES = new Set([
+	"FlatList",
+	"ScrollView",
+	"SectionList",
+	"VirtualizedList"
+]);
+const rnBottomSheetUseIntegratedScrollable = defineRule({
+	id: "rn-bottom-sheet-use-integrated-scrollable",
+	title: "React Native scrollable inside a Bottom Sheet",
+	requires: ["react-native"],
+	severity: "warn",
+	recommendation: "Use @gorhom/bottom-sheet's integrated BottomSheetScrollView, BottomSheetFlatList, BottomSheetSectionList, or BottomSheetVirtualizedList so gestures coordinate with the sheet.",
+	create: (context) => {
+		const reportedScrollables = /* @__PURE__ */ new WeakSet();
+		return { JSXElement(node) {
+			const containerName = resolveImportedJsxComponentName(node.openingElement, GORHOM_BOTTOM_SHEET_MODULE, context.scopes);
+			if (!containerName || !BOTTOM_SHEET_CONTAINER_NAMES.has(containerName)) return;
+			for (const descendant of getStaticJsxDescendantOpeningElements(node, { includeStaticExpressionBranches: true })) {
+				if (reportedScrollables.has(descendant)) continue;
+				const scrollableName = resolveImportedJsxComponentName(descendant, REACT_NATIVE_MODULE$1, context.scopes);
+				if (!scrollableName || !REACT_NATIVE_SCROLLABLE_NAMES.has(scrollableName)) continue;
+				reportedScrollables.add(descendant);
+				context.report({
+					node: descendant,
+					message: `React Native's \`${scrollableName}\` does not coordinate gestures with this Bottom Sheet. Use \`BottomSheet${scrollableName}\` from @gorhom/bottom-sheet.`
+				});
+			}
+		} };
+	}
+});
+//#endregion
 //#region src/plugin/rules/react-native/rn-detox-missing-await.ts
 const EMPTY_VISITORS$6 = {};
 const DETOX_TEST_FILE = /(\.e2e\.[cm]?[jt]sx?$)|((^|\/)e2e\/)/;
@@ -106800,8 +107037,20 @@ const REACT_NATIVE_BUILTIN_LIST_COMPONENTS = new Set([
 ]);
 const RECYCLABLE_LIST_PACKAGES = {
 	FlashList: ["@shopify/flash-list"],
-	LegendList: ["@legendapp/list"]
-};
+	AnimatedFlashList: ["@shopify/flash-list"],
+	LegendList: ["@legendapp/list", "@legendapp/list/react-native"],
+	AnimatedLegendList: ["@legendapp/list/animated", "@legendapp/list/reanimated"],
+	KeyboardAwareLegendList: ["@legendapp/list/keyboard"],
+	KeyboardAvoidingLegendList: ["@legendapp/list/keyboard-legacy"]
+};
+const SHOPIFY_FLASH_LIST_COMPONENTS = new Set(["FlashList", "AnimatedFlashList"]);
+const LEGEND_LIST_V3_PACKAGE_SOURCES = new Set([
+	"@legendapp/list/react-native",
+	"@legendapp/list/animated",
+	"@legendapp/list/reanimated",
+	"@legendapp/list/keyboard",
+	"@legendapp/list/keyboard-legacy"
+]);
 const RECYCLABLE_LIST_PACKAGE_SOURCES = Object.values(RECYCLABLE_LIST_PACKAGES).flat();
 const REACT_NATIVE_LIST_COMPONENTS = new Set([...REACT_NATIVE_BUILTIN_LIST_COMPONENTS, ...Object.keys(RECYCLABLE_LIST_PACKAGES)]);
 const RENDER_ITEM_PROP_NAMES = new Set([
@@ -106889,21 +107138,9 @@ const getInitializerModuleSource = (contextNode, initializer) => {
 };
 //#endregion
 //#region src/plugin/rules/react-native/utils/resolve-imported-recycler-name.ts
-const getJsxMemberObjectName = (node) => {
-	if (!isNodeOfType(node, "JSXOpeningElement")) return null;
-	const elementName = node.name;
-	if (!elementName || !isNodeOfType(elementName, "JSXMemberExpression")) return null;
-	return isNodeOfType(elementName.object, "JSXIdentifier") ? elementName.object.name : null;
-};
-const resolveImportedRecyclerName = (node, localName, options) => {
-	const jsxMemberObjectName = options?.allowNamespaceMemberAccess ? getJsxMemberObjectName(node) : null;
-	for (const [canonicalName, packageSources] of Object.entries(RECYCLABLE_LIST_PACKAGES)) {
-		if (jsxMemberObjectName !== null) {
-			if (localName === canonicalName && packageSources.some((packageSource) => isNamespaceImportFromModule$1(node, jsxMemberObjectName, packageSource))) return canonicalName;
-			continue;
-		}
-		if (packageSources.some((packageSource) => getImportedNameFromModule(node, localName, packageSource) === canonicalName)) return canonicalName;
-	}
+const resolveImportedRecyclerName = (node, scopes, options) => {
+	if (isNodeOfType(node.name, "JSXMemberExpression") && !options?.allowNamespaceMemberAccess) return null;
+	for (const [canonicalName, packageSources] of Object.entries(RECYCLABLE_LIST_PACKAGES)) for (const packageSource of packageSources) if (resolveImportedJsxComponentName(node, packageSource, scopes) === canonicalName) return canonicalName;
 	return null;
 };
 //#endregion
@@ -106923,8 +107160,8 @@ const isLocalBindingReactNativeList = (node, elementName) => {
 	const initializerModuleSource = getInitializerModuleSource(node, declaratorInitializer);
 	return initializerModuleSource !== null && REACT_NATIVE_LIST_MODULE_SOURCES.has(initializerModuleSource);
 };
-const isVirtualizedList = (node, elementName) => {
-	if (resolveImportedRecyclerName(node, elementName, { allowNamespaceMemberAccess: true }) !== null) return true;
+const isVirtualizedList = (node, elementName, scopes) => {
+	if (resolveImportedRecyclerName(node, scopes, { allowNamespaceMemberAccess: true }) !== null) return true;
 	if (isNodeOfType(node.name, "JSXMemberExpression")) {
 		if (!REACT_NATIVE_BUILTIN_LIST_COMPONENTS.has(elementName)) return false;
 		const memberObjectName = getJsxMemberRootObjectName(node.name);
@@ -106981,7 +107218,7 @@ const rnListDataMapped = defineRule({
 	recommendation: "This builds a new array each time the parent redraws, so every row redraws too. Wrap it in `useMemo(() => items.map(...), [items])` to keep the same array.",
 	create: (context) => ({ JSXOpeningElement(node) {
 		const elementName = resolveJsxElementName(node);
-		if (!elementName || !isVirtualizedList(node, elementName)) return;
+		if (!elementName || !isVirtualizedList(node, elementName, context.scopes)) return;
 		for (const attr of node.attributes ?? []) {
 			if (!isNodeOfType(attr, "JSXAttribute")) continue;
 			if (!isNodeOfType(attr.name, "JSXIdentifier") || attr.name.name !== "data") continue;
@@ -106997,12 +107234,14 @@ const rnListDataMapped = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/rules/react-native/rn-list-missing-estimated-item-size.ts
-const SIZING_HINT_ATTRIBUTE_NAMES = new Set(["estimatedItemSize", "estimatedListSize"]);
+//#region src/plugin/rules/react-native/utils/is-flash-list-v2-or-newer.ts
 const isFlashListV2OrNewer = (context) => {
 	const flashListMajorVersion = getReactDoctorNumberSetting(context.settings, "shopifyFlashListMajorVersion");
 	return flashListMajorVersion !== void 0 && flashListMajorVersion >= 2;
 };
+//#endregion
+//#region src/plugin/rules/react-native/rn-list-missing-estimated-item-size.ts
+const SIZING_HINT_ATTRIBUTE_NAMES = new Set(["estimatedItemSize", "estimatedListSize"]);
 const isEmptyArrayLiteral = (node) => {
 	if (!isNodeOfType(node.value, "JSXExpressionContainer")) return false;
 	const expression = node.value.expression;
@@ -107025,9 +107264,10 @@ const rnListMissingEstimatedItemSize = defineRule({
 				if (!fileImportsRecycler) return;
 				const localElementName = resolveJsxElementName(node);
 				if (!localElementName) return;
-				const canonicalRecyclerName = resolveImportedRecyclerName(node, localElementName);
+				const canonicalRecyclerName = resolveImportedRecyclerName(node, context.scopes);
 				if (canonicalRecyclerName === null) return;
-				if (canonicalRecyclerName === "FlashList" && isFlashListV2OrNewer(context)) return;
+				if ([...LEGEND_LIST_V3_PACKAGE_SOURCES].some((packageSource) => resolveImportedJsxComponentName(node, packageSource, context.scopes) !== null)) return;
+				if (SHOPIFY_FLASH_LIST_COMPONENTS.has(canonicalRecyclerName) && isFlashListV2OrNewer(context)) return;
 				let hasSizingHint = false;
 				let dataIsEmptyLiteral = false;
 				let hasDataProp = false;
@@ -107054,15 +107294,1272 @@ const rnListMissingEstimatedItemSize = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-list-recyclable-without-types.ts
+const RENDER_ITEM_INPUT_NAMES = new Set(["item", "index"]);
+const EMPTY_RENDERED_ROOT_NAME = "empty";
+const isSymbolStable = (symbol) => symbol.references.every((reference) => reference.flag === "read");
+const getSymbolVariableDeclarator = (symbol) => {
+	let declaration = symbol.declarationNode;
+	while (declaration && !isNodeOfType(declaration, "VariableDeclarator")) declaration = declaration.parent;
+	return declaration && isNodeOfType(declaration, "VariableDeclarator") ? declaration : null;
+};
+const getConstInitializerExpressions = (symbol) => {
+	if (symbol.kind !== "const" || !symbol.initializer) return [];
+	const declarationInitializer = getSymbolVariableDeclarator(symbol)?.init;
+	return declarationInitializer && declarationInitializer !== symbol.initializer ? [declarationInitializer, symbol.initializer] : [symbol.initializer];
+};
+const getSymbolIdentity = (symbol) => {
+	if (symbol.kind !== "import") return `symbol:${symbol.id}`;
+	const source = getImportDeclarationForSymbol(symbol)?.source.value;
+	if (typeof source !== "string") return `symbol:${symbol.id}`;
+	if (isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier")) return `import:${source}:default`;
+	if (isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier")) return `import:${source}:*`;
+	return `import:${source}:${getImportedName(symbol.declarationNode) ?? symbol.name}`;
+};
+const appendComponentMemberIdentity = (receiverIdentity, propertyName) => {
+	if (!receiverIdentity || !receiverIdentity.startsWith("import:") && !receiverIdentity.startsWith("global:")) return null;
+	if (receiverIdentity.endsWith(":*")) return `${receiverIdentity.slice(0, -1)}${propertyName}`;
+	return `${receiverIdentity}.${propertyName}`;
+};
+const getComponentReferenceIdentity = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const componentReference = stripParenExpression(expression);
+	if (isNodeOfType(componentReference, "Identifier") || isNodeOfType(componentReference, "JSXIdentifier")) {
+		const symbol = scopes.symbolFor(componentReference);
+		if (!symbol) return `global:${componentReference.name}`;
+		if (visitedSymbolIds.has(symbol.id) || !isSymbolStable(symbol)) return null;
+		visitedSymbolIds.add(symbol.id);
+		if (symbol.kind === "import" || symbol.kind === "function" || symbol.kind === "class") return getSymbolIdentity(symbol);
+		if (symbol.kind !== "const" || !symbol.initializer) return null;
+		const initializer = stripParenExpression(symbol.initializer);
+		const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
+		if (destructuredPropertyName) return appendComponentMemberIdentity(getComponentReferenceIdentity(initializer, scopes, visitedSymbolIds), destructuredPropertyName);
+		const isProvenReactHocCall = isNodeOfType(initializer, "CallExpression") && (isReactApiCall(initializer, "memo", scopes, { resolveNamedAliases: true }) || isReactApiCall(initializer, "forwardRef", scopes, { resolveNamedAliases: true })) && initializer.arguments[0] !== void 0 && !isNodeOfType(initializer.arguments[0], "SpreadElement");
+		if (isFunctionLike$1(initializer) || isNodeOfType(initializer, "ClassExpression") || isProvenReactHocCall) return getSymbolIdentity(symbol);
+		if (!isNodeOfType(initializer, "Identifier") && !isNodeOfType(initializer, "MemberExpression")) return null;
+		return getComponentReferenceIdentity(initializer, scopes, visitedSymbolIds);
+	}
+	if (!isNodeOfType(componentReference, "MemberExpression")) return null;
+	const propertyName = getStaticPropertyName(componentReference);
+	if (propertyName === null) return null;
+	return appendComponentMemberIdentity(getComponentReferenceIdentity(componentReference.object, scopes, visitedSymbolIds), propertyName);
+};
+const getJsxElementIdentity = (node, scopes) => {
+	if (isNodeOfType(node, "JSXIdentifier")) {
+		const identity = getComponentReferenceIdentity(node, scopes);
+		if (identity !== `global:${node.name}`) return identity;
+		return /^[a-z]/u.test(node.name) ? `intrinsic:${node.name}` : identity;
+	}
+	if (!isNodeOfType(node, "JSXMemberExpression")) return null;
+	const objectIdentity = getJsxElementIdentity(node.object, scopes);
+	if (!isNodeOfType(node.property, "JSXIdentifier")) return null;
+	return appendComponentMemberIdentity(objectIdentity, node.property.name);
+};
+const isStaticallyEmptyJsxChild = (node) => {
+	const expression = getFinalSequenceExpressionValue(node);
+	if (isNodeOfType(expression, "JSXEmptyExpression")) return true;
+	if (isNodeOfType(expression, "Literal") && (expression.value === null || typeof expression.value === "boolean")) return true;
+	if (isNodeOfType(expression, "UnaryExpression")) return expression.operator === "!" || expression.operator === "void";
+	if (!isNodeOfType(expression, "BinaryExpression")) return false;
+	switch (expression.operator) {
+		case "==":
+		case "!=":
+		case "===":
+		case "!==":
+		case "<":
+		case "<=":
+		case ">":
+		case ">=":
+		case "in":
+		case "instanceof": return true;
+		default: return false;
+	}
+};
+const getStaticSelectorBindingPath = (pattern, bindingIdentifier, scopes) => {
+	if (pattern === bindingIdentifier) return [];
+	if (isNodeOfType(pattern, "AssignmentPattern")) return readStaticSelectorTruthiness(pattern.right, scopes) === false ? getStaticSelectorBindingPath(pattern.left, bindingIdentifier, scopes) : null;
+	if (isNodeOfType(pattern, "RestElement")) return null;
+	if (isNodeOfType(pattern, "ArrayPattern")) {
+		for (const [elementIndex, element] of pattern.elements.entries()) {
+			if (!element) continue;
+			const nestedPath = getStaticSelectorBindingPath(element, bindingIdentifier, scopes);
+			if (nestedPath !== null) return [String(elementIndex), ...nestedPath];
+		}
+		return null;
+	}
+	if (!isNodeOfType(pattern, "ObjectPattern")) return null;
+	for (const property of pattern.properties) {
+		if (!isNodeOfType(property, "Property")) continue;
+		const nestedPath = getStaticSelectorBindingPath(property.value, bindingIdentifier, scopes);
+		if (nestedPath === null) continue;
+		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+		return propertyName === null ? null : [propertyName, ...nestedPath];
+	}
+	return null;
+};
+const getStaticSelectorPropertyName = (memberExpression) => getStaticPropertyName(memberExpression) ?? getStaticPropertyKeyName(memberExpression, {
+	allowComputedString: true,
+	stringifyNonStringLiterals: true
+});
+const getSelectorReferenceKey = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const selector = stripParenExpression(expression);
+	if (isNodeOfType(selector, "Identifier")) {
+		const symbol = scopes.referenceFor(selector)?.resolvedSymbol;
+		if (!symbol || !isSymbolStable(symbol) || visitedSymbolIds.has(symbol.id)) return null;
+		if (symbol.kind === "const" && symbol.initializer) {
+			visitedSymbolIds.add(symbol.id);
+			const declaration = getSymbolVariableDeclarator(symbol);
+			if (declaration?.id === symbol.bindingIdentifier) return getSelectorReferenceKey(symbol.initializer, scopes, visitedSymbolIds) ?? JSON.stringify(["symbol", symbol.id]);
+			if (declaration?.init) {
+				const bindingPath = getStaticSelectorBindingPath(declaration.id, symbol.bindingIdentifier, scopes);
+				let receiverKey = getSelectorReferenceKey(declaration.init, scopes, visitedSymbolIds);
+				if (bindingPath !== null && receiverKey !== null) {
+					for (const propertyName of bindingPath) receiverKey = JSON.stringify([
+						"member",
+						receiverKey,
+						propertyName
+					]);
+					return receiverKey;
+				}
+			}
+			return JSON.stringify(["symbol", symbol.id]);
+		}
+		return JSON.stringify(["symbol", symbol.id]);
+	}
+	if (!isNodeOfType(selector, "MemberExpression")) return null;
+	const propertyName = getStaticSelectorPropertyName(selector);
+	if (propertyName === null) return null;
+	const receiverKey = getSelectorReferenceKey(selector.object, scopes, visitedSymbolIds);
+	return receiverKey === null ? null : JSON.stringify([
+		"member",
+		receiverKey,
+		propertyName
+	]);
+};
+const getStaticComparisonOperandKey = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const operand = stripParenExpression(expression);
+	if (isNodeOfType(operand, "Identifier")) {
+		const symbol = scopes.referenceFor(operand)?.resolvedSymbol;
+		if (symbol?.kind === "const" && symbol.initializer && isSymbolStable(symbol) && getSymbolVariableDeclarator(symbol)?.id === symbol.bindingIdentifier && !visitedSymbolIds.has(symbol.id)) {
+			visitedSymbolIds.add(symbol.id);
+			return getStaticComparisonOperandKey(symbol.initializer, scopes, visitedSymbolIds) ?? JSON.stringify(["symbol", symbol.id]);
+		}
+	}
+	if (isNodeOfType(operand, "UnaryExpression") && operand.operator === "typeof") {
+		const argumentKey = getSelectorReferenceKey(operand.argument, scopes, visitedSymbolIds);
+		return argumentKey === null ? null : JSON.stringify(["typeof", argumentKey]);
+	}
+	return getSelectorReferenceKey(operand, scopes, visitedSymbolIds);
+};
+const getStaticPrimitiveLiteralKey = (expression) => {
+	const literal = stripParenExpression(expression);
+	if (isNodeOfType(literal, "UnaryExpression") && (literal.operator === "-" || literal.operator === "+")) {
+		const argument = stripParenExpression(literal.argument);
+		if (isNodeOfType(argument, "Literal") && typeof argument.value === "number") {
+			const numericValue = literal.operator === "-" ? -argument.value : argument.value;
+			return `number:${String(numericValue)}`;
+		}
+	}
+	if (!isNodeOfType(literal, "Literal")) return null;
+	if (literal.value === null) return "null";
+	if (typeof literal.value === "string") return `string:${JSON.stringify(literal.value)}`;
+	if (typeof literal.value === "number") return `number:${String(literal.value)}`;
+	if (typeof literal.value === "boolean") return `boolean:${String(literal.value)}`;
+	if (typeof literal.value === "bigint") return `bigint:${String(literal.value)}`;
+	return null;
+};
+const getImportedStaticReferenceKey = (expression, scopes) => {
+	const reference = stripParenExpression(expression);
+	if (isNodeOfType(reference, "Identifier")) {
+		const symbol = scopes.referenceFor(reference)?.resolvedSymbol;
+		return symbol?.kind === "import" ? getSymbolIdentity(symbol) : null;
+	}
+	if (!isNodeOfType(reference, "MemberExpression")) return null;
+	const propertyName = getStaticPropertyName(reference);
+	if (propertyName === null) return null;
+	const receiverKey = getImportedStaticReferenceKey(reference.object, scopes);
+	return receiverKey === null ? null : JSON.stringify([
+		"member",
+		receiverKey,
+		propertyName
+	]);
+};
+const getStaticComparisonConstantKey = (expression, scopes) => getStaticPrimitiveLiteralKey(expression) ?? getImportedStaticReferenceKey(expression, scopes);
+const getStaticSelectorIdentity = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const selector = getFinalSequenceExpressionValue(expression);
+	if (isNodeOfType(selector, "Identifier")) {
+		const symbol = scopes.referenceFor(selector)?.resolvedSymbol;
+		if (symbol?.kind === "const" && symbol.initializer && isSymbolStable(symbol) && getSymbolVariableDeclarator(symbol)?.id === symbol.bindingIdentifier && !visitedSymbolIds.has(symbol.id)) {
+			visitedSymbolIds.add(symbol.id);
+			const initializerIdentity = getStaticSelectorIdentity(symbol.initializer, scopes, visitedSymbolIds);
+			if (initializerIdentity) return initializerIdentity;
+		}
+	}
+	if (isNodeOfType(selector, "UnaryExpression") && selector.operator === "!") {
+		const argumentIdentity = getStaticSelectorIdentity(selector.argument, scopes, visitedSymbolIds);
+		return argumentIdentity ? {
+			isInverted: !argumentIdentity.isInverted,
+			key: argumentIdentity.key
+		} : null;
+	}
+	if (isNodeOfType(selector, "BinaryExpression") && [
+		"==",
+		"!=",
+		"===",
+		"!=="
+	].includes(selector.operator)) {
+		const operandPairs = [{
+			literal: selector.right,
+			selectorOperand: selector.left
+		}, {
+			literal: selector.left,
+			selectorOperand: selector.right
+		}];
+		for (const operandPair of operandPairs) {
+			const constantKey = getStaticComparisonConstantKey(operandPair.literal, scopes);
+			if (constantKey === null) continue;
+			const operandKey = getStaticComparisonOperandKey(operandPair.selectorOperand, scopes);
+			if (operandKey === null) continue;
+			return {
+				isInverted: selector.operator === "!=" || selector.operator === "!==",
+				key: JSON.stringify([
+					"comparison",
+					selector.operator.length === 3 ? "strict" : "loose",
+					operandKey,
+					constantKey
+				])
+			};
+		}
+		return null;
+	}
+	if (isNodeOfType(selector, "BinaryExpression") && [
+		"<",
+		"<=",
+		">",
+		">=",
+		"in",
+		"instanceof"
+	].includes(selector.operator)) {
+		const leftKey = getStaticPrimitiveLiteralKey(selector.left) ?? getStaticComparisonOperandKey(selector.left, scopes);
+		const rightKey = getStaticPrimitiveLiteralKey(selector.right) ?? getStaticComparisonOperandKey(selector.right, scopes);
+		if (leftKey !== null && rightKey !== null) return {
+			isInverted: false,
+			key: JSON.stringify([
+				"binary-comparison",
+				selector.operator,
+				leftKey,
+				rightKey
+			])
+		};
+	}
+	const key = getSelectorReferenceKey(selector, scopes);
+	return key === null ? null : {
+		isInverted: false,
+		key
+	};
+};
+const getRenderedRootShapeAlternativeKey = (alternative) => JSON.stringify({
+	facts: [...alternative.facts].map(([key, fact]) => ({
+		key,
+		outcome: fact.outcome
+	})).sort((firstFact, secondFact) => firstFact.key.localeCompare(secondFact.key)),
+	roots: alternative.roots
+});
+const getRenderedRootFactStateKey = (alternative) => JSON.stringify([...alternative.facts].map(([key, fact]) => ({
+	key,
+	outcome: fact.outcome
+})).sort((firstFact, secondFact) => firstFact.key.localeCompare(secondFact.key)));
+const deduplicateRenderedRootShapeAlternatives = (alternatives) => {
+	const deduplicatedAlternatives = [];
+	const alternativeKeys = /* @__PURE__ */ new Set();
+	const alternativeCountsByFactState = /* @__PURE__ */ new Map();
+	for (const alternative of alternatives) {
+		const alternativeKey = getRenderedRootShapeAlternativeKey(alternative);
+		if (alternativeKeys.has(alternativeKey)) continue;
+		const factStateKey = getRenderedRootFactStateKey(alternative);
+		const factStateAlternativeCount = alternativeCountsByFactState.get(factStateKey) ?? 0;
+		if (factStateAlternativeCount > 1) continue;
+		alternativeKeys.add(alternativeKey);
+		alternativeCountsByFactState.set(factStateKey, factStateAlternativeCount + 1);
+		deduplicatedAlternatives.push(alternative);
+		if (deduplicatedAlternatives.length > 64) return null;
+	}
+	return deduplicatedAlternatives;
+};
+const addRenderedRootSelectorFact = (alternatives, identity, expressionOutcome, selector) => {
+	const outcome = identity.isInverted ? !expressionOutcome : expressionOutcome;
+	const constrainedAlternatives = [];
+	for (const alternative of alternatives) {
+		const existingFact = alternative.facts.get(identity.key);
+		if (existingFact && existingFact.outcome !== outcome) continue;
+		constrainedAlternatives.push({
+			facts: new Map(alternative.facts).set(identity.key, {
+				outcome,
+				selector
+			}),
+			roots: alternative.roots
+		});
+	}
+	return constrainedAlternatives;
+};
+const mergeRenderedRootShapeAlternatives = (existingAlternatives, appendedAlternatives) => {
+	const mergedAlternatives = [];
+	for (const existingAlternative of existingAlternatives) for (const appendedAlternative of appendedAlternatives) {
+		const mergedFacts = new Map(existingAlternative.facts);
+		let hasContradictoryFact = false;
+		for (const [key, appendedFact] of appendedAlternative.facts) {
+			const existingFact = mergedFacts.get(key);
+			if (existingFact && existingFact.outcome !== appendedFact.outcome) {
+				hasContradictoryFact = true;
+				break;
+			}
+			mergedFacts.set(key, appendedFact);
+		}
+		if (hasContradictoryFact) continue;
+		mergedAlternatives.push({
+			facts: mergedFacts,
+			roots: [...existingAlternative.roots, ...appendedAlternative.roots]
+		});
+	}
+	return deduplicateRenderedRootShapeAlternatives(mergedAlternatives);
+};
+const combineRenderedRootShapeAlternativeBranches = (branches) => deduplicateRenderedRootShapeAlternatives(branches.flat());
+const getStaticRenderedRootAlternatives = (node, scopes) => {
+	const renderedNode = getFinalSequenceExpressionValue(node);
+	if (isNodeOfType(renderedNode, "JSXElement") && !isJsxFragmentElement(renderedNode.openingElement, scopes)) {
+		const elementIdentity = getJsxElementIdentity(renderedNode.openingElement.name, scopes);
+		return elementIdentity === null ? null : [{
+			facts: /* @__PURE__ */ new Map(),
+			roots: [elementIdentity]
+		}];
+	}
+	if (isNodeOfType(renderedNode, "JSXElement") || isNodeOfType(renderedNode, "JSXFragment")) {
+		let alternatives = [{
+			facts: /* @__PURE__ */ new Map(),
+			roots: []
+		}];
+		for (const child of renderedNode.children) {
+			const childAlternatives = getStaticRenderedRootAlternatives(child, scopes);
+			if (childAlternatives === null) return null;
+			const mergedAlternatives = mergeRenderedRootShapeAlternatives(alternatives, childAlternatives);
+			if (mergedAlternatives === null) return null;
+			alternatives = mergedAlternatives;
+		}
+		return alternatives;
+	}
+	if (isNodeOfType(renderedNode, "JSXText")) return renderedNode.value?.trim() ? null : [{
+		facts: /* @__PURE__ */ new Map(),
+		roots: []
+	}];
+	if (isNodeOfType(renderedNode, "JSXExpressionContainer")) return getStaticRenderedRootAlternatives(renderedNode.expression, scopes);
+	if (isStaticallyEmptyJsxChild(renderedNode)) return [{
+		facts: /* @__PURE__ */ new Map(),
+		roots: []
+	}];
+	if (isNodeOfType(renderedNode, "ConditionalExpression")) {
+		const staticTestValue = readStaticSelectorTruthiness(renderedNode.test, scopes);
+		if (staticTestValue !== null) return getStaticRenderedRootAlternatives(staticTestValue ? renderedNode.consequent : renderedNode.alternate, scopes);
+		const consequentAlternatives = getStaticRenderedRootAlternatives(renderedNode.consequent, scopes);
+		const alternateAlternatives = getStaticRenderedRootAlternatives(renderedNode.alternate, scopes);
+		if (consequentAlternatives === null || alternateAlternatives === null) return null;
+		const selectorIdentity = getStaticSelectorIdentity(renderedNode.test, scopes);
+		return combineRenderedRootShapeAlternativeBranches([selectorIdentity ? addRenderedRootSelectorFact(consequentAlternatives, selectorIdentity, true, renderedNode.test) : consequentAlternatives, selectorIdentity ? addRenderedRootSelectorFact(alternateAlternatives, selectorIdentity, false, renderedNode.test) : alternateAlternatives]);
+	}
+	if (isNodeOfType(renderedNode, "LogicalExpression")) {
+		const selectorIdentity = (renderedNode.operator === "&&" || renderedNode.operator === "||") && isStaticallyEmptyJsxChild(renderedNode.left) ? getStaticSelectorIdentity(renderedNode.left, scopes) : null;
+		if (selectorIdentity) {
+			const rightAlternatives = getStaticRenderedRootAlternatives(renderedNode.right, scopes);
+			if (rightAlternatives === null) return null;
+			const emptyAlternatives = [{
+				facts: /* @__PURE__ */ new Map(),
+				roots: []
+			}];
+			return combineRenderedRootShapeAlternativeBranches([addRenderedRootSelectorFact(renderedNode.operator === "&&" ? rightAlternatives : emptyAlternatives, selectorIdentity, true, renderedNode.left), addRenderedRootSelectorFact(renderedNode.operator === "&&" ? emptyAlternatives : rightAlternatives, selectorIdentity, false, renderedNode.left)]);
+		}
+		const resultAlternatives = [];
+		for (const resultBranch of getStaticLogicalExpressionResultBranches(renderedNode)) {
+			const branchAlternatives = getStaticRenderedRootAlternatives(resultBranch, scopes);
+			if (branchAlternatives === null) return null;
+			resultAlternatives.push(branchAlternatives);
+		}
+		return combineRenderedRootShapeAlternativeBranches(resultAlternatives);
+	}
+	return null;
+};
+const getFlattenedFragmentChildren = (node, scopes) => {
+	const flattenChild = (child) => {
+		const renderedChild = getFinalSequenceExpressionValue(child);
+		if (isNodeOfType(renderedChild, "JSXExpressionContainer")) return flattenChild(renderedChild.expression);
+		if (!isNodeOfType(renderedChild, "JSXFragment") && (!isNodeOfType(renderedChild, "JSXElement") || !isJsxFragmentElement(renderedChild.openingElement, scopes))) return [child];
+		return renderedChild.children.flatMap(flattenChild);
+	};
+	const renderedNode = getFinalSequenceExpressionValue(node);
+	if (!isNodeOfType(renderedNode, "JSXFragment") && (!isNodeOfType(renderedNode, "JSXElement") || !isJsxFragmentElement(renderedNode.openingElement, scopes))) return null;
+	return renderedNode.children.flatMap(flattenChild);
+};
+const forgetFinalizedRenderedRootFacts = (alternatives, futureFactKeyCounts) => deduplicateRenderedRootShapeAlternatives(alternatives.map((alternative) => ({
+	facts: new Map([...alternative.facts].filter(([key]) => (futureFactKeyCounts.get(key) ?? 0) > 0)),
+	roots: alternative.roots
+})));
+const getStaticRenderedRootShapes = (node, scopes) => {
+	let alternatives = getStaticRenderedRootAlternatives(node, scopes);
+	if (alternatives === null) {
+		const fragmentChildren = getFlattenedFragmentChildren(node, scopes);
+		if (fragmentChildren === null) return null;
+		const childAlternatives = [];
+		for (const child of fragmentChildren) {
+			const staticChildAlternatives = getStaticRenderedRootAlternatives(child, scopes);
+			if (staticChildAlternatives === null) return null;
+			childAlternatives.push(staticChildAlternatives);
+		}
+		const futureFactKeyCounts = /* @__PURE__ */ new Map();
+		for (const staticChildAlternatives of childAlternatives) {
+			const childFactKeys = /* @__PURE__ */ new Set();
+			for (const alternative of staticChildAlternatives) for (const key of alternative.facts.keys()) childFactKeys.add(key);
+			for (const key of childFactKeys) futureFactKeyCounts.set(key, (futureFactKeyCounts.get(key) ?? 0) + 1);
+		}
+		let prefixAlternatives = [{
+			facts: /* @__PURE__ */ new Map(),
+			roots: []
+		}];
+		let witnessAlternatives = null;
+		for (const staticChildAlternatives of childAlternatives) {
+			const currentFactKeys = /* @__PURE__ */ new Set();
+			for (const alternative of staticChildAlternatives) for (const key of alternative.facts.keys()) currentFactKeys.add(key);
+			for (const key of currentFactKeys) futureFactKeyCounts.set(key, (futureFactKeyCounts.get(key) ?? 1) - 1);
+			const mergedAlternatives = mergeRenderedRootShapeAlternatives(prefixAlternatives, staticChildAlternatives);
+			if (mergedAlternatives === null) break;
+			prefixAlternatives = mergedAlternatives;
+			for (let firstAlternativeIndex = 0; firstAlternativeIndex < prefixAlternatives.length; firstAlternativeIndex += 1) {
+				const firstAlternative = prefixAlternatives[firstAlternativeIndex];
+				for (let secondAlternativeIndex = firstAlternativeIndex + 1; secondAlternativeIndex < prefixAlternatives.length; secondAlternativeIndex += 1) {
+					const secondAlternative = prefixAlternatives[secondAlternativeIndex];
+					if (JSON.stringify(firstAlternative.roots) === JSON.stringify(secondAlternative.roots)) continue;
+					if ([...firstAlternative.facts].some(([key, firstFact]) => {
+						const secondFact = secondAlternative.facts.get(key);
+						return futureFactKeyCounts.get(key) === 0 && secondFact !== void 0 && secondFact.outcome !== firstFact.outcome;
+					})) {
+						witnessAlternatives = [firstAlternative, secondAlternative];
+						break;
+					}
+				}
+				if (witnessAlternatives) break;
+			}
+			if (witnessAlternatives) break;
+			const remainingAlternatives = forgetFinalizedRenderedRootFacts(prefixAlternatives, futureFactKeyCounts);
+			if (remainingAlternatives === null) break;
+			prefixAlternatives = remainingAlternatives;
+		}
+		if (witnessAlternatives === null) return null;
+		alternatives = witnessAlternatives;
+	}
+	const rootShapes = [];
+	const rootShapeKeys = /* @__PURE__ */ new Set();
+	for (const alternative of alternatives) {
+		const rootShapeKey = JSON.stringify(alternative.roots);
+		if (rootShapeKeys.has(rootShapeKey)) continue;
+		rootShapeKeys.add(rootShapeKey);
+		rootShapes.push([...alternative.roots]);
+	}
+	return rootShapes;
+};
+const getRenderedRootNames = (root, scopes) => {
+	const renderedRootShapes = getStaticRenderedRootShapes(root, scopes);
+	if (renderedRootShapes === null) return null;
+	return renderedRootShapes.map((rootShape) => {
+		const onlyRootName = rootShape[0];
+		return rootShape.length === 1 && onlyRootName ? onlyRootName : `fragment:${JSON.stringify(rootShape)}`;
+	});
+};
+const getPatternBindingIdentifier = (pattern) => {
+	const unwrappedPattern = stripParenExpression(pattern);
+	if (isNodeOfType(unwrappedPattern, "Identifier")) return unwrappedPattern;
+	if (isNodeOfType(unwrappedPattern, "AssignmentPattern")) return getPatternBindingIdentifier(unwrappedPattern.left);
+	return null;
+};
+const getObjectPatternPropertyBinding = (pattern, propertyName) => {
+	const unwrappedPattern = stripParenExpression(pattern);
+	if (!isNodeOfType(unwrappedPattern, "ObjectPattern")) return null;
+	for (const property of unwrappedPattern.properties) {
+		if (!isNodeOfType(property, "Property") || getStaticPropertyKeyName(property, { allowComputedString: true }) !== propertyName) continue;
+		return getPatternBindingIdentifier(property.value);
+	}
+	return null;
+};
+const isUnconditionallyTerminalStatement = (statement) => {
+	if (isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement")) return true;
+	if (isNodeOfType(statement, "BlockStatement")) return statement.body.some(isUnconditionallyTerminalStatement);
+	if (isNodeOfType(statement, "IfStatement")) return Boolean(statement.alternate && isUnconditionallyTerminalStatement(statement.consequent) && isUnconditionallyTerminalStatement(statement.alternate));
+	if (isNodeOfType(statement, "SwitchStatement")) return statement.cases.some((switchCase) => switchCase.test === null) && statement.cases.every((switchCase) => switchCase.consequent.some(isUnconditionallyTerminalStatement));
+	return false;
+};
+const getReachableFunctionReturnStatements = (functionNode, scopes) => collectFunctionReturnStatements(functionNode).filter((returnStatement) => {
+	let descendant = returnStatement;
+	let ancestor = returnStatement.parent;
+	while (ancestor && ancestor !== functionNode) {
+		if (isNodeOfType(ancestor, "IfStatement")) {
+			const staticTestValue = readStaticSelectorTruthiness(ancestor.test, scopes);
+			if (staticTestValue !== null && (staticTestValue && ancestor.alternate === descendant || !staticTestValue && ancestor.consequent === descendant)) return false;
+		}
+		if (isNodeOfType(ancestor, "BlockStatement")) {
+			const descendantIndex = ancestor.body.findIndex((statement) => statement === descendant);
+			if (descendantIndex > 0 && ancestor.body.slice(0, descendantIndex).some((statement) => {
+				if (isNodeOfType(statement, "IfStatement")) {
+					const staticTestValue = readStaticSelectorTruthiness(statement.test, scopes);
+					if (staticTestValue === true) return isUnconditionallyTerminalStatement(statement.consequent);
+					if (staticTestValue === false) return Boolean(statement.alternate && isUnconditionallyTerminalStatement(statement.alternate));
+				}
+				return isUnconditionallyTerminalStatement(statement);
+			})) return false;
+		}
+		descendant = ancestor;
+		ancestor = ancestor.parent;
+	}
+	return true;
+});
+const getRenderItemInputReferences = (functionNode, scopes) => {
+	if (!isFunctionLike$1(functionNode)) return [];
+	const parameter = functionNode.params[0];
+	if (!parameter) return [];
+	const unwrappedParameter = stripParenExpression(parameter);
+	if (isNodeOfType(unwrappedParameter, "Identifier")) {
+		const symbol = scopes.symbolFor(unwrappedParameter);
+		if (!symbol) return [];
+		return [...RENDER_ITEM_INPUT_NAMES].map((inputName) => ({
+			inputName,
+			isStable: isSymbolStable(symbol),
+			propertyName: inputName,
+			symbolId: symbol.id
+		}));
+	}
+	if (!isNodeOfType(unwrappedParameter, "ObjectPattern")) return [];
+	const references = [];
+	for (const inputName of RENDER_ITEM_INPUT_NAMES) {
+		const bindingIdentifier = getObjectPatternPropertyBinding(unwrappedParameter, inputName);
+		const symbol = bindingIdentifier ? scopes.symbolFor(bindingIdentifier) : null;
+		if (symbol) references.push({
+			inputName,
+			isStable: isSymbolStable(symbol),
+			propertyName: null,
+			symbolId: symbol.id
+		});
+	}
+	return references;
+};
+const isStaticallyTruthyContainer = (node) => isNodeOfType(node, "ArrayExpression") || isNodeOfType(node, "ObjectExpression") || isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ClassExpression") || isNodeOfType(node, "NewExpression") || isNodeOfType(node, "JSXElement") || isNodeOfType(node, "JSXFragment");
+const expressionReadsInput = (expression, inputReferences, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const inputExpression = getFinalSequenceExpressionValue(expression);
+	if (isStaticallyTruthyContainer(inputExpression)) return false;
+	let didReadInput = false;
+	walkAst(inputExpression, (node) => {
+		if (didReadInput) return false;
+		if (node !== inputExpression && (isFunctionLike$1(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
+		if (isNodeOfType(node, "Identifier")) {
+			const reference = scopes.referenceFor(node);
+			if (reference && reference.flag !== "write" && inputReferences.some((inputReference) => inputReference.isStable && inputReference.propertyName === null && inputReference.symbolId === reference.resolvedSymbol?.id)) {
+				didReadInput = true;
+				return false;
+			}
+			const symbol = reference?.resolvedSymbol;
+			if (symbol?.kind === "const" && symbol.initializer && isSymbolStable(symbol) && !visitedSymbolIds.has(symbol.id)) {
+				visitedSymbolIds.add(symbol.id);
+				for (const initializer of getConstInitializerExpressions(symbol)) if (expressionReadsInput(initializer, inputReferences, scopes, visitedSymbolIds)) {
+					didReadInput = true;
+					return false;
+				}
+			}
+		}
+		if (!isNodeOfType(node, "MemberExpression")) return;
+		const propertyName = getStaticPropertyName(node);
+		const receiver = stripParenExpression(node.object);
+		if (propertyName === null || !isNodeOfType(receiver, "Identifier")) return;
+		const receiverReference = scopes.referenceFor(receiver);
+		if (receiverReference && receiverReference.flag !== "write" && inputReferences.some((inputReference) => inputReference.isStable && inputReference.propertyName === propertyName && inputReference.symbolId === receiverReference.resolvedSymbol?.id)) {
+			didReadInput = true;
+			return false;
+		}
+	});
+	return didReadInput;
+};
+const climbTransparentExpressionWrappers = (node) => {
+	let expression = node;
+	while (expression.parent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(expression.parent.type) && "expression" in expression.parent && expression.parent.expression === expression) expression = expression.parent;
+	return expression;
+};
+const isProvenStaticCallableReference = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const reference = stripParenExpression(expression);
+	if (isNodeOfType(reference, "MemberExpression")) return getImportedStaticReferenceKey(reference, scopes) !== null;
+	if (!isNodeOfType(reference, "Identifier")) return false;
+	const symbol = scopes.referenceFor(reference)?.resolvedSymbol;
+	if (!symbol) return scopes.isGlobalReference(reference);
+	if (!isSymbolStable(symbol) || visitedSymbolIds.has(symbol.id)) return false;
+	if (symbol.kind === "import" || symbol.kind === "function") return true;
+	if (symbol.kind !== "const" || !symbol.initializer) return false;
+	visitedSymbolIds.add(symbol.id);
+	const initializer = stripParenExpression(symbol.initializer);
+	if (isFunctionLike$1(initializer)) return true;
+	return isNodeOfType(initializer, "Identifier") || isNodeOfType(initializer, "MemberExpression") ? isProvenStaticCallableReference(initializer, scopes, visitedSymbolIds) : false;
+};
+const isProvenStaticCallCallee = (identifier, scopes) => {
+	let callee = climbTransparentExpressionWrappers(identifier);
+	while (isNodeOfType(callee.parent, "MemberExpression") && callee.parent.object === callee) callee = climbTransparentExpressionWrappers(callee.parent);
+	return isNodeOfType(callee.parent, "CallExpression") && callee.parent.callee === callee && isProvenStaticCallableReference(callee, scopes);
+};
+const isInsideComparisonOperand = (identifier) => {
+	let descendant = climbTransparentExpressionWrappers(identifier);
+	let ancestor = descendant.parent;
+	while (isNodeOfType(ancestor, "MemberExpression") && (ancestor.object === descendant || ancestor.property === descendant)) {
+		descendant = climbTransparentExpressionWrappers(ancestor);
+		ancestor = descendant.parent;
+	}
+	return isNodeOfType(ancestor, "BinaryExpression") && [
+		"==",
+		"!=",
+		"===",
+		"!==",
+		"<",
+		"<=",
+		">",
+		">=",
+		"in",
+		"instanceof"
+	].includes(ancestor.operator);
+};
+const expressionReadsOnlyInput = (expression, inputReferences, scopes) => {
+	if (!expressionReadsInput(expression, inputReferences, scopes)) return false;
+	const selector = getFinalSequenceExpressionValue(expression);
+	let hasUnrelatedRead = false;
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	const inspectExpression = (candidate) => {
+		walkAst(candidate, (node) => {
+			if (hasUnrelatedRead) return false;
+			if (node !== candidate && (isFunctionLike$1(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
+			if (!isNodeOfType(node, "Identifier")) return;
+			const parent = node.parent;
+			if (isNodeOfType(parent, "MemberExpression") && parent.property === node && !parent.computed || isNodeOfType(parent, "Property") && parent.key === node && !parent.computed || isProvenStaticCallCallee(node, scopes)) return;
+			const symbol = scopes.referenceFor(node)?.resolvedSymbol;
+			const isDirectInput = inputReferences.some((inputReference) => inputReference.isStable && inputReference.propertyName === null && inputReference.symbolId === symbol?.id);
+			const isInputContainer = isNodeOfType(parent, "MemberExpression") && parent.object === node && inputReferences.some((inputReference) => inputReference.isStable && inputReference.propertyName === getStaticPropertyName(parent) && inputReference.symbolId === symbol?.id);
+			if (isDirectInput || isInputContainer) return;
+			if (symbol?.kind === "import" && isInsideComparisonOperand(node)) return;
+			if (symbol?.kind === "const" && symbol.initializer && isSymbolStable(symbol) && visitedSymbolIds.has(symbol.id)) return;
+			if (symbol?.kind === "const" && symbol.initializer && isSymbolStable(symbol) && !visitedSymbolIds.has(symbol.id)) {
+				visitedSymbolIds.add(symbol.id);
+				const initializers = getConstInitializerExpressions(symbol);
+				if (!initializers.some((initializer) => expressionReadsInput(initializer, inputReferences, scopes)) && initializers.some((initializer) => readStaticSelectorTruthiness(initializer, scopes) === null)) {
+					hasUnrelatedRead = true;
+					return false;
+				}
+				for (const initializer of initializers) inspectExpression(initializer);
+				return;
+			}
+			hasUnrelatedRead = true;
+			return false;
+		});
+	};
+	inspectExpression(selector);
+	return !hasUnrelatedRead;
+};
+const hasInputDependentRenderedRootDifference = (expression, inputReferences, scopes) => {
+	const alternativesHaveInputDependentDifference = (alternatives, eligibleFactKeys) => {
+		for (let firstAlternativeIndex = 0; firstAlternativeIndex < alternatives.length; firstAlternativeIndex += 1) {
+			const firstAlternative = alternatives[firstAlternativeIndex];
+			for (let secondAlternativeIndex = firstAlternativeIndex + 1; secondAlternativeIndex < alternatives.length; secondAlternativeIndex += 1) {
+				const secondAlternative = alternatives[secondAlternativeIndex];
+				if (JSON.stringify(firstAlternative.roots) === JSON.stringify(secondAlternative.roots)) continue;
+				let hasInputDependentDifference = false;
+				let hasAmbientConflict = false;
+				for (const [key, firstFact] of firstAlternative.facts) {
+					const secondFact = secondAlternative.facts.get(key);
+					if (!secondFact || firstFact.outcome === secondFact.outcome) continue;
+					if ((!eligibleFactKeys || eligibleFactKeys.has(key)) && expressionReadsOnlyInput(firstFact.selector, inputReferences, scopes) && expressionReadsOnlyInput(secondFact.selector, inputReferences, scopes)) hasInputDependentDifference = true;
+					else hasAmbientConflict = true;
+				}
+				if (hasInputDependentDifference && !hasAmbientConflict) return true;
+			}
+		}
+		return false;
+	};
+	const renderedExpression = getFinalSequenceExpressionValue(expression);
+	const fragmentChildren = getFlattenedFragmentChildren(renderedExpression, scopes);
+	if (fragmentChildren !== null) {
+		const childAlternatives = [];
+		for (const child of fragmentChildren) {
+			const alternatives = getStaticRenderedRootAlternatives(child, scopes);
+			if (alternatives === null) return false;
+			childAlternatives.push(alternatives);
+		}
+		const futureFactKeyCounts = /* @__PURE__ */ new Map();
+		for (const alternatives of childAlternatives) {
+			const childFactKeys = /* @__PURE__ */ new Set();
+			for (const alternative of alternatives) for (const key of alternative.facts.keys()) childFactKeys.add(key);
+			for (const key of childFactKeys) futureFactKeyCounts.set(key, (futureFactKeyCounts.get(key) ?? 0) + 1);
+		}
+		let prefixAlternatives = [{
+			facts: /* @__PURE__ */ new Map(),
+			roots: []
+		}];
+		for (const alternatives of childAlternatives) {
+			const currentFactKeys = /* @__PURE__ */ new Set();
+			for (const alternative of alternatives) for (const key of alternative.facts.keys()) currentFactKeys.add(key);
+			for (const key of currentFactKeys) futureFactKeyCounts.set(key, (futureFactKeyCounts.get(key) ?? 1) - 1);
+			const mergedAlternatives = mergeRenderedRootShapeAlternatives(prefixAlternatives, alternatives);
+			if (mergedAlternatives === null) return false;
+			prefixAlternatives = mergedAlternatives;
+			const finalFactKeys = /* @__PURE__ */ new Set();
+			for (const alternative of prefixAlternatives) for (const key of alternative.facts.keys()) if (futureFactKeyCounts.get(key) === 0) finalFactKeys.add(key);
+			if (finalFactKeys.size > 0 && alternativesHaveInputDependentDifference(prefixAlternatives, finalFactKeys)) return true;
+			const remainingAlternatives = forgetFinalizedRenderedRootFacts(prefixAlternatives, futureFactKeyCounts);
+			if (remainingAlternatives === null) return false;
+			prefixAlternatives = remainingAlternatives;
+		}
+		return false;
+	}
+	const alternatives = getStaticRenderedRootAlternatives(renderedExpression, scopes);
+	return alternatives !== null && alternativesHaveInputDependentDifference(alternatives);
+};
+const getKnownReturnedRootNames = (expression, scopes) => {
+	const returnedExpression = getFinalSequenceExpressionValue(expression);
+	if (isNodeOfType(returnedExpression, "JSXElement") || isNodeOfType(returnedExpression, "JSXFragment")) {
+		const rootNames = getRenderedRootNames(returnedExpression, scopes);
+		return rootNames === null ? null : new Set(rootNames);
+	}
+	if (isStaticallyEmptyJsxChild(returnedExpression)) return new Set([EMPTY_RENDERED_ROOT_NAME]);
+	let branches;
+	if (isNodeOfType(returnedExpression, "ConditionalExpression")) branches = [returnedExpression.consequent, returnedExpression.alternate];
+	else if (isNodeOfType(returnedExpression, "LogicalExpression")) branches = getStaticLogicalExpressionResultBranches(returnedExpression);
+	else return null;
+	const rootNames = /* @__PURE__ */ new Set();
+	for (const branch of branches) {
+		const branchRootNames = getKnownReturnedRootNames(branch, scopes);
+		if (branchRootNames === null) return null;
+		for (const rootName of branchRootNames) rootNames.add(rootName);
+	}
+	return rootNames;
+};
+const collectKnownStatementRootNames = (statement, scopes) => {
+	const rootNames = /* @__PURE__ */ new Set();
+	let hasUnknownRoot = false;
+	walkAst(statement, (node) => {
+		if (hasUnknownRoot) return false;
+		if (node !== statement && (isFunctionLike$1(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
+		if (!isNodeOfType(node, "ReturnStatement")) return;
+		const returnedRootNames = node.argument ? getKnownReturnedRootNames(node.argument, scopes) : new Set([EMPTY_RENDERED_ROOT_NAME]);
+		if (returnedRootNames === null) {
+			hasUnknownRoot = true;
+			return false;
+		}
+		for (const rootName of returnedRootNames) rootNames.add(rootName);
+		return false;
+	});
+	return hasUnknownRoot || rootNames.size === 0 ? null : rootNames;
+};
+const collectKnownContinuationRootNames = (ifStatement, scopes) => {
+	const parent = ifStatement.parent;
+	if (!parent || !isNodeOfType(parent, "BlockStatement")) return null;
+	const statementIndex = parent.body.findIndex((statement) => statement === ifStatement);
+	if (statementIndex < 0) return null;
+	const rootNames = /* @__PURE__ */ new Set();
+	for (const statement of parent.body.slice(statementIndex + 1)) {
+		const statementRootNames = collectKnownStatementRootNames(statement, scopes);
+		if (statementRootNames) for (const rootName of statementRootNames) rootNames.add(rootName);
+		if (isUnconditionallyTerminalStatement(statement)) break;
+	}
+	return rootNames.size === 0 ? null : rootNames;
+};
+const getDirectStatementRootAlternatives = (statement, scopes) => {
+	if (isNodeOfType(statement, "ReturnStatement")) return statement.argument ? getStaticRenderedRootAlternatives(statement.argument, scopes) : [{
+		facts: /* @__PURE__ */ new Map(),
+		roots: []
+	}];
+	if (isNodeOfType(statement, "BlockStatement") && statement.body.length === 1) return getDirectStatementRootAlternatives(statement.body[0], scopes);
+	return null;
+};
+const getContinuationRootAlternatives = (ifStatement, scopes) => {
+	const parent = ifStatement.parent;
+	if (!parent || !isNodeOfType(parent, "BlockStatement")) return null;
+	const statementIndex = parent.body.findIndex((statement) => statement === ifStatement);
+	if (statementIndex < 0) return null;
+	for (const statement of parent.body.slice(statementIndex + 1)) {
+		const alternatives = getDirectStatementRootAlternatives(statement, scopes);
+		if (alternatives !== null) return alternatives;
+		if (isUnconditionallyTerminalStatement(statement)) return null;
+	}
+	return null;
+};
+const renderedRootFactsAreCompatible = (firstFacts, secondFacts) => {
+	for (const [key, firstFact] of firstFacts) {
+		const secondFact = secondFacts.get(key);
+		if (secondFact && secondFact.outcome !== firstFact.outcome) return false;
+	}
+	return true;
+};
+const hasDistinctKnownIfRootOutcomes = (ifStatement, scopes) => {
+	if (!isUnconditionallyTerminalStatement(ifStatement.consequent)) return false;
+	const consequentAlternatives = getDirectStatementRootAlternatives(ifStatement.consequent, scopes);
+	const alternateAlternatives = ifStatement.alternate ? isUnconditionallyTerminalStatement(ifStatement.alternate) ? getDirectStatementRootAlternatives(ifStatement.alternate, scopes) : null : getContinuationRootAlternatives(ifStatement, scopes);
+	if (consequentAlternatives && alternateAlternatives) return consequentAlternatives.some((consequentAlternative) => alternateAlternatives.some((alternateAlternative) => renderedRootFactsAreCompatible(consequentAlternative.facts, alternateAlternative.facts) && JSON.stringify(consequentAlternative.roots) !== JSON.stringify(alternateAlternative.roots)));
+	const consequentRootNames = collectKnownStatementRootNames(ifStatement.consequent, scopes);
+	const alternateRootNames = ifStatement.alternate ? isUnconditionallyTerminalStatement(ifStatement.alternate) ? collectKnownStatementRootNames(ifStatement.alternate, scopes) : null : collectKnownContinuationRootNames(ifStatement, scopes);
+	if (!consequentRootNames || !alternateRootNames) return false;
+	return [...consequentRootNames].some((rootName) => !alternateRootNames.has(rootName)) || [...alternateRootNames].some((rootName) => !consequentRootNames.has(rootName));
+};
+const hasDistinctKnownSwitchRootOutcomes = (switchStatement, scopes) => {
+	if (!switchStatement.cases.some((switchCase) => switchCase.test === null) || !switchStatement.cases.every((switchCase) => switchCase.consequent.some(isUnconditionallyTerminalStatement))) return false;
+	const caseRootNames = [];
+	for (const switchCase of switchStatement.cases) {
+		const rootNames = collectKnownStatementRootNames(switchCase, scopes);
+		if (!rootNames) return false;
+		caseRootNames.push(rootNames);
+	}
+	for (let firstCaseIndex = 0; firstCaseIndex < caseRootNames.length; firstCaseIndex += 1) {
+		const firstRootNames = caseRootNames[firstCaseIndex];
+		for (let secondCaseIndex = firstCaseIndex + 1; secondCaseIndex < caseRootNames.length; secondCaseIndex += 1) {
+			const secondRootNames = caseRootNames[secondCaseIndex];
+			if ([...firstRootNames].every((rootName) => !secondRootNames.has(rootName))) return true;
+		}
+	}
+	return false;
+};
+const readStaticSelectorTruthiness = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const selector = getFinalSequenceExpressionValue(expression);
+	if (isStaticallyTruthyContainer(selector)) return true;
+	if (isNodeOfType(selector, "Literal")) return Boolean(selector.value);
+	if (isNodeOfType(selector, "Identifier")) {
+		const symbol = scopes.symbolFor(selector);
+		if (symbol && (symbol.kind === "function" || symbol.kind === "class") && isSymbolStable(symbol)) return true;
+		if (symbol?.kind === "const" && symbol.initializer && isSymbolStable(symbol) && getSymbolVariableDeclarator(symbol)?.id === symbol.bindingIdentifier && !visitedSymbolIds.has(symbol.id)) {
+			visitedSymbolIds.add(symbol.id);
+			return readStaticSelectorTruthiness(symbol.initializer, scopes, visitedSymbolIds);
+		}
+	}
+	if (isNodeOfType(selector, "UnaryExpression") && selector.operator === "!") {
+		const argumentTruthiness = readStaticSelectorTruthiness(selector.argument, scopes, visitedSymbolIds);
+		return argumentTruthiness === null ? null : !argumentTruthiness;
+	}
+	if (!isNodeOfType(selector, "LogicalExpression")) return null;
+	const leftTruthiness = readStaticSelectorTruthiness(selector.left, scopes, new Set(visitedSymbolIds));
+	const rightTruthiness = readStaticSelectorTruthiness(selector.right, scopes, new Set(visitedSymbolIds));
+	if (selector.operator === "&&") {
+		if (leftTruthiness === false || rightTruthiness === false) return false;
+		return leftTruthiness === true ? rightTruthiness : null;
+	}
+	if (selector.operator === "||") {
+		if (leftTruthiness === true || rightTruthiness === true) return true;
+		return leftTruthiness === false ? rightTruthiness : null;
+	}
+	return leftTruthiness;
+};
+const analyzeReturnedExpressionSelections = (expression, inputReferences, scopes) => {
+	const returnedExpression = getFinalSequenceExpressionValue(expression);
+	if (isNodeOfType(returnedExpression, "JSXExpressionContainer")) return analyzeReturnedExpressionSelections(returnedExpression.expression, inputReferences, scopes);
+	if (isNodeOfType(returnedExpression, "JSXFragment") || isNodeOfType(returnedExpression, "JSXElement") && isJsxFragmentElement(returnedExpression.openingElement, scopes)) {
+		let hasInputDependentSelection = false;
+		let hasUnrelatedSelection = false;
+		for (const child of returnedExpression.children) {
+			const childAnalysis = analyzeReturnedExpressionSelections(child, inputReferences, scopes);
+			hasInputDependentSelection ||= childAnalysis.hasInputDependentSelection;
+			hasUnrelatedSelection ||= childAnalysis.hasUnrelatedSelection;
+		}
+		return {
+			hasInputDependentSelection,
+			hasProvenInputDependentRootSelection: hasInputDependentRenderedRootDifference(returnedExpression, inputReferences, scopes),
+			hasUnrelatedSelection
+		};
+	}
+	if (isNodeOfType(returnedExpression, "ConditionalExpression")) {
+		const staticTestValue = readStaticSelectorTruthiness(returnedExpression.test, scopes);
+		if (staticTestValue !== null) return analyzeReturnedExpressionSelections(staticTestValue ? returnedExpression.consequent : returnedExpression.alternate, inputReferences, scopes);
+		const consequentAnalysis = analyzeReturnedExpressionSelections(returnedExpression.consequent, inputReferences, scopes);
+		const alternateAnalysis = analyzeReturnedExpressionSelections(returnedExpression.alternate, inputReferences, scopes);
+		const selectorReadsInput = expressionReadsOnlyInput(returnedExpression.test, inputReferences, scopes);
+		const selectedRootNames = getKnownReturnedRootNames(returnedExpression, scopes);
+		return {
+			hasInputDependentSelection: selectorReadsInput || consequentAnalysis.hasInputDependentSelection || alternateAnalysis.hasInputDependentSelection,
+			hasProvenInputDependentRootSelection: selectorReadsInput && selectedRootNames !== null && selectedRootNames.size > 1 || consequentAnalysis.hasProvenInputDependentRootSelection || alternateAnalysis.hasProvenInputDependentRootSelection,
+			hasUnrelatedSelection: !selectorReadsInput && (selectedRootNames === null || selectedRootNames.size > 1) || consequentAnalysis.hasUnrelatedSelection || alternateAnalysis.hasUnrelatedSelection
+		};
+	}
+	if (isNodeOfType(returnedExpression, "LogicalExpression")) {
+		const resultBranches = getStaticLogicalExpressionResultBranches(returnedExpression);
+		if (resultBranches.length < 2) {
+			const onlyResult = resultBranches[0];
+			return onlyResult ? analyzeReturnedExpressionSelections(onlyResult, inputReferences, scopes) : {
+				hasInputDependentSelection: false,
+				hasProvenInputDependentRootSelection: false,
+				hasUnrelatedSelection: false
+			};
+		}
+		const leftAnalysis = analyzeReturnedExpressionSelections(returnedExpression.left, inputReferences, scopes);
+		const rightAnalysis = analyzeReturnedExpressionSelections(returnedExpression.right, inputReferences, scopes);
+		const selectorReadsInput = expressionReadsOnlyInput(returnedExpression.left, inputReferences, scopes);
+		const selectedRootNames = getKnownReturnedRootNames(returnedExpression, scopes);
+		return {
+			hasInputDependentSelection: selectorReadsInput || leftAnalysis.hasInputDependentSelection || rightAnalysis.hasInputDependentSelection,
+			hasProvenInputDependentRootSelection: selectorReadsInput && selectedRootNames !== null && selectedRootNames.size > 1 || leftAnalysis.hasProvenInputDependentRootSelection || rightAnalysis.hasProvenInputDependentRootSelection,
+			hasUnrelatedSelection: !selectorReadsInput && (selectedRootNames === null || selectedRootNames.size > 1) || leftAnalysis.hasUnrelatedSelection || rightAnalysis.hasUnrelatedSelection
+		};
+	}
+	if (isNodeOfType(returnedExpression, "CallExpression") && isReactApiCall(returnedExpression, "createElement", scopes, {
+		allowGlobalReactNamespace: true,
+		resolveNamedAliases: true
+	})) {
+		const componentArgument = returnedExpression.arguments[0];
+		if (componentArgument && !isNodeOfType(componentArgument, "SpreadElement")) return analyzeReturnedExpressionSelections(componentArgument, inputReferences, scopes);
+	}
+	return {
+		hasInputDependentSelection: false,
+		hasProvenInputDependentRootSelection: false,
+		hasUnrelatedSelection: false
+	};
+};
+const analyzeFunctionInputSelections = (functionNode, inputReferences, scopes) => {
+	if (!isFunctionLike$1(functionNode)) return {
+		hasInputDependentSelection: false,
+		hasProvenInputDependentRootSelection: false,
+		hasUnrelatedSelection: false
+	};
+	if (!isNodeOfType(functionNode.body, "BlockStatement")) return analyzeReturnedExpressionSelections(functionNode.body, inputReferences, scopes);
+	let hasInputDependentSelection = false;
+	let hasProvenInputDependentRootSelection = false;
+	let hasUnrelatedSelection = false;
+	const analyzedAncestors = /* @__PURE__ */ new Set();
+	for (const returnStatement of getReachableFunctionReturnStatements(functionNode, scopes)) {
+		const returnedRootNames = returnStatement.argument ? getKnownReturnedRootNames(returnStatement.argument, scopes) : /* @__PURE__ */ new Set();
+		if (returnStatement.argument) {
+			const returnAnalysis = analyzeReturnedExpressionSelections(returnStatement.argument, inputReferences, scopes);
+			hasInputDependentSelection ||= returnAnalysis.hasInputDependentSelection;
+			hasProvenInputDependentRootSelection ||= returnAnalysis.hasProvenInputDependentRootSelection;
+			hasUnrelatedSelection ||= returnAnalysis.hasUnrelatedSelection;
+		}
+		if (returnedRootNames && [...returnedRootNames].every((rootName) => rootName === EMPTY_RENDERED_ROOT_NAME)) continue;
+		let ancestor = returnStatement.parent;
+		while (ancestor && ancestor !== functionNode) {
+			if (analyzedAncestors.has(ancestor)) break;
+			analyzedAncestors.add(ancestor);
+			let selector = null;
+			if (isNodeOfType(ancestor, "IfStatement")) selector = ancestor.test;
+			else if (isNodeOfType(ancestor, "SwitchStatement")) selector = ancestor.discriminant;
+			else if (isNodeOfType(ancestor, "TryStatement") || isNodeOfType(ancestor, "ForStatement") || isNodeOfType(ancestor, "ForInStatement") || isNodeOfType(ancestor, "ForOfStatement") || isNodeOfType(ancestor, "WhileStatement") || isNodeOfType(ancestor, "DoWhileStatement")) hasUnrelatedSelection = true;
+			if (selector) if (expressionReadsOnlyInput(selector, inputReferences, scopes)) {
+				hasInputDependentSelection = true;
+				if (isNodeOfType(ancestor, "IfStatement") && hasDistinctKnownIfRootOutcomes(ancestor, scopes) || isNodeOfType(ancestor, "SwitchStatement") && hasDistinctKnownSwitchRootOutcomes(ancestor, scopes)) hasProvenInputDependentRootSelection = true;
+			} else hasUnrelatedSelection = true;
+			ancestor = ancestor.parent;
+		}
+	}
+	return {
+		hasInputDependentSelection,
+		hasProvenInputDependentRootSelection,
+		hasUnrelatedSelection
+	};
+};
+const expressionHasOnlyInputDependentSelections = (expression, inputReferences, scopes) => {
+	const selectionAnalysis = analyzeReturnedExpressionSelections(expression, inputReferences, scopes);
+	return selectionAnalysis.hasInputDependentSelection && !selectionAnalysis.hasUnrelatedSelection;
+};
+const functionHasOnlyInputDependentSelections = (functionNode, inputReferences, scopes) => {
+	const selectionAnalysis = analyzeFunctionInputSelections(functionNode, inputReferences, scopes);
+	return selectionAnalysis.hasInputDependentSelection && !selectionAnalysis.hasUnrelatedSelection;
+};
+const getComponentExpressionIdentity = (expression, scopes) => {
+	const componentExpression = stripParenExpression(expression);
+	if (isNodeOfType(componentExpression, "Literal")) return typeof componentExpression.value === "string" ? `intrinsic:${componentExpression.value}` : null;
+	if (isNodeOfType(componentExpression, "Identifier")) return getComponentReferenceIdentity(componentExpression, scopes);
+	if (!isNodeOfType(componentExpression, "MemberExpression")) return null;
+	return getComponentReferenceIdentity(componentExpression, scopes);
+};
+const collectStaticComponentIdentities = (expression, identities, scopes) => {
+	const componentExpression = getFinalSequenceExpressionValue(expression);
+	if (isNodeOfType(componentExpression, "ConditionalExpression")) return collectStaticComponentIdentities(componentExpression.consequent, identities, scopes) && collectStaticComponentIdentities(componentExpression.alternate, identities, scopes);
+	if (isNodeOfType(componentExpression, "LogicalExpression")) return getStaticLogicalExpressionResultBranches(componentExpression).every((resultBranch) => collectStaticComponentIdentities(resultBranch, identities, scopes));
+	const identity = getComponentExpressionIdentity(componentExpression, scopes);
+	if (identity === null) return false;
+	identities.add(identity);
+	return true;
+};
+const isReactFragmentReference = (expression, scopes) => {
+	const fragmentExpression = stripParenExpression(expression);
+	const componentIdentity = getComponentReferenceIdentity(fragmentExpression, scopes);
+	if (componentIdentity === "import:react:Fragment" || componentIdentity === "import:react:default.Fragment") return true;
+	if (isNodeOfType(fragmentExpression, "Identifier")) {
+		const symbol = resolveConstIdentifierAlias(fragmentExpression, scopes);
+		return Boolean(symbol && isImportedFromReact(symbol) && getImportedName(symbol.declarationNode) === "Fragment");
+	}
+	if (!isNodeOfType(fragmentExpression, "MemberExpression") || getStaticPropertyName(fragmentExpression) !== "Fragment") return false;
+	const receiver = stripParenExpression(fragmentExpression.object);
+	return Boolean(isNodeOfType(receiver, "Identifier") && (isReactNamespaceImport(receiver, scopes) || receiver.name === "React" && scopes.isGlobalReference(receiver)));
+};
+const getForwardedInput = (expression, inputReferences, scopes) => {
+	const forwardedExpression = stripParenExpression(expression);
+	if (isNodeOfType(forwardedExpression, "Identifier")) {
+		const reference = scopes.referenceFor(forwardedExpression);
+		if (!reference?.resolvedSymbol) return null;
+		const directInput = inputReferences.find((inputReference) => inputReference.isStable && inputReference.propertyName === null && inputReference.symbolId === reference.resolvedSymbol?.id);
+		if (directInput) return {
+			inputNames: new Set([directInput.inputName]),
+			isWholeContainer: false
+		};
+		const containedInputNames = /* @__PURE__ */ new Set();
+		for (const inputReference of inputReferences) if (inputReference.isStable && inputReference.propertyName !== null && inputReference.symbolId === reference.resolvedSymbol.id) containedInputNames.add(inputReference.inputName);
+		return containedInputNames.size > 0 ? {
+			inputNames: containedInputNames,
+			isWholeContainer: true
+		} : null;
+	}
+	if (!isNodeOfType(forwardedExpression, "MemberExpression")) return null;
+	const propertyName = getStaticPropertyName(forwardedExpression);
+	const receiver = stripParenExpression(forwardedExpression.object);
+	if (propertyName === null || !isNodeOfType(receiver, "Identifier")) return null;
+	const receiverReference = scopes.referenceFor(receiver);
+	const matchedInput = inputReferences.find((inputReference) => inputReference.isStable && inputReference.propertyName === propertyName && inputReference.symbolId === receiverReference?.resolvedSymbol?.id);
+	return matchedInput ? {
+		inputNames: new Set([matchedInput.inputName]),
+		isWholeContainer: false
+	} : null;
+};
+const getParameterInputReferences = (parameter, forwardedInput, scopes) => {
+	const unwrappedParameter = stripParenExpression(parameter);
+	if (isNodeOfType(unwrappedParameter, "Identifier")) {
+		if (forwardedInput.isWholeContainer) return [];
+		const symbol = scopes.symbolFor(unwrappedParameter);
+		const inputName = [...forwardedInput.inputNames][0];
+		return symbol && inputName ? [{
+			inputName,
+			isStable: isSymbolStable(symbol),
+			propertyName: null,
+			symbolId: symbol.id
+		}] : [];
+	}
+	if (!isNodeOfType(unwrappedParameter, "ObjectPattern")) return [];
+	const references = [];
+	for (const property of unwrappedParameter.properties) {
+		if (!isNodeOfType(property, "Property")) continue;
+		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+		if (propertyName === null || forwardedInput.isWholeContainer && !forwardedInput.inputNames.has(propertyName)) continue;
+		const bindingIdentifier = getPatternBindingIdentifier(property.value);
+		const symbol = bindingIdentifier ? scopes.symbolFor(bindingIdentifier) : null;
+		if (symbol) references.push({
+			inputName: propertyName,
+			isStable: isSymbolStable(symbol),
+			propertyName: null,
+			symbolId: symbol.id
+		});
+	}
+	return references;
+};
+const getComponentPropInputReferences = (openingElement, componentFunction, inputReferences, scopes) => {
+	if (!isFunctionLike$1(componentFunction)) return [];
+	const parameter = componentFunction.params[0];
+	if (!parameter) return [];
+	const references = [];
+	for (const attribute of openingElement.attributes) {
+		if (!isNodeOfType(attribute, "JSXAttribute") || !isNodeOfType(attribute.name, "JSXIdentifier") || !isNodeOfType(attribute.value, "JSXExpressionContainer")) continue;
+		const attributeName = attribute.name.name;
+		if (getAuthoritativeJsxAttribute(openingElement.attributes, attributeName) !== attribute) continue;
+		const forwardedInput = getForwardedInput(attribute.value.expression, inputReferences, scopes);
+		if (!forwardedInput || forwardedInput.isWholeContainer) continue;
+		const unwrappedParameter = stripParenExpression(parameter);
+		if (isNodeOfType(unwrappedParameter, "Identifier")) {
+			const symbol = scopes.symbolFor(unwrappedParameter);
+			if (symbol) references.push({
+				inputName: attributeName,
+				isStable: isSymbolStable(symbol),
+				propertyName: attributeName,
+				symbolId: symbol.id
+			});
+			continue;
+		}
+		const bindingIdentifier = getObjectPatternPropertyBinding(unwrappedParameter, attributeName);
+		const symbol = bindingIdentifier ? scopes.symbolFor(bindingIdentifier) : null;
+		if (symbol) references.push({
+			inputName: attributeName,
+			isStable: isSymbolStable(symbol),
+			propertyName: null,
+			symbolId: symbol.id
+		});
+	}
+	return references;
+};
+const resolveLocalComponentFunction = (openingElement, scopes) => {
+	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return null;
+	const symbol = resolveConstIdentifierAlias(openingElement.name, scopes);
+	if (!symbol || symbol.kind === "import" || !symbol.initializer || !isSymbolStable(symbol) || hasSymbolWriteBefore(symbol, openingElement.name, scopes)) return null;
+	return unwrapProvenReactHocFunction(symbol.initializer, scopes);
+};
+const collectFunctionRenderedRootNames = (functionNode, names, scopes, analysis) => {
+	if (!isFunctionLike$1(functionNode) || analysis.visitedFunctionNodes.has(functionNode)) return;
+	analysis.visitedFunctionNodes.add(functionNode);
+	if (!isNodeOfType(functionNode.body, "BlockStatement")) {
+		collectReturnedJsxRootNames(functionNode.body, names, scopes, analysis);
+		return;
+	}
+	for (const returnStatement of getReachableFunctionReturnStatements(functionNode, scopes)) if (returnStatement.argument) collectReturnedJsxRootNames(returnStatement.argument, names, scopes, analysis);
+};
+const collectLocalComponentRenderedRootNames = (element, names, scopes, analysis) => {
+	if (!analysis.canFollowLocalRenderer) return false;
+	const componentFunction = resolveLocalComponentFunction(element.openingElement, scopes);
+	if (!componentFunction) return false;
+	if (analysis.visitedFunctionNodes.has(componentFunction)) return true;
+	const componentInputReferences = getComponentPropInputReferences(element.openingElement, componentFunction, analysis.inputReferences, scopes);
+	if (componentInputReferences.length === 0 || !functionHasOnlyInputDependentSelections(componentFunction, componentInputReferences, scopes)) return false;
+	const componentRootNames = /* @__PURE__ */ new Set();
+	collectFunctionRenderedRootNames(componentFunction, componentRootNames, scopes, {
+		canFollowLocalRenderer: false,
+		inputReferences: componentInputReferences,
+		visitedFunctionNodes: analysis.visitedFunctionNodes,
+		visitedSymbolIds: analysis.visitedSymbolIds
+	});
+	if (componentRootNames.size === 0) return false;
+	for (const componentRootName of componentRootNames) names.add(componentRootName);
+	return true;
+};
+const collectItemSelectedComponentRootNames = (element, names, scopes, analysis) => {
+	const componentName = element.openingElement.name;
+	if (!isNodeOfType(componentName, "JSXIdentifier")) return false;
+	const symbol = resolveConstIdentifierAlias(componentName, scopes);
+	if (symbol?.kind !== "const" || !symbol.initializer || analysis.visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, componentName, scopes) || !expressionHasOnlyInputDependentSelections(symbol.initializer, analysis.inputReferences, scopes)) return false;
+	analysis.visitedSymbolIds.add(symbol.id);
+	const componentIdentities = /* @__PURE__ */ new Set();
+	const didResolveEveryComponent = collectStaticComponentIdentities(symbol.initializer, componentIdentities, scopes);
+	analysis.visitedSymbolIds.delete(symbol.id);
+	if (!didResolveEveryComponent || componentIdentities.size === 0) return false;
+	for (const componentIdentity of componentIdentities) names.add(componentIdentity);
+	return true;
+};
+const collectReactCreateElementRootNames = (callExpression, names, scopes, analysis) => {
+	if (!isReactApiCall(callExpression, "createElement", scopes, {
+		allowGlobalReactNamespace: true,
+		resolveNamedAliases: true
+	})) return false;
+	const componentArgument = callExpression.arguments[0];
+	if (!componentArgument || isNodeOfType(componentArgument, "SpreadElement") || isReactFragmentReference(componentArgument, scopes)) return false;
+	const componentIdentities = /* @__PURE__ */ new Set();
+	if (!collectStaticComponentIdentities(componentArgument, componentIdentities, scopes)) return false;
+	if (componentIdentities.size > 1 && !expressionHasOnlyInputDependentSelections(componentArgument, analysis.inputReferences, scopes)) return false;
+	for (const componentIdentity of componentIdentities) names.add(componentIdentity);
+	return componentIdentities.size > 0;
+};
+const collectLocalHelperRenderedRootNames = (callExpression, names, scopes, analysis) => {
+	if (!analysis.canFollowLocalRenderer) return false;
+	const helperCallee = stripParenExpression(callExpression.callee);
+	if (!isNodeOfType(helperCallee, "Identifier")) return false;
+	const helperFunction = resolveStaticLocalCallFunction(callExpression, scopes);
+	if (!helperFunction || !isFunctionLike$1(helperFunction) || helperFunction.async || helperFunction.generator || analysis.visitedFunctionNodes.has(helperFunction)) return false;
+	const helperSymbol = scopes.symbolFor(helperCallee);
+	const functionSymbol = isNodeOfType(helperFunction, "FunctionDeclaration") && helperFunction.id ? scopes.symbolFor(helperFunction.id) : null;
+	if (helperSymbol && !isSymbolStable(helperSymbol) || functionSymbol && !isSymbolStable(functionSymbol)) return false;
+	const helperInputReferences = [];
+	for (let argumentIndex = 0; argumentIndex < callExpression.arguments.length; argumentIndex += 1) {
+		const argument = callExpression.arguments[argumentIndex];
+		const parameter = helperFunction.params[argumentIndex];
+		if (!argument || isNodeOfType(argument, "SpreadElement") || !parameter) continue;
+		const forwardedInput = getForwardedInput(argument, analysis.inputReferences, scopes);
+		if (!forwardedInput) continue;
+		helperInputReferences.push(...getParameterInputReferences(parameter, forwardedInput, scopes));
+	}
+	if (helperInputReferences.length === 0 || !functionHasOnlyInputDependentSelections(helperFunction, helperInputReferences, scopes)) return false;
+	const helperRootNames = /* @__PURE__ */ new Set();
+	collectFunctionRenderedRootNames(helperFunction, helperRootNames, scopes, {
+		canFollowLocalRenderer: false,
+		inputReferences: helperInputReferences,
+		visitedFunctionNodes: analysis.visitedFunctionNodes,
+		visitedSymbolIds: analysis.visitedSymbolIds
+	});
+	if (helperRootNames.size === 0) return false;
+	for (const helperRootName of helperRootNames) names.add(helperRootName);
+	return true;
+};
+const collectReturnedJsxRootNames = (expression, names, scopes, analysis) => {
+	const unwrappedExpression = getFinalSequenceExpressionValue(expression);
+	if (isNodeOfType(unwrappedExpression, "JSXElement")) {
+		if (collectItemSelectedComponentRootNames(unwrappedExpression, names, scopes, analysis) || collectLocalComponentRenderedRootNames(unwrappedExpression, names, scopes, analysis)) return;
+		const rootNames = getRenderedRootNames(unwrappedExpression, scopes);
+		if (rootNames) for (const rootName of rootNames) names.add(rootName);
+		return;
+	}
+	if (isNodeOfType(unwrappedExpression, "JSXFragment")) {
+		const rootNames = getRenderedRootNames(unwrappedExpression, scopes);
+		if (rootNames) for (const rootName of rootNames) names.add(rootName);
+		return;
+	}
+	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
+		if (collectReactCreateElementRootNames(unwrappedExpression, names, scopes, analysis) || collectLocalHelperRenderedRootNames(unwrappedExpression, names, scopes, analysis)) return;
+	}
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		const symbol = resolveConstIdentifierAlias(unwrappedExpression, scopes);
+		if (symbol?.kind === "const" && symbol.initializer && !analysis.visitedSymbolIds.has(symbol.id) && !hasSymbolWriteBefore(symbol, unwrappedExpression, scopes) && expressionHasOnlyInputDependentSelections(symbol.initializer, analysis.inputReferences, scopes)) {
+			analysis.visitedSymbolIds.add(symbol.id);
+			collectReturnedJsxRootNames(symbol.initializer, names, scopes, analysis);
+			analysis.visitedSymbolIds.delete(symbol.id);
+			return;
+		}
+	}
+	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) {
+		const staticTestValue = readStaticSelectorTruthiness(unwrappedExpression.test, scopes);
+		if (staticTestValue !== null) {
+			collectReturnedJsxRootNames(staticTestValue ? unwrappedExpression.consequent : unwrappedExpression.alternate, names, scopes, analysis);
+			return;
+		}
+		collectReturnedJsxRootNames(unwrappedExpression.consequent, names, scopes, analysis);
+		collectReturnedJsxRootNames(unwrappedExpression.alternate, names, scopes, analysis);
+		return;
+	}
+	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
+		for (const resultBranch of getStaticLogicalExpressionResultBranches(unwrappedExpression)) collectReturnedJsxRootNames(resultBranch, names, scopes, analysis);
+		return;
+	}
+};
+const resolveFunctionFromInitializer = (initializer, resultSymbol, scopes) => {
+	const expression = stripParenExpression(initializer);
+	if (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression") || isNodeOfType(expression, "FunctionDeclaration")) return expression;
+	const callbackArgument = getTransparentReactCallbackWrapperArgument(expression, resultSymbol, scopes);
+	if (callbackArgument && (isNodeOfType(callbackArgument, "ArrowFunctionExpression") || isNodeOfType(callbackArgument, "FunctionExpression"))) return callbackArgument;
+	return null;
+};
+const resolveRenderItemFunction = (attribute, scopes) => {
+	if (!isNodeOfType(attribute.value, "JSXExpressionContainer")) return null;
+	const expression = stripParenExpression(attribute.value.expression);
+	const directFunction = resolveFunctionFromInitializer(expression, null, scopes);
+	if (directFunction) return directFunction;
+	if (!isNodeOfType(expression, "Identifier")) return null;
+	const localFunction = resolveExactLocalFunction(expression, scopes);
+	if (localFunction) return localFunction;
+	const symbol = scopes.symbolFor(expression);
+	if (symbol?.kind !== "const" || !symbol.initializer) return null;
+	return resolveFunctionFromInitializer(symbol.initializer, symbol, scopes);
+};
+const renderItemHasHeterogeneousRootTypes = (attribute, scopes, resultCache) => {
+	const renderItemFunction = resolveRenderItemFunction(attribute, scopes);
+	if (!renderItemFunction || !isNodeOfType(renderItemFunction, "ArrowFunctionExpression") && !isNodeOfType(renderItemFunction, "FunctionExpression") && !isNodeOfType(renderItemFunction, "FunctionDeclaration")) return false;
+	const cachedResult = resultCache.get(renderItemFunction);
+	if (cachedResult !== void 0) return cachedResult;
+	const returnedRootNames = /* @__PURE__ */ new Set();
+	const inputReferences = getRenderItemInputReferences(renderItemFunction, scopes);
+	const selectionAnalysis = analyzeFunctionInputSelections(renderItemFunction, inputReferences, scopes);
+	const returnStatements = isNodeOfType(renderItemFunction.body, "BlockStatement") ? getReachableFunctionReturnStatements(renderItemFunction, scopes) : [];
+	if (selectionAnalysis.hasUnrelatedSelection && !selectionAnalysis.hasProvenInputDependentRootSelection || returnStatements.length > 1 && !selectionAnalysis.hasInputDependentSelection) {
+		resultCache.set(renderItemFunction, false);
+		return false;
+	}
+	collectFunctionRenderedRootNames(renderItemFunction, returnedRootNames, scopes, {
+		canFollowLocalRenderer: true,
+		inputReferences,
+		visitedFunctionNodes: /* @__PURE__ */ new Set(),
+		visitedSymbolIds: /* @__PURE__ */ new Set()
+	});
+	const hasHeterogeneousRootTypes = returnedRootNames.size > 1;
+	resultCache.set(renderItemFunction, hasHeterogeneousRootTypes);
+	return hasHeterogeneousRootTypes;
+};
 const rnListRecyclableWithoutTypes = defineRule({
 	id: "rn-list-recyclable-without-types",
 	title: "Recyclable list missing getItemType",
 	tags: ["test-noise"],
 	requires: ["react-native"],
 	severity: "warn",
-	recommendation: "When rows have different shapes, reused cells can show the wrong layout. Add `getItemType={item => item.kind}` so FlashList keeps a separate pool per row type.",
+	recommendation: "When rows have different shapes, reused cells can show the wrong layout. Add `getItemType` that returns a stable type for each row shape so FlashList keeps separate recycling pools.",
 	create: (context) => {
 		let fileImportsRecycler = false;
+		const renderItemResultCache = /* @__PURE__ */ new WeakMap();
 		return {
 			Program(node) {
 				fileImportsRecycler = hasImportFromModules(node, RECYCLABLE_LIST_PACKAGE_SOURCES);
@@ -107071,20 +108568,20 @@ const rnListRecyclableWithoutTypes = defineRule({
 				if (!fileImportsRecycler) return;
 				const elementName = resolveJsxElementName(node);
 				if (!elementName) return;
-				if (resolveImportedRecyclerName(node, elementName, { allowNamespaceMemberAccess: true }) === null) return;
-				let hasRecycleItemsEnabled = false;
-				let hasGetItemType = false;
-				for (const attr of node.attributes ?? []) {
-					if (!isNodeOfType(attr, "JSXAttribute")) continue;
-					if (!isNodeOfType(attr.name, "JSXIdentifier")) continue;
-					if (attr.name.name === "recycleItems") if (!attr.value) hasRecycleItemsEnabled = true;
-					else if (isNodeOfType(attr.value, "JSXExpressionContainer") && isNodeOfType(attr.value.expression, "Literal")) hasRecycleItemsEnabled = attr.value.expression.value === true;
-					else hasRecycleItemsEnabled = true;
-					if (attr.name.name === "getItemType") hasGetItemType = true;
-				}
-				if (hasRecycleItemsEnabled && !hasGetItemType) context.report({
+				const canonicalRecyclerName = resolveImportedRecyclerName(node, context.scopes, { allowNamespaceMemberAccess: true });
+				if (canonicalRecyclerName === null) return;
+				let hasRecycleItemsEnabled = SHOPIFY_FLASH_LIST_COMPONENTS.has(canonicalRecyclerName) && isFlashListV2OrNewer(context);
+				const recycleItemsAttribute = getAuthoritativeJsxAttribute(node.attributes, "recycleItems");
+				if (recycleItemsAttribute) if (!recycleItemsAttribute.value) hasRecycleItemsEnabled = true;
+				else if (isNodeOfType(recycleItemsAttribute.value, "JSXExpressionContainer") && isNodeOfType(recycleItemsAttribute.value.expression, "Literal")) hasRecycleItemsEnabled = recycleItemsAttribute.value.expression.value === true;
+				else hasRecycleItemsEnabled = true;
+				else if (node.attributes.some((attribute) => isNodeOfType(attribute, "JSXSpreadAttribute") && canExpressionOverrideJsxAttribute(attribute.argument, "recycleItems", true, context.scopes))) hasRecycleItemsEnabled = false;
+				const hasPossibleSpreadGetItemType = node.attributes.some((attribute) => isNodeOfType(attribute, "JSXSpreadAttribute") && canExpressionOverrideJsxAttribute(attribute.argument, "getItemType", true, context.scopes));
+				const hasGetItemType = getAuthoritativeJsxAttribute(node.attributes, "getItemType") !== null || hasPossibleSpreadGetItemType;
+				const renderItemAttribute = getAuthoritativeJsxAttribute(node.attributes, "renderItem");
+				if (hasRecycleItemsEnabled && !hasGetItemType && renderItemAttribute && renderItemHasHeterogeneousRootTypes(renderItemAttribute, context.scopes, renderItemResultCache)) context.report({
 					node,
-					message: `Your users see rows of different shapes reuse the wrong cells when <${elementName} recycleItems> has no \`getItemType\`.`
+					message: `Your users see rows of different shapes reuse the wrong cells when <${elementName}> recycles them without \`getItemType\`.`
 				});
 			}
 		};
@@ -107731,7 +109228,7 @@ const rnNoNonNativeNavigator = defineRule({
 	tags: ["test-noise"],
 	requires: ["react-native"],
 	severity: "warn",
-	recommendation: "Use `@react-navigation/native-stack` (or `native-tabs` in v7+) for real native transitions and gestures.",
+	recommendation: "Use `@react-navigation/native-stack` for stack navigation. Treat drawers separately because standalone React Navigation has no native drawer replacement.",
 	create: (context) => ({ ImportDeclaration(node) {
 		const source = node.source?.value;
 		if (typeof source !== "string") return;
@@ -108305,6 +109802,28 @@ const rnNoSingleElementStyleArray = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/react-native/rn-platform-shaking-use-direct-import.ts
+const REACT_NATIVE_MODULE_SOURCE = "react-native";
+const rnPlatformShakingUseDirectImport = defineRule({
+	id: "rn-platform-shaking-use-direct-import",
+	title: "Platform reached through React Native namespace",
+	tags: ["test-noise"],
+	requires: ["expo:54"],
+	severity: "warn",
+	recommendation: "Import `Platform` directly with `import { Platform } from \"react-native\"` so Expo can remove code for the other platform.",
+	create: (context) => ({ MemberExpression(node) {
+		if (node.computed) return;
+		if (!isNodeOfType(node.object, "Identifier")) return;
+		if (!isNodeOfType(node.property, "Identifier") || node.property.name !== "Platform") return;
+		if (context.scopes.symbolFor(node.object)?.kind !== "import") return;
+		if (!isNamespaceImportFromModule$1(node, node.object.name, REACT_NATIVE_MODULE_SOURCE)) return;
+		context.report({
+			node,
+			message: "Expo cannot tree-shake platform branches reached through the React Native namespace, so both platform paths stay in the bundle."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/react-native/rn-prefer-content-inset-adjustment.ts
 const rnPreferContentInsetAdjustment = defineRetiredRule({
 	id: "rn-prefer-content-inset-adjustment",
@@ -108671,6 +110190,97 @@ const rnPressableSharedValueMutation = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/react-native/utils/resolve-reanimated-api-name.ts
+const REANIMATED_MODULE_SOURCE = "react-native-reanimated";
+const resolveReanimatedApiName = (callExpression, scopes, supportedApiNames) => {
+	const reference = resolveImportedApiReference(callExpression.callee, scopes);
+	if (reference?.source !== REANIMATED_MODULE_SOURCE || reference.importedName === null || !supportedApiNames.has(reference.importedName)) return null;
+	return reference.importedName;
+};
+//#endregion
+//#region src/plugin/rules/react-native/rn-reanimated-4-no-legacy-spring-thresholds.ts
+const WITH_SPRING_API_NAMES = new Set(["withSpring"]);
+const LEGACY_SPRING_THRESHOLD_NAMES = new Set(["restDisplacementThreshold", "restSpeedThreshold"]);
+const rnReanimated4NoLegacySpringThresholds = defineRule({
+	id: "rn-reanimated-4-no-legacy-spring-thresholds",
+	title: "Legacy Reanimated spring threshold",
+	tags: ["migration-hint"],
+	requires: ["reanimated:4"],
+	severity: "warn",
+	recommendation: "Replace Reanimated 3 rest thresholds with Reanimated 4's `energyThreshold` spring option.",
+	create: (context) => ({ CallExpression(node) {
+		if (!resolveReanimatedApiName(node, context.scopes, WITH_SPRING_API_NAMES)) return;
+		const configArgument = node.arguments[1];
+		if (!configArgument || isNodeOfType(configArgument, "SpreadElement")) return;
+		const unwrappedConfig = stripParenExpression(configArgument);
+		if (!isNodeOfType(unwrappedConfig, "ObjectExpression")) return;
+		for (const property of unwrappedConfig.properties) {
+			if (!isNodeOfType(property, "Property")) continue;
+			const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+			if (!propertyName || !LEGACY_SPRING_THRESHOLD_NAMES.has(propertyName)) continue;
+			context.report({
+				node: property,
+				message: `Reanimated 4 removed \`${propertyName}\`; use the \`energyThreshold\` spring option instead.`
+			});
+		}
+	} })
+});
+//#endregion
+//#region src/plugin/rules/react-native/rn-reanimated-4-no-removed-api.ts
+const REMOVED_API_MESSAGE_BY_NAME = new Map([
+	["useAnimatedGestureHandler", "Reanimated 4 removed `useAnimatedGestureHandler`; migrate this gesture to the Gesture API."],
+	["useWorkletCallback", "Reanimated 4 removed `useWorkletCallback`; use React's `useCallback` with a `worklet` directive instead."],
+	["combineTransition", "Reanimated 4 removed `combineTransition`; compose the transition with `EntryExitTransition` instead."],
+	["addWhitelistedNativeProps", "Reanimated 4 removed `addWhitelistedNativeProps` because prop whitelisting is no longer needed."],
+	["addWhitelistedUIProps", "Reanimated 4 removed `addWhitelistedUIProps` because prop whitelisting is no longer needed."]
+]);
+const REMOVED_API_NAMES = new Set(REMOVED_API_MESSAGE_BY_NAME.keys());
+const rnReanimated4NoRemovedApi = defineRule({
+	id: "rn-reanimated-4-no-removed-api",
+	title: "API removed in Reanimated 4",
+	tags: ["migration-hint"],
+	requires: ["reanimated:4"],
+	severity: "warn",
+	recommendation: "Migrate removed Reanimated APIs to their Reanimated 4 or Gesture API replacements before upgrading.",
+	create: (context) => ({ CallExpression(node) {
+		const apiName = resolveReanimatedApiName(node, context.scopes, REMOVED_API_NAMES);
+		if (!apiName) return;
+		const message = REMOVED_API_MESSAGE_BY_NAME.get(apiName);
+		if (!message) return;
+		context.report({
+			node,
+			message
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/react-native/rn-reanimated-4-use-worklets-scheduler.ts
+const WORKLETS_MIGRATION_BY_REANIMATED_API = new Map([
+	["runOnUI", "replace `runOnUI(fn)(...args)` with `scheduleOnUI(fn, ...args)`"],
+	["runOnJS", "replace `runOnJS(fn)(...args)` with `scheduleOnRN(fn, ...args)`"],
+	["executeOnUIRuntimeSync", "replace `executeOnUIRuntimeSync(fn)(...args)` with `runOnUISync(fn, ...args)`"],
+	["runOnRuntime", "replace `runOnRuntime(runtime, fn)(...args)` with `scheduleOnRuntime(runtime, fn, ...args)`"]
+]);
+const REANIMATED_SCHEDULER_API_NAMES = new Set(WORKLETS_MIGRATION_BY_REANIMATED_API.keys());
+const rnReanimated4UseWorkletsScheduler = defineRule({
+	id: "rn-reanimated-4-use-worklets-scheduler",
+	title: "Scheduler moved to Worklets",
+	tags: ["migration-hint"],
+	requires: ["reanimated:4"],
+	severity: "warn",
+	recommendation: "Import the corresponding scheduler from `react-native-worklets` when migrating to Reanimated 4.",
+	create: (context) => ({ CallExpression(node) {
+		const apiName = resolveReanimatedApiName(node, context.scopes, REANIMATED_SCHEDULER_API_NAMES);
+		if (!apiName) return;
+		const migration = WORKLETS_MIGRATION_BY_REANIMATED_API.get(apiName);
+		if (!migration) return;
+		context.report({
+			node,
+			message: `For Reanimated 4, ${migration} from \`react-native-worklets\`.`
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/react-native/utils/scrollview_names.ts
 const SCROLLVIEW_NAMES = new Set([
 	"ScrollView",
@@ -108934,7 +110544,7 @@ const rnStylePreferBoxShadow = defineRule({
 	tags: ["test-noise"],
 	requires: ["react-native"],
 	severity: "warn",
-	recommendation: "These shadow keys only work on one platform. On RN v7+, use the CSS `boxShadow` string instead, like `boxShadow: \"0 2px 8px rgba(0,0,0,0.1)\"`, which works on both.",
+	recommendation: "These shadow keys only work on one platform. On the New Architecture, use a CSS `boxShadow` string like `boxShadow: \"0 2px 8px rgba(0,0,0,0.1)\"`, which works on both.",
 	create: (context) => {
 		if (context.filename && isLegacyArchReactNativeFile(normalizeFilename(context.filename))) return EMPTY_VISITORS$3;
 		return {
@@ -130125,6 +131735,30 @@ const reactDoctorRules = [
 			tags: [...new Set(["react-native", ...rnAnimationReactionAsDerived.tags ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/rn-bottom-sheet-no-ignored-scroll-prop",
+		id: "rn-bottom-sheet-no-ignored-scroll-prop",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...rnBottomSheetNoIgnoredScrollProp,
+			framework: "react-native",
+			category: "Bugs",
+			tags: [...new Set(["react-native", ...rnBottomSheetNoIgnoredScrollProp.tags ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/rn-bottom-sheet-no-state-in-on-animate",
+		id: "rn-bottom-sheet-no-state-in-on-animate",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...rnBottomSheetNoStateInOnAnimate,
+			framework: "react-native",
+			category: "Bugs",
+			tags: [...new Set(["react-native", ...rnBottomSheetNoStateInOnAnimate.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/rn-bottom-sheet-prefer-native",
 		id: "rn-bottom-sheet-prefer-native",
@@ -130137,6 +131771,18 @@ const reactDoctorRules = [
 			tags: [...new Set(["react-native", ...rnBottomSheetPreferNative.tags ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/rn-bottom-sheet-use-integrated-scrollable",
+		id: "rn-bottom-sheet-use-integrated-scrollable",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...rnBottomSheetUseIntegratedScrollable,
+			framework: "react-native",
+			category: "Bugs",
+			tags: [...new Set(["react-native", ...rnBottomSheetUseIntegratedScrollable.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/rn-detox-missing-await",
 		id: "rn-detox-missing-await",
@@ -130401,6 +132047,18 @@ const reactDoctorRules = [
 			tags: [...new Set(["react-native", ...rnNoSingleElementStyleArray.tags ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/rn-platform-shaking-use-direct-import",
+		id: "rn-platform-shaking-use-direct-import",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...rnPlatformShakingUseDirectImport,
+			framework: "react-native",
+			category: "Bugs",
+			tags: [...new Set(["react-native", ...rnPlatformShakingUseDirectImport.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/rn-prefer-content-inset-adjustment",
 		id: "rn-prefer-content-inset-adjustment",
@@ -130473,6 +132131,42 @@ const reactDoctorRules = [
 			tags: [...new Set(["react-native", ...rnPressableSharedValueMutation.tags ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/rn-reanimated-4-no-legacy-spring-thresholds",
+		id: "rn-reanimated-4-no-legacy-spring-thresholds",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...rnReanimated4NoLegacySpringThresholds,
+			framework: "react-native",
+			category: "Bugs",
+			tags: [...new Set(["react-native", ...rnReanimated4NoLegacySpringThresholds.tags ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/rn-reanimated-4-no-removed-api",
+		id: "rn-reanimated-4-no-removed-api",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...rnReanimated4NoRemovedApi,
+			framework: "react-native",
+			category: "Bugs",
+			tags: [...new Set(["react-native", ...rnReanimated4NoRemovedApi.tags ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/rn-reanimated-4-use-worklets-scheduler",
+		id: "rn-reanimated-4-use-worklets-scheduler",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...rnReanimated4UseWorkletsScheduler,
+			framework: "react-native",
+			category: "Bugs",
+			tags: [...new Set(["react-native", ...rnReanimated4UseWorkletsScheduler.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/rn-scrollview-dynamic-padding",
 		id: "rn-scrollview-dynamic-padding",