oxlint-plugin-react-doctor 0.2.8 → 0.2.9

package/dist/index.js

@@ -176,7 +176,8 @@ const SUBSCRIPTION_METHOD_NAMES = new Set([
 	"listen",
 	"sub"
 ]);
-const UNSUBSCRIPTION_METHOD_NAMES = new Set([
+const CLEANUP_RETURNING_SUBSCRIPTION_METHOD_NAMES = new Set(["subscribe", "sub"]);
+const GLOBAL_RELEASE_METHOD_NAMES = new Set([
 	"unsubscribe",
 	"removeEventListener",
 	"removeListener",
@@ -186,8 +187,16 @@ const UNSUBSCRIPTION_METHOD_NAMES = new Set([
 	"unsub",
 	"abort"
 ]);
+const BOUND_RESOURCE_RELEASE_METHOD_NAMES = new Set([
+	"remove",
+	"cleanup",
+	"dispose",
+	"destroy",
+	"stop",
+	"teardown"
+]);
 const CLEANUP_LIKE_RELEASE_CALLEE_NAMES = new Set([
-	...UNSUBSCRIPTION_METHOD_NAMES,
+	...GLOBAL_RELEASE_METHOD_NAMES,
 	"cleanup",
 	"dispose",
 	"destroy",
@@ -416,9 +425,10 @@ const sliceBelowSourceRoot = (filename) => {
 	if (cutAt < 0) return filename;
 	return filename.slice(cutAt);
 };
-const isTestlikeFilename = (filename) => {
-	if (!filename) return false;
-	const lastSlash = Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\"));
+const isTestlikeFilename = (rawFilename) => {
+	if (!rawFilename) return false;
+	const filename = rawFilename.replaceAll("\\", "/");
+	const lastSlash = filename.lastIndexOf("/");
 	const basename = lastSlash === -1 ? filename : filename.slice(lastSlash + 1);
 	if (NON_PRODUCTION_BASENAMES.has(basename.toLowerCase())) return true;
 	for (const suffix of NON_PRODUCTION_FILENAME_SUFFIXES) if (basename.includes(suffix)) return true;
@@ -2882,6 +2892,9 @@ const asyncDeferAwait = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/normalize-filename.ts
+const normalizeFilename$1 = (filename) => filename.replaceAll("\\", "/");
+//#endregion
 //#region src/plugin/utils/get-callee-identifier-trail.ts
 const getCalleeIdentifierTrail = (call) => {
 	let entry = call;
@@ -2970,7 +2983,7 @@ const asyncParallel = defineRule({
 	severity: "warn",
 	recommendation: "Use `const [a, b] = await Promise.all([fetchA(), fetchB()])` to run independent operations concurrently",
 	create: (context) => {
-		const filename = context.getFilename?.() ?? "";
+		const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 		const isBrowserTestFile = BROWSER_TEST_FILE_PATTERN.test(filename);
 		let hasTestLibraryImport = false;
 		const shouldSkipFile = () => isBrowserTestFile || hasTestLibraryImport;
@@ -4235,42 +4248,99 @@ const walkInsideStatementBlocks = (node, visitor) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/is-subscribe-like-call-expression.ts
+const getSubscribeLikeMethodName = (node) => {
+	if (!isNodeOfType(node, "CallExpression")) return null;
+	if (!isNodeOfType(node.callee, "MemberExpression")) return null;
+	if (!isNodeOfType(node.callee.property, "Identifier")) return null;
+	return node.callee.property.name;
+};
 const isSubscribeLikeCallExpression = (node) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
-	if (!isNodeOfType(node.callee.property, "Identifier")) return false;
-	return SUBSCRIPTION_METHOD_NAMES.has(node.callee.property.name);
+	const methodName = getSubscribeLikeMethodName(node);
+	return methodName !== null && SUBSCRIPTION_METHOD_NAMES.has(methodName);
+};
+const isCleanupReturningSubscribeLikeCallExpression = (node) => {
+	const methodName = getSubscribeLikeMethodName(node);
+	return methodName !== null && CLEANUP_RETURNING_SUBSCRIPTION_METHOD_NAMES.has(methodName);
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/is-cleanup-return.ts
-const isReleaseLikeCall = (callNode, knownBoundReleaseNames) => {
+const ITERATOR_CALLBACK_METHOD_NAMES = new Set([
+	"each",
+	"every",
+	"filter",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"flatMap",
+	"forEach",
+	"map",
+	"reduce",
+	"reduceRight",
+	"some",
+	"sort",
+	"toSorted"
+]);
+const STATIC_ITERATOR_CALLBACK_METHOD_NAMES = new Set([
+	"from",
+	"fromAsync",
+	"groupBy"
+]);
+const unwrapChainExpression$2 = (node) => isNodeOfType(node, "ChainExpression") ? node.expression : node;
+const isNullLiteral = (node) => isNodeOfType(node, "Literal") && node.value === null;
+const isListenerRemovalViaNullHandler = (callNode) => {
+	if (!isNodeOfType(callNode, "CallExpression")) return false;
+	const callee = unwrapChainExpression$2(callNode.callee);
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "on" && isNullLiteral(callNode.arguments?.[1]);
+};
+const isReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
+	const callNode = unwrapChainExpression$2(node);
 	if (!isNodeOfType(callNode, "CallExpression")) return false;
-	const callee = callNode.callee;
+	if (isListenerRemovalViaNullHandler(callNode)) return true;
+	const callee = unwrapChainExpression$2(callNode.callee);
 	if (isNodeOfType(callee, "Identifier")) {
 		if (TIMER_CLEANUP_CALLEE_NAMES.has(callee.name)) return true;
 		if (CLEANUP_LIKE_RELEASE_CALLEE_NAMES.has(callee.name)) return true;
-		if (knownBoundReleaseNames.has(callee.name)) return true;
+		if (knownCleanupFunctionNames.has(callee.name)) return true;
 		return false;
 	}
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return UNSUBSCRIPTION_METHOD_NAMES.has(callee.property.name);
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
+		if (BOUND_RESOURCE_RELEASE_METHOD_NAMES.has(callee.property.name) && isNodeOfType(callee.object, "Identifier") && knownBoundSubscriptionNames.has(callee.object.name)) return true;
+		return GLOBAL_RELEASE_METHOD_NAMES.has(callee.property.name);
+	}
 	return false;
 };
-const containsReleaseLikeCall = (node, knownBoundReleaseNames) => {
+const isStaticIteratorCallbackCallee = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && isNodeOfType(callee.property, "Identifier") && (callee.object.name === "Array" || callee.object.name === "Map" || callee.object.name === "Object") && STATIC_ITERATOR_CALLBACK_METHOD_NAMES.has(callee.property.name);
+const isIteratorCallbackArgument = (node) => {
+	const parentNode = node.parent;
+	if (!isNodeOfType(parentNode, "CallExpression")) return false;
+	if (!parentNode.arguments?.some((argument) => argument === node)) return false;
+	const callee = unwrapChainExpression$2(parentNode.callee);
+	if (parentNode.arguments[1] === node && isStaticIteratorCallbackCallee(callee)) return true;
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && ITERATOR_CALLBACK_METHOD_NAMES.has(callee.property.name);
+};
+const containsReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
 	let didFindRelease = false;
 	walkAst(node, (child) => {
 		if (didFindRelease) return false;
-		if (isReleaseLikeCall(child, knownBoundReleaseNames)) {
+		if (child !== node && isFunctionLike(child) && !isIteratorCallbackArgument(child)) return false;
+		if (isReleaseLikeCall(child, knownCleanupFunctionNames, knownBoundSubscriptionNames)) {
 			didFindRelease = true;
 			return false;
 		}
 	});
 	return didFindRelease;
 };
-const isCleanupReturn = (returnedValue, knownBoundReleaseNames) => {
+const isCleanupFunctionLike = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
+	if (!isFunctionLike(node)) return false;
+	return containsReleaseLikeCall(node.body, knownCleanupFunctionNames, knownBoundSubscriptionNames);
+};
+const isCleanupReturn = (returnedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
 	if (!returnedValue) return false;
-	if (isNodeOfType(returnedValue, "Identifier")) return knownBoundReleaseNames.has(returnedValue.name);
-	if (isSubscribeLikeCallExpression(returnedValue)) return true;
-	if (isNodeOfType(returnedValue, "ArrowFunctionExpression") || isNodeOfType(returnedValue, "FunctionExpression")) return containsReleaseLikeCall(returnedValue, knownBoundReleaseNames);
+	const unwrappedValue = unwrapChainExpression$2(returnedValue);
+	if (isNodeOfType(unwrappedValue, "Identifier")) return knownCleanupFunctionNames.has(unwrappedValue.name);
+	if (isCleanupReturningSubscribeLikeCallExpression(unwrappedValue)) return true;
+	if (isCleanupFunctionLike(unwrappedValue, knownCleanupFunctionNames, knownBoundSubscriptionNames)) return true;
 	return false;
 };
 //#endregion
@@ -4285,7 +4355,7 @@ const findSubscribeLikeUsages = (callback) => {
 		if (isNodeOfType(lastCallbackStatement, "ReturnStatement") && lastCallbackStatement.argument) cleanupArgument = lastCallbackStatement.argument;
 	}
 	walkAst(callback, (child) => {
-		if (child === cleanupArgument) return false;
+		if (child === cleanupArgument && !isSubscribeLikeCallExpression(child)) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (isNodeOfType(child.callee, "Identifier") && TIMER_CALLEE_NAMES_REQUIRING_CLEANUP.has(child.callee.name)) {
 			usages.push({
@@ -4301,34 +4371,56 @@ const findSubscribeLikeUsages = (callback) => {
 	});
 	return usages;
 };
-const collectReleasableBindingNames = (effectCallback) => {
-	const releasableNames = /* @__PURE__ */ new Set();
-	if (!isNodeOfType(effectCallback, "ArrowFunctionExpression") && !isNodeOfType(effectCallback, "FunctionExpression")) return releasableNames;
-	if (!isNodeOfType(effectCallback.body, "BlockStatement")) return releasableNames;
-	for (const statement of effectCallback.body.body ?? []) {
-		if (!isNodeOfType(statement, "VariableDeclaration")) continue;
-		for (const declarator of statement.declarations ?? []) {
+const collectCleanupBindings = (effectCallback) => {
+	const bindings = {
+		cleanupFunctionNames: /* @__PURE__ */ new Set(),
+		subscriptionNames: /* @__PURE__ */ new Set(),
+		effectScopeVariableNames: /* @__PURE__ */ new Set()
+	};
+	if (!isNodeOfType(effectCallback, "ArrowFunctionExpression") && !isNodeOfType(effectCallback, "FunctionExpression")) return bindings;
+	if (!isNodeOfType(effectCallback.body, "BlockStatement")) return bindings;
+	walkInsideStatementBlocks(effectCallback.body, (child) => {
+		if (!isNodeOfType(child, "VariableDeclaration")) return;
+		for (const declarator of child.declarations ?? []) {
 			if (!isNodeOfType(declarator.id, "Identifier")) continue;
+			const bindingName = declarator.id.name;
+			bindings.effectScopeVariableNames.add(bindingName);
 			const init = declarator.init;
 			if (!init || !isNodeOfType(init, "CallExpression")) continue;
 			if (isSubscribeLikeCallExpression(init)) {
-				releasableNames.add(declarator.id.name);
-				continue;
+				bindings.subscriptionNames.add(bindingName);
+				if (isCleanupReturningSubscribeLikeCallExpression(init)) bindings.cleanupFunctionNames.add(bindingName);
 			}
-			if (isNodeOfType(init.callee, "Identifier") && TIMER_CALLEE_NAMES_REQUIRING_CLEANUP.has(init.callee.name)) releasableNames.add(declarator.id.name);
 		}
-	}
-	return releasableNames;
+	});
+	walkAst(effectCallback.body, (child) => {
+		if (child !== effectCallback.body && (isNodeOfType(child, "ArrowFunctionExpression") || isNodeOfType(child, "FunctionExpression"))) return false;
+		if (isNodeOfType(child, "FunctionDeclaration") && child.id && isCleanupFunctionLike(child, bindings.cleanupFunctionNames, bindings.subscriptionNames)) {
+			bindings.cleanupFunctionNames.add(child.id.name);
+			return false;
+		}
+	});
+	walkInsideStatementBlocks(effectCallback.body, (child) => {
+		if (!isNodeOfType(child, "VariableDeclaration")) return;
+		for (const declarator of child.declarations ?? []) {
+			if (!isNodeOfType(declarator.id, "Identifier") || !declarator.init) continue;
+			if (isCleanupFunctionLike(declarator.init, bindings.cleanupFunctionNames, bindings.subscriptionNames)) bindings.cleanupFunctionNames.add(declarator.id.name);
+		}
+	});
+	walkAst(effectCallback.body, (child) => {
+		if (isNodeOfType(child, "AssignmentExpression") && isNodeOfType(child.left, "Identifier") && bindings.effectScopeVariableNames.has(child.left.name) && isCleanupFunctionLike(child.right, bindings.cleanupFunctionNames, bindings.subscriptionNames)) bindings.cleanupFunctionNames.add(child.left.name);
+	});
+	return bindings;
 };
 const effectHasCleanupRelease = (callback) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
-	if (!isNodeOfType(callback.body, "BlockStatement")) return isSubscribeLikeCallExpression(callback.body);
-	const knownBoundReleaseNames = collectReleasableBindingNames(callback);
+	if (!isNodeOfType(callback.body, "BlockStatement")) return isCleanupReturningSubscribeLikeCallExpression(callback.body);
+	const cleanupBindings = collectCleanupBindings(callback);
 	let didFindCleanupReturn = false;
 	walkInsideStatementBlocks(callback.body, (child) => {
 		if (didFindCleanupReturn) return;
 		if (!isNodeOfType(child, "ReturnStatement")) return;
-		if (isCleanupReturn(child.argument, knownBoundReleaseNames)) didFindCleanupReturn = true;
+		if (isCleanupReturn(child.argument, cleanupBindings.cleanupFunctionNames, cleanupBindings.subscriptionNames)) didFindCleanupReturn = true;
 	});
 	return didFindCleanupReturn;
 };
@@ -5493,7 +5585,19 @@ const exhaustiveDeps = defineRule({
 	id: "exhaustive-deps",
 	severity: "warn",
 	tags: ["test-noise"],
-	recommendation: "List every value the hook callback captures in its dependency array.",
+	recommendation: `Don't blindly add missing dependencies. Read the hook callback first.
+
+Bad:
+useEffect(() => {
+  setCount(count + 1);
+}, [count]);
+
+Better:
+useEffect(() => {
+  setCount((currentCount) => currentCount + 1);
+}, []);
+
+If the missing value is recreated every render, move it inside the hook or stabilize it before adding it to deps.`,
 	category: "Correctness",
 	create: (context) => {
 		const settings = resolveExhaustiveDepsSettings(context.settings);
@@ -7711,7 +7815,7 @@ const jsxFilenameExtension = defineRule({
 		const settings = resolveSettings$34(context.settings);
 		const allowedExtensions = normalizeExtensions(settings.extensions);
 		const allowedList = [...allowedExtensions].map((extension) => `.${extension}`).join(", ");
-		const filename = context.getFilename ? context.getFilename() : "fixture.tsx";
+		const filename = context.getFilename ? normalizeFilename$1(context.getFilename()) : "fixture.tsx";
 		const extensionOnly = path.extname(filename).slice(1);
 		const fileHasAllowedExtension = allowedExtensions.has(extensionOnly);
 		let didReportMismatch = false;
@@ -11348,7 +11452,7 @@ const nextjsMissingMetadata = defineRule({
 	severity: "warn",
 	recommendation: "Add `export const metadata = { title: '...', description: '...' }` or `export async function generateMetadata()`",
 	create: (context) => ({ Program(programNode) {
-		const filename = context.getFilename?.() ?? "";
+		const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 		if (!PAGE_FILE_PATTERN.test(filename)) return;
 		if (INTERNAL_PAGE_PATH_PATTERN.test(filename)) return;
 		if (!programNode.body?.some((statement) => {
@@ -11413,7 +11517,7 @@ const nextjsNoClientFetchForServerData = defineRule({
 				if (!fileHasUseClient || !isHookCall$1(node, EFFECT_HOOK_NAMES$1)) return;
 				const callback = getEffectCallback(node);
 				if (!callback || !containsFetchCall(callback)) return;
-				const filename = context.getFilename?.() ?? "";
+				const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 				if (PAGE_OR_LAYOUT_FILE_PATTERN.test(filename) || PAGES_DIRECTORY_PATTERN.test(filename)) context.report({
 					node,
 					message: "useEffect + fetch in a page/layout — fetch data server-side with a server component instead"
@@ -11446,7 +11550,7 @@ const nextjsNoClientSideRedirect = defineRule({
 	severity: "warn",
 	recommendation: "Avoid redirects inside useEffect. Use an event handler, middleware, or server-side redirect (App Router: redirect() from next/navigation; Pages Router: getServerSideProps redirect)",
 	create: (context) => {
-		const filename = context.getFilename?.() ?? "";
+		const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 		const isPagesRouterFile = PAGES_DIRECTORY_PATTERN.test(filename);
 		return { CallExpression(node) {
 			if (!isHookCall$1(node, EFFECT_HOOK_NAMES$1)) return;
@@ -11515,7 +11619,7 @@ const nextjsNoHeadImport = defineRule({
 	recommendation: "Use the Metadata API instead: `export const metadata = { title: '...' }` or `export async function generateMetadata()`",
 	create: (context) => ({ ImportDeclaration(node) {
 		if (node.source?.value !== "next/head") return;
-		const filename = context.getFilename?.() ?? "";
+		const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 		if (!APP_DIRECTORY_PATTERN.test(filename)) return;
 		context.report({
 			node,
@@ -11532,7 +11636,7 @@ const nextjsNoImgElement = defineRule({
 	severity: "warn",
 	recommendation: "`import Image from 'next/image'` — provides automatic WebP/AVIF, lazy loading, and responsive srcset",
 	create: (context) => {
-		const filename = context.getFilename?.() ?? "";
+		const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 		const isOgRoute = OG_ROUTE_PATTERN.test(filename);
 		return { JSXOpeningElement(node) {
 			if (isOgRoute) return;
@@ -11770,8 +11874,8 @@ const findSideEffect = (node, options = {}) => {
 };
 //#endregion
 //#region src/plugin/rules/nextjs/nextjs-no-side-effect-in-get-handler.ts
-const extractMutatingRouteSegment = (filename) => {
-	const segments = filename.split("/");
+const extractMutatingRouteSegment = (rawFilename) => {
+	const segments = rawFilename.replaceAll("\\", "/").split("/");
 	for (const segment of segments) {
 		const cleaned = segment.replace(/^\[.*\]$/, "");
 		if (MUTATING_ROUTE_SEGMENTS.has(cleaned)) return cleaned;
@@ -11886,7 +11990,7 @@ const nextjsNoSideEffectInGetHandler = defineRule({
 				resolveBinding = buildProgramBindingLookup(node);
 			},
 			ExportNamedDeclaration(node) {
-				const filename = context.getFilename?.() ?? "";
+				const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 				if (!ROUTE_HANDLER_FILE_PATTERN.test(filename)) return;
 				if (CRON_ROUTE_PATTERN.test(filename)) return;
 				if (!isExportedGetHandler(node)) return;
@@ -13500,7 +13604,7 @@ const noBarrelImport = defineRule({
 			if (didReportForFile) return;
 			const source = node.source?.value;
 			if (typeof source !== "string" || !source.startsWith(".")) return;
-			const filename = context.getFilename?.() ?? "";
+			const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 			if (!filename) return;
 			const importRequests = getRuntimeImportRequests(node);
 			if (importRequests.length === 0) return;
@@ -13732,6 +13836,14 @@ const isImportedFromModule = (contextNode, localIdentifierName, moduleSource) =>
 	if (!info) return false;
 	return info.source === moduleSource;
 };
+const getImportedNameFromModule = (contextNode, localIdentifierName, moduleSource) => {
+	const lookup = getImportLookup(contextNode);
+	if (!lookup) return null;
+	const info = lookup.get(localIdentifierName);
+	if (!info) return null;
+	if (info.source !== moduleSource) return null;
+	return info.imported;
+};
 //#endregion
 //#region src/plugin/rules/react-builtins/no-clone-element.ts
 const MESSAGE$21 = "`React.cloneElement` is uncommon and leads to fragile components.";
@@ -19226,7 +19338,7 @@ const noSecretsInClientCode = defineRule({
 	severity: "warn",
 	recommendation: "Move secrets to server-only code. Public client environment variables are bundled into browser code and must not contain secrets",
 	create: (context) => {
-		const filename = context.getFilename?.() ?? "";
+		const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 		const framework = getReactDoctorStringSetting(context.settings, "framework");
 		const rootDirectory = getReactDoctorStringSetting(context.settings, "rootDirectory");
 		let shouldUseVariableNameHeuristic = classifySecretFileExposure(filename, {
@@ -21205,6 +21317,15 @@ const noUnstableNestedComponents = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/is-canonical-react-namespace-name.ts
+const isCanonicalReactNamespaceName = (namespaceName) => {
+	if (namespaceName === "React") return true;
+	if (namespaceName === "react") return true;
+	if (namespaceName.startsWith("_react")) return true;
+	if (namespaceName.startsWith("_React")) return true;
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/performance/no-usememo-simple-expression.ts
 const isSimpleExpression = (node) => {
 	if (!node) return false;
@@ -21237,7 +21358,7 @@ const noUsememoSimpleExpression = defineRule({
 			const namespaceIdentifier = node.callee.object;
 			if (isNodeOfType(namespaceIdentifier, "Identifier")) {
 				const namespaceName = namespaceIdentifier.name;
-				if (!(namespaceName === "React" || namespaceName === "react" || namespaceName.startsWith("_react") || namespaceName.startsWith("_React")) && !isImportedFromModule(namespaceIdentifier, namespaceName, "react")) return;
+				if (!isCanonicalReactNamespaceName(namespaceName) && !isImportedFromModule(namespaceIdentifier, namespaceName, "react")) return;
 			}
 		}
 		const callback = node.arguments?.[0];
@@ -21695,7 +21816,7 @@ const onlyExportComponents = defineRule({
 			allowConstantExport: settings.allowConstantExport
 		};
 		return { Program(node) {
-			if (!isFileNameAllowed(context.getFilename ? context.getFilename() : void 0, settings.checkJS)) return;
+			if (!isFileNameAllowed(context.getFilename ? normalizeFilename$1(context.getFilename()) : void 0, settings.checkJS)) return;
 			const allNodes = collectAllNodes(node);
 			const exports = [];
 			let hasReactExport = false;
@@ -22163,9 +22284,11 @@ const findSubscriptionCall = (effectBodyStatements) => {
 			if (!isNodeOfType(init.callee, "MemberExpression")) continue;
 			if (!isNodeOfType(init.callee.property, "Identifier")) continue;
 			if (!SUBSCRIPTION_METHOD_NAMES.has(init.callee.property.name)) continue;
+			const boundSubscriptionName = isNodeOfType(declarator.id, "Identifier") ? declarator.id.name : null;
 			return {
 				call: init,
-				boundUnsubscribeName: isNodeOfType(declarator.id, "Identifier") ? declarator.id.name : null
+				boundReleaseName: boundSubscriptionName && isCleanupReturningSubscribeLikeCallExpression(init) ? boundSubscriptionName : null,
+				boundSubscriptionName
 			};
 		}
 		if (isNodeOfType(statement, "ExpressionStatement")) {
@@ -22176,7 +22299,8 @@ const findSubscriptionCall = (effectBodyStatements) => {
 			if (!SUBSCRIPTION_METHOD_NAMES.has(expression.callee.property.name)) continue;
 			return {
 				call: expression,
-				boundUnsubscribeName: null
+				boundReleaseName: null,
+				boundSubscriptionName: null
 			};
 		}
 	}
@@ -22212,12 +22336,14 @@ const getSingleSetterCallFromHandler = (handler) => {
 		setterArgument: expression.arguments[0]
 	};
 };
-const cleanupReleasesSubscription = (effectBodyStatements, boundUnsubscribeName) => {
+const cleanupReleasesSubscription = (effectBodyStatements, boundReleaseName, boundSubscriptionName) => {
 	const lastStatement = effectBodyStatements[effectBodyStatements.length - 1];
 	if (!isNodeOfType(lastStatement, "ReturnStatement")) return false;
 	const knownBoundReleaseNames = /* @__PURE__ */ new Set();
-	if (boundUnsubscribeName) knownBoundReleaseNames.add(boundUnsubscribeName);
-	return isCleanupReturn(lastStatement.argument, knownBoundReleaseNames);
+	const knownBoundSubscriptionNames = /* @__PURE__ */ new Set();
+	if (boundReleaseName) knownBoundReleaseNames.add(boundReleaseName);
+	if (boundSubscriptionName) knownBoundSubscriptionNames.add(boundSubscriptionName);
+	return isCleanupReturn(lastStatement.argument, knownBoundReleaseNames, knownBoundSubscriptionNames);
 };
 const preferUseSyncExternalStore = defineRule({
 	id: "prefer-use-sync-external-store",
@@ -22262,7 +22388,7 @@ const preferUseSyncExternalStore = defineRule({
 				const useStateInitializer = useStateInitializerByValueName.get(valueName);
 				if (!useStateInitializer) continue;
 				if (!areExpressionsStructurallyEqual(useStateInitializer, setterPayload.setterArgument)) continue;
-				if (!cleanupReleasesSubscription(effectBodyStatements, subscription.boundUnsubscribeName)) continue;
+				if (!cleanupReleasesSubscription(effectBodyStatements, subscription.boundReleaseName, subscription.boundSubscriptionName)) continue;
 				const matchingBinding = useStateBindings.find((binding) => binding.valueName === valueName);
 				context.report({
 					node: matchingBinding?.declarator ?? effectCall,
@@ -22511,6 +22637,13 @@ const HOOK_OBJECTS_WITH_METHODS = new Map([
 		"set"
 	])]
 ]);
+const HOOK_IMPORT_SOURCES_WITH_UNSAFE_METHOD_DESTRUCTURING = new Map([["useNavigation", new Set(["@react-navigation/native", "@react-navigation/core"])]]);
+const isUnsafeMethodDestructureHookImport = (node, hookSource) => {
+	const moduleSources = HOOK_IMPORT_SOURCES_WITH_UNSAFE_METHOD_DESTRUCTURING.get(hookSource);
+	if (!moduleSources) return false;
+	for (const moduleSource of moduleSources) if (isImportedFromModule(node, hookSource, moduleSource)) return true;
+	return false;
+};
 const buildHookBindingMap = (componentBody) => {
 	const result = /* @__PURE__ */ new Map();
 	if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return result;
@@ -22567,6 +22700,7 @@ const reactCompilerDestructureMethod = defineRule({
 				if (!hookSource) return;
 				const allowedMethods = HOOK_OBJECTS_WITH_METHODS.get(hookSource);
 				if (!allowedMethods || !allowedMethods.has(methodName)) return;
+				if (isUnsafeMethodDestructureHookImport(node, hookSource)) return;
 				if (!isNodeOfType(node.parent, "CallExpression") || node.parent.callee !== node) return;
 				context.report({
 					node,
@@ -22577,6 +22711,51 @@ const reactCompilerDestructureMethod = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/architecture/react-compiler-no-manual-memoization.ts
+const REMOVAL_MESSAGE_BY_REACT_API_NAME = new Map([
+	["useMemo", "Remove `useMemo` — React Compiler auto-memoizes every value in this component. Manual `useMemo` adds noise without improving performance."],
+	["useCallback", "Remove `useCallback` — React Compiler auto-memoizes every function in this component. Manual `useCallback` adds noise without improving performance."],
+	["memo", "Remove `memo()` — React Compiler memoizes component output automatically. Wrapping with `memo` is redundant and obscures the component tree."]
+]);
+const resolveReactApiNameForIdentifier = (callee) => {
+	if (!isNodeOfType(callee, "Identifier")) return null;
+	const importedName = getImportedNameFromModule(callee, callee.name, "react");
+	if (importedName && REMOVAL_MESSAGE_BY_REACT_API_NAME.has(importedName)) return importedName;
+	return null;
+};
+const resolveReactApiNameForMemberExpression = (callee) => {
+	if (!isNodeOfType(callee, "MemberExpression")) return null;
+	if (callee.computed) return null;
+	const namespaceIdentifier = callee.object;
+	const propertyIdentifier = callee.property;
+	if (!isNodeOfType(namespaceIdentifier, "Identifier")) return null;
+	if (!isNodeOfType(propertyIdentifier, "Identifier")) return null;
+	if (!REMOVAL_MESSAGE_BY_REACT_API_NAME.has(propertyIdentifier.name)) return null;
+	const namespaceName = namespaceIdentifier.name;
+	if (isCanonicalReactNamespaceName(namespaceName)) return propertyIdentifier.name;
+	if (isImportedFromModule(namespaceIdentifier, namespaceName, "react")) return propertyIdentifier.name;
+	return null;
+};
+const resolveRemovalMessageForCallee = (callee) => {
+	const apiName = resolveReactApiNameForIdentifier(callee) ?? resolveReactApiNameForMemberExpression(callee);
+	if (!apiName) return null;
+	return REMOVAL_MESSAGE_BY_REACT_API_NAME.get(apiName) ?? null;
+};
+const reactCompilerNoManualMemoization = defineRule({
+	id: "react-compiler-no-manual-memoization",
+	severity: "error",
+	requires: ["react-compiler"],
+	recommendation: "Delete the `useMemo` / `useCallback` / `memo` call and use the bare expression or component — React Compiler memoizes it for you.",
+	create: (context) => ({ CallExpression(node) {
+		const removalMessage = resolveRemovalMessageForCallee(node.callee);
+		if (!removalMessage) return;
+		context.report({
+			node,
+			message: removalMessage
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/utils/has-binding-named.ts
 const hasBindingNamed = (root, bindingName) => {
 	const collected = /* @__PURE__ */ new Set();
@@ -22685,15 +22864,15 @@ const renderingAnimateSvgWrapper = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/correctness/rendering-conditional-render.ts
-const NUMERIC_NAME_HINTS = [
+const NUMERIC_NAME_HINTS$1 = [
 	"count",
 	"length",
 	"total",
 	"size",
 	"num"
 ];
-const isNumericName = (name) => {
-	for (const hint of NUMERIC_NAME_HINTS) {
+const isNumericName$1 = (name) => {
+	for (const hint of NUMERIC_NAME_HINTS$1) {
 		if (name === hint) return true;
 		const camelSuffix = hint.charAt(0).toUpperCase() + hint.slice(1);
 		if (name.endsWith(camelSuffix)) return true;
@@ -22712,7 +22891,7 @@ const renderingConditionalRender = defineRule({
 		const left = node.left;
 		if (!left) return;
 		const isLengthMemberAccess = isNodeOfType(left, "MemberExpression") && isNodeOfType(left.property, "Identifier") && left.property.name === "length";
-		const isNumericIdentifier = isNodeOfType(left, "Identifier") && isNumericName(left.name);
+		const isNumericIdentifier = isNodeOfType(left, "Identifier") && isNumericName$1(left.name);
 		if (isLengthMemberAccess || isNumericIdentifier) context.report({
 			node,
 			message: "Conditional rendering with a numeric value can render '0' — use `value > 0`, `Boolean(value)`, or a ternary"
@@ -22907,7 +23086,8 @@ const renderingSvgPrecision = defineRule({
 	category: "Performance",
 	recommendation: "Truncate path/points/transform decimals to 1–2 digits — sub-pixel precision adds bytes with no visible difference",
 	create: (context) => {
-		const isAutoGenerated = isAutoGeneratedSvgFile(context.getFilename?.());
+		const filename = context.getFilename?.();
+		const isAutoGenerated = isAutoGeneratedSvgFile(filename ? normalizeFilename$1(filename) : void 0);
 		return { JSXAttribute(node) {
 			if (isAutoGenerated) return;
 			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
@@ -23713,18 +23893,32 @@ const REANIMATED_LAYOUT_KEYS = new Set([
 	"minHeight",
 	"maxWidth",
 	"maxHeight",
+	"margin",
 	"marginTop",
 	"marginBottom",
 	"marginLeft",
 	"marginRight",
+	"marginHorizontal",
+	"marginVertical",
+	"padding",
 	"paddingTop",
 	"paddingBottom",
 	"paddingLeft",
 	"paddingRight",
+	"paddingHorizontal",
+	"paddingVertical",
 	"flex",
 	"flexBasis",
 	"flexGrow",
-	"flexShrink"
+	"flexShrink",
+	"borderWidth",
+	"borderTopWidth",
+	"borderBottomWidth",
+	"borderLeftWidth",
+	"borderRightWidth",
+	"fontSize",
+	"lineHeight",
+	"letterSpacing"
 ]);
 const findReturnedObject = (callback) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return null;
@@ -23780,10 +23974,9 @@ const rnAnimationReactionAsDerived = defineRule({
 			singleAssignment = onlyStatement.expression;
 		} else if (body) singleAssignment = body;
 		if (!singleAssignment) return;
-		if (!isNodeOfType(singleAssignment, "AssignmentExpression")) return;
-		if (!isNodeOfType(singleAssignment.left, "MemberExpression")) return;
-		if (!isNodeOfType(singleAssignment.left.property, "Identifier")) return;
-		if (singleAssignment.left.property.name !== "value") return;
+		const isValueAssignment = isNodeOfType(singleAssignment, "AssignmentExpression") && isNodeOfType(singleAssignment.left, "MemberExpression") && isNodeOfType(singleAssignment.left.property, "Identifier") && singleAssignment.left.property.name === "value";
+		const isSetCall = isNodeOfType(singleAssignment, "CallExpression") && isNodeOfType(singleAssignment.callee, "MemberExpression") && isNodeOfType(singleAssignment.callee.property, "Identifier") && singleAssignment.callee.property.name === "set" && (singleAssignment.arguments?.length ?? 0) === 1;
+		if (!isValueAssignment && !isSetCall) return;
 		context.report({
 			node,
 			message: "useAnimatedReaction body is a single shared-value assignment — useDerivedValue is shorter and tracks dependencies natively"
@@ -23793,10 +23986,13 @@ const rnAnimationReactionAsDerived = defineRule({
 //#endregion
 //#region src/plugin/rules/react-native/rn-bottom-sheet-prefer-native.ts
 const JS_BOTTOM_SHEET_PACKAGES = new Set([
-	"@gorhom/bottom-sheet",
 	"react-native-bottom-sheet",
 	"react-native-modal-bottom-sheet",
-	"react-native-raw-bottom-sheet"
+	"react-native-raw-bottom-sheet",
+	"react-native-modalize",
+	"react-native-actions-sheet",
+	"react-native-bottomsheet-reanimated",
+	"@discord/bottom-sheet"
 ]);
 const rnBottomSheetPreferNative = defineRule({
 	id: "rn-bottom-sheet-prefer-native",
@@ -23814,6 +24010,77 @@ const rnBottomSheetPreferNative = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/constants/react-native.ts
+const REACT_NATIVE_TEXT_COMPONENTS = new Set([
+	"Text",
+	"TextInput",
+	"Typography",
+	"Paragraph",
+	"Span",
+	"H1",
+	"H2",
+	"H3",
+	"H4",
+	"H5",
+	"H6"
+]);
+const REACT_NATIVE_TEXT_COMPONENT_KEYWORDS = new Set([
+	"Text",
+	"Title",
+	"Label",
+	"Heading",
+	"Caption",
+	"Subtitle",
+	"Typography",
+	"Paragraph",
+	"Description",
+	"Body"
+]);
+const DEPRECATED_RN_MODULE_REPLACEMENTS = new Map([
+	["AsyncStorage", "@react-native-async-storage/async-storage"],
+	["Picker", "@react-native-picker/picker"],
+	["PickerIOS", "@react-native-picker/picker"],
+	["DatePickerIOS", "@react-native-community/datetimepicker"],
+	["DatePickerAndroid", "@react-native-community/datetimepicker"],
+	["ProgressBarAndroid", "a community alternative"],
+	["ProgressViewIOS", "a community alternative"],
+	["SafeAreaView", "react-native-safe-area-context"],
+	["Slider", "@react-native-community/slider"],
+	["ViewPagerAndroid", "react-native-pager-view"],
+	["WebView", "react-native-webview"],
+	["NetInfo", "@react-native-community/netinfo"],
+	["CameraRoll", "@react-native-camera-roll/camera-roll"],
+	["Clipboard", "@react-native-clipboard/clipboard"],
+	["ImageEditor", "@react-native-community/image-editor"],
+	["MaskedViewIOS", "@react-native-masked-view/masked-view"]
+]);
+const LEGACY_EXPO_PACKAGE_REPLACEMENTS = new Map([
+	["expo-av", "expo-audio for audio and expo-video for video"],
+	["expo-permissions", "the permissions API in each module (e.g. Camera.requestPermissionsAsync())"],
+	["expo-app-loading", "expo-splash-screen"],
+	["expo-linear-gradient", "the `backgroundImage` CSS gradient style prop (New Architecture) or expo-linear-gradient's successor"],
+	["react-native-fast-image", "expo-image (drop-in with caching, placeholders, and crossfades)"]
+]);
+const REACT_NATIVE_LIST_COMPONENTS = new Set([
+	"FlatList",
+	"SectionList",
+	"VirtualizedList",
+	"FlashList",
+	"LegendList"
+]);
+const RENDER_ITEM_PROP_NAMES = new Set([
+	"renderItem",
+	"renderSectionHeader",
+	"renderSectionFooter"
+]);
+const LEGACY_SHADOW_STYLE_PROPERTIES = new Set([
+	"shadowColor",
+	"shadowOffset",
+	"shadowOpacity",
+	"shadowRadius",
+	"elevation"
+]);
+//#endregion
 //#region src/plugin/rules/react-native/rn-list-callback-per-row.ts
 const LIST_ROW_PRESS_HANDLER_PROPS = new Set([
 	"onPress",
@@ -23838,13 +24105,21 @@ const detectInlineRowHandlers = (renderItemFn) => {
 };
 const isRenderItemJsxAttribute = (parent) => {
 	if (!isNodeOfType(parent, "JSXAttribute")) return false;
-	return (isNodeOfType(parent.name, "JSXIdentifier") ? parent.name.name : null) === "renderItem";
+	const attrName = isNodeOfType(parent.name, "JSXIdentifier") ? parent.name.name : null;
+	return attrName ? RENDER_ITEM_PROP_NAMES.has(attrName) : false;
 };
 const isRenderItemFunction = (node) => {
 	const parent = node.parent;
 	if (!isNodeOfType(parent, "JSXExpressionContainer")) return false;
 	return isRenderItemJsxAttribute(parent.parent);
 };
+const resolveRenderPropName = (node) => {
+	const container = node.parent;
+	if (!isNodeOfType(container, "JSXExpressionContainer")) return "renderItem";
+	const attr = container.parent;
+	if (isNodeOfType(attr, "JSXAttribute") && isNodeOfType(attr.name, "JSXIdentifier") && RENDER_ITEM_PROP_NAMES.has(attr.name.name)) return attr.name.name;
+	return "renderItem";
+};
 const rnListCallbackPerRow = defineRule({
 	id: "rn-list-callback-per-row",
 	tags: ["test-noise"],
@@ -23854,12 +24129,13 @@ const rnListCallbackPerRow = defineRule({
 	create: (context) => {
 		const inspect = (node) => {
 			if (!isRenderItemFunction(node)) return;
+			const renderPropName = resolveRenderPropName(node);
 			const inlineHandlers = detectInlineRowHandlers(node);
 			for (const handler of inlineHandlers) {
 				const handlerName = isNodeOfType(handler, "JSXAttribute") && isNodeOfType(handler.name, "JSXIdentifier") ? handler.name.name : "<handler>";
 				context.report({
 					node: handler,
-					message: `Inline ${handlerName} arrow inside renderItem creates a fresh closure per row — hoist with useCallback at list scope and pass the row id as a primitive prop`
+					message: `Inline ${handlerName} arrow inside ${renderPropName} creates a fresh closure per render — hoist with useCallback at list scope`
 				});
 			}
 		};
@@ -23881,13 +24157,33 @@ const resolveJsxElementName = (openingElement) => {
 };
 //#endregion
 //#region src/plugin/rules/react-native/rn-list-data-mapped.ts
-const VIRTUALIZED_LIST_NAMES = new Set([
-	"FlatList",
-	"FlashList",
-	"LegendList",
-	"SectionList",
-	"VirtualizedList"
+const FRESH_ARRAY_METHODS = new Set([
+	"map",
+	"filter",
+	"toSorted",
+	"slice",
+	"toReversed",
+	"concat",
+	"flat",
+	"flatMap",
+	"toSpliced"
 ]);
+const isFreshArrayExpression = (node) => {
+	if (isNodeOfType(node, "ArrayExpression")) return "[...spread]";
+	if (isNodeOfType(node, "CallExpression")) {
+		const callee = node.callee;
+		if (isNodeOfType(callee, "MemberExpression")) {
+			if (isNodeOfType(callee.property, "Identifier")) {
+				const methodName = callee.property.name;
+				if (FRESH_ARRAY_METHODS.has(methodName)) return `.${methodName}(…)`;
+				if (methodName === "from" && isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array") return "Array.from(…)";
+			}
+			return isFreshArrayExpression(callee.object);
+		}
+		if (isNodeOfType(callee, "Identifier") && callee.name === "Array") return "Array(…)";
+	}
+	return null;
+};
 const rnListDataMapped = defineRule({
 	id: "rn-list-data-mapped",
 	tags: ["test-noise"],
@@ -23896,20 +24192,17 @@ const rnListDataMapped = defineRule({
 	recommendation: "Wrap the projection in `useMemo(() => items.map(...), [items])` so the list's `data` prop has a stable reference across parent renders",
 	create: (context) => ({ JSXOpeningElement(node) {
 		const elementName = resolveJsxElementName(node);
-		if (!elementName || !VIRTUALIZED_LIST_NAMES.has(elementName)) return;
+		if (!elementName || !REACT_NATIVE_LIST_COMPONENTS.has(elementName)) return;
 		for (const attr of node.attributes ?? []) {
 			if (!isNodeOfType(attr, "JSXAttribute")) continue;
 			if (!isNodeOfType(attr.name, "JSXIdentifier") || attr.name.name !== "data") continue;
 			if (!isNodeOfType(attr.value, "JSXExpressionContainer")) continue;
 			const expression = attr.value.expression;
-			if (!isNodeOfType(expression, "CallExpression")) continue;
-			if (!isNodeOfType(expression.callee, "MemberExpression")) continue;
-			if (!isNodeOfType(expression.callee.property, "Identifier")) continue;
-			const methodName = expression.callee.property.name;
-			if (methodName !== "map" && methodName !== "filter") continue;
+			const freshArrayDescription = isFreshArrayExpression(expression);
+			if (!freshArrayDescription) continue;
 			context.report({
 				node: attr,
-				message: `<${elementName} data={items.${methodName}(...)}> allocates a fresh array per render — wrap in useMemo at list scope so the data reference stays stable across parent renders`
+				message: `<${elementName} data={…${freshArrayDescription}}> allocates a fresh array per render — wrap in useMemo so the data reference stays stable across parent renders`
 			});
 			return;
 		}
@@ -23944,86 +24237,177 @@ const rnListRecyclableWithoutTypes = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/constants/react-native.ts
-const REACT_NATIVE_TEXT_COMPONENTS = new Set([
-	"Text",
-	"TextInput",
-	"Typography",
-	"Paragraph",
-	"Span",
-	"H1",
-	"H2",
-	"H3",
-	"H4",
-	"H5",
-	"H6"
-]);
-const REACT_NATIVE_TEXT_COMPONENT_KEYWORDS = new Set([
-	"Text",
-	"Title",
-	"Label",
-	"Heading",
-	"Caption",
-	"Subtitle",
-	"Typography",
-	"Paragraph",
-	"Description",
-	"Body"
-]);
-const DEPRECATED_RN_MODULE_REPLACEMENTS = new Map([
-	["AsyncStorage", "@react-native-async-storage/async-storage"],
-	["Picker", "@react-native-picker/picker"],
-	["PickerIOS", "@react-native-picker/picker"],
-	["DatePickerIOS", "@react-native-community/datetimepicker"],
-	["DatePickerAndroid", "@react-native-community/datetimepicker"],
-	["ProgressBarAndroid", "a community alternative"],
-	["ProgressViewIOS", "a community alternative"],
-	["SafeAreaView", "react-native-safe-area-context"],
-	["Slider", "@react-native-community/slider"],
-	["ViewPagerAndroid", "react-native-pager-view"],
-	["WebView", "react-native-webview"],
-	["NetInfo", "@react-native-community/netinfo"],
-	["CameraRoll", "@react-native-camera-roll/camera-roll"],
-	["Clipboard", "@react-native-clipboard/clipboard"],
-	["ImageEditor", "@react-native-community/image-editor"],
-	["MaskedViewIOS", "@react-native-masked-view/masked-view"]
+//#region src/react-native-dependency-names.ts
+const EXPO_MANAGED_DEPENDENCY_NAMES = new Set([
+	"expo",
+	"expo-router",
+	"@expo/cli",
+	"@expo/metro-config",
+	"@expo/metro-runtime"
 ]);
-const LEGACY_EXPO_PACKAGE_REPLACEMENTS = new Map([["expo-av", "expo-audio for audio and expo-video for video"], ["expo-permissions", "the permissions API in each module (e.g. Camera.requestPermissionsAsync())"]]);
-const REACT_NATIVE_LIST_COMPONENTS = new Set([
-	"FlatList",
-	"SectionList",
-	"VirtualizedList",
-	"FlashList"
+const REACT_NATIVE_DEPENDENCY_NAMES = new Set([
+	"react-native",
+	"react-native-tvos",
+	...EXPO_MANAGED_DEPENDENCY_NAMES,
+	"react-native-windows",
+	"react-native-macos"
 ]);
-const LEGACY_SHADOW_STYLE_PROPERTIES = new Set([
-	"shadowColor",
-	"shadowOffset",
-	"shadowOpacity",
-	"shadowRadius",
-	"elevation"
+const REACT_NATIVE_DEPENDENCY_PREFIXES = ["@react-native/", "@react-native-"];
+const isExpoManagedDependencyName = (dependencyName) => EXPO_MANAGED_DEPENDENCY_NAMES.has(dependencyName);
+const isReactNativeDependencyName = (dependencyName) => {
+	if (REACT_NATIVE_DEPENDENCY_NAMES.has(dependencyName)) return true;
+	for (const prefix of REACT_NATIVE_DEPENDENCY_PREFIXES) if (dependencyName.startsWith(prefix)) return true;
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/classify-package-platform.ts
+const WEB_FRAMEWORK_DEPENDENCY_NAMES = new Set([
+	"next",
+	"vite",
+	"react-scripts",
+	"gatsby",
+	"@remix-run/react",
+	"@remix-run/node",
+	"@docusaurus/core",
+	"@docusaurus/preset-classic",
+	"@storybook/react",
+	"@storybook/react-vite",
+	"@storybook/react-webpack5",
+	"@storybook/nextjs",
+	"@storybook/web-components",
+	"storybook",
+	"react-dom",
+	"@vitejs/plugin-react",
+	"@vitejs/plugin-react-swc"
 ]);
+const cachedPlatformByPackageDirectory = /* @__PURE__ */ new Map();
+const cachedPackageDirectoryByFilename = /* @__PURE__ */ new Map();
+const findNearestPackageDirectory = (filename) => {
+	if (!filename) return null;
+	const fromCache = cachedPackageDirectoryByFilename.get(filename);
+	if (fromCache !== void 0) return fromCache;
+	let currentDirectory = path.dirname(filename);
+	while (true) {
+		const candidatePackageJsonPath = path.join(currentDirectory, "package.json");
+		let hasPackageJson = false;
+		try {
+			hasPackageJson = fs.statSync(candidatePackageJsonPath).isFile();
+		} catch {
+			hasPackageJson = false;
+		}
+		if (hasPackageJson) {
+			cachedPackageDirectoryByFilename.set(filename, currentDirectory);
+			return currentDirectory;
+		}
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) {
+			cachedPackageDirectoryByFilename.set(filename, null);
+			return null;
+		}
+		currentDirectory = parentDirectory;
+	}
+};
+const readPackageJsonSafe = (packageJsonPath) => {
+	let rawContents;
+	try {
+		rawContents = fs.readFileSync(packageJsonPath, "utf-8");
+	} catch {
+		return null;
+	}
+	try {
+		const parsed = JSON.parse(rawContents);
+		if (typeof parsed === "object" && parsed !== null) return parsed;
+		return null;
+	} catch {
+		return null;
+	}
+};
+const DEPENDENCY_SECTION_NAMES = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+const iterateDependencyNames = function* (packageJson) {
+	for (const sectionName of DEPENDENCY_SECTION_NAMES) {
+		const section = packageJson[sectionName];
+		if (!section) continue;
+		for (const dependencyName of Object.keys(section)) yield dependencyName;
+	}
+};
+const isReactNativeAware = (packageJson) => {
+	if (typeof packageJson["react-native"] === "string") return true;
+	for (const dependencyName of iterateDependencyNames(packageJson)) if (isReactNativeDependencyName(dependencyName)) return true;
+	return false;
+};
+const isExpoManaged = (packageJson) => {
+	for (const dependencyName of iterateDependencyNames(packageJson)) if (isExpoManagedDependencyName(dependencyName)) return true;
+	return false;
+};
+const isWebFrameworkOnly = (packageJson) => {
+	for (const dependencyName of iterateDependencyNames(packageJson)) if (WEB_FRAMEWORK_DEPENDENCY_NAMES.has(dependencyName)) return true;
+	return false;
+};
+const classifyPackagePlatform = (filename) => {
+	const packageDirectory = findNearestPackageDirectory(filename);
+	if (!packageDirectory) return "unknown";
+	const cached = cachedPlatformByPackageDirectory.get(packageDirectory);
+	if (cached !== void 0) return cached;
+	const packageJson = readPackageJsonSafe(path.join(packageDirectory, "package.json"));
+	if (!packageJson) {
+		cachedPlatformByPackageDirectory.set(packageDirectory, "unknown");
+		return "unknown";
+	}
+	let result;
+	if (isExpoManaged(packageJson)) result = "expo";
+	else if (isReactNativeAware(packageJson)) result = "react-native";
+	else if (isWebFrameworkOnly(packageJson)) result = "web";
+	else result = "unknown";
+	cachedPlatformByPackageDirectory.set(packageDirectory, result);
+	return result;
+};
+//#endregion
+//#region src/plugin/utils/is-expo-managed-file.ts
+const isExpoManagedFileActive = (context) => {
+	const filename = context.getFilename?.() ? normalizeFilename$1(context.getFilename()) : void 0;
+	if (filename) {
+		const packagePlatform = classifyPackagePlatform(filename);
+		if (packagePlatform === "expo") return true;
+		if (packagePlatform === "react-native" || packagePlatform === "web") return false;
+	}
+	return getReactDoctorStringSetting(context.settings, "framework") === "expo";
+};
 //#endregion
 //#region src/plugin/rules/react-native/rn-no-deprecated-modules.ts
+const getExpoAwareReplacement = (importedName, baseReplacement, isExpo) => {
+	if (!isExpo) return baseReplacement;
+	if (importedName === "AsyncStorage") return "expo-sqlite/localStorage (import \"expo-sqlite/localStorage/install\") for simple key-value storage, or expo-secure-store for sensitive data";
+	return baseReplacement;
+};
 const rnNoDeprecatedModules = defineRule({
 	id: "rn-no-deprecated-modules",
 	tags: ["test-noise"],
 	requires: ["react-native"],
 	severity: "error",
 	recommendation: "Import from the community package instead — deprecated modules were removed from the react-native core",
-	create: (context) => ({ ImportDeclaration(node) {
-		if (node.source?.value !== "react-native") return;
-		for (const specifier of node.specifiers ?? []) {
-			if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
-			const importedName = getImportedName(specifier);
-			if (!importedName) continue;
-			const replacement = DEPRECATED_RN_MODULE_REPLACEMENTS.get(importedName);
-			if (!replacement) continue;
-			context.report({
-				node: specifier,
-				message: `"${importedName}" was removed from react-native — use ${replacement} instead`
-			});
-		}
-	} })
+	create: (context) => {
+		const isExpo = isExpoManagedFileActive(context);
+		return { ImportDeclaration(node) {
+			if (node.source?.value !== "react-native") return;
+			for (const specifier of node.specifiers ?? []) {
+				if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
+				const importedName = getImportedName(specifier);
+				if (!importedName) continue;
+				const baseReplacement = DEPRECATED_RN_MODULE_REPLACEMENTS.get(importedName);
+				if (!baseReplacement) continue;
+				const replacement = getExpoAwareReplacement(importedName, baseReplacement, isExpo);
+				context.report({
+					node: specifier,
+					message: `"${importedName}" was removed from react-native — use ${replacement} instead`
+				});
+			}
+		} };
+	}
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-no-dimensions-get.ts
@@ -24047,6 +24431,99 @@ const rnNoDimensionsGet = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/react-native/rn-no-falsy-and-render.ts
+const NUMERIC_NAME_HINTS = [
+	"count",
+	"length",
+	"total",
+	"size",
+	"num",
+	"index",
+	"amount",
+	"quantity",
+	"offset",
+	"width",
+	"height",
+	"duration",
+	"progress",
+	"score",
+	"rank",
+	"level",
+	"step",
+	"max",
+	"min",
+	"sum",
+	"avg",
+	"depth",
+	"balance",
+	"age",
+	"weight",
+	"volume",
+	"distance",
+	"speed",
+	"rate",
+	"ratio",
+	"percent",
+	"percentage"
+];
+const BOOLEAN_PREFIXES = [
+	"is",
+	"has",
+	"can",
+	"should",
+	"did",
+	"will",
+	"show",
+	"hide",
+	"enable",
+	"disable"
+];
+const isNumericName = (name) => {
+	const lower = name.toLowerCase();
+	for (const prefix of BOOLEAN_PREFIXES) if (lower.startsWith(prefix) && name.length > prefix.length && name[prefix.length] === name[prefix.length].toUpperCase()) return false;
+	for (const hint of NUMERIC_NAME_HINTS) {
+		if (lower === hint) return true;
+		const camelSuffix = hint.charAt(0).toUpperCase() + hint.slice(1);
+		if (name.endsWith(camelSuffix)) return true;
+		if (lower.endsWith(`_${hint}`)) return true;
+	}
+	return false;
+};
+const isLikelyNumericExpression = (node) => {
+	if (isNodeOfType(node, "MemberExpression") && isNodeOfType(node.property, "Identifier") && node.property.name === "length") return true;
+	if (isNodeOfType(node, "Identifier") && isNumericName(node.name)) return true;
+	if (isNodeOfType(node, "MemberExpression") && isNodeOfType(node.property, "Identifier") && isNumericName(node.property.name)) return true;
+	return false;
+};
+const rnNoFalsyAndRender = defineRule({
+	id: "rn-no-falsy-and-render",
+	requires: ["react-native"],
+	severity: "error",
+	recommendation: "Use `{value > 0 && <X />}`, `{Boolean(value) && <X />}`, or a ternary `{value ? <X /> : null}` — numeric falsy `0` renders as raw text and crashes on RN",
+	create: (context) => {
+		let isDomComponentFile = false;
+		return {
+			Program(programNode) {
+				isDomComponentFile = hasDirective(programNode, "use dom");
+			},
+			LogicalExpression(node) {
+				if (isDomComponentFile) return;
+				if (node.operator !== "&&") return;
+				if (!(isNodeOfType(node.right, "JSXElement") || isNodeOfType(node.right, "JSXFragment"))) return;
+				const parent = node.parent;
+				if (!(isNodeOfType(parent, "JSXExpressionContainer") || isNodeOfType(parent, "LogicalExpression") && parent.operator === "&&")) return;
+				const left = node.left;
+				if (!left) return;
+				if (!isLikelyNumericExpression(left)) return;
+				context.report({
+					node: left,
+					message: "Conditional rendering with a numeric value can render `0` as raw text — on React Native this crashes. Use `value > 0`, `Boolean(value)`, or a ternary"
+				});
+			}
+		};
+	}
+});
+//#endregion
 //#region src/plugin/rules/react-native/rn-no-inline-flatlist-renderitem.ts
 const rnNoInlineFlatlistRenderitem = defineRule({
 	id: "rn-no-inline-flatlist-renderitem",
@@ -24071,11 +24548,6 @@ const rnNoInlineFlatlistRenderitem = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-no-inline-object-in-list-item.ts
-const RENDER_ITEM_PROP_NAMES = new Set([
-	"renderItem",
-	"renderSectionHeader",
-	"renderSectionFooter"
-]);
 const rnNoInlineObjectInListItem = defineRule({
 	id: "rn-no-inline-object-in-list-item",
 	tags: ["test-noise"],
@@ -24083,23 +24555,22 @@ const rnNoInlineObjectInListItem = defineRule({
 	severity: "warn",
 	recommendation: "Hoist style/object props outside renderItem (StyleSheet.create, useMemo at list scope, or pass primitives) so memo() row components stop bailing",
 	create: (context) => {
-		let renderItemDepth = 0;
-		const isRenderItemAttribute = (parent) => {
-			if (!isNodeOfType(parent, "JSXAttribute")) return false;
-			const attrName = isNodeOfType(parent.name, "JSXIdentifier") ? parent.name.name : null;
-			return attrName ? RENDER_ITEM_PROP_NAMES.has(attrName) : false;
-		};
-		const isRenderItemFunction = (node) => {
-			if (!isNodeOfType(node, "ArrowFunctionExpression") && !isNodeOfType(node, "FunctionExpression")) return false;
+		const renderPropStack = [];
+		const resolveRenderPropName = (node) => {
+			if (!isNodeOfType(node, "ArrowFunctionExpression") && !isNodeOfType(node, "FunctionExpression")) return null;
 			const expressionContainer = node.parent;
-			if (!isNodeOfType(expressionContainer, "JSXExpressionContainer")) return false;
-			return isRenderItemAttribute(expressionContainer.parent);
+			if (!isNodeOfType(expressionContainer, "JSXExpressionContainer")) return null;
+			const attr = expressionContainer.parent;
+			if (!isNodeOfType(attr, "JSXAttribute")) return null;
+			const attrName = isNodeOfType(attr.name, "JSXIdentifier") ? attr.name.name : null;
+			return attrName && RENDER_ITEM_PROP_NAMES.has(attrName) ? attrName : null;
 		};
 		const enter = (node) => {
-			if (isRenderItemFunction(node)) renderItemDepth++;
+			const renderPropName = resolveRenderPropName(node);
+			if (renderPropName) renderPropStack.push(renderPropName);
 		};
 		const exit = (node) => {
-			if (isRenderItemFunction(node)) renderItemDepth = Math.max(0, renderItemDepth - 1);
+			if (resolveRenderPropName(node)) renderPropStack.pop();
 		};
 		return {
 			ArrowFunctionExpression: enter,
@@ -24107,13 +24578,18 @@ const rnNoInlineObjectInListItem = defineRule({
 			FunctionExpression: enter,
 			"FunctionExpression:exit": exit,
 			JSXAttribute(node) {
-				if (renderItemDepth === 0) return;
+				if (renderPropStack.length === 0) return;
 				if (!isNodeOfType(node.value, "JSXExpressionContainer")) return;
-				if (!isNodeOfType(node.value.expression, "ObjectExpression")) return;
+				const expression = node.value.expression;
+				const isInlineObject = isNodeOfType(expression, "ObjectExpression");
+				const isInlineArray = isNodeOfType(expression, "ArrayExpression");
+				if (!isInlineObject && !isInlineArray) return;
 				const propName = isNodeOfType(node.name, "JSXIdentifier") ? node.name.name : "<unknown>";
+				const literalKind = isInlineArray ? "array" : "object";
+				const activeRenderProp = renderPropStack[renderPropStack.length - 1];
 				context.report({
 					node,
-					message: `Inline object literal on "${propName}" inside renderItem — allocates a fresh reference per row and breaks memo() on the row component. Hoist outside renderItem or pass primitives`
+					message: `Inline ${literalKind} literal on "${propName}" inside ${activeRenderProp} — allocates a fresh reference per render and breaks memo(). Hoist outside ${activeRenderProp} or pass primitives`
 				});
 			}
 		};
@@ -24163,7 +24639,9 @@ const rnNoLegacyShadowStyles = defineRule({
 	recommendation: "Use `boxShadow` for cross-platform shadows on the new architecture instead of platform-specific shadow properties",
 	create: (context) => ({
 		JSXAttribute(node) {
-			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "style") return;
+			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+			const attrName = node.name.name;
+			if (attrName !== "style" && !attrName.endsWith("Style")) return;
 			if (!isNodeOfType(node.value, "JSXExpressionContainer")) return;
 			const expression = node.value.expression;
 			if (isNodeOfType(expression, "ObjectExpression")) reportLegacyShadowProperties(expression, context);
@@ -24187,7 +24665,11 @@ const rnNoLegacyShadowStyles = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-no-non-native-navigator.ts
-const NON_NATIVE_NAVIGATOR_PACKAGES = new Set(["@react-navigation/stack", "@react-navigation/drawer"]);
+const NON_NATIVE_NAVIGATOR_PACKAGES = new Map([
+	["@react-navigation/stack", "@react-navigation/native-stack"],
+	["@react-navigation/drawer", "expo-router Drawer (no native equivalent exists for standalone React Navigation)"],
+	["@react-navigation/bottom-tabs", "@react-navigation/native-tabs (v7+) or expo-router NativeTabs"]
+]);
 const rnNoNonNativeNavigator = defineRule({
 	id: "rn-no-non-native-navigator",
 	tags: ["test-noise"],
@@ -24196,8 +24678,9 @@ const rnNoNonNativeNavigator = defineRule({
 	recommendation: "Use `@react-navigation/native-stack` (or `native-tabs` in v7+) for platform-native transitions and gestures",
 	create: (context) => ({ ImportDeclaration(node) {
 		const source = node.source?.value;
-		if (typeof source !== "string" || !NON_NATIVE_NAVIGATOR_PACKAGES.has(source)) return;
-		const replacement = source.replace("@react-navigation/", "@react-navigation/native-");
+		if (typeof source !== "string") return;
+		const replacement = NON_NATIVE_NAVIGATOR_PACKAGES.get(source);
+		if (!replacement) return;
 		context.report({
 			node,
 			message: `${source} uses a JS-implemented navigator — use ${replacement} for native iOS/Android transitions and gestures`
@@ -24368,34 +24851,68 @@ const rnNoRawText = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-no-scroll-state.ts
+const SET_STATE_PATTERN = /^set[A-Z]/;
+const findSetStateInBody = (body) => {
+	let setStateCallNode = null;
+	walkAst(body, (child) => {
+		if (setStateCallNode) return;
+		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && SET_STATE_PATTERN.test(child.callee.name)) setStateCallNode = child;
+	});
+	return setStateCallNode;
+};
 const rnNoScrollState = defineRule({
 	id: "rn-no-scroll-state",
 	tags: ["test-noise"],
 	requires: ["react-native"],
 	severity: "error",
 	recommendation: "Track scroll position with a Reanimated shared value (`useAnimatedScrollHandler`) or a ref — `setState` on every scroll event causes re-render storms",
-	create: (context) => ({ JSXAttribute(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-		if (node.name.name !== "onScroll") return;
-		if (!isNodeOfType(node.value, "JSXExpressionContainer")) return;
-		const expression = node.value.expression;
-		if (!isNodeOfType(expression, "ArrowFunctionExpression") && !isNodeOfType(expression, "FunctionExpression")) return;
-		let setStateCallNode = null;
-		walkAst(expression.body, (child) => {
-			if (setStateCallNode) return;
-			if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && /^set[A-Z]/.test(child.callee.name)) setStateCallNode = child;
-		});
-		if (setStateCallNode) context.report({
-			node: setStateCallNode,
-			message: "setState in onScroll triggers re-renders on every scroll event — use a Reanimated shared value (useAnimatedScrollHandler) or a ref to track scroll position"
-		});
-	} })
+	create: (context) => {
+		const stateSettersInHandlers = /* @__PURE__ */ new Map();
+		return {
+			VariableDeclarator(node) {
+				if (!isNodeOfType(node.id, "Identifier")) return;
+				const variableName = node.id.name;
+				if (!/scroll/i.test(variableName)) return;
+				const init = node.init;
+				if (!isNodeOfType(init, "ArrowFunctionExpression") && !isNodeOfType(init, "FunctionExpression")) return;
+				const setStateCall = findSetStateInBody(init.body);
+				if (setStateCall) stateSettersInHandlers.set(variableName, setStateCall);
+			},
+			JSXAttribute(node) {
+				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+				if (node.name.name !== "onScroll") return;
+				if (!isNodeOfType(node.value, "JSXExpressionContainer")) return;
+				const expression = node.value.expression;
+				if (isNodeOfType(expression, "Identifier")) {
+					const tracked = stateSettersInHandlers.get(expression.name);
+					if (tracked) context.report({
+						node: tracked,
+						message: "setState in onScroll handler triggers re-renders on every scroll event — use a Reanimated shared value (useAnimatedScrollHandler) or a ref to track scroll position"
+					});
+					return;
+				}
+				if (!isNodeOfType(expression, "ArrowFunctionExpression") && !isNodeOfType(expression, "FunctionExpression")) return;
+				const setStateCallNode = findSetStateInBody(expression.body);
+				if (setStateCallNode) context.report({
+					node: setStateCallNode,
+					message: "setState in onScroll triggers re-renders on every scroll event — use a Reanimated shared value (useAnimatedScrollHandler) or a ref to track scroll position"
+				});
+			}
+		};
+	}
 });
 //#endregion
-//#region src/plugin/rules/react-native/utils/scrollview_names.ts
-const SCROLLVIEW_NAMES = new Set(["ScrollView"]);
-//#endregion
 //#region src/plugin/rules/react-native/rn-no-scrollview-mapped-list.ts
+const NON_VIRTUALIZED_SCROLL_CONTAINERS = new Set(["ScrollView"]);
+const ARRAY_ITERATION_METHODS = new Set(["map", "flatMap"]);
+const isArrayIterationExpression = (node) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
+	if (!isNodeOfType(node.callee.property, "Identifier")) return false;
+	if (ARRAY_ITERATION_METHODS.has(node.callee.property.name)) return true;
+	if (node.callee.property.name === "filter" || node.callee.property.name === "slice" || node.callee.property.name === "sort" || node.callee.property.name === "reverse" || node.callee.property.name === "concat") return isArrayIterationExpression(node.callee.object);
+	return false;
+};
 const rnNoScrollviewMappedList = defineRule({
 	id: "rn-no-scrollview-mapped-list",
 	tags: ["test-noise"],
@@ -24404,11 +24921,11 @@ const rnNoScrollviewMappedList = defineRule({
 	recommendation: "Use FlashList, LegendList, or FlatList — `<ScrollView>{items.map(...)}</ScrollView>` mounts every row in memory",
 	create: (context) => ({ JSXElement(node) {
 		const elementName = resolveJsxElementName(node.openingElement);
-		if (!elementName || !SCROLLVIEW_NAMES.has(elementName)) return;
+		if (!elementName || !NON_VIRTUALIZED_SCROLL_CONTAINERS.has(elementName)) return;
 		for (const child of node.children ?? []) {
 			if (!isNodeOfType(child, "JSXExpressionContainer")) continue;
 			const expression = child.expression;
-			if (isNodeOfType(expression, "CallExpression") && isNodeOfType(expression.callee, "MemberExpression") && isNodeOfType(expression.callee.property, "Identifier") && expression.callee.property.name === "map") {
+			if (isArrayIterationExpression(expression)) {
 				context.report({
 					node: child,
 					message: `<${elementName}> rendering items.map(...) — use FlashList, LegendList, or FlatList so only visible rows mount`
@@ -24441,6 +24958,15 @@ const rnNoSingleElementStyleArray = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/react-native/utils/scrollview_names.ts
+const SCROLLVIEW_NAMES = new Set([
+	"ScrollView",
+	"FlatList",
+	"SectionList",
+	"VirtualizedList",
+	"KeyboardAwareScrollView"
+]);
+//#endregion
 //#region src/plugin/rules/react-native/rn-prefer-content-inset-adjustment.ts
 const rnPreferContentInsetAdjustment = defineRule({
 	id: "rn-prefer-content-inset-adjustment",
@@ -24454,9 +24980,10 @@ const rnPreferContentInsetAdjustment = defineRule({
 			if (!isNodeOfType(child, "JSXElement")) continue;
 			const childName = resolveJsxElementName(child.openingElement);
 			if (!childName || !SCROLLVIEW_NAMES.has(childName)) continue;
+			if (childName === "KeyboardAwareScrollView") continue;
 			context.report({
 				node,
-				message: "<SafeAreaView> wrapping <ScrollView> — set `contentInsetAdjustmentBehavior=\"automatic\"` on the ScrollView and drop the SafeAreaView wrapper for native safe-area handling"
+				message: `<SafeAreaView> wrapping <${childName}> — set \`contentInsetAdjustmentBehavior="automatic"\` on the ${childName} and drop the SafeAreaView wrapper for native safe-area handling`
 			});
 			return;
 		}
@@ -24464,23 +24991,28 @@ const rnPreferContentInsetAdjustment = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-prefer-expo-image.ts
+const EMPTY_VISITORS$1 = {};
 const rnPreferExpoImage = defineRule({
 	id: "rn-prefer-expo-image",
 	tags: ["test-noise"],
 	requires: ["react-native"],
 	severity: "warn",
 	recommendation: "Use `<Image>` from `expo-image` instead of `react-native` — same prop API, plus disk + memory caching, placeholders, and crossfades",
-	create: (context) => ({ ImportDeclaration(node) {
-		if (node.source?.value !== "react-native") return;
-		for (const specifier of node.specifiers ?? []) {
-			if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
-			if (getImportedName(specifier) !== "Image") continue;
-			context.report({
-				node: specifier,
-				message: "Importing Image from react-native — prefer expo-image for caching, placeholders, and progressive loading (drop-in API)"
-			});
-		}
-	} })
+	create: (context) => {
+		if (!isExpoManagedFileActive(context)) return EMPTY_VISITORS$1;
+		return { ImportDeclaration(node) {
+			if (node.source?.value !== "react-native") return;
+			for (const specifier of node.specifiers ?? []) {
+				if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
+				const importedName = getImportedName(specifier);
+				if (importedName !== "Image" && importedName !== "ImageBackground") continue;
+				context.report({
+					node: specifier,
+					message: `Importing ${importedName} from react-native — prefer expo-image for caching, placeholders, and progressive loading (drop-in API)`
+				});
+			}
+		} };
+	}
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-prefer-pressable.ts
@@ -24490,6 +25022,7 @@ const TOUCHABLE_COMPONENTS = new Set([
 	"TouchableWithoutFeedback",
 	"TouchableNativeFeedback"
 ]);
+const TOUCHABLE_SOURCES = new Set(["react-native", "react-native-gesture-handler"]);
 const rnPreferPressable = defineRule({
 	id: "rn-prefer-pressable",
 	tags: ["test-noise"],
@@ -24497,7 +25030,8 @@ const rnPreferPressable = defineRule({
 	severity: "warn",
 	recommendation: "Use `<Pressable>` from react-native (or react-native-gesture-handler) instead of legacy Touchable* components",
 	create: (context) => ({ ImportDeclaration(node) {
-		if (node.source?.value !== "react-native") return;
+		const source = node.source?.value;
+		if (typeof source !== "string" || !TOUCHABLE_SOURCES.has(source)) return;
 		for (const specifier of node.specifiers ?? []) {
 			if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
 			const importedName = getImportedName(specifier);
@@ -24511,6 +25045,7 @@ const rnPreferPressable = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-prefer-reanimated.ts
+const JS_THREAD_ANIMATION_IMPORTS = new Set(["Animated", "LayoutAnimation"]);
 const rnPreferReanimated = defineRule({
 	id: "rn-prefer-reanimated",
 	tags: ["test-noise"],
@@ -24521,17 +25056,31 @@ const rnPreferReanimated = defineRule({
 		if (node.source?.value !== "react-native") return;
 		for (const specifier of node.specifiers ?? []) {
 			if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
-			if (getImportedName(specifier) !== "Animated") continue;
+			const importedName = getImportedName(specifier);
+			if (!importedName || !JS_THREAD_ANIMATION_IMPORTS.has(importedName)) continue;
+			const suggestion = importedName === "LayoutAnimation" ? "LayoutAnimation runs animations on the JS thread and causes full layout recalculations — use Reanimated's Layout Animations (entering/exiting/layout props) for UI-thread layout transitions" : "Animated from react-native runs animations on the JS thread — use react-native-reanimated for performant UI-thread animations";
 			context.report({
 				node: specifier,
-				message: "Animated from react-native runs animations on the JS thread — use react-native-reanimated for performant UI-thread animations"
+				message: suggestion
 			});
 		}
 	} })
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-pressable-shared-value-mutation.ts
-const PRESS_HANDLER_PROP_NAMES = new Set(["onPressIn", "onPressOut"]);
+const PRESS_HANDLER_PROP_NAMES = new Set([
+	"onPress",
+	"onPressIn",
+	"onPressOut",
+	"onLongPress"
+]);
+const PRESSABLE_ELEMENT_NAMES = new Set([
+	"Pressable",
+	"TouchableOpacity",
+	"TouchableHighlight",
+	"TouchableWithoutFeedback",
+	"TouchableNativeFeedback"
+]);
 const handlerMutatesIdentifier = (handler, sharedValueBindings) => {
 	if (!isNodeOfType(handler, "ArrowFunctionExpression") && !isNodeOfType(handler, "FunctionExpression")) return false;
 	if (sharedValueBindings.size === 0) return false;
@@ -24578,7 +25127,8 @@ const rnPressableSharedValueMutation = defineRule({
 				trackSharedValueBinding(node);
 			},
 			JSXOpeningElement(node) {
-				if (resolveJsxElementName(node) !== "Pressable") return;
+				const name = resolveJsxElementName(node);
+				if (!name || !PRESSABLE_ELEMENT_NAMES.has(name)) return;
 				if (sharedValueBindingsByComponent.length === 0) return;
 				const activeBindings = /* @__PURE__ */ new Set();
 				for (const frame of sharedValueBindingsByComponent) for (const binding of frame) activeBindings.add(binding);
@@ -24593,7 +25143,7 @@ const rnPressableSharedValueMutation = defineRule({
 					if (!handlerMutatesIdentifier(handler, activeBindings)) continue;
 					context.report({
 						node: attr,
-						message: `<Pressable> ${attr.name.name} mutates a Reanimated shared value — use a Gesture.Tap() inside <GestureDetector> for press animations that stay on the UI thread`
+						message: `<${name}> ${attr.name.name} mutates a Reanimated shared value — use a Gesture.Tap() inside <GestureDetector> for press animations that stay on the UI thread`
 					});
 				}
 			}
@@ -24611,7 +25161,8 @@ const rnScrollviewDynamicPadding = defineRule({
 	create: (context) => ({ JSXOpeningElement(node) {
 		const elementName = resolveJsxElementName(node);
 		if (!elementName) return;
-		if (!SCROLLVIEW_NAMES.has(elementName) && elementName !== "FlatList" && elementName !== "FlashList") return;
+		if (!SCROLLVIEW_NAMES.has(elementName) && elementName !== "FlashList") return;
+		if (elementName === "KeyboardAwareScrollView") return;
 		for (const attr of node.attributes ?? []) {
 			if (!isNodeOfType(attr, "JSXAttribute")) continue;
 			if (!isNodeOfType(attr.name, "JSXIdentifier") || attr.name.name !== "contentContainerStyle") continue;
@@ -24668,13 +25219,23 @@ const rnStylePreferBoxShadow = defineRule({
 			if (attrName !== "style" && !attrName.endsWith("Style")) return;
 			if (!isNodeOfType(node.value, "JSXExpressionContainer")) return;
 			const expression = node.value.expression;
-			if (!isNodeOfType(expression, "ObjectExpression")) return;
-			const match = findLegacyShadowProperty(expression);
-			if (!match) return;
-			context.report({
-				node: match.node,
-				message: `${match.keyName} is iOS/Android-platform-specific — use the cross-platform CSS \`boxShadow\` string (e.g. \`boxShadow: "0 2px 8px rgba(0,0,0,0.1)"\`) on RN v7+`
-			});
+			if (isNodeOfType(expression, "ObjectExpression")) {
+				const match = findLegacyShadowProperty(expression);
+				if (match) context.report({
+					node: match.node,
+					message: `${match.keyName} is iOS/Android-platform-specific — use the cross-platform CSS \`boxShadow\` string (e.g. \`boxShadow: "0 2px 8px rgba(0,0,0,0.1)"\`) on RN v7+`
+				});
+			} else if (isNodeOfType(expression, "ArrayExpression")) for (const element of expression.elements ?? []) {
+				if (!isNodeOfType(element, "ObjectExpression")) continue;
+				const match = findLegacyShadowProperty(element);
+				if (match) {
+					context.report({
+						node: match.node,
+						message: `${match.keyName} is iOS/Android-platform-specific — use the cross-platform CSS \`boxShadow\` string on RN v7+`
+					});
+					return;
+				}
+			}
 		},
 		CallExpression(node) {
 			if (!isNodeOfType(node.callee, "MemberExpression")) return;
@@ -28732,7 +29293,7 @@ const serverFetchWithoutRevalidate = defineRule({
 		let isServerSideFile = false;
 		return {
 			Program(node) {
-				const filename = context.getFilename?.() ?? "";
+				const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 				if (!APP_ROUTER_FILE_PATTERN.test(filename)) {
 					isServerSideFile = false;
 					return;
@@ -28845,7 +29406,7 @@ const serverHoistStaticIo = defineRule({
 			inspectHandlerBody(context, declaration.body, `${handlerName} route handler`, collectIdentifierParams(declaration.params ?? []));
 		},
 		ExportDefaultDeclaration(node) {
-			const filename = context.getFilename?.() ?? "";
+			const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 			if (!PAGES_ROUTER_API_PATH_PATTERN.test(filename)) return;
 			const declaration = node.declaration;
 			if (!declaration || !isNodeOfType(declaration, "FunctionDeclaration") && !isNodeOfType(declaration, "FunctionExpression") && !isNodeOfType(declaration, "ArrowFunctionExpression")) return;
@@ -29312,6 +29873,47 @@ const tanstackStartLoaderParallelFetch = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/tanstack-start/tanstack-start-missing-head-content.ts
+const TANSTACK_ROUTER_PACKAGE = "@tanstack/react-router";
+const HEAD_CONTENT_COMPONENT_NAME = "HeadContent";
+const DOCUMENT_HEAD_ELEMENT_NAME = "head";
+const getJsxMemberRootName = (node) => {
+	if (isNodeOfType(node.object, "JSXIdentifier")) return node.object.name;
+	if (isNodeOfType(node.object, "JSXMemberExpression")) return getJsxMemberRootName(node.object);
+	return null;
+};
+const getJsxMemberPropertyName = (node) => {
+	if (isNodeOfType(node.property, "JSXIdentifier")) return node.property.name;
+	return null;
+};
+const getMemberRootName = (node) => {
+	if (isNodeOfType(node.object, "Identifier")) return node.object.name;
+	if (isNodeOfType(node.object, "MemberExpression")) return getMemberRootName(node.object);
+	return null;
+};
+const getMemberPropertyName = (node) => {
+	if (isNodeOfType(node.property, "Identifier")) return node.property.name;
+	return null;
+};
+const isDocumentHeadElement = (node) => isNodeOfType(node, "JSXElement") && isNodeOfType(node.openingElement.name, "JSXIdentifier") && node.openingElement.name.name === DOCUMENT_HEAD_ELEMENT_NAME;
+const isInsideDocumentHeadElement = (node) => {
+	let currentNode = node.parent;
+	while (currentNode) {
+		if (isDocumentHeadElement(currentNode)) return true;
+		currentNode = currentNode.parent;
+	}
+	return false;
+};
+const isCustomJsxElementName = (node) => {
+	if (isNodeOfType(node, "JSXIdentifier")) {
+		const firstCharacter = node.name.charAt(0);
+		return firstCharacter.toUpperCase() === firstCharacter && firstCharacter.toLowerCase() !== firstCharacter;
+	}
+	if (!isNodeOfType(node, "JSXMemberExpression")) return false;
+	const rootName = getJsxMemberRootName(node);
+	if (!rootName) return false;
+	const firstCharacter = rootName.charAt(0);
+	return firstCharacter.toUpperCase() === firstCharacter && firstCharacter.toLowerCase() !== firstCharacter;
+};
 const tanstackStartMissingHeadContent = defineRule({
 	id: "tanstack-start-missing-head-content",
 	tags: ["test-noise"],
@@ -29320,16 +29922,79 @@ const tanstackStartMissingHeadContent = defineRule({
 	recommendation: "Add `<HeadContent />` inside `<head>` in your __root route — without it, route `head()` meta tags are silently dropped",
 	create: (context) => {
 		let hasHeadContentElement = false;
+		let hasDocumentHeadElement = false;
+		let hasCustomHeadChildElement = false;
+		const headContentComponentNames = new Set([HEAD_CONTENT_COMPONENT_NAME]);
+		const tanstackRouterNamespaceNames = /* @__PURE__ */ new Set();
+		const collectImportBindings = (node) => {
+			if (!isNodeOfType(node, "ImportDeclaration")) return;
+			const isTanstackRouterImport = node.source.value === TANSTACK_ROUTER_PACKAGE;
+			const specifiers = node.specifiers ?? [];
+			for (const specifier of specifiers) {
+				if (isTanstackRouterImport && isNodeOfType(specifier, "ImportNamespaceSpecifier")) {
+					tanstackRouterNamespaceNames.add(specifier.local.name);
+					continue;
+				}
+				if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
+				if (!isNodeOfType(specifier.imported, "Identifier") || specifier.imported.name !== HEAD_CONTENT_COMPONENT_NAME) continue;
+				headContentComponentNames.add(specifier.local.name);
+			}
+		};
+		const collectVariableAlias = (node) => {
+			if (!isNodeOfType(node, "VariableDeclarator")) return;
+			if (!isNodeOfType(node.id, "Identifier")) return;
+			const initializer = node.init;
+			if (!initializer) return;
+			if (isNodeOfType(initializer, "Identifier")) {
+				if (headContentComponentNames.has(initializer.name)) headContentComponentNames.add(node.id.name);
+				if (tanstackRouterNamespaceNames.has(initializer.name)) tanstackRouterNamespaceNames.add(node.id.name);
+				return;
+			}
+			if (!isNodeOfType(initializer, "MemberExpression")) return;
+			const rootName = getMemberRootName(initializer);
+			const propertyName = getMemberPropertyName(initializer);
+			if (rootName && tanstackRouterNamespaceNames.has(rootName) && propertyName === HEAD_CONTENT_COMPONENT_NAME) headContentComponentNames.add(node.id.name);
+		};
 		return {
-			JSXOpeningElement(node) {
+			Program(node) {
 				const filename = context.getFilename?.() ?? "";
 				if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename)) return;
-				if (isNodeOfType(node.name, "JSXIdentifier") && node.name.name === "HeadContent") hasHeadContentElement = true;
+				const statements = node.body ?? [];
+				for (const statement of statements) collectImportBindings(statement);
+				for (const statement of statements) {
+					if (!isNodeOfType(statement, "VariableDeclaration")) continue;
+					for (const declaration of statement.declarations ?? []) collectVariableAlias(declaration);
+				}
 			},
-			"Program:exit"(programNode) {
+			ImportDeclaration(node) {
+				const filename = context.getFilename?.() ?? "";
+				if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename)) return;
+				collectImportBindings(node);
+			},
+			VariableDeclarator(node) {
 				const filename = context.getFilename?.() ?? "";
 				if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename)) return;
-				if (!hasHeadContentElement) context.report({
+				collectVariableAlias(node);
+			},
+			JSXOpeningElement(node) {
+				const filename = normalizeFilename$1(context.getFilename?.() ?? "");
+				if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename)) return;
+				if (isNodeOfType(node.name, "JSXIdentifier")) {
+					if (node.name.name === DOCUMENT_HEAD_ELEMENT_NAME) hasDocumentHeadElement = true;
+					if (headContentComponentNames.has(node.name.name)) hasHeadContentElement = true;
+					if (isInsideDocumentHeadElement(node) && isCustomJsxElementName(node.name)) hasCustomHeadChildElement = true;
+					return;
+				}
+				if (!isNodeOfType(node.name, "JSXMemberExpression")) return;
+				const rootName = getJsxMemberRootName(node.name);
+				const propertyName = getJsxMemberPropertyName(node.name);
+				if (rootName && tanstackRouterNamespaceNames.has(rootName) && propertyName === HEAD_CONTENT_COMPONENT_NAME) hasHeadContentElement = true;
+				if (isInsideDocumentHeadElement(node) && isCustomJsxElementName(node.name)) hasCustomHeadChildElement = true;
+			},
+			"Program:exit"(programNode) {
+				const filename = normalizeFilename$1(context.getFilename?.() ?? "");
+				if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename)) return;
+				if (hasDocumentHeadElement && !hasHeadContentElement && !hasCustomHeadChildElement) context.report({
 					node: programNode,
 					message: "Root route (__root) without <HeadContent /> — route head() meta tags won't render"
 				});
@@ -29346,7 +30011,7 @@ const tanstackStartNoAnchorElement = defineRule({
 	severity: "warn",
 	recommendation: "`import { Link } from '@tanstack/react-router'` — enables type-safe routes, preloading via `preload=\"intent\"`, and client-side navigation",
 	create: (context) => ({ JSXOpeningElement(node) {
-		const filename = context.getFilename?.() ?? "";
+		const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 		if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
 		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
 		const hrefAttribute = (node.attributes ?? []).find((attribute) => isNodeOfType(attribute, "JSXAttribute") && isNodeOfType(attribute.name, "JSXIdentifier") && attribute.name.name === "href");
@@ -29420,7 +30085,7 @@ const tanstackStartNoNavigateInRender = defineRule({
 		const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && typeof node.name.name === "string" && node.name.name.startsWith("on") && UPPERCASE_PATTERN.test(node.name.name.charAt(2));
 		return {
 			CallExpression(node) {
-				const filename = context.getFilename?.() ?? "";
+				const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 				if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
 				if (isDeferredHookCall(node)) deferredCallbackDepth++;
 				if (deferredCallbackDepth > 0 || eventHandlerDepth > 0) return;
@@ -29430,17 +30095,17 @@ const tanstackStartNoNavigateInRender = defineRule({
 				});
 			},
 			"CallExpression:exit"(node) {
-				const filename = context.getFilename?.() ?? "";
+				const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 				if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
 				if (isDeferredHookCall(node)) deferredCallbackDepth = Math.max(0, deferredCallbackDepth - 1);
 			},
 			JSXAttribute(node) {
-				const filename = context.getFilename?.() ?? "";
+				const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 				if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
 				if (isEventHandlerAttribute(node)) eventHandlerDepth++;
 			},
 			"JSXAttribute:exit"(node) {
-				const filename = context.getFilename?.() ?? "";
+				const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 				if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
 				if (isEventHandlerAttribute(node)) eventHandlerDepth = Math.max(0, eventHandlerDepth - 1);
 			}
@@ -29521,7 +30186,7 @@ const tanstackStartNoUseEffectFetch = defineRule({
 	severity: "warn",
 	recommendation: "Fetch data in the route `loader` instead — the router coordinates loading before rendering to avoid waterfalls",
 	create: (context) => ({ CallExpression(node) {
-		const filename = context.getFilename?.() ?? "";
+		const filename = normalizeFilename$1(context.getFilename?.() ?? "");
 		if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
 		if (!isHookCall$1(node, EFFECT_HOOK_NAMES$1)) return;
 		const callback = node.arguments?.[0];
@@ -32090,6 +32755,17 @@ const reactDoctorRules = [
 			category: "Architecture"
 		}
 	},
+	{
+		key: "react-doctor/react-compiler-no-manual-memoization",
+		id: "react-compiler-no-manual-memoization",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...reactCompilerNoManualMemoization,
+			framework: "global",
+			category: "Architecture"
+		}
+	},
 	{
 		key: "react-doctor/react-in-jsx-scope",
 		id: "react-in-jsx-scope",
@@ -32395,6 +33071,18 @@ const reactDoctorRules = [
 			tags: [...new Set(["react-native", ...rnNoDimensionsGet.tags ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/rn-no-falsy-and-render",
+		id: "rn-no-falsy-and-render",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...rnNoFalsyAndRender,
+			framework: "react-native",
+			category: "React Native",
+			tags: [...new Set(["react-native", ...rnNoFalsyAndRender.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/rn-no-inline-flatlist-renderitem",
 		id: "rn-no-inline-flatlist-renderitem",
@@ -32950,138 +33638,18 @@ const reactDoctorRules = [
 ];
 const ruleRegistry = Object.fromEntries(reactDoctorRules.map((rule) => [rule.id, rule.rule]));
 //#endregion
-//#region src/react-native-dependency-names.ts
-const REACT_NATIVE_DEPENDENCY_NAMES = new Set([
-	"react-native",
-	"react-native-tvos",
-	"expo",
-	"expo-router",
-	"@expo/cli",
-	"@expo/metro-config",
-	"@expo/metro-runtime",
-	"react-native-windows",
-	"react-native-macos"
-]);
-const REACT_NATIVE_DEPENDENCY_PREFIXES = ["@react-native/", "@react-native-"];
-const isReactNativeDependencyName = (dependencyName) => {
-	if (REACT_NATIVE_DEPENDENCY_NAMES.has(dependencyName)) return true;
-	for (const prefix of REACT_NATIVE_DEPENDENCY_PREFIXES) if (dependencyName.startsWith(prefix)) return true;
-	return false;
-};
-//#endregion
-//#region src/plugin/utils/classify-package-platform.ts
-const WEB_FRAMEWORK_DEPENDENCY_NAMES = new Set([
-	"next",
-	"vite",
-	"react-scripts",
-	"gatsby",
-	"@remix-run/react",
-	"@remix-run/node",
-	"@docusaurus/core",
-	"@docusaurus/preset-classic",
-	"@storybook/react",
-	"@storybook/react-vite",
-	"@storybook/react-webpack5",
-	"@storybook/nextjs",
-	"@storybook/web-components",
-	"storybook",
-	"react-dom",
-	"@vitejs/plugin-react",
-	"@vitejs/plugin-react-swc"
-]);
-const cachedPlatformByPackageDirectory = /* @__PURE__ */ new Map();
-const cachedPackageDirectoryByFilename = /* @__PURE__ */ new Map();
-const findNearestPackageDirectory = (filename) => {
-	if (!filename) return null;
-	const fromCache = cachedPackageDirectoryByFilename.get(filename);
-	if (fromCache !== void 0) return fromCache;
-	let currentDirectory = path.dirname(filename);
-	while (true) {
-		const candidatePackageJsonPath = path.join(currentDirectory, "package.json");
-		let hasPackageJson = false;
-		try {
-			hasPackageJson = fs.statSync(candidatePackageJsonPath).isFile();
-		} catch {
-			hasPackageJson = false;
-		}
-		if (hasPackageJson) {
-			cachedPackageDirectoryByFilename.set(filename, currentDirectory);
-			return currentDirectory;
-		}
-		const parentDirectory = path.dirname(currentDirectory);
-		if (parentDirectory === currentDirectory) {
-			cachedPackageDirectoryByFilename.set(filename, null);
-			return null;
-		}
-		currentDirectory = parentDirectory;
-	}
-};
-const readPackageJsonSafe = (packageJsonPath) => {
-	let rawContents;
-	try {
-		rawContents = fs.readFileSync(packageJsonPath, "utf-8");
-	} catch {
-		return null;
-	}
-	try {
-		const parsed = JSON.parse(rawContents);
-		if (typeof parsed === "object" && parsed !== null) return parsed;
-		return null;
-	} catch {
-		return null;
-	}
-};
-const DEPENDENCY_SECTION_NAMES = [
-	"dependencies",
-	"devDependencies",
-	"peerDependencies",
-	"optionalDependencies"
-];
-const iterateDependencyNames = function* (packageJson) {
-	for (const sectionName of DEPENDENCY_SECTION_NAMES) {
-		const section = packageJson[sectionName];
-		if (!section) continue;
-		for (const dependencyName of Object.keys(section)) yield dependencyName;
-	}
-};
-const isReactNativeAware = (packageJson) => {
-	if (typeof packageJson["react-native"] === "string") return true;
-	for (const dependencyName of iterateDependencyNames(packageJson)) if (isReactNativeDependencyName(dependencyName)) return true;
-	return false;
-};
-const isWebFrameworkOnly = (packageJson) => {
-	for (const dependencyName of iterateDependencyNames(packageJson)) if (WEB_FRAMEWORK_DEPENDENCY_NAMES.has(dependencyName)) return true;
-	return false;
-};
-const classifyPackagePlatform = (filename) => {
-	const packageDirectory = findNearestPackageDirectory(filename);
-	if (!packageDirectory) return "unknown";
-	const cached = cachedPlatformByPackageDirectory.get(packageDirectory);
-	if (cached !== void 0) return cached;
-	const packageJson = readPackageJsonSafe(path.join(packageDirectory, "package.json"));
-	if (!packageJson) {
-		cachedPlatformByPackageDirectory.set(packageDirectory, "unknown");
-		return "unknown";
-	}
-	let result;
-	if (isReactNativeAware(packageJson)) result = "react-native";
-	else if (isWebFrameworkOnly(packageJson)) result = "web";
-	else result = "unknown";
-	cachedPlatformByPackageDirectory.set(packageDirectory, result);
-	return result;
-};
-//#endregion
 //#region src/plugin/utils/is-react-native-file.ts
 const WEB_FILE_EXTENSION_PATTERN = /\.web\.[cm]?[jt]sx?$/;
 const NATIVE_FILE_EXTENSION_PATTERN = /\.(?:ios|android|native)\.[cm]?[jt]sx?$/;
 const isReactNativeFileActive = (context) => {
-	const filename = context.getFilename?.();
-	if (!filename) return true;
+	const rawFilename = context.getFilename?.();
+	if (!rawFilename) return true;
+	const filename = normalizeFilename$1(rawFilename);
 	if (NATIVE_FILE_EXTENSION_PATTERN.test(filename)) return true;
 	if (WEB_FILE_EXTENSION_PATTERN.test(filename)) return false;
 	const packagePlatform = classifyPackagePlatform(filename);
 	if (packagePlatform === "web") return false;
-	if (packagePlatform === "react-native") return true;
+	if (packagePlatform === "expo" || packagePlatform === "react-native") return true;
 	const framework = getReactDoctorStringSetting(context.settings, "framework");
 	if (framework === "react-native" || framework === "expo") return true;
 	if (framework === "nextjs" || framework === "vite" || framework === "cra" || framework === "remix" || framework === "gatsby" || framework === "tanstack-start") return false;