oxlint-plugin-react-doctor 0.8.3-dev.3d7ea66 → 0.8.3-dev.416fdcc

package/dist/index.js

@@ -8262,6 +8262,56 @@ const isNodeReachableWithinFunction = (node, context) => {
 	return false;
 };
 //#endregion
+//#region src/plugin/utils/is-proven-non-throwing-built-in-call.ts
+const NON_THROWING_CONSOLE_METHOD_NAMES = new Set([
+	"debug",
+	"error",
+	"info",
+	"log",
+	"trace",
+	"warn"
+]);
+const NON_THROWING_NUMBER_BINARY_OPERATORS = new Set([
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"**"
+]);
+const isGlobalPerformanceNowCall = (callNode, scopes) => {
+	const callee = stripParenExpression(callNode.callee);
+	if (!isNodeOfType(callee, "MemberExpression") || callNode.arguments.length !== 0) return false;
+	const receiver = stripParenExpression(callee.object);
+	return isNodeOfType(receiver, "Identifier") && receiver.name === "performance" && scopes.isGlobalReference(receiver) && getStaticPropertyName(callee) === "now";
+};
+const isProvenNonThrowingNumberExpression = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Literal")) return typeof strippedExpression.value === "number";
+	if (isNodeOfType(strippedExpression, "CallExpression")) return isGlobalPerformanceNowCall(strippedExpression, scopes);
+	if (isNodeOfType(strippedExpression, "Identifier")) {
+		const symbol = scopes.symbolFor(strippedExpression);
+		if (symbol?.kind !== "const" || !symbol.initializer || symbol.declarationNode.range[0] >= strippedExpression.range[0] || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return false;
+		visitedSymbolIds.add(symbol.id);
+		return isProvenNonThrowingNumberExpression(symbol.initializer, scopes, visitedSymbolIds);
+	}
+	if (isNodeOfType(strippedExpression, "UnaryExpression")) return (strippedExpression.operator === "+" || strippedExpression.operator === "-") && isProvenNonThrowingNumberExpression(strippedExpression.argument, scopes, visitedSymbolIds);
+	if (!isNodeOfType(strippedExpression, "BinaryExpression")) return false;
+	if (!NON_THROWING_NUMBER_BINARY_OPERATORS.has(strippedExpression.operator)) return false;
+	return isProvenNonThrowingNumberExpression(strippedExpression.left, scopes, new Set(visitedSymbolIds)) && isProvenNonThrowingNumberExpression(strippedExpression.right, scopes, new Set(visitedSymbolIds));
+};
+const isProvenNonThrowingBuiltInCall = (callNode, scopes) => {
+	if (isGlobalPerformanceNowCall(callNode, scopes)) return true;
+	const callee = stripParenExpression(callNode.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const receiver = stripParenExpression(callee.object);
+	if (!isNodeOfType(receiver, "Identifier") || !scopes.isGlobalReference(receiver)) return false;
+	const methodName = getStaticPropertyName(callee);
+	if (receiver.name === "console") return NON_THROWING_CONSOLE_METHOD_NAMES.has(methodName ?? "");
+	const firstArgument = callNode.arguments[0];
+	return Boolean(receiver.name === "Math" && methodName === "round" && callNode.arguments.length === 1 && firstArgument && isProvenNonThrowingNumberExpression(firstArgument, scopes));
+};
+//#endregion
 //#region src/plugin/utils/serialize-reference-key.ts
 const serializeReferenceKey = ({ node, scopes }) => {
 	const expression = stripParenExpression(node);
@@ -9039,11 +9089,10 @@ const functionHasPotentialSynchronousThrow = (functionNode, classBody, scopes, b
 		}
 		if (!isNodeOfType(candidate, "CallExpression")) return;
 		if (cleanupReleaseKeys(candidate, scopes, classBody).length > 0) return;
+		if (isProvenNonThrowingBuiltInCall(candidate, scopes)) return;
 		const callee = stripParenExpression(candidate.callee);
 		if (isNodeOfType(callee, "MemberExpression")) {
-			const receiver = stripParenExpression(callee.object);
-			if (isNodeOfType(receiver, "Identifier") && receiver.name === "console" && scopes.isGlobalReference(receiver)) return;
-			if (isNodeOfType(receiver, "ThisExpression")) {
+			if (isNodeOfType(stripParenExpression(callee.object), "ThisExpression")) {
 				const memberName = getStaticPropertyName(callee);
 				const memberFunction = memberName ? classMemberFunction(classBody, memberName, candidate) : null;
 				if (memberFunction && !functionHasPotentialSynchronousThrow(memberFunction, classBody, scopes, Number.POSITIVE_INFINITY, new Set(visitedFunctions))) return;
@@ -13065,7 +13114,7 @@ const getOutermostTarget = (node) => {
 	}
 	return current;
 };
-const getExecutionOwner = (node) => {
+const getExecutionOwner$1 = (node) => {
 	let current = node;
 	while (current) {
 		if (isFunctionLike$1(current) || isNodeOfType(current, "Program")) return current;
@@ -13207,7 +13256,7 @@ const getSymbolMutationInspector = (scopes) => {
 	const eventsBySymbolId = /* @__PURE__ */ new Map();
 	walkAst(scopes.rootScope.node, (node) => {
 		if (isNodeOfType(node, "CallExpression")) {
-			const owner = getExecutionOwner(node);
+			const owner = getExecutionOwner$1(node);
 			const targetOwner = getLocalCallTarget(node);
 			if (targetOwner && !isStaticallyUnreachable$1(node, owner)) calls.push({
 				call: node,
@@ -13220,7 +13269,7 @@ const getSymbolMutationInspector = (scopes) => {
 		if (propertyNames === void 0) return;
 		const symbol = resolveConstIdentifierAlias(node, scopes);
 		if (!symbol) return;
-		const owner = getExecutionOwner(node);
+		const owner = getExecutionOwner$1(node);
 		if (isStaticallyUnreachable$1(node, owner)) return;
 		const events = eventsBySymbolId.get(symbol.id) ?? [];
 		events.push({
@@ -13231,7 +13280,7 @@ const getSymbolMutationInspector = (scopes) => {
 		eventsBySymbolId.set(symbol.id, events);
 	});
 	const getInvokedOwnersBefore = (checkpoint) => {
-		const checkpointOwner = getExecutionOwner(checkpoint);
+		const checkpointOwner = getExecutionOwner$1(checkpoint);
 		const checkpointStartIndex = getNodeStartIndex(checkpoint);
 		const invokedOwners = /* @__PURE__ */ new Set();
 		const visitOwner = (owner, cutoffIndex) => {
@@ -13328,14 +13377,14 @@ const getSymbolMutationInspector = (scopes) => {
 		return false;
 	};
 	const isExecutionOrderAmbiguous = (usageNode) => {
-		const usageOwner = getExecutionOwner(usageNode);
+		const usageOwner = getExecutionOwner$1(usageNode);
 		if (isNodeOfType(usageOwner, "Program")) return false;
 		const reachingProgramCalls = calls.filter((call) => isNodeOfType(call.owner, "Program") && canOwnerReach(call.targetOwner, usageOwner));
 		if (reachingProgramCalls.length === 0) return false;
 		return reachingProgramCalls.length !== 1 || reachingProgramCalls[0]?.targetOwner !== usageOwner;
 	};
 	const isMutationOrderAmbiguous = (symbol, usageNode, relevantPropertyName) => {
-		const usageOwner = getExecutionOwner(usageNode);
+		const usageOwner = getExecutionOwner$1(usageNode);
 		const usageStartIndex = getNodeStartIndex(usageNode);
 		return (eventsBySymbolId.get(symbol.id) ?? []).some((event) => {
 			if (relevantPropertyName !== null && event.propertyNames !== null && !event.propertyNames.has(relevantPropertyName)) return false;
@@ -13370,7 +13419,7 @@ const getSymbolMutationInspector = (scopes) => {
 				visitOwner(operation.call.targetOwner, Number.POSITIVE_INFINITY, nextActiveOwners, isConditionalPath || isConditionallyExecuted(operation.call.call, operation.call.owner));
 			}
 		};
-		const usageOwner = getExecutionOwner(usageNode);
+		const usageOwner = getExecutionOwner$1(usageNode);
 		if (!isNodeOfType(usageOwner, "Program")) visitOwner(scopes.rootScope.node, getProgramCutoffIndex(usageOwner), /* @__PURE__ */ new Set(), false);
 		visitOwner(usageOwner, getNodeStartIndex(usageNode), /* @__PURE__ */ new Set(), false);
 		return mutationEvents;
@@ -13379,7 +13428,7 @@ const getSymbolMutationInspector = (scopes) => {
 		const events = eventsBySymbolId.get(symbol.id);
 		if (!events) return false;
 		const usageStartIndex = getNodeStartIndex(usageNode);
-		const usageOwner = getExecutionOwner(usageNode);
+		const usageOwner = getExecutionOwner$1(usageNode);
 		const invokedOwners = getInvokedOwnersBefore(usageNode);
 		return events.some((event) => {
 			if (relevantPropertyName !== null && event.propertyNames !== null && !event.propertyNames.has(relevantPropertyName)) return false;
@@ -18015,7 +18064,7 @@ const hasPotentialInterruptionAfterGuard = (callback, guardState, usageNode, con
 		if (child !== callback.body && isFunctionLike$1(child)) return false;
 		const childStart = getRangeStart(child);
 		if (childStart === null || childStart <= guardStart || childStart >= usageStart) return;
-		if (isNodeOfType(child, "CallExpression") || isNodeOfType(child, "AwaitExpression") || isNodeOfType(child, "YieldExpression")) {
+		if (isNodeOfType(child, "AwaitExpression") || isNodeOfType(child, "YieldExpression") || isNodeOfType(child, "CallExpression") && !isProvenNonThrowingBuiltInCall(child, context.scopes)) {
 			if (canNodeReachLaterNodeWithinFunction(child, usageNode, callback, context) || canInterruptionReachUsageThroughCatch(child, usageNode, callback, context)) {
 				hasPotentialInterruption = true;
 				return false;
@@ -18181,7 +18230,7 @@ const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) =>
 	for (const argument of usage.node.arguments ?? []) walkAst(argument, (argumentChild) => {
 		if (hasPotentialInterruption) return false;
 		if (isFunctionLike$1(argumentChild)) return false;
-		if (isNodeOfType(argumentChild, "CallExpression") || isNodeOfType(argumentChild, "AwaitExpression") || isNodeOfType(argumentChild, "YieldExpression")) {
+		if (isNodeOfType(argumentChild, "AwaitExpression") || isNodeOfType(argumentChild, "YieldExpression") || isNodeOfType(argumentChild, "CallExpression") && !isProvenNonThrowingBuiltInCall(argumentChild, context.scopes)) {
 			hasPotentialInterruption = true;
 			return false;
 		}
@@ -24018,22 +24067,26 @@ const isInsideTryStatement = (node, options) => {
 	return false;
 };
 //#endregion
-//#region src/plugin/utils/is-node-conditionally-executed.ts
-const isNodeConditionallyExecuted = (node, boundary) => {
+//#region src/plugin/utils/get-conditional-execution-regions.ts
+const getConditionalExecutionRegions = (node, boundary) => {
+	const regions = /* @__PURE__ */ new Set();
 	let child = node;
 	let parent = child.parent ?? null;
 	while (parent && parent !== boundary) {
-		if (isNodeOfType(parent, "IfStatement") && parent.test !== child) return true;
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === child || parent.alternate === child)) return true;
-		if (isNodeOfType(parent, "LogicalExpression") && parent.right === child) return true;
-		if (isNodeOfType(parent, "AssignmentPattern") && parent.right === child) return true;
-		if (isNodeOfType(parent, "SwitchCase")) return true;
+		if (isNodeOfType(parent, "IfStatement") && parent.test !== child) regions.add(child);
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === child || parent.alternate === child)) regions.add(child);
+		if (isNodeOfType(parent, "LogicalExpression") && parent.right === child) regions.add(child);
+		if (isNodeOfType(parent, "AssignmentPattern") && parent.right === child) regions.add(child);
+		if (isNodeOfType(parent, "SwitchCase")) regions.add(parent);
 		child = parent;
 		parent = child.parent ?? null;
 	}
-	return false;
+	return regions;
 };
 //#endregion
+//#region src/plugin/utils/is-node-conditionally-executed.ts
+const isNodeConditionallyExecuted = (node, boundary) => getConditionalExecutionRegions(node, boundary).size > 0;
+//#endregion
 //#region src/plugin/utils/is-non-source-filename.ts
 const NON_SOURCE_FILENAME_MARKERS = [
 	"/dist/",
@@ -63405,10 +63458,9 @@ const chainCarriesRejectionHandler = (node, scopes) => {
 			}
 			if (isNodeOfType(child, "CallExpression")) {
 				const callee = stripParenExpression(child.callee);
-				const receiver = isNodeOfType(callee, "MemberExpression") ? stripParenExpression(callee.object) : null;
-				const isConsoleCall = isNodeOfType(receiver, "Identifier") && receiver.name === "console" && (!scopes || scopes.isGlobalReference(receiver));
+				const isKnownNonThrowingBuiltInCall = Boolean(scopes && isProvenNonThrowingBuiltInCall(child, scopes));
 				const localFunction = scopes && isNodeOfType(callee, "Identifier") ? resolveExactLocalFunction(callee, scopes) : null;
-				if (!isConsoleCall && !isPromiseResolveCall(child, scopes) && !chainCarriesRejectionHandler(child, scopes) && (!localFunction || !scopes || subtreeCanThrowSynchronously(localFunction, localFunction, scopes))) {
+				if (!isKnownNonThrowingBuiltInCall && !isPromiseResolveCall(child, scopes) && !chainCarriesRejectionHandler(child, scopes) && (!localFunction || !scopes || subtreeCanThrowSynchronously(localFunction, localFunction, scopes))) {
 					canReject = true;
 					return false;
 				}
@@ -63885,6 +63937,7 @@ const helperHasUnhandledSynchronousCall = (helper, depth, scopes, visitedFunctio
 			ancestor = ancestor.parent ?? null;
 		}
 		if (isInsideNonRethrowingTry(child, helper)) return;
+		if (scopes && isProvenNonThrowingBuiltInCall(child, scopes)) return;
 		if (isPromiseResolveCall(child, scopes) || chainCarriesRejectionHandler(child, scopes) || isSyncArrayLiteralMethodCall(child, scopes) || isThunkActionDispatchCall(child) || isNeverRejectingPromiseCombinatorCall(child, depth, scopes)) return;
 		const callee = stripParenExpression(child.callee);
 		if (scopes && isNodeOfType(callee, "Identifier") && isReactHookResultReference(callee, STATE_HOOK_NAMES, 1, scopes)) return;
@@ -63894,7 +63947,6 @@ const helperHasUnhandledSynchronousCall = (helper, depth, scopes, visitedFunctio
 		}
 		if (isNodeOfType(callee, "MemberExpression")) {
 			const receiver = stripParenExpression(callee.object);
-			if (isNodeOfType(receiver, "Identifier") && receiver.name === "console" && (!scopes || scopes.isGlobalReference(receiver))) return;
 			if (getStaticPropertyName(callee) === "push" && isNodeOfType(receiver, "Identifier")) {
 				const receiverSymbol = scopes?.symbolFor(receiver);
 				if (isNodeOfType(receiverSymbol?.initializer ? stripParenExpression(receiverSymbol.initializer) : null, "ArrayExpression") && receiverSymbol?.references.every((reference) => {
@@ -64364,16 +64416,20 @@ const areOnExclusiveBranches = (first, second, functionNode) => {
 };
 const REACT_SETTER_CALLEE_PATTERN = /^set[A-Z]/;
 const isProvenNonThrowingSynchronousCall = (callNode, context) => {
+	if (isProvenNonThrowingBuiltInCall(callNode, context.scopes)) return true;
 	const callee = stripParenExpression(callNode.callee);
 	if (isNodeOfType(callee, "Identifier")) {
 		if (isReactHookResultReference(callee, STATE_HOOK_NAMES, 1, context.scopes) || context.scopes.isGlobalReference(callee) && REACT_SETTER_CALLEE_PATTERN.test(callee.name)) return true;
+		if (context.scopes.isGlobalReference(callee) && callee.name === "String") {
+			const firstArgument = callNode.arguments[0];
+			const strippedArgument = firstArgument ? stripParenExpression(firstArgument) : null;
+			return Boolean(callNode.arguments.length === 1 && strippedArgument && isNodeOfType(strippedArgument, "Identifier") && context.scopes.symbolFor(strippedArgument)?.kind === "catch-clause-parameter");
+		}
 		const localFunction = resolveExactLocalFunction(callee, context.scopes);
 		if (localFunction && isFunctionLike$1(localFunction) && !localFunction.async) return !subtreeCanThrowSynchronously(localFunction, localFunction, context.scopes) && !helperHasUnhandledSynchronousCall(localFunction, NEVER_REJECTING_ANALYSIS_MAX_DEPTH, context.scopes);
 		return false;
 	}
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	const receiver = stripParenExpression(callee.object);
-	return Boolean(isNodeOfType(receiver, "Identifier") && receiver.name === "console" && context.scopes.isGlobalReference(receiver));
+	return false;
 };
 const subtreeHasAbruptSynchronousOperation = (root, functionBoundary, context) => {
 	let canCompleteAbruptly = false;
@@ -73602,14 +73658,6 @@ const REJECTING_PROMISE_COMBINATOR_NAMES = new Set([
 const MAX_INITIATOR_RESOLUTION_DEPTH = 3;
 const STATE_DISPATCHER_HOOK_NAMES = new Set(["useState", "useReducer"]);
 const REF_HOOK_NAMES = new Set(["useRef"]);
-const NON_REJECTING_CONSOLE_METHOD_NAMES = new Set([
-	"debug",
-	"error",
-	"info",
-	"log",
-	"trace",
-	"warn"
-]);
 const MESSAGE$26 = "This promise chain runs in an effect, ends in a `.then` that sets state or mutates a ref, and has no `.catch` or enclosing try/catch, so a rejection leaves the state unset and surfaces as an unhandled rejection. Add a `.catch` handler on the chain (`.finally` does not count).";
 const isKnownNonThenableHandlerReturn = (expression, context, visitedBindingIdentifiers = /* @__PURE__ */ new Set()) => {
 	const strippedExpression = stripParenExpression(expression);
@@ -73646,6 +73694,10 @@ const isKnownNonRejectingHandler = (argument, context) => {
 			return false;
 		}
 		if (!isNodeOfType(child, "CallExpression")) return;
+		if (isProvenNonThrowingBuiltInCall(child, context.scopes)) {
+			didFindKnownNonRejectingCall = true;
+			return;
+		}
 		const callee = stripParenExpression(child.callee);
 		if (isNodeOfType(callee, "Identifier") && isReactHookResultReference(callee, STATE_DISPATCHER_HOOK_NAMES, 1, context.scopes)) {
 			if (context.scopes.symbolFor(callee)?.references.every((reference) => reference.flag === "read")) {
@@ -73653,13 +73705,6 @@ const isKnownNonRejectingHandler = (argument, context) => {
 				return;
 			}
 		}
-		if (isNodeOfType(callee, "MemberExpression")) {
-			const receiver = stripParenExpression(callee.object);
-			if (isNodeOfType(receiver, "Identifier") && receiver.name === "console" && context.scopes.isGlobalReference(receiver) && NON_REJECTING_CONSOLE_METHOD_NAMES.has(getStaticPropertyName(callee) ?? "")) {
-				didFindKnownNonRejectingCall = true;
-				return;
-			}
-		}
 		canReject = true;
 		return false;
 	});
@@ -73668,11 +73713,10 @@ const isKnownNonRejectingHandler = (argument, context) => {
 const isTrustedNonThrowingMethodCallee = (member, context) => {
 	const parent = member.parent;
 	if (!parent || !isNodeOfType(parent, "CallExpression") || parent.callee !== member) return false;
+	if (isProvenNonThrowingBuiltInCall(parent, context.scopes)) return true;
 	const receiver = stripParenExpression(member.object);
 	if (!isNodeOfType(receiver, "Identifier") || !context.scopes.isGlobalReference(receiver)) return false;
-	const methodName = getStaticPropertyName(member);
-	if (receiver.name === "console") return NON_REJECTING_CONSOLE_METHOD_NAMES.has(methodName ?? "");
-	return receiver.name === "Promise" && methodName === "resolve";
+	return receiver.name === "Promise" && getStaticPropertyName(member) === "resolve";
 };
 const handlerHasPotentiallyThrowingMemberRead = (argument, context) => {
 	if (!argument) return false;
@@ -91330,6 +91374,35 @@ const getModuleNamespaceSource = (expression, scopes, visitedSymbolIds = /* @__P
 	return getModuleNamespaceSource(symbol.initializer, scopes, visitedSymbolIds);
 };
 //#endregion
+//#region src/plugin/rules/r3f/utils/r3f-public-modules.ts
+const R3F_PUBLIC_MODULES = new Set([
+	"@react-three/fiber",
+	"@react-three/fiber/legacy",
+	"@react-three/fiber/native",
+	"@react-three/fiber/webgpu",
+	"react-three-fiber"
+]);
+//#endregion
+//#region src/plugin/rules/r3f/utils/has-r3f-runtime-import.ts
+const isR3fRuntimeModule = (moduleSource) => R3F_PUBLIC_MODULES.has(moduleSource) || moduleSource.startsWith("@react-three/");
+const hasR3fRuntimeImport = (program, scopes) => program.body.some((statement) => {
+	if (isNodeOfType(statement, "ImportDeclaration") && !isTypeOnlyImport(statement) && typeof statement.source.value === "string") return isR3fRuntimeModule(statement.source.value);
+	if (isNodeOfType(statement, "TSImportEqualsDeclaration")) {
+		const moduleSource = getModuleNamespaceSource(statement.id, scopes);
+		return moduleSource !== null && isR3fRuntimeModule(moduleSource);
+	}
+	if (isNodeOfType(statement, "ExpressionStatement")) {
+		const moduleSource = getGlobalRequireModuleSource(statement.expression, scopes);
+		return moduleSource !== null && isR3fRuntimeModule(moduleSource);
+	}
+	if (!isNodeOfType(statement, "VariableDeclaration")) return false;
+	return statement.declarations.some((declaration) => {
+		if (!declaration.init) return false;
+		const moduleSource = getGlobalRequireModuleSource(declaration.init, scopes);
+		return moduleSource !== null && isR3fRuntimeModule(moduleSource);
+	});
+});
+//#endregion
 //#region src/plugin/rules/r3f/utils/get-api-reference-provenance.ts
 const getApiReferenceProvenance = (reference, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const candidate = stripParenExpression(reference);
@@ -91385,35 +91458,6 @@ const getApiReferenceProvenance = (reference, scopes, visitedSymbolIds = /* @__P
 	return getApiReferenceProvenance(symbol.initializer, scopes, visitedSymbolIds);
 };
 //#endregion
-//#region src/plugin/rules/r3f/utils/r3f-public-modules.ts
-const R3F_PUBLIC_MODULES = new Set([
-	"@react-three/fiber",
-	"@react-three/fiber/legacy",
-	"@react-three/fiber/native",
-	"@react-three/fiber/webgpu",
-	"react-three-fiber"
-]);
-//#endregion
-//#region src/plugin/rules/r3f/utils/has-r3f-runtime-import.ts
-const isR3fRuntimeModule = (moduleSource) => R3F_PUBLIC_MODULES.has(moduleSource) || moduleSource.startsWith("@react-three/");
-const hasR3fRuntimeImport = (program, scopes) => program.body.some((statement) => {
-	if (isNodeOfType(statement, "ImportDeclaration") && !isTypeOnlyImport(statement) && typeof statement.source.value === "string") return isR3fRuntimeModule(statement.source.value);
-	if (isNodeOfType(statement, "TSImportEqualsDeclaration")) {
-		const moduleSource = getModuleNamespaceSource(statement.id, scopes);
-		return moduleSource !== null && isR3fRuntimeModule(moduleSource);
-	}
-	if (isNodeOfType(statement, "ExpressionStatement")) {
-		const moduleSource = getGlobalRequireModuleSource(statement.expression, scopes);
-		return moduleSource !== null && isR3fRuntimeModule(moduleSource);
-	}
-	if (!isNodeOfType(statement, "VariableDeclaration")) return false;
-	return statement.declarations.some((declaration) => {
-		if (!declaration.init) return false;
-		const moduleSource = getGlobalRequireModuleSource(declaration.init, scopes);
-		return moduleSource !== null && isR3fRuntimeModule(moduleSource);
-	});
-});
-//#endregion
 //#region src/plugin/rules/r3f/utils/is-r3f-canvas.ts
 const isR3fCanvas = (node, context) => {
 	const provenance = getApiReferenceProvenance(node.name, context.scopes);
@@ -91501,6 +91545,43 @@ const resolveLocalReactCallback = (expression, scopes) => {
 	return resolveExactLocalFunction(wrappedCallback, scopes);
 };
 //#endregion
+//#region src/plugin/rules/r3f/utils/resolve-raw-device-pixel-ratio.ts
+const resolveRawDevicePixelRatio = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "UnaryExpression") && candidate.operator === "+") return resolveRawDevicePixelRatio(candidate.argument, scopes, visitedSymbolIds);
+	if (isNodeOfType(candidate, "BinaryExpression")) {
+		const rawLeft = resolveRawDevicePixelRatio(candidate.left, scopes, new Set(visitedSymbolIds));
+		const rawRight = resolveRawDevicePixelRatio(candidate.right, scopes, new Set(visitedSymbolIds));
+		if (rawLeft && !rawRight) {
+			const rightOperand = stripParenExpression(candidate.right);
+			if (isNodeOfType(rightOperand, "Literal") && typeof rightOperand.value === "number" && Number.isFinite(rightOperand.value) && (candidate.operator === "+" || candidate.operator === "-" || (candidate.operator === "*" || candidate.operator === "/" || candidate.operator === "**") && rightOperand.value > 0)) return rawLeft;
+		}
+		if (rawRight && !rawLeft) {
+			const leftOperand = stripParenExpression(candidate.left);
+			if (isNodeOfType(leftOperand, "Literal") && typeof leftOperand.value === "number" && Number.isFinite(leftOperand.value) && (candidate.operator === "+" || candidate.operator === "*" && leftOperand.value > 0)) return rawRight;
+		}
+		return null;
+	}
+	if (isNodeOfType(candidate, "ArrayExpression") && candidate.elements.length === 2) {
+		const upperBound = candidate.elements[1];
+		return upperBound && !isNodeOfType(upperBound, "SpreadElement") ? resolveRawDevicePixelRatio(upperBound, scopes, new Set(visitedSymbolIds)) : null;
+	}
+	if (isNodeOfType(candidate, "MemberExpression")) {
+		const receiver = stripParenExpression(candidate.object);
+		return getStaticPropertyName(candidate) === "devicePixelRatio" && isNodeOfType(receiver, "Identifier") && (receiver.name === "window" || receiver.name === "globalThis") && scopes.isGlobalReference(receiver) ? candidate : null;
+	}
+	if (!isNodeOfType(candidate, "Identifier")) return null;
+	const symbol = scopes.symbolFor(candidate);
+	if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || !isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return null;
+	visitedSymbolIds.add(symbol.id);
+	if (getDestructuredBindingPropertyName(symbol.bindingIdentifier) === "devicePixelRatio") {
+		const initializer = stripParenExpression(symbol.initializer);
+		if (isNodeOfType(initializer, "Identifier") && (initializer.name === "window" || initializer.name === "globalThis") && scopes.isGlobalReference(initializer)) return candidate;
+	}
+	if (symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
+	return resolveRawDevicePixelRatio(symbol.initializer, scopes, visitedSymbolIds);
+};
+//#endregion
 //#region src/plugin/rules/r3f/utils/walk-function-execution.ts
 const isUseTransitionCall = (expression, scopes) => {
 	const candidate = stripParenExpression(expression);
@@ -91575,43 +91656,6 @@ const walkFunctionExecution = (functionNode, scopes, visitor) => {
 };
 //#endregion
 //#region src/plugin/rules/r3f/r3f-cap-device-pixel-ratio.ts
-const THREE_RENDERER_CONSTRUCTOR_NAMES = new Set(["WebGLRenderer", "WebGPURenderer"]);
-const isThreeModuleSource$4 = (moduleSource) => moduleSource === "three" || moduleSource.startsWith("three/") || moduleSource === "three-stdlib";
-const resolveRawDevicePixelRatio = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const candidate = stripParenExpression(expression);
-	if (isNodeOfType(candidate, "UnaryExpression") && candidate.operator === "+") return resolveRawDevicePixelRatio(candidate.argument, context, visitedSymbolIds);
-	if (isNodeOfType(candidate, "BinaryExpression")) {
-		const rawLeft = resolveRawDevicePixelRatio(candidate.left, context, new Set(visitedSymbolIds));
-		const rawRight = resolveRawDevicePixelRatio(candidate.right, context, new Set(visitedSymbolIds));
-		if (rawLeft && !rawRight) {
-			const rightOperand = stripParenExpression(candidate.right);
-			if (isNodeOfType(rightOperand, "Literal") && typeof rightOperand.value === "number" && Number.isFinite(rightOperand.value) && (candidate.operator === "+" || candidate.operator === "-" || (candidate.operator === "*" || candidate.operator === "/" || candidate.operator === "**") && rightOperand.value > 0)) return rawLeft;
-		}
-		if (rawRight && !rawLeft) {
-			const leftOperand = stripParenExpression(candidate.left);
-			if (isNodeOfType(leftOperand, "Literal") && typeof leftOperand.value === "number" && Number.isFinite(leftOperand.value) && (candidate.operator === "+" || candidate.operator === "*" && leftOperand.value > 0)) return rawRight;
-		}
-		return null;
-	}
-	if (isNodeOfType(candidate, "ArrayExpression") && candidate.elements.length === 2) {
-		const upperBound = candidate.elements[1];
-		return upperBound && !isNodeOfType(upperBound, "SpreadElement") ? resolveRawDevicePixelRatio(upperBound, context, new Set(visitedSymbolIds)) : null;
-	}
-	if (isNodeOfType(candidate, "MemberExpression")) {
-		const receiver = stripParenExpression(candidate.object);
-		return getStaticPropertyName(candidate) === "devicePixelRatio" && isNodeOfType(receiver, "Identifier") && (receiver.name === "window" || receiver.name === "globalThis") && context.scopes.isGlobalReference(receiver) ? candidate : null;
-	}
-	if (!isNodeOfType(candidate, "Identifier")) return null;
-	const symbol = context.scopes.symbolFor(candidate);
-	if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || !isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return null;
-	visitedSymbolIds.add(symbol.id);
-	if (getDestructuredBindingPropertyName(symbol.bindingIdentifier) === "devicePixelRatio") {
-		const initializer = stripParenExpression(symbol.initializer);
-		if (isNodeOfType(initializer, "Identifier") && (initializer.name === "window" || initializer.name === "globalThis") && context.scopes.isGlobalReference(initializer)) return candidate;
-	}
-	if (symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
-	return resolveRawDevicePixelRatio(symbol.initializer, context, visitedSymbolIds);
-};
 const getExplicitObjectPropertyValue = (expression, propertyName) => {
 	const candidate = stripParenExpression(expression);
 	if (!isNodeOfType(candidate, "ObjectExpression")) return null;
@@ -91644,18 +91688,6 @@ const isR3fRootReceiver = (expression, context, visitedSymbolIds = /* @__PURE__
 	if (symbol.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return false;
 	return isR3fRootReceiver(symbol.initializer, context, visitedSymbolIds);
 };
-const isThreeRendererReceiver = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const candidate = stripParenExpression(expression);
-	if (isNodeOfType(candidate, "NewExpression")) {
-		const provenance = getApiReferenceProvenance(candidate.callee, context.scopes);
-		return Boolean(provenance && isThreeModuleSource$4(provenance.moduleSource) && THREE_RENDERER_CONSTRUCTOR_NAMES.has(provenance.apiName));
-	}
-	if (!isNodeOfType(candidate, "Identifier")) return false;
-	const symbol = context.scopes.symbolFor(candidate);
-	if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return false;
-	visitedSymbolIds.add(symbol.id);
-	return isThreeRendererReceiver(symbol.initializer, context, visitedSymbolIds);
-};
 const useThreeSelectsSetDpr = (call, context) => {
 	if (!isR3fApiCall(call, "useThree", context.scopes)) return false;
 	const selectorExpression = call.arguments[0];
@@ -91687,7 +91719,7 @@ const r3fCapDevicePixelRatio = defineRule({
 	create: (context) => {
 		let importsReactThreeFiber = false;
 		const reportRawDpr = (expression) => {
-			const rawDpr = resolveRawDevicePixelRatio(expression, context);
+			const rawDpr = resolveRawDevicePixelRatio(expression, context.scopes);
 			if (!rawDpr) return;
 			context.report({
 				node: rawDpr,
@@ -91716,10 +91748,6 @@ const r3fCapDevicePixelRatio = defineRule({
 					if (dprValue) reportRawDpr(dprValue);
 					return;
 				}
-				if (methodName === "setPixelRatio" && isThreeRendererReceiver(node.callee.object, context)) {
-					reportRawDpr(firstArgument);
-					return;
-				}
 			},
 			Identifier(node) {
 				const parent = node.parent;
@@ -91733,6 +91761,14 @@ const r3fCapDevicePixelRatio = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/r3f/constants.ts
+const THREE_INTERPOLATION_FACTOR_ARGUMENT_BY_METHOD = new Map([
+	["lerp", 1],
+	["lerpColors", 2],
+	["lerpHSL", 1],
+	["lerpVectors", 2],
+	["slerp", 1],
+	["slerpQuaternions", 2]
+]);
 const THREE_POSTPROCESSING_PASS_DISPOSAL_RELEASES = new Map([
 	["RenderPixelatedPass", 147],
 	["OutputPass", 153],
@@ -92011,7 +92047,7 @@ const THREE_OBJECT_MEMBER_PROPERTIES = new Set([
 	"rotation",
 	"scale"
 ]);
-const hasThreeObjectProvenance = (expression, callback, managedRefSymbolIds, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+const hasThreeObjectProvenance$1 = (expression, callback, managedRefSymbolIds, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const firstCallbackParameter = isFunctionLike$1(callback) ? callback.params[0] : null;
 	const callbackParameter = isNodeOfType(firstCallbackParameter, "AssignmentPattern") ? firstCallbackParameter.left : firstCallbackParameter;
 	let current = stripParenExpression(expression);
@@ -92032,7 +92068,7 @@ const hasThreeObjectProvenance = (expression, callback, managedRefSymbolIds, con
 	const symbol = context.scopes.symbolFor(current);
 	if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return false;
 	visitedSymbolIds.add(symbol.id);
-	return hasThreeObjectProvenance(symbol.initializer, callback, managedRefSymbolIds, context, visitedSymbolIds);
+	return hasThreeObjectProvenance$1(symbol.initializer, callback, managedRefSymbolIds, context, visitedSymbolIds);
 };
 const r3fNoCloneInUseFrame = defineRule({
 	id: "r3f-no-clone-in-use-frame",
@@ -92049,7 +92085,7 @@ const r3fNoCloneInUseFrame = defineRule({
 				const callback = resolveR3fCallback(node, "useFrame", context.scopes);
 				if (!callback) return;
 				walkFunctionExecution(callback, context.scopes, (candidate, isConditionallyExecuted) => {
-					if (isConditionallyExecuted || !isNodeOfType(candidate, "CallExpression") || !isNodeOfType(candidate.callee, "MemberExpression") || getStaticPropertyName(candidate.callee) !== "clone" || !hasThreeObjectProvenance(candidate.callee.object, callback, managedRefSymbolIds, context)) return;
+					if (isConditionallyExecuted || !isNodeOfType(candidate, "CallExpression") || !isNodeOfType(candidate.callee, "MemberExpression") || getStaticPropertyName(candidate.callee) !== "clone" || !hasThreeObjectProvenance$1(candidate.callee.object, callback, managedRefSymbolIds, context)) return;
 					context.report({
 						node: candidate,
 						message: "This clone allocates a new Three.js object every executed frame. Reuse a scratch object or clone once outside useFrame"
@@ -92720,6 +92756,9 @@ const r3fNoFreshUseThreeSelector = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/r3f/utils/is-three-module-source.ts
+const isThreeModuleSource$1 = (moduleSource) => moduleSource === "three" || moduleSource === "three-stdlib" || moduleSource.startsWith("three/");
+//#endregion
 //#region src/plugin/rules/r3f/r3f-no-imperative-attach-of-managed-ref.ts
 const IMPERATIVE_ATTACH_METHOD_NAMES = new Set(["add", "attach"]);
 const THREE_OBJECT3D_CONSTRUCTOR_NAMES = new Set([
@@ -92748,12 +92787,11 @@ const THREE_OBJECT3D_CONSTRUCTOR_NAMES = new Set([
 	"SpotLight",
 	"Sprite"
 ]);
-const isThreeModuleSource$3 = (moduleSource) => moduleSource === "three" || moduleSource === "three-stdlib" || moduleSource.startsWith("three/");
 const hasThreeObject3DProvenance = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const candidate = stripParenExpression(expression);
 	if (isNodeOfType(candidate, "NewExpression")) {
 		const provenance = getApiReferenceProvenance(candidate.callee, scopes);
-		return Boolean(provenance && isThreeModuleSource$3(provenance.moduleSource) && THREE_OBJECT3D_CONSTRUCTOR_NAMES.has(provenance.apiName));
+		return Boolean(provenance && isThreeModuleSource$1(provenance.moduleSource) && THREE_OBJECT3D_CONSTRUCTOR_NAMES.has(provenance.apiName));
 	}
 	if (!isNodeOfType(candidate, "Identifier")) return false;
 	const symbol = scopes.symbolFor(candidate);
@@ -92918,15 +92956,15 @@ const GEOMETRY_OWNER_CONSTRUCTORS = new Set([
 	"SkinnedMesh"
 ]);
 const MATERIAL_OWNER_CONSTRUCTORS = new Set([...GEOMETRY_OWNER_CONSTRUCTORS, "Sprite"]);
-const isThreeModuleSource$2 = (source) => typeof source === "string" && (source === "three" || source.startsWith("three/") || source === "three-stdlib");
-const getThreeConstructorName = (constructorExpression, scopes) => {
+const isThreeModuleSource = (source) => typeof source === "string" && (source === "three" || source.startsWith("three/") || source === "three-stdlib");
+const getThreeConstructorName$1 = (constructorExpression, scopes) => {
 	const provenance = getApiReferenceProvenance(stripParenExpression(constructorExpression), scopes);
-	return provenance && isThreeModuleSource$2(provenance.moduleSource) ? provenance.apiName : null;
+	return provenance && isThreeModuleSource(provenance.moduleSource) ? provenance.apiName : null;
 };
 const hasThreeResourceOwnerProvenance = (expression, ownerConstructors, scopes, visitedSymbolIds) => {
 	const candidate = stripParenExpression(expression);
 	if (isNodeOfType(candidate, "NewExpression")) {
-		const constructorName = getThreeConstructorName(candidate.callee, scopes);
+		const constructorName = getThreeConstructorName$1(candidate.callee, scopes);
 		return Boolean(constructorName && ownerConstructors.has(constructorName));
 	}
 	if (isNodeOfType(candidate, "Identifier")) {
@@ -92940,7 +92978,7 @@ const hasThreeResourceOwnerProvenance = (expression, ownerConstructors, scopes,
 const getResourceMethods = (constructorSuffix) => constructorSuffix === "Geometry" ? GEOMETRY_RESOURCE_METHODS : MATERIAL_RESOURCE_METHODS;
 const hasThreeResourceProvenance = (expression, constructorSuffix, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const candidate = stripParenExpression(expression);
-	if (isNodeOfType(candidate, "NewExpression")) return getThreeConstructorName(candidate.callee, scopes)?.endsWith(constructorSuffix) ?? false;
+	if (isNodeOfType(candidate, "NewExpression")) return getThreeConstructorName$1(candidate.callee, scopes)?.endsWith(constructorSuffix) ?? false;
 	if (isNodeOfType(candidate, "Identifier")) {
 		const symbol = scopes.symbolFor(candidate);
 		if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return false;
@@ -92980,7 +93018,7 @@ const hasProvenIndexedThreeGeometry = (expression, scopes, visitedSymbolIds = /*
 };
 const hasFreshThreeResource = (expression, constructorSuffix, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const candidate = stripParenExpression(expression);
-	if (isNodeOfType(candidate, "NewExpression")) return getThreeConstructorName(candidate.callee, scopes)?.endsWith(constructorSuffix) ?? false;
+	if (isNodeOfType(candidate, "NewExpression")) return getThreeConstructorName$1(candidate.callee, scopes)?.endsWith(constructorSuffix) ?? false;
 	if (isNodeOfType(candidate, "Identifier")) {
 		const symbol = scopes.symbolFor(candidate);
 		if (symbol?.kind !== "const" || symbol.scope.kind === "module" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return false;
@@ -93599,32 +93637,39 @@ const isGlobalBrowserFunctionCall = (call, functionName, scopes) => {
 	return isNodeOfType(receiver, "Identifier") && (receiver.name === "globalThis" || receiver.name === "window") && scopes.isGlobalReference(receiver);
 };
 //#endregion
-//#region src/plugin/rules/r3f/r3f-no-recursive-raf-with-use-frame.ts
-const EFFECT_HOOK_NAMES$3 = new Set([
-	"useEffect",
-	"useInsertionEffect",
-	"useLayoutEffect"
-]);
+//#region src/plugin/utils/resolve-recursive-animation-frame-callback.ts
 const getAnimationFrameCallback = (call, scopes) => {
 	const callbackArgument = call.arguments[0];
-	if (!callbackArgument || isNodeOfType(callbackArgument, "SpreadElement")) return null;
-	return resolveExactLocalFunction(callbackArgument, scopes);
+	return callbackArgument && !isNodeOfType(callbackArgument, "SpreadElement") ? resolveExactLocalFunction(callbackArgument, scopes) : null;
 };
-const callbackDirectlySchedulesItself = (callback, scopes) => {
+const callbackSchedulesItself = (callback, scopes) => {
 	let doesScheduleItself = false;
 	walkAst(callback, (candidate) => {
 		if (doesScheduleItself || candidate !== callback && isFunctionLike$1(candidate)) return false;
-		if (!isNodeOfType(candidate, "CallExpression") || !isGlobalBrowserFunctionCall(candidate, "requestAnimationFrame", scopes)) return;
-		doesScheduleItself = getAnimationFrameCallback(candidate, scopes) === callback;
+		if (isNodeOfType(candidate, "CallExpression") && isGlobalBrowserFunctionCall(candidate, "requestAnimationFrame", scopes) && getAnimationFrameCallback(candidate, scopes) === callback) {
+			doesScheduleItself = true;
+			return false;
+		}
 	});
 	return doesScheduleItself;
 };
+const resolveRecursiveAnimationFrameCallback = (call, scopes) => {
+	if (!isGlobalBrowserFunctionCall(call, "requestAnimationFrame", scopes)) return null;
+	const callback = getAnimationFrameCallback(call, scopes);
+	return callback && callbackSchedulesItself(callback, scopes) ? callback : null;
+};
+//#endregion
+//#region src/plugin/rules/r3f/r3f-no-recursive-raf-with-use-frame.ts
+const EFFECT_HOOK_NAMES$3 = new Set([
+	"useEffect",
+	"useInsertionEffect",
+	"useLayoutEffect"
+]);
 const collectRecursiveAnimationFrameStarts = (executedFunction, scopes) => {
 	const starts = /* @__PURE__ */ new Set();
 	walkFunctionExecution(executedFunction, scopes, (candidate) => {
 		if (!isNodeOfType(candidate, "CallExpression") || !isGlobalBrowserFunctionCall(candidate, "requestAnimationFrame", scopes)) return;
-		const callback = getAnimationFrameCallback(candidate, scopes);
-		if (callback && callbackDirectlySchedulesItself(callback, scopes)) starts.add(candidate);
+		if (resolveRecursiveAnimationFrameCallback(candidate, scopes)) starts.add(candidate);
 	});
 	return starts;
 };
@@ -94128,7 +94173,7 @@ const r3fNoStateInPointerMove = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/r3f/r3f-no-sync-readback-in-use-frame.ts
+//#region src/plugin/utils/is-cpu-typed-array.ts
 const CPU_TYPED_ARRAY_CONSTRUCTORS = new Set([
 	"BigInt64Array",
 	"BigUint64Array",
@@ -94142,44 +94187,61 @@ const CPU_TYPED_ARRAY_CONSTRUCTORS = new Set([
 	"Uint16Array",
 	"Uint32Array"
 ]);
-const CANVAS_2D_CONTEXT_NAMES = new Set(["2d"]);
+const isCpuTypedArray = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Identifier")) {
+		const symbol = scopes.symbolFor(candidate);
+		if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return false;
+		visitedSymbolIds.add(symbol.id);
+		return isCpuTypedArray(symbol.initializer, scopes, visitedSymbolIds);
+	}
+	if (!isNodeOfType(candidate, "NewExpression")) return false;
+	const callee = stripParenExpression(candidate.callee);
+	return isNodeOfType(callee, "Identifier") && CPU_TYPED_ARRAY_CONSTRUCTORS.has(callee.name) && scopes.isGlobalReference(callee);
+};
+//#endregion
+//#region src/plugin/utils/is-webgl-context-reference.ts
 const WEBGL_CONTEXT_NAMES = new Set([
 	"experimental-webgl",
 	"webgl",
 	"webgl2"
 ]);
-const isContextFromGetContext = (expression, contextNames, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+const isWebglContextReference = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const candidate = stripParenExpression(expression);
 	if (isNodeOfType(candidate, "Identifier")) {
 		const symbol = scopes.symbolFor(candidate);
 		if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return false;
 		visitedSymbolIds.add(symbol.id);
-		return isContextFromGetContext(symbol.initializer, contextNames, scopes, visitedSymbolIds);
+		return isWebglContextReference(symbol.initializer, scopes, visitedSymbolIds);
 	}
 	if (!isNodeOfType(candidate, "CallExpression") || !isNodeOfType(candidate.callee, "MemberExpression") || getStaticPropertyName(candidate.callee) !== "getContext") return false;
 	const contextName = candidate.arguments[0];
-	if (!contextName || isNodeOfType(contextName, "SpreadElement")) return false;
-	const staticContextName = stripParenExpression(contextName);
-	return Boolean(isNodeOfType(staticContextName, "Literal") && typeof staticContextName.value === "string" && contextNames.has(staticContextName.value));
+	const staticContextName = contextName && !isNodeOfType(contextName, "SpreadElement") ? stripParenExpression(contextName) : null;
+	return Boolean(staticContextName && isNodeOfType(staticContextName, "Literal") && typeof staticContextName.value === "string" && WEBGL_CONTEXT_NAMES.has(staticContextName.value));
 };
-const isCpuTypedArray = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+//#endregion
+//#region src/plugin/rules/r3f/r3f-no-sync-readback-in-use-frame.ts
+const CANVAS_2D_CONTEXT_NAMES = new Set(["2d"]);
+const isContextFromGetContext = (expression, contextNames, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const candidate = stripParenExpression(expression);
 	if (isNodeOfType(candidate, "Identifier")) {
 		const symbol = scopes.symbolFor(candidate);
 		if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return false;
 		visitedSymbolIds.add(symbol.id);
-		return isCpuTypedArray(symbol.initializer, scopes, visitedSymbolIds);
+		return isContextFromGetContext(symbol.initializer, contextNames, scopes, visitedSymbolIds);
 	}
-	if (!isNodeOfType(candidate, "NewExpression")) return false;
-	const callee = stripParenExpression(candidate.callee);
-	return isNodeOfType(callee, "Identifier") && CPU_TYPED_ARRAY_CONSTRUCTORS.has(callee.name) && scopes.isGlobalReference(callee);
+	if (!isNodeOfType(candidate, "CallExpression") || !isNodeOfType(candidate.callee, "MemberExpression") || getStaticPropertyName(candidate.callee) !== "getContext") return false;
+	const contextName = candidate.arguments[0];
+	if (!contextName || isNodeOfType(contextName, "SpreadElement")) return false;
+	const staticContextName = stripParenExpression(contextName);
+	return Boolean(isNodeOfType(staticContextName, "Literal") && typeof staticContextName.value === "string" && contextNames.has(staticContextName.value));
 };
 const getReadbackKind = (node, callback, context) => {
 	if (!isNodeOfType(node.callee, "MemberExpression")) return null;
 	const methodName = getStaticPropertyName(node.callee);
 	if (methodName === "readRenderTargetPixels" && (isR3fCallbackStateProperty(node.callee.object, callback, "gl", context.scopes) || isR3fCallbackStateProperty(node.callee.object, callback, "renderer", context.scopes))) return "three";
 	if (methodName === "getImageData" && isContextFromGetContext(node.callee.object, CANVAS_2D_CONTEXT_NAMES, context.scopes)) return "canvas";
-	if (methodName === "readPixels" && isContextFromGetContext(node.callee.object, WEBGL_CONTEXT_NAMES, context.scopes)) {
+	if (methodName === "readPixels" && isWebglContextReference(node.callee.object, context.scopes)) {
 		const destination = node.arguments[6];
 		return destination && !isNodeOfType(destination, "SpreadElement") && isCpuTypedArray(destination, context.scopes) ? "webgl" : null;
 	}
@@ -94374,6 +94436,36 @@ const r3fPreferUseLoader = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/r3f/utils/resolve-static-number.ts
+const resolveStaticNumber = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Literal") && typeof candidate.value === "number") return Number.isFinite(candidate.value) ? candidate.value : null;
+	if (isNodeOfType(candidate, "Identifier")) {
+		const symbol = scopes.symbolFor(candidate);
+		if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return null;
+		visitedSymbolIds.add(symbol.id);
+		return resolveStaticNumber(symbol.initializer, scopes, visitedSymbolIds);
+	}
+	if (isNodeOfType(candidate, "UnaryExpression")) {
+		const argument = resolveStaticNumber(candidate.argument, scopes, visitedSymbolIds);
+		if (argument === null) return null;
+		if (candidate.operator === "+") return argument;
+		if (candidate.operator === "-") return -argument;
+		return null;
+	}
+	if (!isNodeOfType(candidate, "BinaryExpression")) return null;
+	const left = resolveStaticNumber(candidate.left, scopes, new Set(visitedSymbolIds));
+	const right = resolveStaticNumber(candidate.right, scopes, new Set(visitedSymbolIds));
+	if (left === null || right === null) return null;
+	let result = null;
+	if (candidate.operator === "+") result = left + right;
+	if (candidate.operator === "-") result = left - right;
+	if (candidate.operator === "*") result = left * right;
+	if (candidate.operator === "/") result = left / right;
+	if (candidate.operator === "**") result = left ** right;
+	return result !== null && Number.isFinite(result) ? result : null;
+};
+//#endregion
 //#region src/plugin/rules/r3f/r3f-require-frame-delta.ts
 const TRANSFORM_PROPERTIES = new Set([
 	"position",
@@ -94436,34 +94528,6 @@ const expressionReferencesDelta = (expression, callback, context, visitedSymbolI
 	});
 	return referencesDelta;
 };
-const resolveStaticNumber = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const candidate = stripParenExpression(expression);
-	if (isNodeOfType(candidate, "Literal") && typeof candidate.value === "number") return Number.isFinite(candidate.value) ? candidate.value : null;
-	if (isNodeOfType(candidate, "Identifier")) {
-		const symbol = context.scopes.symbolFor(candidate);
-		if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return null;
-		visitedSymbolIds.add(symbol.id);
-		return resolveStaticNumber(symbol.initializer, context, visitedSymbolIds);
-	}
-	if (isNodeOfType(candidate, "UnaryExpression")) {
-		const argument = resolveStaticNumber(candidate.argument, context, visitedSymbolIds);
-		if (argument === null) return null;
-		if (candidate.operator === "+") return argument;
-		if (candidate.operator === "-") return -argument;
-		return null;
-	}
-	if (!isNodeOfType(candidate, "BinaryExpression")) return null;
-	const left = resolveStaticNumber(candidate.left, context, new Set(visitedSymbolIds));
-	const right = resolveStaticNumber(candidate.right, context, new Set(visitedSymbolIds));
-	if (left === null || right === null) return null;
-	let result = null;
-	if (candidate.operator === "+") result = left + right;
-	if (candidate.operator === "-") result = left - right;
-	if (candidate.operator === "*") result = left * right;
-	if (candidate.operator === "/") result = left / right;
-	if (candidate.operator === "**") result = left ** right;
-	return result !== null && Number.isFinite(result) ? result : null;
-};
 const isThreeMathUtils = (expression, context) => {
 	return getApiReferenceModuleSource(expression, "MathUtils", context.scopes) === "three";
 };
@@ -94523,7 +94587,7 @@ const isConditionallyExecutedOnlyByReactRefAvailability = (node, callback, conte
 	}
 	return didFindRefAvailabilityCondition;
 };
-const getFixedInterpolationFactor = (node, callback, managedRefSymbolIds, context) => {
+const getFixedInterpolationFactor$1 = (node, callback, managedRefSymbolIds, context) => {
 	if (!isNodeOfType(node.callee, "MemberExpression")) return null;
 	const methodName = getStaticPropertyName(node.callee);
 	let factorArgumentIndex;
@@ -94532,7 +94596,7 @@ const getFixedInterpolationFactor = (node, callback, managedRefSymbolIds, contex
 	if (factorArgumentIndex === void 0) return null;
 	const factor = node.arguments[factorArgumentIndex];
 	if (!factor || isNodeOfType(factor, "SpreadElement")) return null;
-	const staticFactor = resolveStaticNumber(factor, context);
+	const staticFactor = resolveStaticNumber(factor, context.scopes);
 	return staticFactor !== null && staticFactor > 0 && staticFactor < 1 ? factor : null;
 };
 const getRotationOwner = (expression) => {
@@ -94606,7 +94670,7 @@ const r3fRequireFrameDelta = defineRule({
 						return;
 					}
 					if (!isNodeOfType(candidate, "CallExpression")) return;
-					const factor = getFixedInterpolationFactor(candidate, callback, managedRefSymbolIds, context);
+					const factor = getFixedInterpolationFactor$1(candidate, callback, managedRefSymbolIds, context);
 					if (!factor || expressionReferencesDelta(factor, callback, context) || isConditionallyExecuted && !isBehindReactRefAvailabilityGuard) return;
 					context.report({
 						node: factor,
@@ -95646,20 +95710,30 @@ const ownedResourceHasMethodCall = (analysis, methodName, scopes, matchesCall =
 	return false;
 };
 //#endregion
+//#region src/plugin/rules/r3f/utils/create-owned-three-resource-cleanup-visitors.ts
+const createOwnedThreeResourceCleanupVisitors = ({ analysisOptions, constructorNameSuffix, context, message }) => ({ NewExpression(node) {
+	const provenance = getApiReferenceProvenance(node.callee, context.scopes);
+	if (!provenance || !isThreeModuleSource$1(provenance.moduleSource) || !provenance.apiName.endsWith(constructorNameSuffix)) return;
+	const ownership = analyzeOwnedLifecycleResource(node, context, analysisOptions);
+	if (!ownership || ownership.hasUnknownOwnershipTransfer) return;
+	const allocationFunction = findEnclosingFunction$1(node);
+	if (allocationFunction && ownedResourceHasMethodCall(ownership, "dispose", context.scopes, (call) => call.range[0] > node.range[1] && findEnclosingFunction$1(call) === allocationFunction && !isNodeConditionallyExecuted(call, allocationFunction))) return;
+	const cleanup = analyzeOwnedLifecycleCleanup(ownership, context, (cleanupFunction) => functionInvokesOwnedResourceMethod(cleanupFunction, ownership, "dispose", context.scopes));
+	if (cleanup.isProven || cleanup.isUnknown) return;
+	context.report({
+		node,
+		message
+	});
+} });
+//#endregion
 //#region src/plugin/rules/r3f/r3f-require-owned-texture-cleanup.ts
-const OWNED_TEXTURE_CONSTRUCTOR_NAMES = new Set([
-	"CanvasTexture",
-	"DataTexture",
-	"Texture",
-	"VideoTexture"
-]);
 const TEXTURE_BORROWING_METHOD_NAMES = /* @__PURE__ */ new Set();
 const isMaterialTexturePropertyName = (propertyName) => propertyName === "map" || propertyName === "matcap" || Boolean(propertyName?.endsWith("Map"));
 const isThreeMaterialAllocation = (expression, context) => {
 	const candidate = stripParenExpression(expression);
 	if (!isNodeOfType(candidate, "NewExpression")) return false;
 	const provenance = getApiReferenceProvenance(candidate.callee, context.scopes);
-	return Boolean(provenance?.moduleSource === "three" && provenance.apiName.endsWith("Material"));
+	return Boolean(provenance && isThreeModuleSource$1(provenance.moduleSource) && provenance.apiName.endsWith("Material"));
 };
 const expressionResolvesToThreeMaterial = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const candidate = stripParenExpression(expression);
@@ -95722,27 +95796,21 @@ const r3fRequireOwnedTextureCleanup = defineRule({
 	category: "Performance",
 	severity: "warn",
 	recommendation: "Dispose locally constructed textures in a React effect cleanup",
-	create: (context) => ({ NewExpression(node) {
-		const provenance = getApiReferenceProvenance(node.callee, context.scopes);
-		if (provenance?.moduleSource !== "three" || !OWNED_TEXTURE_CONSTRUCTOR_NAMES.has(provenance.apiName)) return;
-		const ownership = analyzeOwnedLifecycleResource(node, context, {
+	create: (context) => createOwnedThreeResourceCleanupVisitors({
+		analysisOptions: {
 			borrowedArgumentMethodNames: TEXTURE_BORROWING_METHOD_NAMES,
 			isBorrowedReference: (reference) => isBorrowedByThreeMaterial(reference, context),
 			retainsOwnershipInJsx: true
-		});
-		if (!ownership || ownership.hasUnknownOwnershipTransfer) return;
-		const cleanup = analyzeOwnedLifecycleCleanup(ownership, context, (cleanupFunction) => functionInvokesOwnedResourceMethod(cleanupFunction, ownership, "dispose", context.scopes));
-		if (cleanup.isProven || cleanup.isUnknown) return;
-		context.report({
-			node,
-			message: "This locally constructed Three.js texture owns GPU resources but has no provable React cleanup. Dispose it when the owning component or hook releases it"
-		});
-	} })
+		},
+		constructorNameSuffix: "Texture",
+		context,
+		message: "This locally constructed Three.js texture owns GPU resources but has no provable React cleanup. Dispose it when the owning component or hook releases it"
+	})
 });
 //#endregion
 //#region src/plugin/rules/r3f/r3f-require-projection-matrix-update.ts
 const CAMERA_HOST_NAMES = new Set(["orthographicCamera", "perspectiveCamera"]);
-const PROJECTION_PROPERTY_NAMES = new Set([
+const PROJECTION_PROPERTY_NAMES$1 = new Set([
 	"aspect",
 	"bottom",
 	"far",
@@ -95805,7 +95873,7 @@ const hasManagedCameraRefProvenance = (expression, managedCameraRefSymbolIds, co
 const hasR3fCameraProvenance = (expression, frameCallbacks, managedCameraRefSymbolIds, context) => hasStableRootBinding(expression, context.scopes) && (hasUseThreeCameraProvenance(expression, context) || hasFrameCameraProvenance(expression, frameCallbacks, context) || hasManagedCameraRefProvenance(expression, managedCameraRefSymbolIds, context));
 const getProjectionMutationReceiver = (node) => {
 	const mutationTarget = isNodeOfType(node, "AssignmentExpression") ? stripParenExpression(node.left) : isNodeOfType(node, "UpdateExpression") ? stripParenExpression(node.argument) : null;
-	return mutationTarget && isNodeOfType(mutationTarget, "MemberExpression") && PROJECTION_PROPERTY_NAMES.has(getStaticPropertyName(mutationTarget) ?? "") ? mutationTarget.object : null;
+	return mutationTarget && isNodeOfType(mutationTarget, "MemberExpression") && PROJECTION_PROPERTY_NAMES$1.has(getStaticPropertyName(mutationTarget) ?? "") ? mutationTarget.object : null;
 };
 const getOnlyCallExpression = (statement) => {
 	if (isNodeOfType(statement, "BlockStatement")) return statement.body.length === 1 ? getOnlyCallExpression(statement.body[0]) : null;
@@ -96229,14 +96297,16 @@ const r3fWebgpuNoGlState = defineRule({
 	})
 });
 //#endregion
-//#region src/plugin/rules/r3f/r3f-webgpu-no-js-uniform-branch.ts
-const WEBGPU_GRAPH_HOOKS = new Set([
-	"useLocalNodes",
-	"useNodes",
-	"usePostProcessing",
-	"useRenderPipeline"
-]);
-const WEBGPU_TWO_CALLBACK_HOOKS = new Set(["usePostProcessing", "useRenderPipeline"]);
+//#region src/plugin/rules/r3f/utils/get-control-flow-test.ts
+const getControlFlowTest = (node) => {
+	if (isNodeOfType(node, "IfStatement") || isNodeOfType(node, "WhileStatement") || isNodeOfType(node, "DoWhileStatement") || isNodeOfType(node, "ConditionalExpression")) return node.test;
+	if (isNodeOfType(node, "SwitchStatement")) return node.discriminant;
+	if (isNodeOfType(node, "ForStatement")) return node.test;
+	if (isNodeOfType(node, "LogicalExpression")) return node.left;
+	return null;
+};
+//#endregion
+//#region src/plugin/rules/r3f/utils/resolves-to-tsl-uniform.ts
 const TSL_UNIFORM_MODULES = new Set(["three/tsl", "three/webgpu"]);
 const resolvesToTslUniform = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const candidate = stripParenExpression(expression);
@@ -96247,6 +96317,15 @@ const resolvesToTslUniform = (expression, scopes, visitedSymbolIds = /* @__PURE_
 	visitedSymbolIds.add(symbol.id);
 	return resolvesToTslUniform(symbol.initializer, scopes, visitedSymbolIds);
 };
+//#endregion
+//#region src/plugin/rules/r3f/r3f-webgpu-no-js-uniform-branch.ts
+const WEBGPU_GRAPH_HOOKS = new Set([
+	"useLocalNodes",
+	"useNodes",
+	"usePostProcessing",
+	"useRenderPipeline"
+]);
+const WEBGPU_TWO_CALLBACK_HOOKS = new Set(["usePostProcessing", "useRenderPipeline"]);
 const isUniformValueMember = (expression, callback, scopes) => {
 	const candidate = stripParenExpression(expression);
 	if (!isNodeOfType(candidate, "MemberExpression") || getStaticPropertyName(candidate) !== "value") return false;
@@ -96277,13 +96356,6 @@ const expressionReferencesUniformValue = (expression, callback, scopes, visitedS
 	});
 	return didFindUniformValue;
 };
-const getControlFlowTest = (node) => {
-	if (isNodeOfType(node, "IfStatement") || isNodeOfType(node, "WhileStatement") || isNodeOfType(node, "DoWhileStatement") || isNodeOfType(node, "ConditionalExpression")) return node.test;
-	if (isNodeOfType(node, "SwitchStatement")) return node.discriminant;
-	if (isNodeOfType(node, "ForStatement")) return node.test;
-	if (isNodeOfType(node, "LogicalExpression")) return node.left;
-	return null;
-};
 const getWebgpuGraphHookName = (node, context) => {
 	for (const hookName of WEBGPU_GRAPH_HOOKS) if (isApiCallFromModules(node, hookName, R3F_WEBGPU_MODULES, context.scopes)) return hookName;
 	return null;
@@ -113807,6 +113879,363 @@ const tenantStaticProxyRisk = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/rules/r3f/utils/get-three-constructor-name.ts
+const getThreeConstructorName = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "NewExpression")) {
+		const provenance = getApiReferenceProvenance(candidate.callee, scopes);
+		return provenance && isThreeModuleSource$1(provenance.moduleSource) ? provenance.apiName : null;
+	}
+	if (!isNodeOfType(candidate, "Identifier")) return null;
+	const symbol = scopes.symbolFor(candidate);
+	if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
+	visitedSymbolIds.add(symbol.id);
+	return getThreeConstructorName(symbol.initializer, scopes, visitedSymbolIds);
+};
+//#endregion
+//#region src/plugin/rules/r3f/utils/is-three-renderer-reference.ts
+const THREE_RENDERER_CONSTRUCTOR_NAMES = new Set(["WebGLRenderer", "WebGPURenderer"]);
+const isThreeRendererReference = (expression, scopes) => THREE_RENDERER_CONSTRUCTOR_NAMES.has(getThreeConstructorName(expression, scopes) ?? "");
+//#endregion
+//#region src/plugin/rules/r3f/three-cap-device-pixel-ratio.ts
+const threeCapDevicePixelRatio = defineRule({
+	id: "three-cap-device-pixel-ratio",
+	title: "Unbounded Three.js device pixel ratio",
+	category: "Performance",
+	severity: "warn",
+	recommendation: "Cap renderer pixel ratio, commonly at 2, so high-density displays do not multiply GPU work without a bound",
+	create: (context) => ({ CallExpression(node) {
+		if (!isNodeOfType(node.callee, "MemberExpression") || getStaticPropertyName(node.callee) !== "setPixelRatio" || !isThreeRendererReference(node.callee.object, context.scopes)) return;
+		const pixelRatio = node.arguments[0];
+		if (!pixelRatio || isNodeOfType(pixelRatio, "SpreadElement")) return;
+		const rawPixelRatio = resolveRawDevicePixelRatio(pixelRatio, context.scopes);
+		if (!rawPixelRatio) return;
+		context.report({
+			node: rawPixelRatio,
+			message: "This renderer uses the device's raw pixel ratio without a cap. Bound the ratio to limit the rendered pixel count on high-density displays"
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-limit-shadowed-point-lights.ts
+const getExecutionOwner = (node, program) => findEnclosingFunction$1(node) ?? program;
+const threeLimitShadowedPointLights = defineRule({
+	id: "three-limit-shadowed-point-lights",
+	title: "Too many shadow-casting Three.js point lights",
+	category: "Performance",
+	severity: "warn",
+	recommendation: "Keep at most two shadow-casting point lights in one scene, or use cheaper directional, spot, baked, or fake shadows",
+	create: (context) => {
+		const sceneLightFacts = [];
+		const shadowedPointLights = [];
+		let program = null;
+		return {
+			Program(node) {
+				program = node;
+			},
+			CallExpression(node) {
+				if (!program || !isNodeOfType(node.callee, "MemberExpression") || getStaticPropertyName(node.callee) !== "add" || getThreeConstructorName(node.callee.object, context.scopes) !== "Scene") return;
+				const owner = getExecutionOwner(node, program);
+				if (isNodeConditionallyExecuted(node, owner)) return;
+				const sceneKey = resolveExpressionKey$1(node.callee.object, context);
+				if (!sceneKey) return;
+				for (const light of node.arguments) {
+					if (isNodeOfType(light, "SpreadElement") || getThreeConstructorName(light, context.scopes) !== "PointLight") continue;
+					const lightKey = resolveExpressionKey$1(light, context);
+					if (lightKey) sceneLightFacts.push({
+						lightKey,
+						owner,
+						sceneKey
+					});
+				}
+			},
+			AssignmentExpression(node) {
+				const assignedValue = stripParenExpression(node.right);
+				if (!program || node.operator !== "=" || !isNodeOfType(node.left, "MemberExpression") || getStaticPropertyName(node.left) !== "castShadow" || getThreeConstructorName(node.left.object, context.scopes) !== "PointLight" || !isNodeOfType(assignedValue, "Literal") || assignedValue.value !== true) return;
+				const owner = getExecutionOwner(node, program);
+				if (isNodeConditionallyExecuted(node, owner)) return;
+				const lightKey = resolveExpressionKey$1(node.left.object, context);
+				if (lightKey) shadowedPointLights.push({
+					lightKey,
+					node,
+					owner
+				});
+			},
+			"Program:exit"() {
+				const countByOwnerAndScene = /* @__PURE__ */ new Map();
+				const countedLights = /* @__PURE__ */ new Map();
+				for (const shadowedLight of shadowedPointLights) {
+					const matchingScene = sceneLightFacts.find((sceneLight) => sceneLight.owner === shadowedLight.owner && sceneLight.lightKey === shadowedLight.lightKey);
+					if (!matchingScene) continue;
+					const ownerCounts = countByOwnerAndScene.get(shadowedLight.owner) ?? /* @__PURE__ */ new Map();
+					const ownerLights = countedLights.get(shadowedLight.owner) ?? /* @__PURE__ */ new Map();
+					countByOwnerAndScene.set(shadowedLight.owner, ownerCounts);
+					countedLights.set(shadowedLight.owner, ownerLights);
+					const sceneLights = ownerLights.get(matchingScene.sceneKey) ?? /* @__PURE__ */ new Set();
+					ownerLights.set(matchingScene.sceneKey, sceneLights);
+					if (sceneLights.has(shadowedLight.lightKey)) continue;
+					sceneLights.add(shadowedLight.lightKey);
+					const nextCount = (ownerCounts.get(matchingScene.sceneKey) ?? 0) + 1;
+					ownerCounts.set(matchingScene.sceneKey, nextCount);
+					if (nextCount <= 2) continue;
+					context.report({
+						node: shadowedLight.node,
+						message: "This is the third or later shadow-casting point light added to the same scene. Each point-light shadow renders six cube faces, multiplying shadow passes"
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/r3f/utils/has-three-object-provenance.ts
+const hasThreeObjectProvenance = (expression, scopes) => {
+	let candidate = stripParenExpression(expression);
+	while (isNodeOfType(candidate, "MemberExpression")) candidate = stripParenExpression(candidate.object);
+	return getThreeConstructorName(candidate, scopes) !== null;
+};
+//#endregion
+//#region src/plugin/rules/r3f/utils/resolve-three-pointer-move-callback.ts
+const callbackExecutesThreeWork = (callback, context) => {
+	let executesThreeWork = false;
+	walkFunctionExecution(callback, context.scopes, (candidate) => {
+		if (executesThreeWork) return;
+		if (isNodeOfType(candidate, "NewExpression")) {
+			const provenance = getApiReferenceProvenance(candidate.callee, context.scopes);
+			executesThreeWork = Boolean(provenance && isThreeModuleSource$1(provenance.moduleSource));
+			return;
+		}
+		if (isNodeOfType(candidate, "CallExpression") && isNodeOfType(candidate.callee, "MemberExpression")) {
+			executesThreeWork = hasThreeObjectProvenance(candidate.callee.object, context.scopes);
+			return;
+		}
+		const target = isNodeOfType(candidate, "AssignmentExpression") ? stripParenExpression(candidate.left) : isNodeOfType(candidate, "UpdateExpression") ? stripParenExpression(candidate.argument) : null;
+		executesThreeWork = Boolean(target && isNodeOfType(target, "MemberExpression") && hasThreeObjectProvenance(target.object, context.scopes));
+	});
+	return executesThreeWork;
+};
+const getPointerMoveListenerCallback = (node, context) => {
+	if (!isNodeOfType(node, "CallExpression") || !isNodeOfType(node.callee, "MemberExpression") || getStaticPropertyName(node.callee) !== "addEventListener") return null;
+	const eventName = node.arguments[0];
+	const callback = node.arguments[1];
+	const listenerTarget = stripParenExpression(node.callee.object);
+	if (!eventName || isNodeOfType(eventName, "SpreadElement") || !isNodeOfType(eventName, "Literal") || eventName.value !== "pointermove" || !callback || isNodeOfType(callback, "SpreadElement") || !isNodeOfType(listenerTarget, "MemberExpression") || getStaticPropertyName(listenerTarget) !== "domElement" || !isThreeRendererReference(listenerTarget.object, context.scopes)) return null;
+	return resolveLocalReactCallback(callback, context.scopes);
+};
+const resolveThreePointerMoveCallback = (node, context) => {
+	if (isNodeOfType(node, "CallExpression")) return getPointerMoveListenerCallback(node, context);
+	if (!isNodeOfType(node, "JSXOpeningElement") || resolveJsxElementType(node) !== "canvas") return null;
+	const attribute = getAuthoritativeJsxAttribute(node.attributes, "onPointerMove");
+	if (!attribute?.value || !isNodeOfType(attribute.value, "JSXExpressionContainer") || isNodeOfType(attribute.value.expression, "JSXEmptyExpression")) return null;
+	const callback = resolveLocalReactCallback(attribute.value.expression, context.scopes);
+	return callback && callbackExecutesThreeWork(callback, context) ? callback : null;
+};
+//#endregion
+//#region src/plugin/rules/r3f/three-no-allocation-in-pointer-move.ts
+const threeNoAllocationInPointerMove = defineRule({
+	id: "three-no-allocation-in-pointer-move",
+	title: "Three.js allocation inside pointer-move handler",
+	severity: "warn",
+	recommendation: "Reuse vectors, raycasters, and other Three.js objects while handling continuous pointer movement",
+	create: (context) => {
+		const analyzedCallbacks = /* @__PURE__ */ new Set();
+		const analyzeCallback = (node) => {
+			const callback = resolveThreePointerMoveCallback(node, context);
+			if (!callback || analyzedCallbacks.has(callback)) return;
+			analyzedCallbacks.add(callback);
+			walkFunctionExecution(callback, context.scopes, (candidate, isConditionallyExecuted) => {
+				if (isConditionallyExecuted) return;
+				if (isNodeOfType(candidate, "NewExpression")) {
+					const provenance = getApiReferenceProvenance(candidate.callee, context.scopes);
+					if (!provenance || !isThreeModuleSource$1(provenance.moduleSource)) return;
+					context.report({
+						node: candidate,
+						message: "This Three.js constructor allocates on every pointer movement. Reuse an object created outside the handler"
+					});
+					return;
+				}
+				if (!isNodeOfType(candidate, "CallExpression") || !isNodeOfType(candidate.callee, "MemberExpression") || getStaticPropertyName(candidate.callee) !== "clone" || !hasThreeObjectProvenance(candidate.callee.object, context.scopes)) return;
+				context.report({
+					node: candidate,
+					message: "This clone allocates a Three.js object on every pointer movement. Copy into a reusable object instead"
+				});
+			});
+		};
+		return {
+			CallExpression(node) {
+				analyzeCallback(node);
+			},
+			JSXOpeningElement(node) {
+				analyzeCallback(node);
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/r3f/utils/resolve-three-animation-loop-callback.ts
+const callbackRendersWithThree = (callback, scopes) => {
+	let doesRenderWithThree = false;
+	walkFunctionExecution(callback, scopes, (candidate) => {
+		if (!doesRenderWithThree && isNodeOfType(candidate, "CallExpression") && isNodeOfType(candidate.callee, "MemberExpression") && THREE_RENDER_METHOD_NAMES.has(getStaticPropertyName(candidate.callee) ?? "") && isThreeRendererReference(candidate.callee.object, scopes)) doesRenderWithThree = true;
+	});
+	return doesRenderWithThree;
+};
+const resolveThreeAnimationLoopCallback = (call, scopes) => {
+	if (isNodeOfType(call.callee, "MemberExpression") && getStaticPropertyName(call.callee) === "setAnimationLoop" && isThreeRendererReference(call.callee.object, scopes)) {
+		const callbackArgument = call.arguments[0];
+		return callbackArgument && !isNodeOfType(callbackArgument, "SpreadElement") ? resolveLocalReactCallback(callbackArgument, scopes) : null;
+	}
+	const callback = resolveRecursiveAnimationFrameCallback(call, scopes);
+	return callback && callbackRendersWithThree(callback, scopes) ? callback : null;
+};
+//#endregion
+//#region src/plugin/rules/r3f/three-no-async-animation-loop.ts
+const threeNoAsyncAnimationLoop = defineRule({
+	id: "three-no-async-animation-loop",
+	title: "Async Three.js animation callback",
+	category: "Correctness",
+	severity: "warn",
+	recommendation: "Keep animation callbacks synchronous; start asynchronous work outside the loop and consume completed state during frames",
+	create: (context) => {
+		const reportedCallbacks = /* @__PURE__ */ new Set();
+		return { CallExpression(node) {
+			const callback = resolveThreeAnimationLoopCallback(node, context.scopes);
+			if (!isFunctionLike$1(callback) || !callback.async || reportedCallbacks.has(callback)) return;
+			reportedCallbacks.add(callback);
+			context.report({
+				node: callback,
+				message: "The animation scheduler ignores this Promise, so rejected work can become unhandled and awaited work can overlap across frames. Keep the callback synchronous"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-no-clone-in-animation-loop.ts
+const threeNoCloneInAnimationLoop = defineRule({
+	id: "three-no-clone-in-animation-loop",
+	title: "Three.js clone inside animation loop",
+	severity: "warn",
+	recommendation: "Clone once before the animation loop or copy values into a reusable scratch object during frames",
+	create: (context) => {
+		const analyzedCallbacks = /* @__PURE__ */ new Set();
+		return { CallExpression(node) {
+			const callback = resolveThreeAnimationLoopCallback(node, context.scopes);
+			if (!callback || analyzedCallbacks.has(callback)) return;
+			analyzedCallbacks.add(callback);
+			walkFunctionExecution(callback, context.scopes, (candidate, isConditionallyExecuted) => {
+				if (isConditionallyExecuted || !isNodeOfType(candidate, "CallExpression") || !isNodeOfType(candidate.callee, "MemberExpression") || getStaticPropertyName(candidate.callee) !== "clone" || !hasThreeObjectProvenance(candidate.callee.object, context.scopes)) return;
+				context.report({
+					node: candidate,
+					message: "This clone allocates a new Three.js object every executed frame. Copy into a reusable object or clone once outside the animation loop"
+				});
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-no-new-in-animation-loop.ts
+const threeNoNewInAnimationLoop = defineRule({
+	id: "three-no-new-in-animation-loop",
+	title: "Allocation inside Three.js animation loop",
+	severity: "warn",
+	recommendation: "Allocate reusable objects before the animation loop and mutate them in place during each frame",
+	create: (context) => {
+		const analyzedCallbacks = /* @__PURE__ */ new Set();
+		return { CallExpression(node) {
+			const callback = resolveThreeAnimationLoopCallback(node, context.scopes);
+			if (!callback || analyzedCallbacks.has(callback)) return;
+			analyzedCallbacks.add(callback);
+			walkFunctionExecution(callback, context.scopes, (candidate, isConditionallyExecuted) => {
+				if (candidate.type !== "NewExpression" || isConditionallyExecuted) return;
+				context.report({
+					node: candidate,
+					message: "This constructor allocates a new object every executed frame. Reuse an object allocated outside the Three.js animation loop"
+				});
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/utils/function-is-referenced-as-jsx-element.ts
+const functionIsReferencedAsJsxElement = (functionNode, scopes) => getFunctionBindingSymbols(functionNode, scopes).some((symbol) => symbol.references.some((reference) => {
+	const referenceNode = reference.identifier;
+	const parentNode = referenceNode.parent;
+	return Boolean(isNodeOfType(referenceNode, "JSXIdentifier") && parentNode && isNodeOfType(parentNode, "JSXOpeningElement") && parentNode.name === referenceNode);
+}));
+//#endregion
+//#region src/plugin/rules/r3f/three-no-object-construction-in-render.ts
+const threeNoObjectConstructionInRender = defineRule({
+	id: "three-no-object-construction-in-render",
+	title: "Three.js object constructed during React render",
+	severity: "warn",
+	recommendation: "Construct mutable Three.js objects in a stable initializer, effect, event, or module scope instead of recreating them during React render",
+	create: (context) => ({ NewExpression(node) {
+		const provenance = getApiReferenceProvenance(node.callee, context.scopes);
+		const renderOwner = findRenderPhaseComponentOrHook(node, context.scopes);
+		if (!provenance || !isThreeModuleSource$1(provenance.moduleSource) || !renderOwner || isInsideStableReactInitializer(node, context.scopes)) return;
+		const renderOwnerName = componentOrHookDisplayNameForFunction(renderOwner);
+		if (!renderOwnerName || !isReactHookName(renderOwnerName) && !functionHasReactComponentEvidence(renderOwner, context.scopes, context.cfg) && !functionIsReferencedAsJsxElement(renderOwner, context.scopes)) return;
+		context.report({
+			node,
+			message: `new ${provenance.apiName}() creates a fresh mutable Three.js object during this render. Move it to useMemo, a lazy useState initializer, an initialized-once ref, or module scope`
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-no-state-in-animation-loop.ts
+const threeNoStateInAnimationLoop = defineRule({
+	id: "three-no-state-in-animation-loop",
+	title: "React state update inside Three.js animation loop",
+	severity: "warn",
+	recommendation: "Mutate Three.js objects or refs during frames; reserve React state for guarded, infrequent transitions",
+	create: (context) => {
+		const analyzedCallbacks = /* @__PURE__ */ new Set();
+		return { CallExpression(node) {
+			const callback = resolveThreeAnimationLoopCallback(node, context.scopes);
+			if (!callback || analyzedCallbacks.has(callback)) return;
+			analyzedCallbacks.add(callback);
+			walkFunctionExecution(callback, context.scopes, (candidate) => {
+				if (!isNodeOfType(candidate, "CallExpression") || !resolveStateSetterBinding(candidate.callee, context.scopes) || isGuardedStateTransition(candidate, callback, context.scopes)) return;
+				context.report({
+					node: candidate,
+					message: "This React state update can schedule a component render every frame. Mutate a Three.js object or ref, or guard an infrequent state transition"
+				});
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-no-state-in-pointer-move.ts
+const threeNoStateInPointerMove = defineRule({
+	id: "three-no-state-in-pointer-move",
+	title: "React state update inside Three.js pointer-move handler",
+	severity: "warn",
+	recommendation: "Keep continuous pointer previews in Three.js objects or refs and publish React state when the interaction commits",
+	create: (context) => {
+		const analyzedCallbacks = /* @__PURE__ */ new Set();
+		const analyzeCallback = (node) => {
+			const callback = resolveThreePointerMoveCallback(node, context);
+			if (!callback || analyzedCallbacks.has(callback)) return;
+			analyzedCallbacks.add(callback);
+			walkFunctionExecution(callback, context.scopes, (candidate) => {
+				if (!isNodeOfType(candidate, "CallExpression") || !resolveStateSetterBinding(candidate.callee, context.scopes) || isGuardedStateTransition(candidate, callback, context.scopes)) return;
+				context.report({
+					node: candidate,
+					message: "This React state update can render on every pointer movement. Mutate a Three.js object or ref and publish state on pointer-up"
+				});
+			});
+		};
+		return {
+			CallExpression(node) {
+				analyzeCallback(node);
+			},
+			JSXOpeningElement(node) {
+				analyzeCallback(node);
+			}
+		};
+	}
+});
+//#endregion
 //#region src/plugin/rules/r3f/three-require-animation-mixer-cleanup.ts
 const MIXER_BORROWING_METHOD_NAMES = /* @__PURE__ */ new Set();
 const FINE_GRAINED_UNCACHE_METHOD_NAMES = ["uncacheAction", "uncacheClip"];
@@ -113914,6 +114343,247 @@ const threeRequireControlsCleanup = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/r3f/three-require-frame-delta.ts
+const TRANSFORM_PROPERTY_NAMES = new Set([
+	"position",
+	"quaternion",
+	"rotation",
+	"scale"
+]);
+const isThreeTransformMember = (expression, context) => {
+	let candidate = stripParenExpression(expression);
+	let hasTransformProperty = false;
+	while (isNodeOfType(candidate, "MemberExpression")) {
+		if (TRANSFORM_PROPERTY_NAMES.has(getStaticPropertyName(candidate) ?? "")) hasTransformProperty = true;
+		candidate = stripParenExpression(candidate.object);
+	}
+	return hasTransformProperty && hasThreeObjectProvenance(expression, context.scopes);
+};
+const expressionUsesThreeClockDelta = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	let usesDelta = false;
+	walkAst(expression, (candidate) => {
+		if (isNodeOfType(candidate, "CallExpression") && isNodeOfType(candidate.callee, "MemberExpression") && getStaticPropertyName(candidate.callee) === "getDelta" && getThreeConstructorName(candidate.callee.object, context.scopes) === "Clock") {
+			usesDelta = true;
+			return false;
+		}
+		if (!isNodeOfType(candidate, "Identifier")) return;
+		const symbol = context.scopes.symbolFor(candidate);
+		if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return;
+		visitedSymbolIds.add(symbol.id);
+		if (expressionUsesThreeClockDelta(symbol.initializer, context, visitedSymbolIds)) {
+			usesDelta = true;
+			return false;
+		}
+	});
+	return usesDelta;
+};
+const getFixedInterpolationFactor = (node, context) => {
+	if (!isNodeOfType(node.callee, "MemberExpression")) return null;
+	const methodName = getStaticPropertyName(node.callee);
+	let factorArgumentIndex;
+	if (methodName === "lerp" && getApiReferenceModuleSource(node.callee.object, "MathUtils", context.scopes) === "three") factorArgumentIndex = 2;
+	else if (methodName && hasThreeObjectProvenance(node.callee.object, context.scopes)) factorArgumentIndex = THREE_INTERPOLATION_FACTOR_ARGUMENT_BY_METHOD.get(methodName);
+	if (factorArgumentIndex === void 0) return null;
+	const factor = node.arguments[factorArgumentIndex];
+	if (!factor || isNodeOfType(factor, "SpreadElement")) return null;
+	const staticFactor = resolveStaticNumber(factor, context.scopes);
+	return staticFactor !== null && staticFactor > 0 && staticFactor < 1 ? factor : null;
+};
+const threeRequireFrameDelta = defineRule({
+	id: "three-require-frame-delta",
+	title: "Frame-rate-dependent Three.js animation",
+	category: "Correctness",
+	severity: "warn",
+	recommendation: "Scale incremental transforms and interpolation by Clock.getDelta(), use delta-aware damping, or assign from absolute animation time",
+	create: (context) => {
+		const analyzedCallbacks = /* @__PURE__ */ new Set();
+		return { CallExpression(node) {
+			const callback = resolveThreeAnimationLoopCallback(node, context.scopes);
+			if (!callback || analyzedCallbacks.has(callback)) return;
+			analyzedCallbacks.add(callback);
+			walkFunctionExecution(callback, context.scopes, (candidate, isConditionallyExecuted) => {
+				if (isConditionallyExecuted) return;
+				if (isNodeOfType(candidate, "UpdateExpression") && isThreeTransformMember(candidate.argument, context)) {
+					context.report({
+						node: candidate,
+						message: "This transform changes by a fixed amount per frame, so animation speed depends on refresh rate. Use a Three.js Clock delta instead of an update operator"
+					});
+					return;
+				}
+				if (isNodeOfType(candidate, "AssignmentExpression") && (candidate.operator === "+=" || candidate.operator === "-=") && isThreeTransformMember(candidate.left, context) && !expressionUsesThreeClockDelta(candidate.right, context)) {
+					context.report({
+						node: candidate,
+						message: "This transform changes by a fixed amount per frame, so animation speed depends on refresh rate. Multiply the increment by Clock.getDelta()"
+					});
+					return;
+				}
+				if (!isNodeOfType(candidate, "CallExpression")) return;
+				const factor = getFixedInterpolationFactor(candidate, context);
+				if (!factor || expressionUsesThreeClockDelta(factor, context)) return;
+				context.report({
+					node: factor,
+					message: "This fixed interpolation factor converges once per frame, so its speed changes with refresh rate. Derive the factor from Clock.getDelta() or use delta-aware damping"
+				});
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-require-instanced-buffer-update.ts
+const getInstancedBufferMutation = (node, context) => {
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return null;
+	const methodName = getStaticPropertyName(callee);
+	if (methodName !== "setMatrixAt" && methodName !== "setColorAt") return null;
+	if (getThreeConstructorName(callee.object, context.scopes) !== "InstancedMesh") return null;
+	const receiverKey = resolveExpressionKey$1(callee.object, context);
+	if (!receiverKey) return null;
+	return {
+		bufferPropertyName: methodName === "setMatrixAt" ? "instanceMatrix" : "instanceColor",
+		methodName,
+		node,
+		receiverKey
+	};
+};
+const getInstancedBufferCompletion = (node, context) => {
+	const assignedValue = stripParenExpression(node.right);
+	const needsUpdateMember = stripParenExpression(node.left);
+	if (node.operator !== "=" || !isNodeOfType(assignedValue, "Literal") || assignedValue.value !== true || !isNodeOfType(needsUpdateMember, "MemberExpression") || getStaticPropertyName(needsUpdateMember) !== "needsUpdate") return null;
+	const bufferMember = stripParenExpression(needsUpdateMember.object);
+	if (!isNodeOfType(bufferMember, "MemberExpression")) return null;
+	const bufferPropertyName = getStaticPropertyName(bufferMember);
+	if (bufferPropertyName !== "instanceMatrix" && bufferPropertyName !== "instanceColor") return null;
+	if (getThreeConstructorName(bufferMember.object, context.scopes) !== "InstancedMesh") return null;
+	const receiverKey = resolveExpressionKey$1(bufferMember.object, context);
+	return receiverKey ? {
+		bufferPropertyName,
+		node,
+		receiverKey
+	} : null;
+};
+const getOpaqueInstancedBufferCompletions = (node, context) => {
+	if (!isImportedOrStableParameterCall(node, context.scopes)) return [];
+	const completions = [];
+	for (const argument of node.arguments) {
+		if (isNodeOfType(argument, "SpreadElement")) continue;
+		const candidate = stripParenExpression(argument);
+		if (isNodeOfType(candidate, "MemberExpression")) {
+			const bufferPropertyName = getStaticPropertyName(candidate);
+			if ((bufferPropertyName === "instanceMatrix" || bufferPropertyName === "instanceColor") && getThreeConstructorName(candidate.object, context.scopes) === "InstancedMesh") {
+				const receiverKey = resolveExpressionKey$1(candidate.object, context);
+				if (receiverKey) completions.push({
+					bufferPropertyName,
+					node,
+					receiverKey
+				});
+				continue;
+			}
+		}
+		if (getThreeConstructorName(candidate, context.scopes) !== "InstancedMesh") continue;
+		const receiverKey = resolveExpressionKey$1(candidate, context);
+		if (!receiverKey) continue;
+		completions.push({
+			bufferPropertyName: "instanceMatrix",
+			node,
+			receiverKey
+		});
+		completions.push({
+			bufferPropertyName: "instanceColor",
+			node,
+			receiverKey
+		});
+	}
+	return completions;
+};
+const completionCoversMutation = (mutation, completions, program, context) => {
+	const owner = context.cfg.enclosingFunction(mutation.node);
+	const matchingCompletions = completions.filter((completion) => completion.receiverKey === mutation.receiverKey && completion.bufferPropertyName === mutation.bufferPropertyName && context.cfg.enclosingFunction(completion.node) === owner);
+	if (owner) return doNodesCoverEveryPathAfterNode(mutation.node, matchingCompletions.map((completion) => completion.node), context);
+	const mutationStart = getRangeStart(mutation.node);
+	return matchingCompletions.some((completion) => {
+		const completionStart = getRangeStart(completion.node);
+		return mutationStart !== null && completionStart !== null && completionStart > mutationStart && !isNodeConditionallyExecuted(completion.node, program);
+	});
+};
+const threeRequireInstancedBufferUpdate = defineRule({
+	id: "three-require-instanced-buffer-update",
+	title: "Three.js instanced mesh buffer is not marked for upload",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "After setMatrixAt or setColorAt, set the matching instance buffer's needsUpdate flag to true",
+	create: (context) => {
+		const mutations = [];
+		const completions = [];
+		let program = null;
+		return {
+			Program(node) {
+				program = node;
+			},
+			AssignmentExpression(node) {
+				const completion = getInstancedBufferCompletion(node, context);
+				if (completion) completions.push(completion);
+			},
+			CallExpression(node) {
+				const mutation = getInstancedBufferMutation(node, context);
+				if (mutation) {
+					mutations.push(mutation);
+					return;
+				}
+				completions.push(...getOpaqueInstancedBufferCompletions(node, context));
+			},
+			"Program:exit"() {
+				if (!program) return;
+				for (const mutation of mutations) {
+					if (completionCoversMutation(mutation, completions, program, context)) continue;
+					context.report({
+						node: mutation.node,
+						message: `After ${mutation.methodName}, set ${mutation.bufferPropertyName}.needsUpdate to true so Three.js uploads the changed instance data`
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-require-owned-geometry-cleanup.ts
+const threeRequireOwnedGeometryCleanup = defineRule({
+	id: "three-require-owned-geometry-cleanup",
+	title: "Locally owned Three.js geometry is not disposed",
+	category: "Performance",
+	severity: "warn",
+	recommendation: "Dispose locally constructed geometries when their React owner releases them",
+	create: (context) => createOwnedThreeResourceCleanupVisitors({
+		constructorNameSuffix: "Geometry",
+		context,
+		message: "This locally constructed Three.js geometry owns GPU buffers but has no provable React cleanup. Dispose it when the owning component or hook releases it"
+	})
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-require-owned-material-cleanup.ts
+const threeRequireOwnedMaterialCleanup = defineRule({
+	id: "three-require-owned-material-cleanup",
+	title: "Locally owned Three.js material is not disposed",
+	category: "Performance",
+	severity: "warn",
+	recommendation: "Dispose locally constructed materials when their React owner releases them",
+	create: (context) => createOwnedThreeResourceCleanupVisitors({
+		constructorNameSuffix: "Material",
+		context,
+		message: "This locally constructed Three.js material owns a GPU shader program but has no provable React cleanup. Dispose it when the owning component or hook releases it"
+	})
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-require-owned-texture-cleanup.ts
+const threeRequireOwnedTextureCleanup = defineRule({
+	id: "three-require-owned-texture-cleanup",
+	title: "Locally owned Three.js texture is not disposed",
+	category: "Performance",
+	severity: "warn",
+	disabledWhen: ["r3f"],
+	recommendation: "Dispose locally constructed textures when their React owner releases them",
+	create: r3fRequireOwnedTextureCleanup.create
+});
+//#endregion
 //#region src/plugin/rules/r3f/three-require-postprocessing-cleanup.ts
 const POSTPROCESSING_BORROWING_METHOD_NAMES = /* @__PURE__ */ new Set();
 const THREE_COMPOSER_BORROWING_METHOD_NAMES = new Set(["addPass", "insertPass"]);
@@ -114033,6 +114703,110 @@ const threeRequirePostprocessingCleanup = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/r3f/three-require-projection-matrix-update.ts
+const CAMERA_CONSTRUCTOR_NAMES = new Set(["OrthographicCamera", "PerspectiveCamera"]);
+const PROJECTION_PROPERTY_NAMES = new Set([
+	"aspect",
+	"bottom",
+	"far",
+	"filmGauge",
+	"filmOffset",
+	"fov",
+	"left",
+	"near",
+	"right",
+	"top",
+	"zoom"
+]);
+const getProjectionMutation = (node, context) => {
+	const target = isNodeOfType(node, "AssignmentExpression") ? stripParenExpression(node.left) : isNodeOfType(node, "UpdateExpression") ? stripParenExpression(node.argument) : null;
+	if (!target || !isNodeOfType(target, "MemberExpression") || !PROJECTION_PROPERTY_NAMES.has(getStaticPropertyName(target) ?? "") || !CAMERA_CONSTRUCTOR_NAMES.has(getThreeConstructorName(target.object, context.scopes) ?? "")) return null;
+	const receiverKey = resolveExpressionKey$1(target.object, context);
+	return receiverKey ? {
+		node,
+		receiverKey
+	} : null;
+};
+const getProjectionUpdate = (node, context) => {
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "MemberExpression") || getStaticPropertyName(callee) !== "updateProjectionMatrix" || !CAMERA_CONSTRUCTOR_NAMES.has(getThreeConstructorName(callee.object, context.scopes) ?? "")) return null;
+	const receiverKey = resolveExpressionKey$1(callee.object, context);
+	return receiverKey ? {
+		node,
+		receiverKey
+	} : null;
+};
+const getOpaqueProjectionUpdates = (node, context) => {
+	if (!isImportedOrStableParameterCall(node, context.scopes)) return [];
+	const updates = [];
+	for (const argument of node.arguments) {
+		if (isNodeOfType(argument, "SpreadElement") || !CAMERA_CONSTRUCTOR_NAMES.has(getThreeConstructorName(argument, context.scopes) ?? "")) continue;
+		const receiverKey = resolveExpressionKey$1(argument, context);
+		if (receiverKey) updates.push({
+			node,
+			receiverKey
+		});
+	}
+	return updates;
+};
+const moduleUpdateCoversMutation = (mutation, update, program) => {
+	const mutationStart = getRangeStart(mutation.node);
+	const updateStart = getRangeStart(update.node);
+	if (mutationStart === null || updateStart === null || updateStart <= mutationStart) return false;
+	if (!isNodeConditionallyExecuted(update.node, program)) return true;
+	const mutationRegions = getConditionalExecutionRegions(mutation.node, program);
+	return [...getConditionalExecutionRegions(update.node, program)].every((region) => mutationRegions.has(region));
+};
+const updateCoversMutation = (mutation, updates, program, context) => {
+	const owner = context.cfg.enclosingFunction(mutation.node);
+	const matchingUpdates = updates.filter((update) => update.receiverKey === mutation.receiverKey && context.cfg.enclosingFunction(update.node) === owner);
+	if (owner) return doNodesCoverEveryPathAfterNode(mutation.node, matchingUpdates.map((update) => update.node), context);
+	return matchingUpdates.some((update) => moduleUpdateCoversMutation(mutation, update, program));
+};
+const threeRequireProjectionMatrixUpdate = defineRule({
+	id: "three-require-projection-matrix-update",
+	title: "Missing Three.js camera projection-matrix update",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Call camera.updateProjectionMatrix() after changing projection properties so Three.js renders the new frustum",
+	create: (context) => {
+		const mutations = [];
+		const updates = [];
+		let program = null;
+		return {
+			Program(node) {
+				program = node;
+			},
+			AssignmentExpression(node) {
+				const mutation = getProjectionMutation(node, context);
+				if (mutation) mutations.push(mutation);
+			},
+			UpdateExpression(node) {
+				const mutation = getProjectionMutation(node, context);
+				if (mutation) mutations.push(mutation);
+			},
+			CallExpression(node) {
+				const update = getProjectionUpdate(node, context);
+				if (update) {
+					updates.push(update);
+					return;
+				}
+				updates.push(...getOpaqueProjectionUpdates(node, context));
+			},
+			"Program:exit"() {
+				if (!program) return;
+				for (const mutation of mutations) {
+					if (updateCoversMutation(mutation, updates, program, context)) continue;
+					context.report({
+						node: mutation.node,
+						message: "This camera projection property changes without a later updateProjectionMatrix() call on every path, so Three.js can keep rendering a stale projection matrix"
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
 //#region src/plugin/rules/r3f/three-require-render-target-cleanup.ts
 const RENDER_TARGET_CONSTRUCTORS = new Set([
 	"RenderTarget",
@@ -114045,7 +114819,6 @@ const RENDER_TARGET_BORROWING_METHODS = new Set([
 	"setRenderTarget",
 	"setRenderTargetTextures"
 ]);
-const isThreeModuleSource$1 = (moduleSource) => moduleSource === "three" || moduleSource === "three-stdlib" || moduleSource.startsWith("three/");
 const threeRequireRenderTargetCleanup = defineRule({
 	id: "three-require-render-target-cleanup",
 	title: "Undisposed Three.js render target",
@@ -114070,7 +114843,6 @@ const threeRequireRenderTargetCleanup = defineRule({
 //#endregion
 //#region src/plugin/rules/r3f/three-require-renderer-cleanup.ts
 const RENDERER_CONSTRUCTORS = new Set(["WebGLRenderer", "WebGPURenderer"]);
-const isThreeModuleSource = (moduleSource) => moduleSource === "three" || moduleSource === "three-stdlib" || moduleSource.startsWith("three/");
 const isNullArgument = (call) => {
 	const argument = call.arguments[0];
 	return Boolean(isNodeOfType(argument, "Literal") && argument.value === null);
@@ -114199,7 +114971,7 @@ const threeRequireRendererCleanup = defineRule({
 	recommendation: "Dispose component-owned renderers and stop their animation loop or animation frame in matching React cleanup",
 	create: (context) => ({ NewExpression(node) {
 		const provenance = getApiReferenceProvenance(node.callee, context.scopes);
-		if (!provenance || !RENDERER_CONSTRUCTORS.has(provenance.apiName) || !isThreeModuleSource(provenance.moduleSource)) return;
+		if (!provenance || !RENDERER_CONSTRUCTORS.has(provenance.apiName) || !isThreeModuleSource$1(provenance.moduleSource)) return;
 		const analysis = analyzeOwnedLifecycleResource(node, context, { isBorrowedReference: (reference) => isRetainedByUnusedLocalReactRef(reference, context.scopes) });
 		if (!analysis || analysis.hasUnknownOwnershipTransfer || isRendererSuppliedToR3fCanvas(analysis, context)) return;
 		const disposeCleanup = analyzeOwnedLifecycleCleanup(analysis, context, (cleanupFunction) => functionInvokesOwnedResourceMethod(cleanupFunction, analysis, "dispose", context.scopes));
@@ -114221,6 +114993,124 @@ const threeRequireRendererCleanup = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/r3f/three-tsl-no-js-uniform-branch.ts
+const TSL_MODULES = new Set(["three/tsl", "three/webgpu"]);
+const expressionReferencesTslUniformValue = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	let referencesUniformValue = false;
+	walkAst(expression, (candidate) => {
+		if (referencesUniformValue) return false;
+		if (isNodeOfType(candidate, "MemberExpression") && getStaticPropertyName(candidate) === "value" && resolvesToTslUniform(candidate.object, scopes)) {
+			referencesUniformValue = true;
+			return false;
+		}
+		if (!isNodeOfType(candidate, "Identifier")) return;
+		const symbol = scopes.symbolFor(candidate);
+		if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read")) return;
+		visitedSymbolIds.add(symbol.id);
+		if (expressionReferencesTslUniformValue(symbol.initializer, scopes, visitedSymbolIds)) {
+			referencesUniformValue = true;
+			return false;
+		}
+	});
+	return referencesUniformValue;
+};
+const threeTslNoJsUniformBranch = defineRule({
+	id: "three-tsl-no-js-uniform-branch",
+	title: "JavaScript branch reads a TSL uniform value",
+	category: "Correctness",
+	severity: "warn",
+	recommendation: "Express uniform-dependent shader control flow with TSL If, select, or Loop nodes so it runs on the GPU",
+	create: (context) => ({ CallExpression(node) {
+		if (!isApiCallFromModules(node, "Fn", TSL_MODULES, context.scopes)) return;
+		const callbackArgument = node.arguments[0];
+		if (!callbackArgument || isNodeOfType(callbackArgument, "SpreadElement")) return;
+		const callback = resolveExactLocalFunction(callbackArgument, context.scopes);
+		if (!isFunctionLike$1(callback)) return;
+		const reportedTests = /* @__PURE__ */ new Set();
+		walkFunctionExecution(callback, context.scopes, (candidate) => {
+			const controlFlowTest = getControlFlowTest(candidate);
+			if (!controlFlowTest || !expressionReferencesTslUniformValue(controlFlowTest, context.scopes)) return;
+			for (const reportedTest of reportedTests) if (isAstDescendant(controlFlowTest, reportedTest)) return;
+			reportedTests.add(controlFlowTest);
+			context.report({
+				node: controlFlowTest,
+				message: "This JavaScript branch reads a TSL uniform while the shader graph is built, so later uniform changes cannot change the branch. Use TSL control flow"
+			});
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/utils/program-constructs-three-webgpu-renderer.ts
+const programConstructsThreeWebgpuRenderer = (program, scopes) => {
+	let doesConstructRenderer = false;
+	walkAst(program, (candidate) => {
+		if (!doesConstructRenderer && isNodeOfType(candidate, "NewExpression") && getThreeConstructorName(candidate, scopes) === "WebGPURenderer") {
+			doesConstructRenderer = true;
+			return false;
+		}
+	});
+	return doesConstructRenderer;
+};
+//#endregion
+//#region src/plugin/rules/r3f/three-webgpu-no-legacy-effect-composer.ts
+const threeWebgpuNoLegacyEffectComposer = defineRule({
+	id: "three-webgpu-no-legacy-effect-composer",
+	title: "Legacy EffectComposer used with WebGPURenderer",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Use WebGPURenderer's node-based post-processing pipeline instead of the legacy WebGL EffectComposer",
+	create: (context) => {
+		let constructsWebgpuRenderer = false;
+		return {
+			Program(node) {
+				constructsWebgpuRenderer = programConstructsThreeWebgpuRenderer(node, context.scopes);
+			},
+			NewExpression(node) {
+				if (!constructsWebgpuRenderer || getThreeConstructorName(node, context.scopes) !== "EffectComposer") return;
+				context.report({
+					node,
+					message: "Legacy EffectComposer does not support Three.js WebGPURenderer. Build post-processing with the renderer's node-based pipeline"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-webgpu-no-legacy-material-api.ts
+const LEGACY_SHADER_MATERIAL_NAMES = new Set(["RawShaderMaterial", "ShaderMaterial"]);
+const threeWebgpuNoLegacyMaterialApi = defineRule({
+	id: "three-webgpu-no-legacy-material-api",
+	title: "Legacy material API used with WebGPURenderer",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Use Three.js node materials and TSL for custom shaders rendered by WebGPURenderer",
+	create: (context) => {
+		let constructsWebgpuRenderer = false;
+		return {
+			Program(node) {
+				constructsWebgpuRenderer = programConstructsThreeWebgpuRenderer(node, context.scopes);
+			},
+			NewExpression(node) {
+				const constructorName = getThreeConstructorName(node, context.scopes);
+				if (!constructsWebgpuRenderer || !constructorName) return;
+				if (!LEGACY_SHADER_MATERIAL_NAMES.has(constructorName)) return;
+				context.report({
+					node,
+					message: "ShaderMaterial and RawShaderMaterial are not supported by Three.js WebGPURenderer. Build this shader with a node material and TSL"
+				});
+			},
+			AssignmentExpression(node) {
+				if (!constructsWebgpuRenderer || !isNodeOfType(node.left, "MemberExpression") || getStaticPropertyName(node.left) !== "onBeforeCompile") return;
+				if (!getThreeConstructorName(node.left.object, context.scopes)?.endsWith("Material")) return;
+				context.report({
+					node,
+					message: "onBeforeCompile patches WebGL shader source and is not supported by Three.js WebGPURenderer. Use a node material and TSL"
+				});
+			}
+		};
+	}
+});
+//#endregion
 //#region src/plugin/rules/security-scan/unsafe-json-in-html.ts
 const SINK_JSON_STRINGIFY_PATTERNS = [/dangerouslySetInnerHTML\s*=\s*\{\{\s*__html\s*:[\s\S]{0,300}?\bJSON\.stringify\s*\(/gi, /<script\b[^>]*>(?:(?!<\/script>)[\s\S]){0,300}?\bJSON\.stringify\s*\(/gi];
 const INLINE_SCRIPT_PATTERN_INDEX = 1;
@@ -114978,6 +115868,44 @@ const webAnimationOffsetsValid = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/webgl/webgl-no-sync-readback-in-animation-loop.ts
+const getBlockingReadbackKind = (call, context) => {
+	if (!isNodeOfType(call.callee, "MemberExpression")) return null;
+	const methodName = getStaticPropertyName(call.callee);
+	if (methodName === "readRenderTargetPixels" && isThreeRendererReference(call.callee.object, context.scopes)) return "three";
+	if (!isWebglContextReference(call.callee.object, context.scopes)) return null;
+	if (methodName === "finish") return "finish";
+	let destinationArgumentIndex = null;
+	if (methodName === "readPixels") destinationArgumentIndex = 6;
+	else if (methodName === "getBufferSubData") destinationArgumentIndex = 2;
+	if (destinationArgumentIndex === null) return null;
+	const destination = call.arguments[destinationArgumentIndex];
+	return destination && !isNodeOfType(destination, "SpreadElement") && isCpuTypedArray(destination, context.scopes) ? "raw" : null;
+};
+const webglNoSyncReadbackInAnimationLoop = defineRule({
+	id: "webgl-no-sync-readback-in-animation-loop",
+	title: "Synchronous GPU readback inside animation loop",
+	severity: "warn",
+	recommendation: "Move GPU readback to a discrete or asynchronous path and reuse the latest completed result during frames",
+	create: (context) => {
+		const analyzedCallbacks = /* @__PURE__ */ new Set();
+		return { CallExpression(node) {
+			const callback = resolveThreeAnimationLoopCallback(node, context.scopes) ?? resolveRecursiveAnimationFrameCallback(node, context.scopes);
+			if (!callback || analyzedCallbacks.has(callback)) return;
+			analyzedCallbacks.add(callback);
+			walkFunctionExecution(callback, context.scopes, (candidate, isConditionallyExecuted) => {
+				if (!isNodeOfType(candidate, "CallExpression") || isConditionallyExecuted) return;
+				const readbackKind = getBlockingReadbackKind(candidate, context);
+				if (!readbackKind) return;
+				context.report({
+					node: candidate,
+					message: readbackKind === "finish" ? "finish blocks the calling thread until queued GPU work completes. Synchronize outside the animation loop" : "Synchronous GPU readback can stall the frame until prior GPU work completes. Use an asynchronous or event-driven readback path"
+				});
+			});
+		} };
+	}
+});
+//#endregion
 //#region src/plugin/rules/security-scan/webhook-signature-risk.ts
 const WEBHOOK_HANDLER_PATTERN = /(?:^|\/)[^/]*webhook[^/]*\/|(?:^|\/)[^/]*webhook[^/]*\.[cm]?[jt]s$|\bwebhook\b/i;
 const WEBHOOK_ENTRYPOINT_PATTERN = /\b(?:export\s+(?:async\s+)?function\s+POST|export\s+const\s+(?:POST|handler|webhook)|webhookHandler|webhookRoute)\b/i;
@@ -126797,6 +127725,171 @@ const reactDoctorRules = [
 			tags: [...new Set(["security-scan", ...tenantStaticProxyRisk.tags ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/three-cap-device-pixel-ratio",
+		id: "three-cap-device-pixel-ratio",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeCapDevicePixelRatio,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeCapDevicePixelRatio.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeCapDevicePixelRatio.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-limit-shadowed-point-lights",
+		id: "three-limit-shadowed-point-lights",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeLimitShadowedPointLights,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeLimitShadowedPointLights.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeLimitShadowedPointLights.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-no-allocation-in-pointer-move",
+		id: "three-no-allocation-in-pointer-move",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeNoAllocationInPointerMove,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeNoAllocationInPointerMove.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeNoAllocationInPointerMove.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-no-async-animation-loop",
+		id: "three-no-async-animation-loop",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeNoAsyncAnimationLoop,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeNoAsyncAnimationLoop.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeNoAsyncAnimationLoop.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-no-clone-in-animation-loop",
+		id: "three-no-clone-in-animation-loop",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeNoCloneInAnimationLoop,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeNoCloneInAnimationLoop.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeNoCloneInAnimationLoop.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-no-new-in-animation-loop",
+		id: "three-no-new-in-animation-loop",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeNoNewInAnimationLoop,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeNoNewInAnimationLoop.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeNoNewInAnimationLoop.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-no-object-construction-in-render",
+		id: "three-no-object-construction-in-render",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeNoObjectConstructionInRender,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeNoObjectConstructionInRender.tags ?? []
+			])],
+			requires: [...new Set([
+				"react",
+				"three",
+				...threeNoObjectConstructionInRender.requires ?? []
+			])]
+		}
+	},
+	{
+		key: "react-doctor/three-no-state-in-animation-loop",
+		id: "three-no-state-in-animation-loop",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeNoStateInAnimationLoop,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeNoStateInAnimationLoop.tags ?? []
+			])],
+			requires: [...new Set([
+				"react",
+				"three",
+				...threeNoStateInAnimationLoop.requires ?? []
+			])]
+		}
+	},
+	{
+		key: "react-doctor/three-no-state-in-pointer-move",
+		id: "three-no-state-in-pointer-move",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeNoStateInPointerMove,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeNoStateInPointerMove.tags ?? []
+			])],
+			requires: [...new Set([
+				"react",
+				"three",
+				...threeNoStateInPointerMove.requires ?? []
+			])]
+		}
+	},
 	{
 		key: "react-doctor/three-require-animation-mixer-cleanup",
 		id: "three-require-animation-mixer-cleanup",
@@ -126807,7 +127900,7 @@ const reactDoctorRules = [
 			framework: "global",
 			category: "Bugs",
 			tags: [...new Set([
-				"r3f",
+				"three",
 				"webgl",
 				...threeRequireAnimationMixerCleanup.tags ?? []
 			])],
@@ -126828,7 +127921,7 @@ const reactDoctorRules = [
 			framework: "global",
 			category: "Bugs",
 			tags: [...new Set([
-				"r3f",
+				"three",
 				"webgl",
 				...threeRequireControlsCleanup.tags ?? []
 			])],
@@ -126839,6 +127932,103 @@ const reactDoctorRules = [
 			])]
 		}
 	},
+	{
+		key: "react-doctor/three-require-frame-delta",
+		id: "three-require-frame-delta",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeRequireFrameDelta,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeRequireFrameDelta.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeRequireFrameDelta.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-require-instanced-buffer-update",
+		id: "three-require-instanced-buffer-update",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeRequireInstancedBufferUpdate,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeRequireInstancedBufferUpdate.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeRequireInstancedBufferUpdate.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-require-owned-geometry-cleanup",
+		id: "three-require-owned-geometry-cleanup",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeRequireOwnedGeometryCleanup,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeRequireOwnedGeometryCleanup.tags ?? []
+			])],
+			requires: [...new Set([
+				"react",
+				"three",
+				...threeRequireOwnedGeometryCleanup.requires ?? []
+			])]
+		}
+	},
+	{
+		key: "react-doctor/three-require-owned-material-cleanup",
+		id: "three-require-owned-material-cleanup",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeRequireOwnedMaterialCleanup,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeRequireOwnedMaterialCleanup.tags ?? []
+			])],
+			requires: [...new Set([
+				"react",
+				"three",
+				...threeRequireOwnedMaterialCleanup.requires ?? []
+			])]
+		}
+	},
+	{
+		key: "react-doctor/three-require-owned-texture-cleanup",
+		id: "three-require-owned-texture-cleanup",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeRequireOwnedTextureCleanup,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeRequireOwnedTextureCleanup.tags ?? []
+			])],
+			requires: [...new Set([
+				"react",
+				"three",
+				...threeRequireOwnedTextureCleanup.requires ?? []
+			])]
+		}
+	},
 	{
 		key: "react-doctor/three-require-postprocessing-cleanup",
 		id: "three-require-postprocessing-cleanup",
@@ -126849,7 +128039,7 @@ const reactDoctorRules = [
 			framework: "global",
 			category: "Bugs",
 			tags: [...new Set([
-				"r3f",
+				"three",
 				"webgl",
 				...threeRequirePostprocessingCleanup.tags ?? []
 			])],
@@ -126860,6 +128050,23 @@ const reactDoctorRules = [
 			])]
 		}
 	},
+	{
+		key: "react-doctor/three-require-projection-matrix-update",
+		id: "three-require-projection-matrix-update",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeRequireProjectionMatrixUpdate,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeRequireProjectionMatrixUpdate.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeRequireProjectionMatrixUpdate.requires ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/three-require-render-target-cleanup",
 		id: "three-require-render-target-cleanup",
@@ -126870,7 +128077,7 @@ const reactDoctorRules = [
 			framework: "global",
 			category: "Bugs",
 			tags: [...new Set([
-				"r3f",
+				"three",
 				"webgl",
 				...threeRequireRenderTargetCleanup.tags ?? []
 			])],
@@ -126891,7 +128098,7 @@ const reactDoctorRules = [
 			framework: "global",
 			category: "Bugs",
 			tags: [...new Set([
-				"r3f",
+				"three",
 				"webgl",
 				...threeRequireRendererCleanup.tags ?? []
 			])],
@@ -126902,6 +128109,57 @@ const reactDoctorRules = [
 			])]
 		}
 	},
+	{
+		key: "react-doctor/three-tsl-no-js-uniform-branch",
+		id: "three-tsl-no-js-uniform-branch",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeTslNoJsUniformBranch,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeTslNoJsUniformBranch.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeTslNoJsUniformBranch.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-webgpu-no-legacy-effect-composer",
+		id: "three-webgpu-no-legacy-effect-composer",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeWebgpuNoLegacyEffectComposer,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeWebgpuNoLegacyEffectComposer.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeWebgpuNoLegacyEffectComposer.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-webgpu-no-legacy-material-api",
+		id: "three-webgpu-no-legacy-material-api",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeWebgpuNoLegacyMaterialApi,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeWebgpuNoLegacyMaterialApi.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeWebgpuNoLegacyMaterialApi.requires ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/unsafe-json-in-html",
 		id: "unsafe-json-in-html",
@@ -127007,6 +128265,18 @@ const reactDoctorRules = [
 			category: "Bugs"
 		}
 	},
+	{
+		key: "react-doctor/webgl-no-sync-readback-in-animation-loop",
+		id: "webgl-no-sync-readback-in-animation-loop",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...webglNoSyncReadbackInAnimationLoop,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set(["webgl", ...webglNoSyncReadbackInAnimationLoop.tags ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/webhook-signature-risk",
 		id: "webhook-signature-risk",