oxlint-plugin-react-doctor 0.9.1-dev.6904ff1 → 0.9.1-dev.846c2df

package/dist/index.js

@@ -4,6 +4,8 @@ import { parseSync, visitorKeys } from "oxc-parser";
 import * as fs from "node:fs";
 import { readFileSync } from "node:fs";
 import { analyze } from "eslint-scope";
+import { visit } from "@shaderfrog/glsl-parser/ast/index.js";
+import { parse } from "@shaderfrog/glsl-parser/index.js";
 //#region src/plugin/utils/is-node-of-type.ts
 const isNodeOfType = (node, type) => node !== null && typeof node === "object" && "type" in node && node.type === type;
 //#endregion
@@ -22875,10 +22877,10 @@ const hasBroaderDeclaredDependency = (declaredKey, declaredKeys) => {
 	for (const otherDeclaredKey of declaredKeys) if (otherDeclaredKey !== declaredKey && declaredKey.startsWith(`${otherDeclaredKey}.`)) return true;
 	return false;
 };
-const getMemberRootIdentifier$1 = (node) => {
+const getMemberRootIdentifier$2 = (node) => {
 	const stripped = unwrapExpression$3(node);
 	if (isNodeOfType(stripped, "Identifier")) return stripped;
-	if (isNodeOfType(stripped, "MemberExpression")) return getMemberRootIdentifier$1(stripped.object);
+	if (isNodeOfType(stripped, "MemberExpression")) return getMemberRootIdentifier$2(stripped.object);
 	return null;
 };
 const hasComputedMemberExpression = (node) => {
@@ -22915,7 +22917,7 @@ const resolveIdentitySourceKeysFromExpression = (expression, scopes, visitedSymb
 	if (isNodeOfType(stripped, "MemberExpression")) {
 		if (hasComputedMemberExpression(stripped)) return null;
 		const sourceKey = stringifyMemberChain(stripped);
-		const rootIdentifier = getMemberRootIdentifier$1(stripped);
+		const rootIdentifier = getMemberRootIdentifier$2(stripped);
 		const rootSymbol = rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
 		if (!sourceKey || !rootSymbol) return null;
 		if (isOutsideAllFunctions(rootSymbol)) return /* @__PURE__ */ new Set();
@@ -23009,7 +23011,7 @@ const resolveDerivedExpressionSourceKeys = (expression, scopes, visitedSymbolIds
 	if (isNodeOfType(candidate, "MemberExpression")) {
 		if (hasComputedMemberExpression(candidate)) return null;
 		const sourceKey = stringifyMemberChain(candidate);
-		const rootIdentifier = getMemberRootIdentifier$1(candidate);
+		const rootIdentifier = getMemberRootIdentifier$2(candidate);
 		const rootSymbol = rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
 		if (!sourceKey || !rootSymbol) return null;
 		if (isOutsideAllFunctions(rootSymbol) || symbolHasStableValue(rootSymbol, scopes)) return /* @__PURE__ */ new Set();
@@ -23096,14 +23098,14 @@ const isUseCallbackResultDep = (node, scopes) => {
 	return Boolean(initializer && isNodeOfType(initializer, "CallExpression") && getHookName(initializer.callee, scopes) === "useCallback");
 };
 const isExtraReactiveDepAllowed = (node, scopes) => {
-	const rootIdentifier = getMemberRootIdentifier$1(node);
+	const rootIdentifier = getMemberRootIdentifier$2(node);
 	if (!rootIdentifier) return false;
 	const symbol = scopes.symbolFor(rootIdentifier);
 	if (!symbol || isOutsideAllFunctions(symbol)) return false;
 	return !isUseCallbackResultDep(node, scopes);
 };
 const getRootSymbol = (node, scopes) => {
-	const rootIdentifier = getMemberRootIdentifier$1(node);
+	const rootIdentifier = getMemberRootIdentifier$2(node);
 	return rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
 };
 const getDeclaredDepSymbolSource = (node) => {
@@ -23392,7 +23394,7 @@ const findRefCurrentInCleanup = (callback, scopes) => {
 		if (isNodeOfType(node, "MemberExpression")) {
 			const candidateName = getRefCurrentNameFromMemberExpression(node);
 			if (candidateName) {
-				const rootIdentifier = getMemberRootIdentifier$1(node);
+				const rootIdentifier = getMemberRootIdentifier$2(node);
 				const symbol = rootIdentifier ? scopes.symbolFor(rootIdentifier) : null;
 				const callbackScope = scopes.ownScopeFor(callback) ?? scopes.scopeFor(callback);
 				if (!symbol || !isDescendantScope(symbol.scope, callbackScope)) {
@@ -23465,7 +23467,7 @@ const hasRefCurrentAssignment = (callback, refCurrentName) => {
 	return didAssignRefCurrent;
 };
 const isOuterFunctionScopeDep = (node, callback, scopes) => {
-	const rootIdentifier = getMemberRootIdentifier$1(node);
+	const rootIdentifier = getMemberRootIdentifier$2(node);
 	if (!rootIdentifier) return false;
 	const symbol = scopes.symbolFor(rootIdentifier);
 	if (!symbol || isOutsideAllFunctions(symbol)) return false;
@@ -98683,6 +98685,20 @@ const THREE_INTERPOLATION_FACTOR_ARGUMENT_BY_METHOD = new Map([
 	["slerp", 1],
 	["slerpQuaternions", 2]
 ]);
+const GLSL_POSITION_COMPONENT_BIT_BY_ALIAS = new Map([
+	["x", 1],
+	["r", 1],
+	["s", 1],
+	["y", 2],
+	["g", 2],
+	["t", 2],
+	["z", 4],
+	["b", 4],
+	["p", 4],
+	["w", 8],
+	["a", 8],
+	["q", 8]
+]);
 const THREE_POSTPROCESSING_PASS_DISPOSAL_RELEASES = new Map([
 	["RenderPixelatedPass", 147],
 	["OutputPass", 153],
@@ -98690,6 +98706,73 @@ const THREE_POSTPROCESSING_PASS_DISPOSAL_RELEASES = new Map([
 	["RenderTransitionPass", 164],
 	["FXAAPass", 177]
 ]);
+const THREE_RENDERER_MANAGED_SHADER_UNIFORM_NAMES = new Set([
+	"ambientLightColor",
+	"bindMatrix",
+	"bindMatrixInverse",
+	"boneTexture",
+	"boneTextureSize",
+	"cameraPosition",
+	"clippingPlanes",
+	"directionalLights",
+	"directionalLightShadows",
+	"directionalShadowMap",
+	"directionalShadowMatrix",
+	"fogColor",
+	"fogDensity",
+	"fogFar",
+	"fogNear",
+	"hemisphereLights",
+	"isOrthographic",
+	"lightProbe",
+	"logDepthBufFC",
+	"ltc_1",
+	"ltc_2",
+	"modelMatrix",
+	"modelViewMatrix",
+	"morphTargetBaseInfluence",
+	"morphTargetInfluences",
+	"morphTargetsTexture",
+	"morphTargetsTextureSize",
+	"normalMatrix",
+	"pointLights",
+	"pointLightShadows",
+	"pointShadowMap",
+	"pointShadowMatrix",
+	"probesMax",
+	"probesMin",
+	"probesResolution",
+	"probesSH",
+	"projectionMatrix",
+	"receiveShadow",
+	"rectAreaLights",
+	"spotLightMap",
+	"spotLightMatrix",
+	"spotLights",
+	"spotLightShadows",
+	"spotShadowMap",
+	"toneMappingExposure",
+	"transmissionSamplerMap",
+	"transmissionSamplerSize",
+	"viewMatrix"
+]);
+const THREE_SHADER_MATERIAL_INJECTED_FRAGMENT_NAMES = new Set([
+	"cameraPosition",
+	"isOrthographic",
+	"viewMatrix"
+]);
+const THREE_SHADER_MATERIAL_INJECTED_VERTEX_NAMES = new Set([
+	"cameraPosition",
+	"isOrthographic",
+	"modelMatrix",
+	"modelViewMatrix",
+	"normal",
+	"normalMatrix",
+	"position",
+	"projectionMatrix",
+	"uv",
+	"viewMatrix"
+]);
 //#endregion
 //#region src/plugin/rules/r3f/r3f-limit-shadowed-point-lights.ts
 const resolvesToTrue = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
@@ -121827,9 +121910,9 @@ const getJsxMemberRootIdentifier = (node) => {
 	return null;
 };
 const getJsxMemberPropertyName = (node) => isNodeOfType(node.property, "JSXIdentifier") ? node.property.name : null;
-const getMemberRootIdentifier = (node) => {
+const getMemberRootIdentifier$1 = (node) => {
 	if (isNodeOfType(node.object, "Identifier")) return node.object;
-	if (isNodeOfType(node.object, "MemberExpression")) return getMemberRootIdentifier(node.object);
+	if (isNodeOfType(node.object, "MemberExpression")) return getMemberRootIdentifier$1(node.object);
 	return null;
 };
 const getMemberPropertyName = (node) => isNodeOfType(node.property, "Identifier") ? node.property.name : null;
@@ -121934,7 +122017,7 @@ const tanstackStartMissingScripts = defineRule({
 				return didCollectAlias;
 			}
 			if (!isNodeOfType(node.init, "MemberExpression")) return false;
-			const rootIdentifier = getMemberRootIdentifier(node.init);
+			const rootIdentifier = getMemberRootIdentifier$1(node.init);
 			const rootDeclaration = rootIdentifier ? getBindingDeclaration(rootIdentifier, context) : null;
 			const propertyName = getMemberPropertyName(node.init);
 			if (!rootDeclaration || !tanstackRouterNamespaceDeclarations.has(rootDeclaration)) return false;
@@ -121968,7 +122051,7 @@ const tanstackStartMissingScripts = defineRule({
 				return factoryDeclaration ? rootRouteFactoryDeclarations.has(factoryDeclaration) : TANSTACK_ROOT_ROUTE_FACTORY_NAMES.has(callee.name);
 			}
 			if (!isNodeOfType(callee, "MemberExpression")) return false;
-			const rootIdentifier = getMemberRootIdentifier(callee);
+			const rootIdentifier = getMemberRootIdentifier$1(callee);
 			const rootDeclaration = rootIdentifier ? getBindingDeclaration(rootIdentifier, context) : null;
 			const propertyName = getMemberPropertyName(callee);
 			return Boolean(rootDeclaration && tanstackRouterNamespaceDeclarations.has(rootDeclaration) && propertyName && TANSTACK_ROOT_ROUTE_FACTORY_NAMES.has(propertyName));
@@ -122791,6 +122874,47 @@ const threeNoCloneInAnimationLoop = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/r3f/utils/visit-three-animation-loop-enabled-property-writes.ts
+const visitThreeAnimationLoopEnabledPropertyWrites = (call, scopes, propertyNames, analyzedCallbacks, visitor) => {
+	const callback = resolveThreeAnimationLoopCallback(call, scopes);
+	if (!callback || analyzedCallbacks.has(callback)) return;
+	analyzedCallbacks.add(callback);
+	walkFunctionExecution(callback, scopes, (candidate, isConditionallyExecuted) => {
+		if (isConditionallyExecuted || !isNodeOfType(candidate, "AssignmentExpression") || candidate.operator !== "=" || !isNodeOfType(candidate.left, "MemberExpression") || !isNodeOfType(candidate.right, "Literal") || candidate.right.value !== true) return;
+		const propertyName = getStaticPropertyName(candidate.left);
+		if (!propertyName || !propertyNames.has(propertyName)) return;
+		const constructorName = getThreeConstructorName(candidate.left.object, scopes);
+		if (!constructorName) return;
+		visitor({
+			constructorName,
+			node: candidate,
+			propertyName
+		});
+	});
+};
+//#endregion
+//#region src/plugin/rules/r3f/three-no-material-recompile-in-animation-loop.ts
+const MATERIAL_RECOMPILE_PROPERTY_NAMES = new Set(["needsUpdate"]);
+const threeNoMaterialRecompileInAnimationLoop = defineRule({
+	id: "three-no-material-recompile-in-animation-loop",
+	title: "Material recompiled inside animation loop",
+	category: "Performance",
+	severity: "error",
+	recommendation: "Change material defines or features outside the animation loop and set needsUpdate only when the compiled program must change",
+	create: (context) => {
+		const analyzedCallbacks = /* @__PURE__ */ new Set();
+		return { CallExpression(node) {
+			visitThreeAnimationLoopEnabledPropertyWrites(node, context.scopes, MATERIAL_RECOMPILE_PROPERTY_NAMES, analyzedCallbacks, ({ constructorName, node: assignment }) => {
+				if (!constructorName.endsWith("Material")) return;
+				context.report({
+					node: assignment,
+					message: "Setting material.needsUpdate every frame forces Three.js to reconsider and often rebuild the GPU program. Set it only after a shader-affecting material change"
+				});
+			});
+		} };
+	}
+});
+//#endregion
 //#region src/plugin/rules/r3f/three-no-new-in-animation-loop.ts
 const threeNoNewInAnimationLoop = defineRule({
 	id: "three-no-new-in-animation-loop",
@@ -122840,6 +122964,28 @@ const threeNoObjectConstructionInRender = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/r3f/three-no-redundant-uniforms-need-update.ts
+const UNIFORM_UPDATE_PROPERTY_NAMES = new Set(["uniformsNeedUpdate"]);
+const threeNoRedundantUniformsNeedUpdate = defineRule({
+	id: "three-no-redundant-uniforms-need-update",
+	title: "Redundant uniformsNeedUpdate inside animation loop",
+	category: "Performance",
+	severity: "warn",
+	recommendation: "Mutate ShaderMaterial uniform values directly; Three.js uploads custom uniforms during rendering",
+	create: (context) => {
+		const analyzedCallbacks = /* @__PURE__ */ new Set();
+		return { CallExpression(node) {
+			visitThreeAnimationLoopEnabledPropertyWrites(node, context.scopes, UNIFORM_UPDATE_PROPERTY_NAMES, analyzedCallbacks, ({ constructorName, node: assignment }) => {
+				if (constructorName !== "ShaderMaterial" && constructorName !== "RawShaderMaterial") return;
+				context.report({
+					node: assignment,
+					message: "Shader material custom uniforms are refreshed during rendering, so setting uniformsNeedUpdate on every animation frame is redundant"
+				});
+			});
+		} };
+	}
+});
+//#endregion
 //#region src/plugin/rules/r3f/three-no-state-in-animation-loop.ts
 const threeNoStateInAnimationLoop = defineRule({
 	id: "three-no-state-in-animation-loop",
@@ -122894,6 +123040,631 @@ const threeNoStateInPointerMove = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/rules/r3f/three-on-before-compile-require-program-cache-key.ts
+const SHADER_PROGRAM_PROPERTY_NAMES = new Set([
+	"defines",
+	"fragmentShader",
+	"vertexShader"
+]);
+const MATERIAL_PROGRAM_OPTION_NAMES = ["customProgramCacheKey", "onBeforeCompile"];
+const isScopeWithin$1 = (candidateScope, ancestorScope) => {
+	let currentScope = candidateScope;
+	while (currentScope) {
+		if (currentScope === ancestorScope) return true;
+		currentScope = currentScope.parent;
+	}
+	return false;
+};
+const getMemberRootIdentifier = (expression) => {
+	let candidate = expression;
+	while (isNodeOfType(candidate, "MemberExpression")) candidate = candidate.object;
+	return isNodeOfType(candidate, "Identifier") ? candidate : null;
+};
+const getShaderProgramPropertyName = (member, shaderParameterSymbol, context) => {
+	const rootIdentifier = getMemberRootIdentifier(member);
+	if (!rootIdentifier || context.scopes.symbolFor(rootIdentifier)?.id !== shaderParameterSymbol.id) return null;
+	let candidate = member;
+	let propertyName = null;
+	while (isNodeOfType(candidate, "MemberExpression")) {
+		propertyName = getStaticPropertyName(candidate);
+		if (isNodeOfType(candidate.object, "Identifier")) break;
+		candidate = candidate.object;
+	}
+	return propertyName && SHADER_PROGRAM_PROPERTY_NAMES.has(propertyName) ? propertyName : null;
+};
+const expressionDependsOnMutableCapture = (expression, callbackScope, context) => {
+	const visitedLocalSymbolIds = /* @__PURE__ */ new Set();
+	const inspectExpression = (expressionToInspect) => {
+		let dependsOnMutableCapture = false;
+		walkAst(expressionToInspect, (candidate) => {
+			if (dependsOnMutableCapture || candidate !== expressionToInspect && isFunctionLike$1(candidate)) return false;
+			if (isNodeOfType(candidate, "ThisExpression")) {
+				dependsOnMutableCapture = true;
+				return false;
+			}
+			if (isNodeOfType(candidate, "MemberExpression")) {
+				const rootIdentifier = getMemberRootIdentifier(candidate);
+				const symbol = rootIdentifier ? context.scopes.symbolFor(rootIdentifier) : null;
+				if (symbol && !isScopeWithin$1(symbol.scope, callbackScope) && symbol.kind !== "import" && symbol.kind !== "function" && symbol.kind !== "class") {
+					dependsOnMutableCapture = true;
+					return false;
+				}
+			}
+			if (!isNodeOfType(candidate, "Identifier")) return;
+			const symbol = context.scopes.symbolFor(candidate);
+			const hasMutableConstInitializer = symbol?.kind === "const" && Boolean(symbol.initializer && (isNodeOfType(symbol.initializer, "ArrayExpression") || isNodeOfType(symbol.initializer, "ObjectExpression") || isNodeOfType(symbol.initializer, "NewExpression")));
+			if (symbol && !isScopeWithin$1(symbol.scope, callbackScope) && (symbol.kind === "let" || symbol.kind === "var" || symbol.kind === "parameter" || hasMutableConstInitializer)) {
+				dependsOnMutableCapture = true;
+				return false;
+			}
+			if (!symbol || !isScopeWithin$1(symbol.scope, callbackScope) || visitedLocalSymbolIds.has(symbol.id)) return;
+			const initializer = getDirectUnreassignedInitializer(symbol);
+			if (!initializer || isFunctionLike$1(initializer) || isNodeOfType(initializer, "ArrayExpression") || isNodeOfType(initializer, "ObjectExpression") || isNodeOfType(initializer, "NewExpression")) return;
+			visitedLocalSymbolIds.add(symbol.id);
+			if (inspectExpression(initializer)) {
+				dependsOnMutableCapture = true;
+				return false;
+			}
+		});
+		return dependsOnMutableCapture;
+	};
+	return inspectExpression(expression);
+};
+const callbackHasVariantDependentPatch = (callback, context) => {
+	const callbackScope = context.scopes.ownScopeFor(callback);
+	if (!callbackScope || !isFunctionLike$1(callback)) return false;
+	const shaderParameter = callback.params[0];
+	if (!shaderParameter || !isNodeOfType(shaderParameter, "Identifier")) return false;
+	const shaderParameterSymbol = context.scopes.symbolFor(shaderParameter);
+	if (!shaderParameterSymbol) return false;
+	const subtreeHasShaderProgramWrite = (subtree) => {
+		let hasWrite = false;
+		walkAst(subtree, (candidate) => {
+			if (hasWrite || candidate !== subtree && isFunctionLike$1(candidate)) return false;
+			if (isNodeOfType(candidate, "AssignmentExpression") && isNodeOfType(candidate.left, "MemberExpression") && getShaderProgramPropertyName(candidate.left, shaderParameterSymbol, context)) {
+				hasWrite = true;
+				return false;
+			}
+		});
+		return hasWrite;
+	};
+	let hasVariantDependentPatch = false;
+	walkAst(callback.body, (candidate) => {
+		if (hasVariantDependentPatch || candidate !== callback.body && isFunctionLike$1(candidate)) return false;
+		if (isNodeOfType(candidate, "AssignmentExpression") && isNodeOfType(candidate.left, "MemberExpression") && getShaderProgramPropertyName(candidate.left, shaderParameterSymbol, context) && expressionDependsOnMutableCapture(candidate.right, callbackScope, context)) {
+			hasVariantDependentPatch = true;
+			return false;
+		}
+		if (isNodeOfType(candidate, "IfStatement") && expressionDependsOnMutableCapture(candidate.test, callbackScope, context) && (subtreeHasShaderProgramWrite(candidate.consequent) || Boolean(candidate.alternate && subtreeHasShaderProgramWrite(candidate.alternate)))) {
+			hasVariantDependentPatch = true;
+			return false;
+		}
+		if (isNodeOfType(candidate, "ConditionalExpression") && expressionDependsOnMutableCapture(candidate.test, callbackScope, context) && (subtreeHasShaderProgramWrite(candidate.consequent) || subtreeHasShaderProgramWrite(candidate.alternate))) {
+			hasVariantDependentPatch = true;
+			return false;
+		}
+		if (isNodeOfType(candidate, "LogicalExpression") && expressionDependsOnMutableCapture(candidate.left, callbackScope, context) && subtreeHasShaderProgramWrite(candidate.right)) {
+			hasVariantDependentPatch = true;
+			return false;
+		}
+		if (isNodeOfType(candidate, "SwitchStatement") && (expressionDependsOnMutableCapture(candidate.discriminant, callbackScope, context) || candidate.cases.some((switchCase) => switchCase.test && expressionDependsOnMutableCapture(switchCase.test, callbackScope, context))) && candidate.cases.some((switchCase) => switchCase.consequent.some(subtreeHasShaderProgramWrite))) {
+			hasVariantDependentPatch = true;
+			return false;
+		}
+		if ((isNodeOfType(candidate, "WhileStatement") || isNodeOfType(candidate, "DoWhileStatement")) && expressionDependsOnMutableCapture(candidate.test, callbackScope, context) && subtreeHasShaderProgramWrite(candidate.body)) {
+			hasVariantDependentPatch = true;
+			return false;
+		}
+		if (isNodeOfType(candidate, "ForStatement") && candidate.test && expressionDependsOnMutableCapture(candidate.test, callbackScope, context) && subtreeHasShaderProgramWrite(candidate.body)) {
+			hasVariantDependentPatch = true;
+			return false;
+		}
+		if ((isNodeOfType(candidate, "ForInStatement") || isNodeOfType(candidate, "ForOfStatement")) && expressionDependsOnMutableCapture(candidate.right, callbackScope, context) && subtreeHasShaderProgramWrite(candidate.body)) {
+			hasVariantDependentPatch = true;
+			return false;
+		}
+	});
+	return hasVariantDependentPatch;
+};
+const getStableMaterialSymbol = (expression, context) => {
+	if (!isNodeOfType(expression, "Identifier")) return null;
+	const symbol = context.scopes.symbolFor(expression);
+	const initializer = symbol ? getDirectUnreassignedInitializer(symbol) : null;
+	if (!symbol || !initializer || !getThreeConstructorName(initializer, context.scopes)?.endsWith("Material")) return null;
+	return symbol;
+};
+const getConstructorMaterialSymbol = (node, context) => {
+	const parent = node.parent;
+	if (!isNodeOfType(parent, "VariableDeclarator") || parent.init !== node || !isNodeOfType(parent.id, "Identifier")) return null;
+	const symbol = context.scopes.symbolFor(parent.id);
+	return symbol && getDirectUnreassignedInitializer(symbol) === node ? symbol : null;
+};
+const isUsableProgramCacheKey = (expression, context) => {
+	if (resolveExactLocalFunction(expression, context.scopes)) return true;
+	let candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Identifier")) {
+		if (candidate.name === "undefined" && context.scopes.isGlobalReference(candidate)) return false;
+		const symbol = resolveConstIdentifierAlias(candidate, context.scopes);
+		if (symbol?.kind !== "const" || !symbol.initializer) return true;
+		candidate = stripParenExpression(symbol.initializer);
+	}
+	return !(isNodeOfType(candidate, "ArrayExpression") || isNodeOfType(candidate, "ClassExpression") || isNodeOfType(candidate, "Literal") || isNodeOfType(candidate, "ObjectExpression") || isNodeOfType(candidate, "TemplateLiteral") || isNodeOfType(candidate, "UnaryExpression"));
+};
+const threeOnBeforeCompileRequireProgramCacheKey = defineRule({
+	id: "three-on-before-compile-require-program-cache-key",
+	title: "onBeforeCompile variant lacks a program cache key",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Return every mutable shader-patch variant from customProgramCacheKey on the same material",
+	create: (context) => {
+		const candidates = [];
+		const materialSymbolsWithCacheKeys = /* @__PURE__ */ new Set();
+		return {
+			NewExpression(node) {
+				if (!getThreeConstructorName(node, context.scopes)?.endsWith("Material")) return;
+				const options = node.arguments[0];
+				if (!options || isNodeOfType(options, "SpreadElement")) return;
+				const optionsObject = resolveStableOptionsObject(options, MATERIAL_PROGRAM_OPTION_NAMES, context.scopes, node);
+				if (!optionsObject) return;
+				const properties = getEffectiveObjectPropertiesInInsertionOrder(optionsObject.properties);
+				if (!properties) return;
+				const cacheKeyProperty = properties.find((property) => getStaticPropertyKeyName(property, { allowComputedString: true }) === "customProgramCacheKey");
+				const onBeforeCompileProperty = properties.find((property) => getStaticPropertyKeyName(property, { allowComputedString: true }) === "onBeforeCompile");
+				const materialSymbol = getConstructorMaterialSymbol(node, context);
+				const hasConstructorCacheKey = Boolean(cacheKeyProperty && isUsableProgramCacheKey(cacheKeyProperty.value, context));
+				if (hasConstructorCacheKey && materialSymbol) materialSymbolsWithCacheKeys.add(materialSymbol.id);
+				if (!onBeforeCompileProperty) return;
+				const callback = resolveExactLocalFunction(onBeforeCompileProperty.value, context.scopes);
+				if (!callback || !callbackHasVariantDependentPatch(callback, context)) return;
+				candidates.push({
+					hasConstructorCacheKey,
+					materialSymbolId: materialSymbol?.id ?? null,
+					node: onBeforeCompileProperty
+				});
+			},
+			AssignmentExpression(node) {
+				if (!isNodeOfType(node.left, "MemberExpression")) return;
+				const propertyName = getStaticPropertyName(node.left);
+				if (propertyName !== "onBeforeCompile" && propertyName !== "customProgramCacheKey") return;
+				const materialSymbol = getStableMaterialSymbol(node.left.object, context);
+				if (!materialSymbol) return;
+				if (propertyName === "customProgramCacheKey") {
+					if (isUsableProgramCacheKey(node.right, context)) materialSymbolsWithCacheKeys.add(materialSymbol.id);
+					else materialSymbolsWithCacheKeys.delete(materialSymbol.id);
+					return;
+				}
+				const callback = resolveExactLocalFunction(node.right, context.scopes);
+				if (!callback || !callbackHasVariantDependentPatch(callback, context)) return;
+				candidates.push({
+					hasConstructorCacheKey: false,
+					materialSymbolId: materialSymbol.id,
+					node
+				});
+			},
+			"Program:exit"() {
+				for (const candidate of candidates) {
+					if (candidate.materialSymbolId === null && candidate.hasConstructorCacheKey || candidate.materialSymbolId !== null && materialSymbolsWithCacheKeys.has(candidate.materialSymbolId)) continue;
+					context.report({
+						node: candidate.node,
+						message: "This onBeforeCompile patch changes shader source from mutable captured state, but the material has no customProgramCacheKey for those program variants"
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/rules/r3f/utils/get-glsl-type-specifier-name.ts
+const getGlslTypeSpecifierName = (specifier) => {
+	const typeName = specifier.specifier;
+	if (typeName.type === "keyword") return typeName.token;
+	if (typeName.type === "identifier" || typeName.type === "type_name") return typeName.identifier;
+	return null;
+};
+//#endregion
+//#region src/plugin/rules/r3f/utils/mask-glsl-comments.ts
+const GLSL_COMMENT_PATTERN = /\/\*[\s\S]*?(?:\*\/|$)|\/\/[^\r\n]*/g;
+const NON_LINE_BREAK_PATTERN = /[^\r\n]/g;
+const maskGlslComments = (source) => source.replace(GLSL_COMMENT_PATTERN, (comment) => comment.replace(NON_LINE_BREAK_PATTERN, " "));
+//#endregion
+//#region src/plugin/rules/r3f/utils/parse-glsl-shader-source.ts
+const GLSL_CONDITIONAL_DIRECTIVE_PATTERN = /^[ \t]*#[ \t]*(?:if|ifdef|ifndef|elif|else|endif)\b/m;
+const THREE_INCLUDE_DIRECTIVE_PATTERN = /^[ \t]*#[ \t]*include[ \t]+<[^>\r\n]+>[^\r\n]*/gm;
+const maskThreeIncludeDirectives = (source) => source.replace(THREE_INCLUDE_DIRECTIVE_PATTERN, (directive) => directive.replace(/[^\r\n]/g, " "));
+const parseGlslShaderSource = (source, stage) => {
+	const sourceWithoutComments = maskGlslComments(source);
+	if (GLSL_CONDITIONAL_DIRECTIVE_PATTERN.test(sourceWithoutComments)) return null;
+	try {
+		return parse(maskThreeIncludeDirectives(sourceWithoutComments), {
+			includeLocation: true,
+			quiet: true,
+			stage
+		});
+	} catch {
+		return null;
+	}
+};
+//#endregion
+//#region src/plugin/rules/r3f/utils/resolve-static-shader-source.ts
+const shiftSegments = (source, offset) => source.segments.map((segment) => ({
+	endOffset: segment.endOffset + offset,
+	node: segment.node,
+	startOffset: segment.startOffset + offset
+}));
+const combineStaticShaderSources = (sources, separator, fallbackNode) => {
+	let text = "";
+	const segments = [];
+	sources.forEach((source, sourceIndex) => {
+		if (sourceIndex > 0 && separator) {
+			segments.push(...shiftSegments(separator, text.length));
+			text += separator.text;
+		}
+		segments.push(...shiftSegments(source, text.length));
+		text += source.text;
+	});
+	return {
+		fallbackNode,
+		segments,
+		text
+	};
+};
+const resolveStaticShaderSourceExpression = (expression, scopes, visitedSymbolIds) => {
+	const candidate = stripParenExpression(expression);
+	const directStaticString = getStaticStringExpression$1(candidate);
+	if (directStaticString !== null) return {
+		fallbackNode: candidate,
+		segments: directStaticString.length === 0 ? [] : [{
+			endOffset: directStaticString.length,
+			node: candidate,
+			startOffset: 0
+		}],
+		text: directStaticString
+	};
+	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 null;
+		const nextVisitedSymbolIds = new Set(visitedSymbolIds);
+		nextVisitedSymbolIds.add(symbol.id);
+		return resolveStaticShaderSourceExpression(symbol.initializer, scopes, nextVisitedSymbolIds);
+	}
+	if (isNodeOfType(candidate, "BinaryExpression") && candidate.operator === "+") {
+		const leftSource = resolveStaticShaderSourceExpression(candidate.left, scopes, new Set(visitedSymbolIds));
+		const rightSource = resolveStaticShaderSourceExpression(candidate.right, scopes, new Set(visitedSymbolIds));
+		return leftSource && rightSource ? combineStaticShaderSources([leftSource, rightSource], null, candidate) : null;
+	}
+	if (!isNodeOfType(candidate, "CallExpression") || !isNodeOfType(candidate.callee, "MemberExpression") || getStaticPropertyName(candidate.callee) !== "join") return null;
+	const arrayExpression = stripParenExpression(candidate.callee.object);
+	if (!isNodeOfType(arrayExpression, "ArrayExpression") || candidate.arguments.length > 1) return null;
+	const separatorArgument = candidate.arguments[0];
+	let separator;
+	if (!separatorArgument) separator = {
+		fallbackNode: candidate,
+		segments: [],
+		text: ","
+	};
+	else if (isNodeOfType(separatorArgument, "SpreadElement")) separator = null;
+	else separator = resolveStaticShaderSourceExpression(separatorArgument, scopes, new Set(visitedSymbolIds));
+	if (!separator) return null;
+	const elementSources = [];
+	for (const element of arrayExpression.elements) {
+		if (!element || isNodeOfType(element, "SpreadElement")) return null;
+		const elementSource = resolveStaticShaderSourceExpression(element, scopes, new Set(visitedSymbolIds));
+		if (!elementSource) return null;
+		elementSources.push(elementSource);
+	}
+	return combineStaticShaderSources(elementSources, separator, candidate);
+};
+const resolveStaticShaderSource = (expression, scopes) => {
+	const source = resolveStaticShaderSourceExpression(expression, scopes, /* @__PURE__ */ new Set());
+	if (!source) return null;
+	return {
+		getOriginNodeAtOffset: (offset) => source.segments.find((segment) => offset >= segment.startOffset && offset < segment.endOffset)?.node ?? source.fallbackNode,
+		text: source.text
+	};
+};
+//#endregion
+//#region src/plugin/rules/r3f/utils/resolve-static-three-shader-material.ts
+const SHADER_MATERIAL_CONSTRUCTORS = new Set(["RawShaderMaterial", "ShaderMaterial"]);
+const STATIC_SHADER_MATERIAL_PROPERTY_NAMES = [
+	"clipping",
+	"fog",
+	"fragmentShader",
+	"glslVersion",
+	"lights",
+	"morphNormals",
+	"morphTargets",
+	"skinning",
+	"transmission",
+	"uniforms",
+	"vertexShader"
+];
+const resolveShaderStage = (expression, stage, context) => {
+	if (!expression) return null;
+	const source = resolveStaticShaderSource(expression, context.scopes);
+	if (!source) return null;
+	const program = parseGlslShaderSource(source.text, stage);
+	return program ? {
+		expression,
+		program,
+		source,
+		stage
+	} : null;
+};
+const resolveStaticThreeShaderMaterial = (node, context) => {
+	const provenance = getApiReferenceProvenance(node.callee, context.scopes);
+	if (!provenance || !isThreeModuleSource$1(provenance.moduleSource) || !SHADER_MATERIAL_CONSTRUCTORS.has(provenance.apiName)) return null;
+	const options = node.arguments[0];
+	if (!options || isNodeOfType(options, "SpreadElement")) return null;
+	const optionsObject = resolveStableOptionsObject(options, STATIC_SHADER_MATERIAL_PROPERTY_NAMES, context.scopes, node);
+	if (!optionsObject) return null;
+	const unresolvedPropertyNames = new Set(STATIC_SHADER_MATERIAL_PROPERTY_NAMES);
+	const properties = /* @__PURE__ */ new Map();
+	for (let propertyIndex = optionsObject.properties.length - 1; propertyIndex >= 0; propertyIndex -= 1) {
+		const property = optionsObject.properties[propertyIndex];
+		if (!property || isNodeOfType(property, "SpreadElement")) return null;
+		if (!isNodeOfType(property, "Property")) continue;
+		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+		if (!propertyName) return null;
+		if (!unresolvedPropertyNames.has(propertyName)) continue;
+		unresolvedPropertyNames.delete(propertyName);
+		if (property.kind === "init" && !property.method) properties.set(propertyName, property.value);
+	}
+	const fragmentShaderExpression = properties.get("fragmentShader");
+	const vertexShaderExpression = properties.get("vertexShader");
+	return {
+		constructorName: provenance.apiName,
+		constructorNode: node,
+		fragmentShader: resolveShaderStage(fragmentShaderExpression, "fragment", context),
+		optionsObject,
+		properties,
+		vertexShader: resolveShaderStage(vertexShaderExpression, "vertex", context)
+	};
+};
+//#endregion
+//#region src/plugin/rules/r3f/three-raw-shader-require-fragment-float-precision.ts
+const FLOAT_TYPE_NAME_PATTERN = /^(?:float|vec[234]|mat[234](?:x[234])?)$/;
+const PRECISION_QUALIFIER_NAMES$1 = new Set([
+	"highp",
+	"lowp",
+	"mediump"
+]);
+const hasPrecisionQualifier = (qualifiers) => Boolean(qualifiers?.some((qualifier) => qualifier.type === "keyword" && PRECISION_QUALIFIER_NAMES$1.has(qualifier.token)));
+const threeRawShaderRequireFragmentFloatPrecision = defineRule({
+	id: "three-raw-shader-require-fragment-float-precision",
+	title: "Raw fragment shader lacks float precision",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Declare a default fragment float precision or qualify every floating-point declaration",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (material?.constructorName !== "RawShaderMaterial" || !material.fragmentShader) return;
+		let hasDefaultFloatPrecision = false;
+		const unqualifiedFloatNodes = [];
+		visit(material.fragmentShader.program, {
+			precision: { enter: ({ node: precision }) => {
+				if (getGlslTypeSpecifierName(precision.specifier) === "float") hasDefaultFloatPrecision = true;
+			} },
+			fully_specified_type: { enter: ({ node: specifiedType }) => {
+				const typeName = getGlslTypeSpecifierName(specifiedType.specifier);
+				if (unqualifiedFloatNodes.length === 0 && !hasDefaultFloatPrecision && typeName && FLOAT_TYPE_NAME_PATTERN.test(typeName) && !hasPrecisionQualifier(specifiedType.qualifiers)) unqualifiedFloatNodes.push(specifiedType);
+			} },
+			parameter_declaration: { enter: ({ node: parameter }) => {
+				const typeName = getGlslTypeSpecifierName(parameter.specifier);
+				if (unqualifiedFloatNodes.length === 0 && !hasDefaultFloatPrecision && typeName && FLOAT_TYPE_NAME_PATTERN.test(typeName) && !hasPrecisionQualifier(parameter.qualifier)) unqualifiedFloatNodes.push(parameter);
+			} }
+		});
+		const firstUnqualifiedFloatNode = unqualifiedFloatNodes[0];
+		if (!firstUnqualifiedFloatNode) return;
+		context.report({
+			node: material.fragmentShader.source.getOriginNodeAtOffset(firstUnqualifiedFloatNode.location?.start.offset ?? 0),
+			message: "RawShaderMaterial does not receive Three.js precision declarations, and fragment GLSL has no default float precision for this unqualified declaration"
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/utils/get-glsl-numeric-constant.ts
+const getGlslNumericConstant = (node) => {
+	let value = null;
+	if (node.type === "float_constant") value = Number(node.token.replace(/(?:lf|LF|f|F)$/, ""));
+	else if (node.type === "double_constant") value = Number(node.token.replace(/(?:lf|LF)$/, ""));
+	else if (node.type === "uint_constant") value = Number(node.token.replace(/[uU]$/, ""));
+	else if (node.type === "int_constant") value = Number(node.token);
+	else if (node.type === "group") value = getGlslNumericConstant(node.expression);
+	else if (node.type === "unary" && (node.operator.literal === "+" || node.operator.literal === "-")) {
+		const operand = getGlslNumericConstant(node.expression);
+		if (operand !== null) value = node.operator.literal === "-" ? -operand : operand;
+	}
+	return value !== null && Number.isFinite(value) ? value : null;
+};
+//#endregion
+//#region src/plugin/rules/r3f/utils/collect-glsl-global-declarations.ts
+const GLSL_INTERPOLATION_QUALIFIER_NAMES = new Set([
+	"centroid",
+	"flat",
+	"noperspective",
+	"sample",
+	"smooth"
+]);
+const GLSL_PRIMARY_INTERPOLATION_QUALIFIER_NAMES = new Set([
+	"flat",
+	"noperspective",
+	"smooth"
+]);
+const getArraySize = (declaration, typeQuantifiers) => {
+	const quantifiers = [...Array.isArray(typeQuantifiers) ? typeQuantifiers : [], ...Array.isArray(declaration.quantifier) ? declaration.quantifier : []];
+	if (quantifiers.length === 0) return null;
+	if (quantifiers.length !== 1) return void 0;
+	return getGlslNumericConstant(quantifiers[0].expression) ?? void 0;
+};
+const getQualifierName = (qualifier) => qualifier.type === "keyword" ? qualifier.token : null;
+const getInterpolation = (qualifiers) => {
+	const interpolationQualifiers = [...qualifiers].filter((qualifier) => GLSL_INTERPOLATION_QUALIFIER_NAMES.has(qualifier));
+	if (!interpolationQualifiers.some((qualifier) => GLSL_PRIMARY_INTERPOLATION_QUALIFIER_NAMES.has(qualifier))) interpolationQualifiers.push("smooth");
+	return interpolationQualifiers.sort().join(" ");
+};
+const collectGlslGlobalDeclarations = (program) => {
+	const declarations = [];
+	const globalBindings = program.scopes[0]?.bindings;
+	for (const statement of program.program) {
+		if (statement.type !== "declaration_statement" || statement.declaration.type !== "declarator_list") continue;
+		const declaratorList = statement.declaration;
+		const typeName = getGlslTypeSpecifierName(declaratorList.specified_type.specifier);
+		if (!typeName) continue;
+		const qualifierNodes = declaratorList.specified_type.qualifiers ?? [];
+		const qualifiers = /* @__PURE__ */ new Set();
+		let hasLayoutQualifier = false;
+		for (const qualifier of qualifierNodes) {
+			if (qualifier.type === "layout_qualifier") {
+				hasLayoutQualifier = true;
+				continue;
+			}
+			const qualifierName = getQualifierName(qualifier);
+			if (qualifierName) qualifiers.add(qualifierName);
+		}
+		for (const declaration of declaratorList.declarations) {
+			const name = declaration.identifier.identifier;
+			const binding = globalBindings?.[name];
+			declarations.push({
+				arraySize: getArraySize(declaration, declaratorList.specified_type.specifier.quantifier),
+				hasLayoutQualifier,
+				interpolation: getInterpolation(qualifiers),
+				isStaticallyUsed: Boolean(binding?.references.some((reference) => reference !== binding.declaration)),
+				name,
+				node: declaration,
+				qualifiers,
+				typeName
+			});
+		}
+	}
+	return declarations;
+};
+//#endregion
+//#region src/plugin/rules/r3f/utils/get-glsl-function-call-name.ts
+const getGlslFunctionCallName = (node) => {
+	if (node.identifier.type === "identifier") return node.identifier.identifier;
+	if (node.identifier.type !== "type_specifier") return null;
+	const specifier = node.identifier.specifier;
+	if (specifier.type === "keyword") return specifier.token;
+	return specifier.type === "identifier" || specifier.type === "type_name" ? specifier.identifier : null;
+};
+//#endregion
+//#region src/plugin/rules/r3f/utils/has-glsl-function-declaration.ts
+const hasGlslFunctionDeclaration = (program, functionName) => {
+	const overloads = program.scopes[0]?.functions[functionName];
+	return Boolean(overloads && Object.values(overloads).some((overload) => Boolean(overload.declaration)));
+};
+//#endregion
+//#region src/plugin/rules/r3f/utils/has-glsl-function-like-macro.ts
+const hasGlslFunctionLikeMacro = (source, functionName) => new RegExp(`^[ \\t]*#[ \\t]*define[ \\t]+${functionName}(?:[ \\t]|\\()`, "m").test(maskGlslComments(source));
+//#endregion
+//#region src/plugin/rules/r3f/three-raw-shader-require-glsl3-version.ts
+const GLSL3_ONLY_FUNCTION_NAMES = new Set([
+	"acosh",
+	"asinh",
+	"atanh",
+	"bitCount",
+	"bitfieldExtract",
+	"bitfieldInsert",
+	"bitfieldReverse",
+	"cosh",
+	"determinant",
+	"findLSB",
+	"findMSB",
+	"floatBitsToInt",
+	"floatBitsToUint",
+	"frexp",
+	"imulExtended",
+	"intBitsToFloat",
+	"interpolateAtCentroid",
+	"interpolateAtOffset",
+	"interpolateAtSample",
+	"inverse",
+	"isinf",
+	"isnan",
+	"ldexp",
+	"modf",
+	"outerProduct",
+	"packHalf2x16",
+	"packSnorm2x16",
+	"packUnorm2x16",
+	"round",
+	"roundEven",
+	"sinh",
+	"tanh",
+	"texelFetch",
+	"texelFetchOffset",
+	"texture",
+	"textureGrad",
+	"textureGradOffset",
+	"textureLod",
+	"textureLodOffset",
+	"textureOffset",
+	"textureProj",
+	"textureProjGrad",
+	"textureProjGradOffset",
+	"textureProjLod",
+	"textureProjLodOffset",
+	"textureProjOffset",
+	"textureSize",
+	"transpose",
+	"trunc",
+	"uaddCarry",
+	"uintBitsToFloat",
+	"umulExtended",
+	"unpackHalf2x16",
+	"unpackSnorm2x16",
+	"unpackUnorm2x16",
+	"usubBorrow"
+]);
+const GLSL3_ONLY_TYPE_NAME_PATTERN = /^(?:uint|uvec[234]|mat[234]x[234]|sampler3D|sampler2DArray|[iu]sampler(?:2D|3D|Cube|2DArray))$/;
+const GLSL3_ONLY_CONSTRUCTOR_NAME_PATTERN = /^(?:uint|uvec[234]|mat[234]x[234])$/;
+const shaderUsesGlsl3Syntax = (shader) => {
+	if (collectGlslGlobalDeclarations(shader.program).some((declaration) => declaration.hasLayoutQualifier || declaration.qualifiers.has("in") || declaration.qualifiers.has("out") || GLSL3_ONLY_TYPE_NAME_PATTERN.test(declaration.typeName))) return true;
+	let usesGlsl3Syntax = false;
+	visit(shader.program, {
+		binary: { enter: ({ node }) => {
+			if (node.operator.literal === "<<" || node.operator.literal === ">>" || node.operator.literal === "&" || node.operator.literal === "|" || node.operator.literal === "^") usesGlsl3Syntax = true;
+		} },
+		assignment: { enter: ({ node }) => {
+			const operatorLiteral = String(node.operator.literal);
+			if (operatorLiteral === "<<=" || operatorLiteral === ">>=" || operatorLiteral === "&=" || operatorLiteral === "|=" || operatorLiteral === "^=") usesGlsl3Syntax = true;
+		} },
+		function_call: { enter: ({ node }) => {
+			const functionName = getGlslFunctionCallName(node);
+			if (functionName && (GLSL3_ONLY_FUNCTION_NAMES.has(functionName) || GLSL3_ONLY_CONSTRUCTOR_NAME_PATTERN.test(functionName)) && !hasGlslFunctionLikeMacro(shader.source.text, functionName) && !hasGlslFunctionDeclaration(shader.program, functionName)) usesGlsl3Syntax = true;
+		} },
+		switch_statement: { enter: () => {
+			usesGlsl3Syntax = true;
+		} }
+	});
+	return usesGlsl3Syntax;
+};
+const getGlsl3Configuration = (expression, context) => {
+	if (!expression) return false;
+	if (isNodeOfType(expression, "Literal")) return expression.value === "300 es";
+	const provenance = getApiReferenceProvenance(expression, context.scopes);
+	if (!provenance || !isThreeModuleSource$1(provenance.moduleSource)) return null;
+	return provenance.apiName === "GLSL3";
+};
+const threeRawShaderRequireGlsl3Version = defineRule({
+	id: "three-raw-shader-require-glsl3-version",
+	title: "Raw shader uses GLSL 3 syntax without GLSL3",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Set glslVersion to THREE.GLSL3 when RawShaderMaterial uses GLSL 3 syntax",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (material?.constructorName !== "RawShaderMaterial") return;
+		if (getGlsl3Configuration(material.properties.get("glslVersion"), context) !== false) return;
+		const incompatibleShader = [material.vertexShader, material.fragmentShader].find((shader) => Boolean(shader && shaderUsesGlsl3Syntax(shader)));
+		if (!incompatibleShader) return;
+		context.report({
+			node: incompatibleShader.expression,
+			message: "This RawShaderMaterial uses GLSL 3-only syntax but does not set glslVersion to THREE.GLSL3, so Three.js compiles it as GLSL 1"
+		});
+	} })
+});
+//#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"];
@@ -123651,6 +124422,917 @@ const threeRequireRendererCleanup = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/rules/r3f/three-shader-no-constant-out-of-bounds-index.ts
+const getTypeIndexElementCounts = (typeName) => {
+	const vectorMatch = /^[biud]?vec([234])$/.exec(typeName);
+	if (vectorMatch) return [Number(vectorMatch[1])];
+	const floatingPointMatrixMatch = /^mat([234])(?:x([234]))?$/.exec(typeName);
+	return floatingPointMatrixMatch ? [Number(floatingPointMatrixMatch[1]), Number(floatingPointMatrixMatch[2] ?? floatingPointMatrixMatch[1])] : [];
+};
+const getDeclarationIndexElementCounts = (declaration) => {
+	const typeElementCounts = getTypeIndexElementCounts(declaration.typeName);
+	if (declaration.arraySize === null) return typeElementCounts;
+	return [typeof declaration.arraySize === "number" ? declaration.arraySize : null, ...typeElementCounts];
+};
+const getIndexQuantifiers = (postfix) => {
+	const quantifiers = [];
+	let currentPostfix = postfix;
+	while (currentPostfix.type === "postfix") {
+		if (currentPostfix.expression.type !== "quantifier") return quantifiers.length > 0 ? quantifiers : null;
+		quantifiers.push(currentPostfix.expression);
+		currentPostfix = currentPostfix.postfix;
+	}
+	if (currentPostfix.type === "quantifier") quantifiers.push(currentPostfix);
+	return quantifiers.length > 0 ? quantifiers : null;
+};
+const checkShader$10 = (shader, context) => {
+	const declarationsByName = new Map(collectGlslGlobalDeclarations(shader.program).map((declaration) => [declaration.name, declaration]));
+	const globalBindings = shader.program.scopes[0]?.bindings;
+	visit(shader.program, { postfix: { enter: ({ node }) => {
+		if (node.expression.type !== "identifier") return;
+		const quantifiers = getIndexQuantifiers(node.postfix);
+		if (!quantifiers) return;
+		const declaration = declarationsByName.get(node.expression.identifier);
+		const binding = globalBindings?.[node.expression.identifier];
+		if (!declaration || !binding?.references.includes(node.expression)) return;
+		const elementCounts = getDeclarationIndexElementCounts(declaration);
+		for (const [quantifierIndex, quantifier] of quantifiers.entries()) {
+			const elementCount = elementCounts[quantifierIndex];
+			const index = getGlslNumericConstant(quantifier.expression);
+			if (elementCount === null || elementCount === void 0 || index === null || !Number.isInteger(index) || index >= 0 && index < elementCount) continue;
+			context.report({
+				node: shader.source.getOriginNodeAtOffset(quantifier.location?.start.offset ?? 0),
+				message: `The constant index ${index} is outside ${declaration.name}'s valid range 0–${elementCount - 1}, which is a GLSL compile error or undefined access`
+			});
+		}
+	} } });
+};
+const threeShaderNoConstantOutOfBoundsIndex = defineRule({
+	id: "three-shader-no-constant-out-of-bounds-index",
+	title: "Shader uses a constant out-of-bounds index",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Keep constant array, vector, and matrix indices within their declared bounds",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (!material) return;
+		if (material.fragmentShader) checkShader$10(material.fragmentShader, context);
+		if (material.vertexShader) checkShader$10(material.vertexShader, context);
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/utils/does-glsl-expression-depend-on-fragment-input.ts
+const FRAGMENT_INPUT_BUILTIN_NAMES = new Set([
+	"gl_FragCoord",
+	"gl_FrontFacing",
+	"gl_HelperInvocation",
+	"gl_Layer",
+	"gl_PointCoord",
+	"gl_PrimitiveID",
+	"gl_SampleID",
+	"gl_SampleMaskIn",
+	"gl_SamplePosition",
+	"gl_ViewportIndex"
+]);
+const doesGlslExpressionDependOnFragmentInput = (expression, fragmentInputReferences) => {
+	let dependsOnFragmentInput = false;
+	visit(expression, { identifier: { enter: (path) => {
+		if (dependsOnFragmentInput || path.parent?.type === "field_selection" || path.parent?.type === "function_call" && path.key === "identifier" || path.parent?.type === "type_specifier") return;
+		dependsOnFragmentInput = fragmentInputReferences.has(path.node) || FRAGMENT_INPUT_BUILTIN_NAMES.has(path.node.identifier);
+	} } });
+	return dependsOnFragmentInput;
+};
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-no-derivatives-in-nonuniform-flow.ts
+const DERIVATIVE_FUNCTION_NAMES = new Set([
+	"dFdx",
+	"dFdy",
+	"fwidth"
+]);
+const IMPLICIT_DERIVATIVE_TEXTURE_FUNCTION_NAMES = new Set([
+	"texture",
+	"texture2D",
+	"texture2DProj",
+	"texture3D",
+	"texture3DProj",
+	"textureCube",
+	"textureOffset",
+	"textureProj",
+	"textureProjOffset"
+]);
+const getControllingExpressions = (path) => {
+	const controllingExpressions = [];
+	let currentPath = path;
+	while (currentPath?.parentPath) {
+		const parentPath = currentPath.parentPath;
+		const parent = parentPath.node;
+		if (parent.type === "function") break;
+		const alternateNodes = parent.type === "if_statement" ? Reflect.get(parent, "else") : null;
+		const isInsideAlternate = currentPath.key === "else" || Array.isArray(alternateNodes) && alternateNodes.includes(currentPath.node);
+		if (parent.type === "if_statement" && (currentPath.key === "body" || isInsideAlternate)) controllingExpressions.push(parent.condition);
+		if (parent.type === "while_statement" && currentPath.key === "body") controllingExpressions.push(parent.condition);
+		if (parent.type === "do_statement" && currentPath.key === "body") controllingExpressions.push(parent.expression);
+		if (parent.type === "for_statement" && currentPath.key === "body" && parent.condition) controllingExpressions.push(...[
+			parent.init,
+			parent.condition,
+			parent.operation
+		].filter(Boolean));
+		if (parent.type === "ternary" && (currentPath.key === "left" || currentPath.key === "right")) controllingExpressions.push(parent.expression);
+		if (parent.type === "binary" && currentPath.key === "right" && (parent.operator.literal === "&&" || parent.operator.literal === "||")) controllingExpressions.push(parent.left);
+		if (parent.type === "switch_statement" && currentPath.key === "cases") controllingExpressions.push(parent.expression);
+		currentPath = parentPath;
+	}
+	return controllingExpressions;
+};
+const checkShader$9 = (shader, context) => {
+	const globalBindings = shader.program.scopes[0]?.bindings;
+	const fragmentInputReferences = /* @__PURE__ */ new Set();
+	for (const declaration of collectGlslGlobalDeclarations(shader.program)) {
+		if (!declaration.qualifiers.has("in") && !declaration.qualifiers.has("varying")) continue;
+		const binding = globalBindings?.[declaration.name];
+		if (!binding) continue;
+		for (const reference of binding.references) if (reference !== binding.declaration) fragmentInputReferences.add(reference);
+	}
+	visit(shader.program, { function_call: { enter: (path) => {
+		const functionName = getGlslFunctionCallName(path.node);
+		if (!functionName || !DERIVATIVE_FUNCTION_NAMES.has(functionName) && !IMPLICIT_DERIVATIVE_TEXTURE_FUNCTION_NAMES.has(functionName) || hasGlslFunctionLikeMacro(shader.source.text, functionName) || hasGlslFunctionDeclaration(shader.program, functionName)) return;
+		if (!getControllingExpressions(path).some((controllingExpression) => doesGlslExpressionDependOnFragmentInput(controllingExpression, fragmentInputReferences))) return;
+		context.report({
+			node: shader.source.getOriginNodeAtOffset(path.node.location?.start.offset ?? 0),
+			message: `${functionName} executes only on fragment-input-dependent lanes, so implicit derivatives are undefined. Move it before the divergent branch or use explicit gradients`
+		});
+	} } });
+};
+const threeShaderNoDerivativesInNonuniformFlow = defineRule({
+	id: "three-shader-no-derivatives-in-nonuniform-flow",
+	title: "Shader derivative runs in non-uniform control flow",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Evaluate derivatives and implicit-LOD texture samples before fragment-input-dependent branches",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (material?.fragmentShader) checkShader$9(material.fragmentShader, context);
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/utils/get-glsl-function-call-arguments.ts
+const getGlslFunctionCallArguments = (node) => node.args.filter((argument) => argument.type !== "literal" || argument.literal !== ",");
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-no-invalid-clamp-bounds.ts
+const checkShader$8 = (shader, context) => {
+	if (hasGlslFunctionLikeMacro(shader.source.text, "clamp") || hasGlslFunctionDeclaration(shader.program, "clamp")) return;
+	visit(shader.program, { function_call: { enter: ({ node }) => {
+		if (getGlslFunctionCallName(node) !== "clamp") return;
+		const argumentsWithoutSeparators = getGlslFunctionCallArguments(node);
+		if (argumentsWithoutSeparators.length !== 3) return;
+		const minimum = getGlslNumericConstant(argumentsWithoutSeparators[1]);
+		const maximum = getGlslNumericConstant(argumentsWithoutSeparators[2]);
+		if (minimum === null || maximum === null || minimum <= maximum) return;
+		context.report({
+			node: shader.source.getOriginNodeAtOffset(node.location?.start.offset ?? 0),
+			message: `GLSL clamp requires minVal not to exceed maxVal, but this call uses ${minimum} and ${maximum}, so its result is undefined`
+		});
+	} } });
+};
+const threeShaderNoInvalidClampBounds = defineRule({
+	id: "three-shader-no-invalid-clamp-bounds",
+	title: "Shader uses invalid clamp bounds",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Keep clamp minVal less than or equal to maxVal",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (!material) return;
+		if (material.fragmentShader) checkShader$8(material.fragmentShader, context);
+		if (material.vertexShader) checkShader$8(material.vertexShader, context);
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-no-invalid-constant-bit-operations.ts
+const getInvalidBitfieldMessage = (node, shader) => {
+	const functionName = getGlslFunctionCallName(node);
+	if (functionName !== "bitfieldExtract" && functionName !== "bitfieldInsert" || hasGlslFunctionLikeMacro(shader.source.text, functionName) || hasGlslFunctionDeclaration(shader.program, functionName)) return null;
+	const callArguments = getGlslFunctionCallArguments(node);
+	const offsetArgumentIndex = functionName === "bitfieldExtract" ? 1 : 2;
+	const bitsArgumentIndex = offsetArgumentIndex + 1;
+	const offset = callArguments[offsetArgumentIndex] ? getGlslNumericConstant(callArguments[offsetArgumentIndex]) : null;
+	const bits = callArguments[bitsArgumentIndex] ? getGlslNumericConstant(callArguments[bitsArgumentIndex]) : null;
+	if (offset === null || bits === null || offset >= 0 && bits >= 0 && offset + bits <= 32) return null;
+	return `GLSL ${functionName} uses offset ${offset} and width ${bits}, outside a 32-bit integer`;
+};
+const reportInvalidShift = (right, locationOffset, shader, context) => {
+	const shiftCount = getGlslNumericConstant(right);
+	if (shiftCount === null || shiftCount >= 0 && shiftCount < 32) return;
+	context.report({
+		node: shader.source.getOriginNodeAtOffset(locationOffset ?? 0),
+		message: `GLSL shift count ${shiftCount} is outside the valid range 0–31`
+	});
+};
+const checkShader$7 = (shader, context) => {
+	visit(shader.program, {
+		binary: { enter: ({ node }) => {
+			if (node.operator.literal !== "<<" && node.operator.literal !== ">>") return;
+			reportInvalidShift(node.right, node.location?.start.offset, shader, context);
+		} },
+		assignment: { enter: ({ node }) => {
+			const operatorLiteral = String(node.operator.literal);
+			if (operatorLiteral !== "<<=" && operatorLiteral !== ">>=") return;
+			reportInvalidShift(node.right, node.location?.start.offset, shader, context);
+		} },
+		function_call: { enter: ({ node }) => {
+			const message = getInvalidBitfieldMessage(node, shader);
+			if (!message) return;
+			context.report({
+				node: shader.source.getOriginNodeAtOffset(node.location?.start.offset ?? 0),
+				message
+			});
+		} }
+	});
+};
+const threeShaderNoInvalidConstantBitOperations = defineRule({
+	id: "three-shader-no-invalid-constant-bit-operations",
+	title: "Shader uses invalid constant bit operations",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Keep shift counts and bitfield ranges within the integer bit width",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (!material) return;
+		if (material.fragmentShader) checkShader$7(material.fragmentShader, context);
+		if (material.vertexShader) checkShader$7(material.vertexShader, context);
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-no-invalid-constant-math.ts
+const INVALID_NONPOSITIVE_FUNCTIONS = new Set([
+	"inversesqrt",
+	"log",
+	"log2"
+]);
+const getInvalidFunctionCallMessage = (node, shader) => {
+	const functionName = getGlslFunctionCallName(node);
+	if (!functionName || hasGlslFunctionLikeMacro(shader.source.text, functionName) || hasGlslFunctionDeclaration(shader.program, functionName)) return null;
+	const callArguments = getGlslFunctionCallArguments(node);
+	const firstArgument = callArguments[0];
+	if (!firstArgument) return null;
+	const firstValue = getGlslNumericConstant(firstArgument);
+	if (functionName === "asin" || functionName === "acos") return firstValue !== null && Math.abs(firstValue) > 1 ? `GLSL ${functionName} is undefined outside the range -1 to 1, but received ${firstValue}` : null;
+	if (functionName === "atan" && callArguments.length === 2) {
+		const secondValue = getGlslNumericConstant(callArguments[1]);
+		return firstValue === 0 && secondValue === 0 ? "GLSL atan is undefined when both arguments are zero" : null;
+	}
+	if (functionName === "acosh") return firstValue !== null && firstValue < 1 ? `GLSL acosh is undefined below 1, but received ${firstValue}` : null;
+	if (functionName === "atanh") return firstValue !== null && Math.abs(firstValue) >= 1 ? `GLSL atanh is undefined outside the range -1 to 1, but received ${firstValue}` : null;
+	if (functionName === "ldexp" && callArguments.length === 2) {
+		const exponent = getGlslNumericConstant(callArguments[1]);
+		return exponent !== null && exponent > 128 ? `GLSL ldexp is undefined above exponent 128, but received ${exponent}` : null;
+	}
+	if (functionName === "pow") {
+		if (firstValue !== null && firstValue < 0) return `GLSL pow is undefined for the negative base ${firstValue}`;
+		const exponent = callArguments[1] ? getGlslNumericConstant(callArguments[1]) : null;
+		return firstValue === 0 && exponent !== null && exponent <= 0 ? `GLSL pow is undefined for a zero base and the nonpositive exponent ${exponent}` : null;
+	}
+	if (functionName === "sqrt") return firstValue !== null && firstValue < 0 ? `GLSL sqrt is undefined for the negative argument ${firstValue}` : null;
+	if (INVALID_NONPOSITIVE_FUNCTIONS.has(functionName)) return firstValue !== null && firstValue <= 0 ? `GLSL ${functionName} is undefined for the nonpositive argument ${firstValue}` : null;
+	if (functionName !== "mod" || callArguments.length !== 2) return null;
+	return getGlslNumericConstant(callArguments[1]) === 0 ? "GLSL mod is undefined with a zero divisor" : null;
+};
+const reportConstantZeroDivisor = (operator, right, locationOffset, shader, context) => {
+	if (getGlslNumericConstant(right) !== 0) return;
+	context.report({
+		node: shader.source.getOriginNodeAtOffset(locationOffset ?? 0),
+		message: `GLSL ${operator.startsWith("/") ? "division" : "remainder"} by a constant zero has undefined results`
+	});
+};
+const checkShader$6 = (shader, context) => {
+	visit(shader.program, {
+		binary: { enter: ({ node }) => {
+			if (node.operator.literal !== "/" && node.operator.literal !== "%") return;
+			reportConstantZeroDivisor(node.operator.literal, node.right, node.location?.start.offset, shader, context);
+		} },
+		assignment: { enter: ({ node }) => {
+			if (node.operator.literal !== "/=" && node.operator.literal !== "%=") return;
+			reportConstantZeroDivisor(node.operator.literal, node.right, node.location?.start.offset, shader, context);
+		} },
+		function_call: { enter: ({ node }) => {
+			const message = getInvalidFunctionCallMessage(node, shader);
+			if (!message) return;
+			context.report({
+				node: shader.source.getOriginNodeAtOffset(node.location?.start.offset ?? 0),
+				message
+			});
+		} }
+	});
+};
+const threeShaderNoInvalidConstantMath = defineRule({
+	id: "three-shader-no-invalid-constant-math",
+	title: "Shader uses invalid constant math",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Keep constant arguments within the defined GLSL builtin and operator domains",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (!material) return;
+		if (material.fragmentShader) checkShader$6(material.fragmentShader, context);
+		if (material.vertexShader) checkShader$6(material.vertexShader, context);
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-no-invalid-smoothstep-edges.ts
+const checkShaderSource = (shader, context) => {
+	if (hasGlslFunctionLikeMacro(shader.source.text, "smoothstep") || hasGlslFunctionDeclaration(shader.program, "smoothstep")) return;
+	visit(shader.program, { function_call: { enter: ({ node }) => {
+		if (getGlslFunctionCallName(node) !== "smoothstep") return;
+		const argumentsWithoutSeparators = getGlslFunctionCallArguments(node);
+		if (argumentsWithoutSeparators.length !== 3) return;
+		const firstEdge = getGlslNumericConstant(argumentsWithoutSeparators[0]);
+		const secondEdge = getGlslNumericConstant(argumentsWithoutSeparators[1]);
+		if (firstEdge === null || secondEdge === null || firstEdge < secondEdge) return;
+		const shaderOffset = node.location?.start.offset ?? 0;
+		context.report({
+			node: shader.source.getOriginNodeAtOffset(shaderOffset),
+			message: `GLSL smoothstep requires edge0 to be less than edge1, but this call uses ${firstEdge} and ${secondEdge}, so its result is undefined`
+		});
+	} } });
+};
+const threeShaderNoInvalidSmoothstepEdges = defineRule({
+	id: "three-shader-no-invalid-smoothstep-edges",
+	title: "Shader uses invalid smoothstep edges",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Keep smoothstep edge0 below edge1 and invert the result when a descending transition is needed",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (!material) return;
+		if (material.fragmentShader) checkShaderSource(material.fragmentShader, context);
+		if (material.vertexShader) checkShaderSource(material.vertexShader, context);
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-no-inverse-of-uniform.ts
+const checkShader$5 = (shader, context) => {
+	if (hasGlslFunctionLikeMacro(shader.source.text, "inverse") || hasGlslFunctionDeclaration(shader.program, "inverse")) return;
+	const globalBindings = shader.program.scopes[0]?.bindings;
+	const uniformReferences = new Set(collectGlslGlobalDeclarations(shader.program).filter((declaration) => declaration.qualifiers.has("uniform")).flatMap((declaration) => globalBindings?.[declaration.name]?.references ?? []));
+	visit(shader.program, { function_call: { enter: ({ node }) => {
+		if (getGlslFunctionCallName(node) !== "inverse") return;
+		const callArguments = getGlslFunctionCallArguments(node);
+		const matrix = callArguments[0];
+		if (callArguments.length !== 1 || matrix?.type !== "identifier" || !uniformReferences.has(matrix)) return;
+		context.report({
+			node: shader.source.getOriginNodeAtOffset(node.location?.start.offset ?? 0),
+			message: `The matrix ${matrix.identifier} is uniform across this draw, but inverse recomputes it for every shader invocation. Compute and bind the inverse matrix on the CPU`
+		});
+	} } });
+};
+const threeShaderNoInverseOfUniform = defineRule({
+	id: "three-shader-no-inverse-of-uniform",
+	title: "Shader inverts a uniform matrix per invocation",
+	category: "Performance",
+	severity: "warn",
+	recommendation: "Compute uniform matrix inverses once on the CPU and upload the result",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (!material) return;
+		if (material.fragmentShader) checkShader$5(material.fragmentShader, context);
+		if (material.vertexShader) checkShader$5(material.vertexShader, context);
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-no-redeclared-builtins.ts
+const checkShader$4 = (shader, injectedNames, context) => {
+	for (const declaration of collectGlslGlobalDeclarations(shader.program)) {
+		if (!injectedNames.has(declaration.name)) continue;
+		context.report({
+			node: shader.source.getOriginNodeAtOffset(declaration.node.location?.start.offset ?? 0),
+			message: `ShaderMaterial already injects ${declaration.name} into the ${shader.stage} shader, so this declaration collides with Three.js's generated prefix`
+		});
+	}
+};
+const threeShaderNoRedeclaredBuiltins = defineRule({
+	id: "three-shader-no-redeclared-builtins",
+	title: "ShaderMaterial redeclares a Three.js builtin",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Use ShaderMaterial built-in attributes and uniforms without redeclaring them",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (material?.constructorName !== "ShaderMaterial") return;
+		if (material.vertexShader) checkShader$4(material.vertexShader, THREE_SHADER_MATERIAL_INJECTED_VERTEX_NAMES, context);
+		if (material.fragmentShader) checkShader$4(material.fragmentShader, THREE_SHADER_MATERIAL_INJECTED_FRAGMENT_NAMES, context);
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-no-redundant-frag-depth.ts
+const FRAGMENT_DEPTH_OUTPUT_NAMES = new Set(["gl_FragDepth", "gl_FragDepthEXT"]);
+const CONDITIONAL_NODE_TYPES = new Set([
+	"do_statement",
+	"for_statement",
+	"if_statement",
+	"switch_statement",
+	"ternary",
+	"while_statement"
+]);
+const isDefaultFragmentDepthAssignment = (node) => {
+	if (node.operator.literal !== "=" || node.left.type !== "identifier" || !FRAGMENT_DEPTH_OUTPUT_NAMES.has(node.left.identifier) || node.right.type !== "postfix" || node.right.expression.type !== "identifier" || node.right.expression.identifier !== "gl_FragCoord" || node.right.postfix.type !== "field_selection") return false;
+	return Reflect.get(node.right.postfix.selection, "identifier") === "z";
+};
+const isUnconditionalMainAssignment = (path) => {
+	let currentPath = path.parentPath;
+	while (currentPath) {
+		if (CONDITIONAL_NODE_TYPES.has(currentPath.node.type)) return false;
+		if (currentPath.node.type === "binary") {
+			const operator = currentPath.node.operator.literal;
+			if (operator === "&&" || operator === "||") return false;
+		}
+		if (currentPath.node.type === "function") return currentPath.node.prototype.header.name.identifier === "main";
+		currentPath = currentPath.parentPath;
+	}
+	return false;
+};
+const checkShader$3 = (shader, context) => {
+	const depthAssignments = [];
+	visit(shader.program, { assignment: { enter: (path) => {
+		if (path.node.left.type === "identifier" && FRAGMENT_DEPTH_OUTPUT_NAMES.has(path.node.left.identifier)) depthAssignments.push(path);
+	} } });
+	if (depthAssignments.length !== 1 || !isDefaultFragmentDepthAssignment(depthAssignments[0].node) || !isUnconditionalMainAssignment(depthAssignments[0])) return;
+	const assignment = depthAssignments[0].node;
+	context.report({
+		node: shader.source.getOriginNodeAtOffset(assignment.location?.start.offset ?? 0),
+		message: "This shader unconditionally writes the fixed-function depth value back to gl_FragDepth. Remove the redundant write so early depth testing remains available"
+	});
+};
+const threeShaderNoRedundantFragDepth = defineRule({
+	id: "three-shader-no-redundant-frag-depth",
+	title: "Shader redundantly writes fragment depth",
+	category: "Performance",
+	severity: "warn",
+	recommendation: "Let fixed-function depth supply gl_FragCoord.z when depth is unchanged",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (material?.fragmentShader) checkShader$3(material.fragmentShader, context);
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-no-version-directive.ts
+const VERSION_DIRECTIVE_PATTERN = /^[ \t]*#[ \t]*version\b/m;
+const checkShader$2 = (shader, context) => {
+	const versionDirectiveOffset = maskGlslComments(shader.source.text).search(VERSION_DIRECTIVE_PATTERN);
+	if (versionDirectiveOffset < 0) return;
+	context.report({
+		node: shader.source.getOriginNodeAtOffset(versionDirectiveOffset),
+		message: "Three.js prepends its own shader prefix before custom source, so an inline #version directive is not first and cannot compile. Set the material glslVersion property instead"
+	});
+};
+const threeShaderNoVersionDirective = defineRule({
+	id: "three-shader-no-version-directive",
+	title: "Three shader source contains a version directive",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Set glslVersion on the material instead of writing #version in shader source",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (!material) return;
+		if (material.fragmentShader) checkShader$2(material.fragmentShader, context);
+		if (material.vertexShader) checkShader$2(material.vertexShader, context);
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-prefer-small-integer-pow.ts
+const SMALL_INTEGER_POW_EXPONENTS = new Set([
+	2,
+	3,
+	4
+]);
+const checkShader$1 = (shader, context) => {
+	if (hasGlslFunctionLikeMacro(shader.source.text, "pow") || hasGlslFunctionDeclaration(shader.program, "pow")) return;
+	visit(shader.program, { function_call: { enter: ({ node }) => {
+		if (getGlslFunctionCallName(node) !== "pow") return;
+		const callArguments = getGlslFunctionCallArguments(node);
+		if (callArguments.length !== 2) return;
+		const exponent = getGlslNumericConstant(callArguments[1]);
+		if (exponent === null || !SMALL_INTEGER_POW_EXPONENTS.has(exponent)) return;
+		context.report({
+			node: shader.source.getOriginNodeAtOffset(node.location?.start.offset ?? 0),
+			message: `This pow call has the small integer exponent ${exponent}. Explicit multiplication avoids a general exponentiation operation and makes the intended cost clear`
+		});
+	} } });
+};
+const threeShaderPreferSmallIntegerPow = defineRule({
+	id: "three-shader-prefer-small-integer-pow",
+	title: "Shader uses pow for a small integer exponent",
+	category: "Performance",
+	severity: "warn",
+	recommendation: "Use explicit multiplication for powers of two, three, or four",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (!material) return;
+		if (material.fragmentShader) checkShader$1(material.fragmentShader, context);
+		if (material.vertexShader) checkShader$1(material.vertexShader, context);
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-prefer-squared-distance-comparison.ts
+const DISTANCE_FUNCTION_NAMES = new Set(["distance", "length"]);
+const ORDERING_OPERATORS = new Set([
+	"<",
+	"<=",
+	">",
+	">="
+]);
+const getDistanceFunctionCall = (node) => {
+	if (node.type === "group") return getDistanceFunctionCall(node.expression);
+	return node.type === "function_call" && DISTANCE_FUNCTION_NAMES.has(getGlslFunctionCallName(node) ?? "") ? node : null;
+};
+const getDistanceComparison = (left, right) => {
+	const leftCall = getDistanceFunctionCall(left);
+	const rightThreshold = getGlslNumericConstant(right);
+	if (leftCall && rightThreshold !== null && rightThreshold >= 0) return {
+		functionCall: leftCall,
+		threshold: rightThreshold
+	};
+	const rightCall = getDistanceFunctionCall(right);
+	const leftThreshold = getGlslNumericConstant(left);
+	return rightCall && leftThreshold !== null && leftThreshold >= 0 ? {
+		functionCall: rightCall,
+		threshold: leftThreshold
+	} : null;
+};
+const checkShader = (shader, context) => {
+	visit(shader.program, { binary: { enter: ({ node }) => {
+		if (!ORDERING_OPERATORS.has(node.operator.literal)) return;
+		const comparison = getDistanceComparison(node.left, node.right);
+		if (!comparison) return;
+		const functionName = getGlslFunctionCallName(comparison.functionCall);
+		if (!functionName || hasGlslFunctionLikeMacro(shader.source.text, functionName) || hasGlslFunctionDeclaration(shader.program, functionName)) return;
+		context.report({
+			node: shader.source.getOriginNodeAtOffset(node.location?.start.offset ?? 0),
+			message: `Compare squared ${functionName === "length" ? "length using dot(v, v)" : "distance using dot(a - b, a - b)"} against ${comparison.threshold * comparison.threshold} to avoid computing a square root`
+		});
+	} } });
+};
+const threeShaderPreferSquaredDistanceComparison = defineRule({
+	id: "three-shader-prefer-squared-distance-comparison",
+	title: "Shader compares a computed distance",
+	category: "Performance",
+	severity: "warn",
+	recommendation: "Compare squared vector distance against a squared nonnegative threshold",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (!material) return;
+		if (material.fragmentShader) checkShader(material.fragmentShader, context);
+		if (material.vertexShader) checkShader(material.vertexShader, context);
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/utils/has-glsl-array-dimension-mismatch.ts
+const hasGlslArrayDimensionMismatch = (firstArraySize, secondArraySize) => firstArraySize === null !== (secondArraySize === null) || typeof firstArraySize === "number" && typeof secondArraySize === "number" && firstArraySize !== secondArraySize;
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-require-matching-uniforms.ts
+const PRECISION_QUALIFIER_NAMES = [
+	"highp",
+	"mediump",
+	"lowp"
+];
+const getPrecision = (declaration) => PRECISION_QUALIFIER_NAMES.find((precision) => declaration.qualifiers.has(precision)) ?? null;
+const getMismatch = (vertexUniform, fragmentUniform) => {
+	if (vertexUniform.typeName !== fragmentUniform.typeName) return `type ${vertexUniform.typeName} in the vertex shader and ${fragmentUniform.typeName} in the fragment shader`;
+	if (hasGlslArrayDimensionMismatch(vertexUniform.arraySize, fragmentUniform.arraySize)) return "different array dimensions";
+	const vertexPrecision = getPrecision(vertexUniform);
+	const fragmentPrecision = getPrecision(fragmentUniform);
+	return vertexPrecision === null || fragmentPrecision === null || vertexPrecision === fragmentPrecision ? null : `precision ${vertexPrecision} in the vertex shader and ${fragmentPrecision} in the fragment shader`;
+};
+const getUsedUniforms = (declarations) => new Map(declarations.filter((declaration) => declaration.qualifiers.has("uniform") && declaration.isStaticallyUsed).map((declaration) => [declaration.name, declaration]));
+const threeShaderRequireMatchingUniforms = defineRule({
+	id: "three-shader-require-matching-uniforms",
+	title: "Shader stages declare incompatible uniforms",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Use the same type, array dimensions, and precision for uniforms shared by both shader stages",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (!material?.vertexShader || !material.fragmentShader) return;
+		const vertexUniforms = getUsedUniforms(collectGlslGlobalDeclarations(material.vertexShader.program));
+		const fragmentUniforms = getUsedUniforms(collectGlslGlobalDeclarations(material.fragmentShader.program));
+		for (const [uniformName, fragmentUniform] of fragmentUniforms) {
+			const vertexUniform = vertexUniforms.get(uniformName);
+			if (!vertexUniform) continue;
+			const mismatch = getMismatch(vertexUniform, fragmentUniform);
+			if (!mismatch) continue;
+			context.report({
+				node: material.fragmentShader.source.getOriginNodeAtOffset(fragmentUniform.node.location?.start.offset ?? 0),
+				message: `Uniform ${uniformName} has ${mismatch}, so the shader stages cannot link consistently`
+			});
+		}
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-require-matching-varyings.ts
+const isVertexOutput = (declaration) => declaration.qualifiers.has("out") || declaration.qualifiers.has("varying");
+const isFragmentInput = (declaration) => declaration.qualifiers.has("in") || declaration.qualifiers.has("varying");
+const getInterfaceMismatch = (vertexOutput, fragmentInput) => {
+	if (vertexOutput.typeName !== fragmentInput.typeName) return `type ${vertexOutput.typeName} in the vertex shader but ${fragmentInput.typeName} in the fragment shader`;
+	if (hasGlslArrayDimensionMismatch(vertexOutput.arraySize, fragmentInput.arraySize)) return "different array dimensions";
+	return vertexOutput.interpolation === fragmentInput.interpolation ? null : `interpolation ${vertexOutput.interpolation} in the vertex shader but ${fragmentInput.interpolation} in the fragment shader`;
+};
+const threeShaderRequireMatchingVaryings = defineRule({
+	id: "three-shader-require-matching-varyings",
+	title: "Shader stage interface does not match",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Declare every statically used fragment input as a compatible vertex output with the same name",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (!material?.vertexShader || !material.fragmentShader) return;
+		const vertexOutputs = new Map(collectGlslGlobalDeclarations(material.vertexShader.program).filter(isVertexOutput).map((declaration) => [declaration.name, declaration]));
+		const fragmentInputs = collectGlslGlobalDeclarations(material.fragmentShader.program).filter((declaration) => isFragmentInput(declaration) && declaration.isStaticallyUsed && !declaration.name.startsWith("gl_") && !declaration.hasLayoutQualifier);
+		for (const fragmentInput of fragmentInputs) {
+			const vertexOutput = vertexOutputs.get(fragmentInput.name);
+			const mismatch = vertexOutput ? getInterfaceMismatch(vertexOutput, fragmentInput) : "no matching vertex output";
+			if (!mismatch) continue;
+			context.report({
+				node: material.fragmentShader.source.getOriginNodeAtOffset(fragmentInput.node.location?.start.offset ?? 0),
+				message: `Fragment input ${fragmentInput.name} has ${mismatch}, so the shader program cannot link with a defined value`
+			});
+		}
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/utils/does-glsl-main-write-position-on-all-paths.ts
+const getPositionSwizzleWriteMask = (selection) => {
+	let writeMask = 0;
+	for (const componentAlias of selection) {
+		const componentBit = GLSL_POSITION_COMPONENT_BIT_BY_ALIAS.get(componentAlias);
+		if (!componentBit) return 0;
+		writeMask |= componentBit;
+	}
+	return writeMask;
+};
+const getExpressionPositionWriteMask = (expression) => {
+	if (expression.type === "assignment" && expression.operator.literal === "=") {
+		if (expression.left.type === "identifier" && expression.left.identifier === "gl_Position") return 15;
+		if (expression.left.type === "postfix" && expression.left.expression.type === "identifier" && expression.left.expression.identifier === "gl_Position" && expression.left.postfix.type === "field_selection") {
+			const selection = Reflect.get(expression.left.postfix.selection, "identifier");
+			return typeof selection === "string" ? getPositionSwizzleWriteMask(selection) : 0;
+		}
+	}
+	if (expression.type === "binary" && expression.operator.literal === ",") return getExpressionPositionWriteMask(expression.left) | getExpressionPositionWriteMask(expression.right);
+	if (expression.type === "group") return getExpressionPositionWriteMask(expression.expression);
+	if (expression.type === "ternary") return getExpressionPositionWriteMask(expression.left) & getExpressionPositionWriteMask(expression.right);
+	return 0;
+};
+const expressionContainsPositionWrite = (expression) => {
+	let containsPositionWrite = false;
+	visit(expression, { assignment: { enter: ({ node }) => {
+		if (getExpressionPositionWriteMask(node) !== 0) containsPositionWrite = true;
+	} } });
+	return containsPositionWrite;
+};
+const getBooleanConstant = (expression) => {
+	if (expression.type !== "bool_constant") return null;
+	return expression.token === "true";
+};
+const analyzeCompoundStatement = (statement, inputStates) => {
+	let activeStates = inputStates;
+	let hasUnwrittenReturn = false;
+	for (const child of statement.statements) {
+		if (activeStates.size === 0) break;
+		const childResult = analyzeStatement(child, activeStates);
+		if (!childResult.isSupported) return childResult;
+		activeStates = childResult.activeStates;
+		hasUnwrittenReturn ||= childResult.hasUnwrittenReturn;
+	}
+	return {
+		activeStates,
+		hasUnwrittenReturn,
+		isSupported: true
+	};
+};
+const analyzeStatement = (statement, inputStates) => {
+	if (statement.type === "compound_statement") return analyzeCompoundStatement(statement, inputStates);
+	if (statement.type === "expression_statement") {
+		const expressionWriteMask = getExpressionPositionWriteMask(statement.expression);
+		if (expressionWriteMask === 0 && expressionContainsPositionWrite(statement.expression)) return {
+			activeStates: inputStates,
+			hasUnwrittenReturn: false,
+			isSupported: false
+		};
+		return {
+			activeStates: expressionWriteMask === 0 ? inputStates : new Set([...inputStates].map((state) => state | expressionWriteMask)),
+			hasUnwrittenReturn: false,
+			isSupported: true
+		};
+	}
+	if (statement.type === "return_statement") return {
+		activeStates: /* @__PURE__ */ new Set(),
+		hasUnwrittenReturn: [...inputStates].some((state) => state !== 15),
+		isSupported: true
+	};
+	if (statement.type === "if_statement") {
+		if (expressionContainsPositionWrite(statement.condition)) return {
+			activeStates: inputStates,
+			hasUnwrittenReturn: false,
+			isSupported: false
+		};
+		const constantCondition = getBooleanConstant(statement.condition);
+		const consequent = analyzeStatement(statement.body, inputStates);
+		if (!consequent.isSupported) return consequent;
+		const alternateNodes = Reflect.get(statement, "else");
+		const alternateStatement = Array.isArray(alternateNodes) ? alternateNodes[alternateNodes.length - 1] : void 0;
+		const alternate = alternateStatement ? analyzeStatement(alternateStatement, inputStates) : {
+			activeStates: inputStates,
+			hasUnwrittenReturn: false,
+			isSupported: true
+		};
+		if (!alternate.isSupported) return alternate;
+		if (constantCondition !== null) return constantCondition ? consequent : alternate;
+		return {
+			activeStates: new Set([...consequent.activeStates, ...alternate.activeStates]),
+			hasUnwrittenReturn: consequent.hasUnwrittenReturn || alternate.hasUnwrittenReturn,
+			isSupported: true
+		};
+	}
+	if (statement.type === "for_statement" || statement.type === "while_statement") {
+		const controlExpressions = statement.type === "for_statement" ? [
+			Reflect.get(statement, "init"),
+			Reflect.get(statement, "condition"),
+			Reflect.get(statement, "operation")
+		] : [statement.condition];
+		if (controlExpressions.some((expression) => !expression) || controlExpressions.some(expressionContainsPositionWrite)) return {
+			activeStates: inputStates,
+			hasUnwrittenReturn: false,
+			isSupported: false
+		};
+		const bodyResult = analyzeStatement(statement.body, inputStates);
+		return {
+			activeStates: inputStates,
+			hasUnwrittenReturn: bodyResult.hasUnwrittenReturn,
+			isSupported: bodyResult.isSupported
+		};
+	}
+	if (statement.type === "declaration_statement" && expressionContainsPositionWrite(statement.declaration)) return {
+		activeStates: inputStates,
+		hasUnwrittenReturn: false,
+		isSupported: false
+	};
+	if (statement.type === "do_statement" || statement.type === "switch_statement" || statement.type === "break_statement" || statement.type === "continue_statement") return {
+		activeStates: inputStates,
+		hasUnwrittenReturn: false,
+		isSupported: false
+	};
+	return {
+		activeStates: inputStates,
+		hasUnwrittenReturn: false,
+		isSupported: true
+	};
+};
+const callsUserDefinedFunction = (mainFunction, program) => {
+	let callsFunction = false;
+	visit(mainFunction.body, { function_call: { enter: ({ node }) => {
+		const functionName = getGlslFunctionCallName(node);
+		if (functionName && hasGlslFunctionDeclaration(program, functionName)) callsFunction = true;
+	} } });
+	return callsFunction;
+};
+const doesGlslMainWritePositionOnAllPaths = (program, source) => {
+	const mainFunction = program.program.find((node) => node.type === "function" && node.prototype.header.name.identifier === "main") ?? null;
+	if (!mainFunction || /^[ \t]*#[ \t]*define\b/m.test(maskGlslComments(source)) || callsUserDefinedFunction(mainFunction, program)) return {
+		mainFunction,
+		writesPositionOnAllPaths: null
+	};
+	const result = analyzeCompoundStatement(mainFunction.body, new Set([0]));
+	if (!result.isSupported) return {
+		mainFunction,
+		writesPositionOnAllPaths: null
+	};
+	return {
+		mainFunction,
+		writesPositionOnAllPaths: !result.hasUnwrittenReturn && [...result.activeStates].every((state) => state === 15)
+	};
+};
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-require-position-on-all-paths.ts
+const threeShaderRequirePositionOnAllPaths = defineRule({
+	id: "three-shader-require-position-on-all-paths",
+	title: "Vertex shader leaves gl_Position undefined",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Assign gl_Position before every return and on every path through main",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (!material?.vertexShader) return;
+		const analysis = doesGlslMainWritePositionOnAllPaths(material.vertexShader.program, material.vertexShader.source.text);
+		if (!analysis.mainFunction || analysis.writesPositionOnAllPaths !== false) return;
+		context.report({
+			node: material.vertexShader.source.getOriginNodeAtOffset(analysis.mainFunction.location?.start.offset ?? 0),
+			message: "At least one path through vertex main returns or falls through without assigning gl_Position, leaving the clip-space position undefined"
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/r3f/utils/collect-authoritative-static-object-property-names.ts
+const collectAuthoritativeStaticObjectPropertyNames = (objectExpression) => {
+	const propertyNames = /* @__PURE__ */ new Set();
+	for (let propertyIndex = objectExpression.properties.length - 1; propertyIndex >= 0; propertyIndex -= 1) {
+		const property = objectExpression.properties[propertyIndex];
+		if (!property || isNodeOfType(property, "SpreadElement")) return null;
+		if (!isNodeOfType(property, "Property")) continue;
+		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+		if (!propertyName) return null;
+		propertyNames.add(propertyName);
+	}
+	return propertyNames;
+};
+//#endregion
+//#region src/plugin/rules/r3f/three-shader-require-uniform-bindings.ts
+const MANAGED_UNIFORM_FEATURE_BY_NAME = new Map([
+	["ambientLightColor", "lights"],
+	["bindMatrix", "skinning"],
+	["bindMatrixInverse", "skinning"],
+	["boneTexture", "skinning"],
+	["boneTextureSize", "skinning"],
+	["clippingPlanes", "clipping"],
+	["directionalLights", "lights"],
+	["directionalLightShadows", "lights"],
+	["directionalShadowMap", "lights"],
+	["directionalShadowMatrix", "lights"],
+	["fogColor", "fog"],
+	["fogDensity", "fog"],
+	["fogFar", "fog"],
+	["fogNear", "fog"],
+	["hemisphereLights", "lights"],
+	["lightProbe", "lights"],
+	["ltc_1", "lights"],
+	["ltc_2", "lights"],
+	["morphTargetBaseInfluence", "morphTargets"],
+	["morphTargetInfluences", "morphTargets"],
+	["morphTargetsTexture", "morphTargets"],
+	["morphTargetsTextureSize", "morphTargets"],
+	["pointLights", "lights"],
+	["pointLightShadows", "lights"],
+	["pointShadowMap", "lights"],
+	["pointShadowMatrix", "lights"],
+	["probesMax", "lights"],
+	["probesMin", "lights"],
+	["probesResolution", "lights"],
+	["probesSH", "lights"],
+	["receiveShadow", "lights"],
+	["rectAreaLights", "lights"],
+	["spotLightMap", "lights"],
+	["spotLightMatrix", "lights"],
+	["spotLights", "lights"],
+	["spotLightShadows", "lights"],
+	["spotShadowMap", "lights"],
+	["transmissionSamplerMap", "transmission"],
+	["transmissionSamplerSize", "transmission"]
+]);
+const isRendererManagedUniform = (uniformName, material) => {
+	if (material.constructorName !== "ShaderMaterial" || !THREE_RENDERER_MANAGED_SHADER_UNIFORM_NAMES.has(uniformName)) return false;
+	const requiredFeature = MANAGED_UNIFORM_FEATURE_BY_NAME.get(uniformName);
+	if (!requiredFeature) return true;
+	const featureExpression = material.properties.get(requiredFeature);
+	return featureExpression !== void 0 && readStaticBoolean(featureExpression) !== false;
+};
+const isCustomUniform = (declaration, material) => declaration.qualifiers.has("uniform") && declaration.isStaticallyUsed && !declaration.name.startsWith("gl_") && !isRendererManagedUniform(declaration.name, material);
+const threeShaderRequireUniformBindings = defineRule({
+	id: "three-shader-require-uniform-bindings",
+	title: "Shader uniform has no material binding",
+	category: "Correctness",
+	severity: "error",
+	recommendation: "Add every custom GLSL uniform to the ShaderMaterial uniforms object with a compatible value",
+	create: (context) => ({ NewExpression(node) {
+		const material = resolveStaticThreeShaderMaterial(node, context);
+		if (!material) return;
+		const declarationsByName = /* @__PURE__ */ new Map();
+		for (const shader of [material.vertexShader, material.fragmentShader]) {
+			if (!shader) continue;
+			for (const declaration of collectGlslGlobalDeclarations(shader.program)) if (isCustomUniform(declaration, material) && !declarationsByName.has(declaration.name)) declarationsByName.set(declaration.name, {
+				declaration,
+				shader
+			});
+		}
+		if (declarationsByName.size === 0) return;
+		const uniformNames = [...declarationsByName.keys()];
+		const uniformsExpression = material.properties.get("uniforms");
+		let boundUniformNames;
+		if (!uniformsExpression) boundUniformNames = /* @__PURE__ */ new Set();
+		else {
+			const uniformsObject = resolveStableOptionsObject(uniformsExpression, uniformNames, context.scopes, material.constructorNode);
+			if (!uniformsObject || !isNodeOfType(uniformsObject, "ObjectExpression")) return;
+			const propertyNames = collectAuthoritativeStaticObjectPropertyNames(uniformsObject);
+			if (!propertyNames) return;
+			boundUniformNames = propertyNames;
+		}
+		for (const [uniformName, declarationSource] of declarationsByName) {
+			if (boundUniformNames.has(uniformName)) continue;
+			context.report({
+				node: declarationSource.shader.source.getOriginNodeAtOffset(declarationSource.declaration.node.location?.start.offset ?? 0),
+				message: `GLSL uniform ${uniformName} has no matching entry in this material's uniforms object, so it keeps its default value`
+			});
+		}
+	} })
+});
+//#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()) => {
@@ -136754,6 +138436,23 @@ const reactDoctorRules = [
 			requires: [...new Set(["three", ...threeNoCloneInAnimationLoop.requires ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/three-no-material-recompile-in-animation-loop",
+		id: "three-no-material-recompile-in-animation-loop",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeNoMaterialRecompileInAnimationLoop,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeNoMaterialRecompileInAnimationLoop.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeNoMaterialRecompileInAnimationLoop.requires ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/three-no-new-in-animation-loop",
 		id: "three-no-new-in-animation-loop",
@@ -136792,6 +138491,23 @@ const reactDoctorRules = [
 			])]
 		}
 	},
+	{
+		key: "react-doctor/three-no-redundant-uniforms-need-update",
+		id: "three-no-redundant-uniforms-need-update",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeNoRedundantUniformsNeedUpdate,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeNoRedundantUniformsNeedUpdate.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeNoRedundantUniformsNeedUpdate.requires ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/three-no-state-in-animation-loop",
 		id: "three-no-state-in-animation-loop",
@@ -136834,6 +138550,57 @@ const reactDoctorRules = [
 			])]
 		}
 	},
+	{
+		key: "react-doctor/three-on-before-compile-require-program-cache-key",
+		id: "three-on-before-compile-require-program-cache-key",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeOnBeforeCompileRequireProgramCacheKey,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeOnBeforeCompileRequireProgramCacheKey.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeOnBeforeCompileRequireProgramCacheKey.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-raw-shader-require-fragment-float-precision",
+		id: "three-raw-shader-require-fragment-float-precision",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeRawShaderRequireFragmentFloatPrecision,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeRawShaderRequireFragmentFloatPrecision.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeRawShaderRequireFragmentFloatPrecision.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-raw-shader-require-glsl3-version",
+		id: "three-raw-shader-require-glsl3-version",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeRawShaderRequireGlsl3Version,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeRawShaderRequireGlsl3Version.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeRawShaderRequireGlsl3Version.requires ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/three-require-animation-mixer-cleanup",
 		id: "three-require-animation-mixer-cleanup",
@@ -137053,6 +138820,278 @@ const reactDoctorRules = [
 			])]
 		}
 	},
+	{
+		key: "react-doctor/three-shader-no-constant-out-of-bounds-index",
+		id: "three-shader-no-constant-out-of-bounds-index",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderNoConstantOutOfBoundsIndex,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderNoConstantOutOfBoundsIndex.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderNoConstantOutOfBoundsIndex.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-no-derivatives-in-nonuniform-flow",
+		id: "three-shader-no-derivatives-in-nonuniform-flow",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderNoDerivativesInNonuniformFlow,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderNoDerivativesInNonuniformFlow.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderNoDerivativesInNonuniformFlow.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-no-invalid-clamp-bounds",
+		id: "three-shader-no-invalid-clamp-bounds",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderNoInvalidClampBounds,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderNoInvalidClampBounds.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderNoInvalidClampBounds.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-no-invalid-constant-bit-operations",
+		id: "three-shader-no-invalid-constant-bit-operations",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderNoInvalidConstantBitOperations,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderNoInvalidConstantBitOperations.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderNoInvalidConstantBitOperations.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-no-invalid-constant-math",
+		id: "three-shader-no-invalid-constant-math",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderNoInvalidConstantMath,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderNoInvalidConstantMath.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderNoInvalidConstantMath.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-no-invalid-smoothstep-edges",
+		id: "three-shader-no-invalid-smoothstep-edges",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderNoInvalidSmoothstepEdges,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderNoInvalidSmoothstepEdges.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderNoInvalidSmoothstepEdges.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-no-inverse-of-uniform",
+		id: "three-shader-no-inverse-of-uniform",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderNoInverseOfUniform,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderNoInverseOfUniform.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderNoInverseOfUniform.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-no-redeclared-builtins",
+		id: "three-shader-no-redeclared-builtins",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderNoRedeclaredBuiltins,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderNoRedeclaredBuiltins.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderNoRedeclaredBuiltins.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-no-redundant-frag-depth",
+		id: "three-shader-no-redundant-frag-depth",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderNoRedundantFragDepth,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderNoRedundantFragDepth.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderNoRedundantFragDepth.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-no-version-directive",
+		id: "three-shader-no-version-directive",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderNoVersionDirective,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderNoVersionDirective.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderNoVersionDirective.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-prefer-small-integer-pow",
+		id: "three-shader-prefer-small-integer-pow",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderPreferSmallIntegerPow,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderPreferSmallIntegerPow.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderPreferSmallIntegerPow.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-prefer-squared-distance-comparison",
+		id: "three-shader-prefer-squared-distance-comparison",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderPreferSquaredDistanceComparison,
+			framework: "global",
+			category: "Performance",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderPreferSquaredDistanceComparison.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderPreferSquaredDistanceComparison.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-require-matching-uniforms",
+		id: "three-shader-require-matching-uniforms",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderRequireMatchingUniforms,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderRequireMatchingUniforms.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderRequireMatchingUniforms.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-require-matching-varyings",
+		id: "three-shader-require-matching-varyings",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderRequireMatchingVaryings,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderRequireMatchingVaryings.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderRequireMatchingVaryings.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-require-position-on-all-paths",
+		id: "three-shader-require-position-on-all-paths",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderRequirePositionOnAllPaths,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderRequirePositionOnAllPaths.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderRequirePositionOnAllPaths.requires ?? []])]
+		}
+	},
+	{
+		key: "react-doctor/three-shader-require-uniform-bindings",
+		id: "three-shader-require-uniform-bindings",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...threeShaderRequireUniformBindings,
+			framework: "global",
+			category: "Bugs",
+			tags: [...new Set([
+				"three",
+				"webgl",
+				...threeShaderRequireUniformBindings.tags ?? []
+			])],
+			requires: [...new Set(["three", ...threeShaderRequireUniformBindings.requires ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/three-tsl-no-js-uniform-branch",
 		id: "three-tsl-no-js-uniform-branch",