oxlint-plugin-react-doctor 0.8.1-dev.5774353 → 0.8.1-dev.61bf03e

package/dist/index.js

@@ -3173,7 +3173,7 @@ const getJsxPropStaticStringValues = (attribute, scopes) => getJsxPropStaticStri
 const getJsxPropExhaustiveStaticStringValues = (attribute, scopes) => getJsxPropStaticStringValuesWithMode(attribute, scopes, null, true);
 //#endregion
 //#region src/plugin/rules/a11y/anchor-has-content.ts
-const MESSAGE$63 = "Blind users can't follow this link because screen readers announce nothing, so add visible text, `aria-label`, or `aria-labelledby`.";
+const MESSAGE$66 = "Blind users can't follow this link because screen readers announce nothing, so add visible text, `aria-label`, or `aria-labelledby`.";
 const hasLinkRole = (roleValue) => roleValue.trim().split(/\s+/).find((roleToken) => VALID_ARIA_ROLES.has(roleToken)) === "link";
 const isTransComponentsTemplate = (node) => {
 	let current = node.parent;
@@ -3215,7 +3215,7 @@ const anchorHasContent = defineRule({
 			if (isTransComponentsTemplate(node)) return;
 			context.report({
 				node: opening.name,
-				message: MESSAGE$63
+				message: MESSAGE$66
 			});
 		} };
 	}
@@ -3703,7 +3703,7 @@ const parseJsxValue = (value) => {
 };
 //#endregion
 //#region src/plugin/rules/a11y/aria-activedescendant-has-tabindex.ts
-const MESSAGE$62 = "Keyboard users can't focus this element with `aria-activedescendant` because it isn't tabbable, so add `tabIndex={0}`.";
+const MESSAGE$65 = "Keyboard users can't focus this element with `aria-activedescendant` because it isn't tabbable, so add `tabIndex={0}`.";
 const ariaActivedescendantHasTabindex = defineRule({
 	id: "aria-activedescendant-has-tabindex",
 	title: "aria-activedescendant missing tabindex",
@@ -3721,7 +3721,7 @@ const ariaActivedescendantHasTabindex = defineRule({
 			if (tabIndexValue === null || tabIndexValue >= -1) return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$62
+				message: MESSAGE$65
 			});
 			return;
 		}
@@ -3729,7 +3729,7 @@ const ariaActivedescendantHasTabindex = defineRule({
 		if (canContentEditableBeTabbable(node, context.scopes, context.settings)) return;
 		context.report({
 			node: node.name,
-			message: MESSAGE$62
+			message: MESSAGE$65
 		});
 	} })
 });
@@ -6827,7 +6827,7 @@ const stripThisParameter = (parameters) => {
 };
 //#endregion
 //#region src/plugin/rules/security/auth-token-in-web-storage.ts
-const MESSAGE$61 = "Storing an auth token in `localStorage`/`sessionStorage` exposes it to any XSS on the page: JavaScript can read web storage and exfiltrate the token. Keep tokens in an `HttpOnly`, `Secure`, `SameSite` cookie instead.";
+const MESSAGE$64 = "Storing an auth token in `localStorage`/`sessionStorage` exposes it to any XSS on the page: JavaScript can read web storage and exfiltrate the token. Keep tokens in an `HttpOnly`, `Secure`, `SameSite` cookie instead.";
 const STORAGE_NAMES = new Set(["localStorage", "sessionStorage"]);
 const STORAGE_GLOBALS = new Set([
 	"window",
@@ -6999,7 +6999,7 @@ const authTokenInWebStorage = defineRule({
 			})) return;
 			context.report({
 				node,
-				message: MESSAGE$61
+				message: MESSAGE$64
 			});
 		},
 		AssignmentExpression(node) {
@@ -7010,7 +7010,7 @@ const authTokenInWebStorage = defineRule({
 			if (!propertyName || !isAuthCredentialKey(propertyName)) return;
 			context.report({
 				node: target,
-				message: MESSAGE$61
+				message: MESSAGE$64
 			});
 		}
 	}))
@@ -7149,7 +7149,7 @@ const CI_INSTALL_NEAR_SECRET_PATTERN = /(?:npm|pnpm|yarn|bun)\s+(?:install|ci)\b
 const INSTALL_COMMAND_PATTERN = /(?:npm|pnpm|yarn|bun)\s+(?:install|ci)\b/i;
 const SECRET_REFERENCE_PATTERN = /\bsecrets\.[A-Z0-9_]+/;
 const IGNORE_SCRIPTS_FLAG_PATTERN = /--ignore-scripts\b/;
-const MESSAGE$60 = "The build or install pipeline can execute package lifecycle code while CI secrets may be present.";
+const MESSAGE$63 = "The build or install pipeline can execute package lifecycle code while CI secrets may be present.";
 const isWorkflowPath = (relativePath) => /(?:^|\/)\.github\/workflows\/[^/]+\.ya?ml$/i.test(relativePath);
 const scanWorkflowContent = (content) => {
 	const lines = content.split("\n");
@@ -7194,7 +7194,7 @@ const scanWorkflowContent = (content) => {
 		const installLineOffset = Math.max(step.lines.findIndex((stepLine) => INSTALL_COMMAND_PATTERN.test(stepLine)), 0);
 		const installColumnIndex = step.lines[installLineOffset].search(INSTALL_COMMAND_PATTERN);
 		return [{
-			message: MESSAGE$60,
+			message: MESSAGE$63,
 			line: step.startLineIndex + installLineOffset + 1,
 			column: (installColumnIndex === -1 ? 0 : installColumnIndex) + 1
 		}];
@@ -7204,7 +7204,7 @@ const scanWorkflowContent = (content) => {
 const scanNonWorkflowConfig = scanByPattern({
 	shouldScan: (file) => isConfigOrCiPath(file.relativePath) && !file.relativePath.endsWith("package.json") && !isWorkflowPath(file.relativePath),
 	pattern: CI_INSTALL_NEAR_SECRET_PATTERN,
-	message: MESSAGE$60
+	message: MESSAGE$63
 });
 const scan = (file) => {
 	if (isWorkflowPath(file.relativePath)) return scanWorkflowContent(file.content);
@@ -7954,7 +7954,7 @@ const isPureEventBlockerHandler = (attribute) => {
 };
 //#endregion
 //#region src/plugin/rules/a11y/click-events-have-key-events.ts
-const MESSAGE$59 = "Keyboard users can't trigger this click handler because there's no keyboard one, so add `onKeyUp`, `onKeyDown`, or `onKeyPress`.";
+const MESSAGE$62 = "Keyboard users can't trigger this click handler because there's no keyboard one, so add `onKeyUp`, `onKeyDown`, or `onKeyPress`.";
 const KEY_HANDLERS = [
 	"onKeyUp",
 	"onKeyDown",
@@ -8165,7 +8165,7 @@ const clickEventsHaveKeyEvents = defineRule({
 			if (KEY_HANDLERS.some((handler) => hasJsxPropIgnoreCase(node.attributes, handler) || spreadEventValues.has(handler.toLowerCase()))) return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$59
+				message: MESSAGE$62
 			});
 		} };
 	}
@@ -10243,21 +10243,19 @@ const isReactComponentName = (name) => {
 	return firstCharacter >= 65 && firstCharacter <= 90;
 };
 //#endregion
-//#region src/plugin/rules/react-ui/utils/get-class-name-literal.ts
-const getClassNameLiteral = (classAttribute) => {
-	if (!isNodeOfType(classAttribute, "JSXAttribute")) return null;
-	if (!classAttribute.value) return null;
-	if (isNodeOfType(classAttribute.value, "Literal") && typeof classAttribute.value.value === "string") return classAttribute.value.value;
-	if (isNodeOfType(classAttribute.value, "JSXExpressionContainer")) {
-		const expression = classAttribute.value.expression;
-		if (isNodeOfType(expression, "Literal") && typeof expression.value === "string") return expression.value;
-		if (isNodeOfType(expression, "TemplateLiteral") && expression.quasis?.length === 1) return expression.quasis[0].value?.raw ?? null;
-	}
+//#region src/plugin/utils/get-jsx-attribute-static-string.ts
+const getJsxAttributeStaticString = (attribute) => {
+	if (!isNodeOfType(attribute, "JSXAttribute") || !attribute.value) return null;
+	if (isNodeOfType(attribute.value, "Literal") && typeof attribute.value.value === "string") return attribute.value.value;
+	if (!isNodeOfType(attribute.value, "JSXExpressionContainer")) return null;
+	const expression = attribute.value.expression;
+	if (isNodeOfType(expression, "Literal") && typeof expression.value === "string") return expression.value;
+	if (isNodeOfType(expression, "TemplateLiteral") && expression.expressions.length === 0 && expression.quasis.length === 1) return expression.quasis[0].value.raw;
 	return null;
 };
 //#endregion
 //#region src/plugin/rules/a11y/control-has-associated-label.ts
-const MESSAGE$58 = "Blind users can't tell what this control does because screen readers find no label, so add visible text, `aria-label`, or `aria-labelledby`.";
+const MESSAGE$61 = "Blind users can't tell what this control does because screen readers find no label, so add visible text, `aria-label`, or `aria-labelledby`.";
 const NON_OPERABLE_ELEMENTS = new Set([
 	"td",
 	"th",
@@ -10315,7 +10313,7 @@ const collectStaticTemplateClassTokens = (templateLiteral) => {
 const hasDisplayNoneClass = (opening) => {
 	const classAttribute = hasJsxPropIgnoreCase(opening.attributes, "className") ?? hasJsxPropIgnoreCase(opening.attributes, "class");
 	if (!classAttribute) return false;
-	const literalValue = getClassNameLiteral(classAttribute);
+	const literalValue = getJsxAttributeStaticString(classAttribute);
 	if (literalValue !== null) return literalValue.split(/\s+/).some(isDisplayNoneClassToken);
 	if (classAttribute.value && isNodeOfType(classAttribute.value, "JSXExpressionContainer") && isNodeOfType(classAttribute.value.expression, "TemplateLiteral")) return collectStaticTemplateClassTokens(classAttribute.value.expression).some(isDisplayNoneClassToken);
 	return false;
@@ -10787,7 +10785,7 @@ const controlHasAssociatedLabel = defineRule({
 					if (candidate.enclosingBindingName !== null && labelEmbeddedNames.has(candidate.enclosingBindingName)) continue;
 					context.report({
 						node: candidate.opening,
-						message: MESSAGE$58
+						message: MESSAGE$61
 					});
 				}
 			}
@@ -12431,7 +12429,7 @@ const noRedundantPaddingAxes = defineRule({
 	recommendation: "Collapse matching padding axes to `p-N` so duplicated classes do not make spacing harder to scan; keep split axes only when breakpoints differ.",
 	create: (context) => ({ JSXAttribute(jsxAttribute) {
 		if (!isNodeOfType(jsxAttribute.name, "JSXIdentifier") || jsxAttribute.name.name !== "className") return;
-		const classNameLiteral = getClassNameLiteral(jsxAttribute);
+		const classNameLiteral = getJsxAttributeStaticString(jsxAttribute);
 		if (!classNameLiteral) return;
 		if (!classNameLiteral.includes("px-") || !classNameLiteral.includes("py-")) return;
 		if (hasResponsivePrefix(classNameLiteral, "px") || hasResponsivePrefix(classNameLiteral, "py")) return;
@@ -12459,7 +12457,7 @@ const noRedundantSizeAxes = defineRule({
 		return { JSXAttribute(jsxAttribute) {
 			if (didReportInFile) return;
 			if (!isNodeOfType(jsxAttribute.name, "JSXIdentifier") || jsxAttribute.name.name !== "className") return;
-			const classNameLiteral = getClassNameLiteral(jsxAttribute);
+			const classNameLiteral = getJsxAttributeStaticString(jsxAttribute);
 			if (!classNameLiteral) return;
 			if (!classNameLiteral.includes("w-") || !classNameLiteral.includes("h-")) return;
 			if (hasResponsivePrefix(classNameLiteral, "w") || hasResponsivePrefix(classNameLiteral, "h")) return;
@@ -12487,7 +12485,7 @@ const noSpaceOnFlexChildren = defineRule({
 	recommendation: "Use `gap-*` on the flex or grid parent. `space-x-*` and `space-y-*` leave gaps when a child is hidden, miss spacing on wrapped lines, and don't flip in right-to-left layouts.",
 	create: (context) => ({ JSXAttribute(jsxAttribute) {
 		if (!isNodeOfType(jsxAttribute.name, "JSXIdentifier") || jsxAttribute.name.name !== "className") return;
-		const classNameLiteral = getClassNameLiteral(jsxAttribute);
+		const classNameLiteral = getJsxAttributeStaticString(jsxAttribute);
 		if (!classNameLiteral) return;
 		if (!classNameLiteral.includes("space-")) return;
 		const tokens = tokenizeClassName(classNameLiteral);
@@ -12594,7 +12592,7 @@ const noVagueButtonLabel = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/dialog-has-accessible-name.ts
-const MESSAGE$57 = "This dialog has no accessible name, so screen readers announce it as just “dialog.” Add `aria-label` or point `aria-labelledby` at its heading.";
+const MESSAGE$60 = "This dialog has no accessible name, so screen readers announce it as just “dialog.” Add `aria-label` or point `aria-labelledby` at its heading.";
 const DIALOG_ROLES = new Set(["dialog", "alertdialog"]);
 const NAME_PROVIDING_ATTRIBUTES = [
 	"aria-label",
@@ -12619,7 +12617,7 @@ const dialogHasAccessibleName = defineRule({
 			if (NAME_PROVIDING_ATTRIBUTES.some((attribute) => hasJsxPropIgnoreCase(node.attributes, attribute))) return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$57
+				message: MESSAGE$60
 			});
 		} };
 	}
@@ -12659,7 +12657,7 @@ const isEs6Component = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/display-name.ts
-const MESSAGE$56 = "This component shows up as Anonymous in React DevTools because it has no `displayName`.";
+const MESSAGE$59 = "This component shows up as Anonymous in React DevTools because it has no `displayName`.";
 const DEFAULT_ADDITIONAL_HOCS = [
 	"observer",
 	"lazy",
@@ -12852,7 +12850,7 @@ const displayName = defineRule({
 		const reportAt = (node) => {
 			context.report({
 				node,
-				message: MESSAGE$56
+				message: MESSAGE$59
 			});
 		};
 		return {
@@ -19266,7 +19264,7 @@ const forbidElements = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/forward-ref-uses-ref.ts
-const MESSAGE$55 = "The parent can't reach this component's node because the `forwardRef` wrapper ignores `ref`.";
+const MESSAGE$58 = "The parent can't reach this component's node because the `forwardRef` wrapper ignores `ref`.";
 const forwardRefUsesRef = defineRule({
 	id: "forward-ref-uses-ref",
 	title: "forwardRef without ref parameter",
@@ -19289,7 +19287,7 @@ const forwardRefUsesRef = defineRule({
 		if (isNodeOfType(onlyParam, "RestElement")) return;
 		context.report({
 			node: inner,
-			message: MESSAGE$55
+			message: MESSAGE$58
 		});
 	} })
 });
@@ -19330,7 +19328,7 @@ const gitProviderUrlInjectionRisk = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/heading-has-content.ts
-const MESSAGE$54 = "Blind users can't use this heading to navigate because screen readers skip it empty, so add text, `aria-label`, or `aria-labelledby`.";
+const MESSAGE$57 = "Blind users can't use this heading to navigate because screen readers skip it empty, so add text, `aria-label`, or `aria-labelledby`.";
 const DEFAULT_HEADING_TAGS = [
 	"h1",
 	"h2",
@@ -19364,7 +19362,7 @@ const headingHasContent = defineRule({
 			for (const attribute of ["aria-label", "aria-labelledby"]) if (hasJsxPropIgnoreCase(node.attributes, attribute)) return;
 			context.report({
 				node,
-				message: MESSAGE$54
+				message: MESSAGE$57
 			});
 		} };
 	}
@@ -19532,7 +19530,7 @@ const hooksNoNanInDeps = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/html-has-lang.ts
-const MESSAGE$53 = "Screen readers may mispronounce this page because it doesn't declare a language, so add a `lang` attribute like `en`.";
+const MESSAGE$56 = "Screen readers may mispronounce this page because it doesn't declare a language, so add a `lang` attribute like `en`.";
 const resolveSettings$38 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { htmlTags: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.htmlHasLang ?? {} : {}).htmlTags ?? ["html"] };
@@ -19579,13 +19577,13 @@ const htmlHasLang = defineRule({
 			if (!lang) {
 				context.report({
 					node: node.name,
-					message: MESSAGE$53
+					message: MESSAGE$56
 				});
 				return;
 			}
 			if (evaluateLang(lang.value) === "empty") context.report({
 				node: lang,
-				message: MESSAGE$53
+				message: MESSAGE$56
 			});
 		} };
 	}
@@ -19858,7 +19856,7 @@ const isJsxFragmentElement = (node, scopes) => {
 };
 //#endregion
 //#region src/plugin/rules/a11y/iframe-has-title.ts
-const MESSAGE$52 = "Screen reader users cannot identify this `<iframe>` because it has no title. Add a `title` that describes its content.";
+const MESSAGE$55 = "Screen reader users cannot identify this `<iframe>` because it has no title. Add a `title` that describes its content.";
 const isStaticallyAriaHidden = (openingElement) => {
 	const ariaHiddenAttribute = getAuthoritativeJsxAttribute(openingElement.attributes, "aria-hidden", false);
 	if (!ariaHiddenAttribute) return false;
@@ -19947,14 +19945,14 @@ const iframeHasTitle = defineRule({
 		if (!titleAttr) {
 			if (hasSpread || tag === "iframe") context.report({
 				node: node.name,
-				message: MESSAGE$52
+				message: MESSAGE$55
 			});
 			return;
 		}
 		const verdict = evaluateTitleValue(titleAttr.value);
 		if (verdict === "missing" || verdict === "empty") context.report({
 			node: titleAttr,
-			message: MESSAGE$52
+			message: MESSAGE$55
 		});
 	} })
 });
@@ -20079,7 +20077,7 @@ const iframeMissingSandbox = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/img-redundant-alt.ts
-const MESSAGE$51 = "Screen reader users hear \"image\" or \"photo\" twice because they already announce it, so describe what the image shows instead.";
+const MESSAGE$54 = "Screen reader users hear \"image\" or \"photo\" twice because they already announce it, so describe what the image shows instead.";
 const DEFAULT_COMPONENTS = ["img"];
 const DEFAULT_REDUNDANT_WORDS = [
 	"image",
@@ -20144,7 +20142,7 @@ const imgRedundantAlt = defineRule({
 			if (!altAttribute) return;
 			if (altValueRedundant(altAttribute, settings.words)) context.report({
 				node: altAttribute,
-				message: MESSAGE$51
+				message: MESSAGE$54
 			});
 		} };
 	}
@@ -21797,7 +21795,7 @@ const isDiscardedProbeInsideTry = (node) => {
 	return false;
 };
 const isComponentOrHookName = (name) => /^[A-Z]/.test(name) || /^use[A-Z0-9]/.test(name);
-const getFunctionName = (functionNode) => {
+const getFunctionName$1 = (functionNode) => {
 	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id.name;
 	const holder = functionNode.parent;
 	if (holder && isNodeOfType(holder, "VariableDeclarator") && isNodeOfType(holder.id, "Identifier")) return holder.id.name;
@@ -21806,7 +21804,7 @@ const getFunctionName = (functionNode) => {
 const isUncacheableOptionsMergeUtility = (node) => {
 	const enclosingFunction = findEnclosingFunction$1(node);
 	if (!enclosingFunction || !isFunctionLike$1(enclosingFunction)) return false;
-	const functionName = getFunctionName(enclosingFunction);
+	const functionName = getFunctionName$1(enclosingFunction);
 	if (!functionName || isComponentOrHookName(functionName)) return false;
 	const parameterNames = /* @__PURE__ */ new Set();
 	for (const parameter of enclosingFunction.params ?? []) collectPatternNames(parameter, parameterNames);
@@ -22108,7 +22106,7 @@ const getHoistableRegExpConstructionKind = (node, context) => {
 	if (!STATEFUL_REGEXP_FLAGS_PATTERN.test(effectiveFlags)) return "stateless";
 	return isSafeStatefulReplaceAllSearch(node, effectiveFlags, context) ? "statefulReplaceAll" : null;
 };
-const MESSAGE$50 = "`new RegExp()` rebuilds the pattern on every loop pass. Move it to a constant outside the loop.";
+const MESSAGE$53 = "`new RegExp()` rebuilds the pattern on every loop pass. Move it to a constant outside the loop.";
 const jsHoistRegexp = defineRule({
 	id: "js-hoist-regexp",
 	title: "RegExp built inside a loop",
@@ -22125,7 +22123,7 @@ const jsHoistRegexp = defineRule({
 			if (constructionKind === "statefulReplaceAll" && cachedEnvironmentHazard === "replaceAllIntegrityLost") return;
 			context.report({
 				node,
-				message: MESSAGE$50
+				message: MESSAGE$53
 			});
 		};
 		return createLoopAwareVisitors({
@@ -24892,7 +24890,7 @@ const jsxMaxDepth = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-comment-textnodes.ts
-const MESSAGE$49 = "Your users see this comment as text on the page because `//` & `/*` aren't hidden in JSX.";
+const MESSAGE$52 = "Your users see this comment as text on the page because `//` & `/*` aren't hidden in JSX.";
 const LITERAL_TEXT_TAGS = new Set([
 	"code",
 	"pre",
@@ -24962,7 +24960,7 @@ const jsxNoCommentTextnodes = defineRule({
 		if (isDeliberateStyledCommentToken(node)) return;
 		context.report({
 			node,
-			message: MESSAGE$49
+			message: MESSAGE$52
 		});
 	} })
 });
@@ -24993,7 +24991,7 @@ const isInsideFunctionScope = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-constructed-context-values.ts
-const MESSAGE$48 = "Every reader of this context redraws on each render because you build its `value` inline.";
+const MESSAGE$51 = "Every reader of this context redraws on each render because you build its `value` inline.";
 const CONTEXT_MODULES$1 = [
 	"react",
 	"use-context-selector",
@@ -25096,7 +25094,7 @@ const jsxNoConstructedContextValues = defineRule({
 					if (!isConstructedValue(innerExpression)) continue;
 					context.report({
 						node: attribute,
-						message: MESSAGE$48
+						message: MESSAGE$51
 					});
 				}
 			}
@@ -25962,7 +25960,7 @@ const DATA_ARRAY_PROP_SUFFIXES = [
 ];
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-new-array-as-prop.ts
-const MESSAGE$47 = "This child redraws every render because the prop gets a brand new array each time.";
+const MESSAGE$50 = "This child redraws every render because the prop gets a brand new array each time.";
 const isDataArrayPropName = (propName) => {
 	if (DATA_ARRAY_PROP_NAMES.has(propName)) return true;
 	for (const suffix of DATA_ARRAY_PROP_SUFFIXES) if (propName.length > suffix.length && propName.endsWith(suffix)) return true;
@@ -26049,7 +26047,7 @@ const jsxNoNewArrayAsProp = defineRule({
 				if (!isArrayProducingExpression(expressionNode) && !followsRenderLocalArrayBinding(expressionNode, node)) return;
 				context.report({
 					node,
-					message: MESSAGE$47
+					message: MESSAGE$50
 				});
 			}
 		};
@@ -26307,7 +26305,7 @@ const SAFE_RECEIVER_NAMES = new Set([
 ]);
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-new-function-as-prop.ts
-const MESSAGE$46 = "This child redraws every render because the prop gets a brand new function each time.";
+const MESSAGE$49 = "This child redraws every render because the prop gets a brand new function each time.";
 const isAccessorPredicateName = (propName) => {
 	for (const prefix of ACCESSOR_PREDICATE_PREFIXES) {
 		if (propName.length <= prefix.length) continue;
@@ -26514,7 +26512,7 @@ const jsxNoNewFunctionAsProp = defineRule({
 				if (!isFunctionProducingExpression(expressionNode) && !followsRenderLocalFunctionBinding(expressionNode, node)) return;
 				context.report({
 					node,
-					message: MESSAGE$46
+					message: MESSAGE$49
 				});
 			}
 		};
@@ -26734,7 +26732,7 @@ const CONFIG_OBJECT_PROP_SUFFIXES = [
 ];
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-new-object-as-prop.ts
-const MESSAGE$45 = "This child redraws every render because the prop gets a brand new object each time.";
+const MESSAGE$48 = "This child redraws every render because the prop gets a brand new object each time.";
 const isConfigObjectPropName = (propName) => {
 	if (CONFIG_OBJECT_PROP_NAMES.has(propName)) return true;
 	for (const suffix of CONFIG_OBJECT_PROP_SUFFIXES) if (propName.length > suffix.length && propName.endsWith(suffix)) return true;
@@ -26823,7 +26821,7 @@ const jsxNoNewObjectAsProp = defineRule({
 				if (!isObjectProducingExpression(expressionNode) && !followsRenderLocalObjectBinding(expressionNode, node)) return;
 				context.report({
 					node,
-					message: MESSAGE$45
+					message: MESSAGE$48
 				});
 			}
 		};
@@ -26831,7 +26829,7 @@ const jsxNoNewObjectAsProp = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-script-url.ts
-const MESSAGE$44 = "A `javascript:` URL is an XSS hole that runs injected input as code.";
+const MESSAGE$47 = "A `javascript:` URL is an XSS hole that runs injected input as code.";
 const JAVASCRIPT_URL_PATTERN = /^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;
 const resolveSettings$28 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
@@ -26869,7 +26867,7 @@ const jsxNoScriptUrl = defineRule({
 				if (!value || !isNodeOfType(value, "Literal") || typeof value.value !== "string") continue;
 				if (JAVASCRIPT_URL_PATTERN.test(value.value)) context.report({
 					node: attribute,
-					message: MESSAGE$44
+					message: MESSAGE$47
 				});
 			}
 		} };
@@ -27212,7 +27210,7 @@ const jsxPropsNoSpreadMulti = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-props-no-spreading.ts
-const MESSAGE$43 = "You can't tell what props reach this element when you spread them.";
+const MESSAGE$46 = "You can't tell what props reach this element when you spread them.";
 const resolveSettings$25 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxPropsNoSpreading ?? {} : {};
@@ -27255,7 +27253,7 @@ const jsxPropsNoSpreading = defineRule({
 				}
 				context.report({
 					node: attribute,
-					message: MESSAGE$43
+					message: MESSAGE$46
 				});
 				didReportInFile = true;
 				return;
@@ -27531,7 +27529,7 @@ const labelHasAssociatedControl = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/lang.ts
-const MESSAGE$42 = "Screen readers can't pick the right voice because this `lang` isn't a real language code, so use a valid one like `en` or `en-US`.";
+const MESSAGE$45 = "Screen readers can't pick the right voice because this `lang` isn't a real language code, so use a valid one like `en` or `en-US`.";
 const COMMON_LANGUAGE_PRIMARY_TAGS = new Set([
 	"aa",
 	"ab",
@@ -28011,7 +28009,7 @@ const lang = defineRule({
 			if (expression.type === "Identifier" && expression.name === "undefined" || expression.type === "Literal" && expression.value === null) {
 				context.report({
 					node: langAttr,
-					message: MESSAGE$42
+					message: MESSAGE$45
 				});
 				return;
 			}
@@ -28020,7 +28018,7 @@ const lang = defineRule({
 		if (value === null) return;
 		if (!isValidLangTag(value)) context.report({
 			node: langAttr,
-			message: MESSAGE$42
+			message: MESSAGE$45
 		});
 	} })
 });
@@ -28071,7 +28069,7 @@ const mdxSsrExecutionRisk = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/media-has-caption.ts
-const MESSAGE$41 = "Deaf and hard-of-hearing users need captions for this media. Add a `<track kind=\"captions\">` inside the `<audio>` or `<video>`.";
+const MESSAGE$44 = "Deaf and hard-of-hearing users need captions for this media. Add a `<track kind=\"captions\">` inside the `<audio>` or `<video>`.";
 const DEFAULT_AUDIO = ["audio"];
 const DEFAULT_VIDEO = ["video"];
 const DEFAULT_TRACK = ["track"];
@@ -28161,7 +28159,7 @@ const mediaHasCaption = defineRule({
 			if (!parent || !isNodeOfType(parent, "JSXElement")) {
 				context.report({
 					node: node.name,
-					message: MESSAGE$41
+					message: MESSAGE$44
 				});
 				return;
 			}
@@ -28180,12 +28178,553 @@ const mediaHasCaption = defineRule({
 				return kindValue.value.toLowerCase() === "captions";
 			})) context.report({
 				node: node.name,
-				message: MESSAGE$41
+				message: MESSAGE$44
 			});
 		} };
 	}
 });
 //#endregion
+//#region src/plugin/utils/get-class-binding-symbol.ts
+const getClassBindingSymbol = (classNode, scopes) => {
+	if (isNodeOfType(classNode.id, "Identifier")) return scopes.symbolFor(classNode.id);
+	const parent = classNode.parent;
+	return isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier") ? scopes.symbolFor(parent.id) : null;
+};
+//#endregion
+//#region src/plugin/utils/mobx-rule-gates.ts
+const MOBX_RULE_GATES = {
+	"mobx-reaction-disposer-discarded": { requires: ["mobx:4"] },
+	"mobx-no-make-auto-observable-in-inheritance": { requires: ["mobx:6"] },
+	"mobx-no-computed-side-effects": { requires: ["mobx:4"] },
+	"mobx-async-action-requires-action": { requires: ["mobx:4"] },
+	"mobx-no-observer-wrapped-memo": { requires: [
+		"mobx:4",
+		"mobx-react-binding",
+		"react"
+	] },
+	"mobx-make-observable-unconditional": { requires: ["mobx:6"] },
+	"mobx-legacy-decorator-needs-make-observable": { requires: ["mobx:6"] },
+	"mobx-initialize-before-make-auto-observable": { requires: ["mobx:6"] },
+	"mobx-observable-read-needs-observer": {
+		requires: [
+			"mobx:4",
+			"mobx-react-binding",
+			"react"
+		],
+		disabledWhen: ["mobx-react-observer"]
+	},
+	"mobx-observer-before-inject": { requires: [
+		"mobx:4",
+		"mobx-react",
+		"react"
+	] },
+	"mobx-reaction-requires-observable": { requires: ["mobx:4"] },
+	"mobx-no-invalid-observable-override": { requires: ["mobx:6"] },
+	"mobx-no-observable-prop-to-untracked-child": { requires: [
+		"mobx:4",
+		"mobx-react-binding",
+		"react"
+	] },
+	"mobx-no-stale-observable-snapshot-after-await": { requires: ["mobx:4"] },
+	"mobx-no-reaction-comparison-value-mutation": { requires: ["mobx:4"] },
+	"mobx-observer-class-no-should-component-update": { requires: [
+		"mobx:4",
+		"mobx-react",
+		"react"
+	] },
+	"mobx-enable-static-rendering-for-ssr": { requires: [
+		"mobx:4",
+		"mobx-react-binding",
+		"react",
+		"ssr"
+	] },
+	"mobx-no-rest-destructure-observable": { requires: [
+		"mobx:4",
+		"mobx-react-binding",
+		"react"
+	] },
+	"mobx-computed-depends-on-non-observable": { requires: ["mobx:4"] },
+	"mobx-no-keepalive-computed-without-disposal": { requires: ["mobx:4"] }
+};
+//#endregion
+//#region src/plugin/utils/resolve-imported-api-reference.ts
+const resolveImportSymbol = (symbol) => {
+	const importDeclaration = getImportDeclarationForSymbol(symbol);
+	if (!importDeclaration || typeof importDeclaration.source.value !== "string") return null;
+	if (isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier")) return {
+		source: importDeclaration.source.value,
+		importedName: null,
+		isNamespace: true
+	};
+	if (isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier")) return {
+		source: importDeclaration.source.value,
+		importedName: "default",
+		isNamespace: false
+	};
+	const importedName = getImportedName(symbol.declarationNode);
+	return importedName ? {
+		source: importDeclaration.source.value,
+		importedName,
+		isNamespace: false
+	} : null;
+};
+const resolveIdentifierReference = (identifier, scopes, visitedSymbolIds) => {
+	const symbol = scopes.symbolFor(identifier);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return null;
+	if (symbol.kind === "import") return resolveImportSymbol(symbol);
+	if (symbol.kind !== "const" || !symbol.initializer) return null;
+	visitedSymbolIds.add(symbol.id);
+	if (isNodeOfType(symbol.declarationNode, "VariableDeclarator") && isNodeOfType(symbol.declarationNode.id, "ObjectPattern")) {
+		const receiver = resolveImportedApiReference(symbol.initializer, scopes, visitedSymbolIds);
+		if (!receiver || !receiver.isNamespace && receiver.importedName !== "default") return null;
+		for (const property of symbol.declarationNode.id.properties) {
+			if (!isNodeOfType(property, "Property")) continue;
+			if ((isNodeOfType(property.value, "AssignmentPattern") ? property.value.left : property.value) !== symbol.bindingIdentifier) continue;
+			const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+			return propertyName ? {
+				source: receiver.source,
+				importedName: propertyName,
+				isNamespace: false
+			} : null;
+		}
+		return null;
+	}
+	return resolveImportedApiReference(symbol.initializer, scopes, visitedSymbolIds);
+};
+const resolveImportedApiReference = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "Identifier")) return resolveIdentifierReference(unwrappedExpression, scopes, visitedSymbolIds);
+	if (!isNodeOfType(unwrappedExpression, "MemberExpression")) return null;
+	const propertyName = getStaticPropertyName(unwrappedExpression);
+	if (!propertyName) return null;
+	const receiver = resolveImportedApiReference(unwrappedExpression.object, scopes, visitedSymbolIds);
+	if (!receiver || !receiver.isNamespace && receiver.importedName !== "default") return null;
+	return {
+		source: receiver.source,
+		importedName: propertyName,
+		isNamespace: false
+	};
+};
+//#endregion
+//#region src/plugin/rules/mobx/mobx-no-make-auto-observable-in-inheritance.ts
+const MESSAGE$43 = "MobX does not support `makeAutoObservable(this)` in inherited classes. Use composition or explicit `makeObservable` annotations.";
+const getEnclosingConstructorClass = (node) => {
+	let ancestor = node.parent;
+	while (ancestor) {
+		if (!isFunctionLike$1(ancestor)) {
+			ancestor = ancestor.parent ?? null;
+			continue;
+		}
+		const methodDefinition = ancestor.parent;
+		if (!isNodeOfType(methodDefinition, "MethodDefinition") || methodDefinition.kind !== "constructor") return null;
+		const classNode = methodDefinition.parent?.parent;
+		return isNodeOfType(classNode, "ClassDeclaration") || isNodeOfType(classNode, "ClassExpression") ? classNode : null;
+	}
+	return null;
+};
+const isNonNullSuperclass = (classNode) => {
+	if (!classNode.superClass) return false;
+	const superClass = stripParenExpression(classNode.superClass);
+	return !(isNodeOfType(superClass, "Literal") && superClass.value === null);
+};
+const subclassedClassSymbolIdsByAnalysis = /* @__PURE__ */ new WeakMap();
+const getSubclassedClassSymbolIds = (node, scopes) => {
+	const cached = subclassedClassSymbolIdsByAnalysis.get(scopes);
+	if (cached) return cached;
+	const symbolIds = /* @__PURE__ */ new Set();
+	const program = findProgramRoot(node);
+	if (program) walkAst(program, (candidate) => {
+		if (!isNodeOfType(candidate, "ClassDeclaration") && !isNodeOfType(candidate, "ClassExpression") || !isNonNullSuperclass(candidate)) return;
+		const superClassExpression = candidate.superClass;
+		if (!superClassExpression) return;
+		const superClass = stripParenExpression(superClassExpression);
+		if (!isNodeOfType(superClass, "Identifier")) return;
+		const symbol = resolveConstIdentifierAlias(superClass, scopes);
+		if (symbol?.kind === "class" || symbol?.kind === "const" && isNodeOfType(symbol.initializer, "ClassExpression")) symbolIds.add(symbol.id);
+	});
+	subclassedClassSymbolIdsByAnalysis.set(scopes, symbolIds);
+	return symbolIds;
+};
+const isMakeAutoObservableCall = (callExpression, scopes) => {
+	const reference = resolveImportedApiReference(callExpression.callee, scopes);
+	return reference?.source === "mobx" && reference.importedName === "makeAutoObservable";
+};
+const mobxNoMakeAutoObservableInInheritance = defineRule({
+	id: "mobx-no-make-auto-observable-in-inheritance",
+	title: "Unsupported MobX auto-observable inheritance",
+	severity: "error",
+	category: "Bugs",
+	requires: MOBX_RULE_GATES["mobx-no-make-auto-observable-in-inheritance"].requires,
+	recommendation: "Replace inheritance with composition, or annotate inherited members explicitly with `makeObservable`.",
+	create: (context) => ({ CallExpression(callExpression) {
+		if (!isMakeAutoObservableCall(callExpression, context.scopes)) return;
+		const target = callExpression.arguments[0];
+		if (!target || !isNodeOfType(stripParenExpression(target), "ThisExpression")) return;
+		const classNode = getEnclosingConstructorClass(callExpression);
+		if (!classNode) return;
+		const classSymbol = getClassBindingSymbol(classNode, context.scopes);
+		const isSubclassed = Boolean(classSymbol && getSubclassedClassSymbolIds(callExpression, context.scopes).has(classSymbol.id));
+		if (!isNonNullSuperclass(classNode) && !isSubclassed) return;
+		context.report({
+			node: callExpression,
+			message: MESSAGE$43
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/mobx/mobx-no-observer-wrapped-memo.ts
+const OBSERVER_MODULES = new Set(["mobx-react", "mobx-react-lite"]);
+const MESSAGE$42 = "`observer` cannot wrap an already memoized or observed component. Apply `observer` first, then place `memo` outside only if needed.";
+const isObserverCall = (callExpression, scopes) => {
+	const reference = resolveImportedApiReference(callExpression.callee, scopes);
+	return Boolean(reference?.importedName === "observer" && OBSERVER_MODULES.has(reference.source));
+};
+const hasInvalidInnerWrapper = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		const symbol = scopes.symbolFor(unwrappedExpression);
+		if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return false;
+		visitedSymbolIds.add(symbol.id);
+		return hasInvalidInnerWrapper(symbol.initializer, scopes, visitedSymbolIds);
+	}
+	if (!isNodeOfType(unwrappedExpression, "CallExpression")) return false;
+	const reference = resolveImportedApiReference(unwrappedExpression.callee, scopes);
+	if (reference?.importedName === "observer" && OBSERVER_MODULES.has(reference.source)) return true;
+	return reference?.source === "react" && reference.importedName === "memo";
+};
+const mobxNoObserverWrappedMemo = defineRule({
+	id: "mobx-no-observer-wrapped-memo",
+	title: "Invalid MobX observer wrapper order",
+	severity: "error",
+	category: "Bugs",
+	requires: MOBX_RULE_GATES["mobx-no-observer-wrapped-memo"].requires,
+	recommendation: "Pass the component directly to `observer`, or apply React `memo` outside the resulting observer component.",
+	create: (context) => ({ CallExpression(callExpression) {
+		if (!isObserverCall(callExpression, context.scopes)) return;
+		const componentArgument = callExpression.arguments[0];
+		if (!componentArgument) return;
+		if (!hasInvalidInnerWrapper(componentArgument, context.scopes)) return;
+		context.report({
+			node: callExpression,
+			message: MESSAGE$42
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/utils/is-result-discarded-call.ts
+const isResultDiscardedCall = (callExpression) => {
+	let node = callExpression;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "ExpressionStatement")) return true;
+		if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "void") return true;
+		if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === node) return true;
+		if (isNodeOfType(parent, "ChainExpression")) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "SequenceExpression")) {
+			const expressions = parent.expressions ?? [];
+			if (expressions[expressions.length - 1] !== node) return true;
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		return false;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/resolve-stable-options-object.ts
+const resolveStableOptionsObject = (expression, observedPropertyNames, scopes, referenceNode = expression, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "ObjectExpression")) return unwrappedExpression;
+	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
+	const symbol = scopes.symbolFor(unwrappedExpression);
+	if (!symbol?.initializer || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, referenceNode, scopes) || observedPropertyNames.some((propertyName) => hasPossibleStaticPropertyWriteBefore(unwrappedExpression, propertyName, referenceNode, scopes))) return null;
+	visitedSymbolIds.add(symbol.id);
+	return resolveStableOptionsObject(symbol.initializer, observedPropertyNames, scopes, referenceNode, visitedSymbolIds);
+};
+//#endregion
+//#region src/plugin/rules/mobx/mobx-reaction-disposer-discarded.ts
+const MESSAGE$41 = "This MobX reaction discards its disposer and can outlive its owner. Store and dispose it during teardown, or provide an AbortSignal.";
+const LEAKING_SUBSCRIPTION_NAMES = new Set(["reaction", "autorun"]);
+const OPTIONS_ARGUMENT_INDEX = {
+	autorun: 1,
+	reaction: 2
+};
+const DISPOSER_COERCION_NAMES = new Set([
+	"Boolean",
+	"Number",
+	"String"
+]);
+const NON_OBSERVABLE_GLOBAL_RECEIVER_NAMES = new Set([
+	"Array",
+	"Boolean",
+	"JSON",
+	"Math",
+	"Number",
+	"Object",
+	"String",
+	"console"
+]);
+const NON_OBSERVING_IMPORTED_METHOD_NAMES = new Set([
+	"add",
+	"clear",
+	"delete",
+	"remove",
+	"save",
+	"set",
+	"update",
+	"write"
+]);
+const REACTION_PARAMETER_INDEX = {
+	autorun: 0,
+	reaction: 2
+};
+const REACTION_CALLBACK_INDEX = {
+	autorun: 0,
+	reaction: 1
+};
+const OBSERVATION_CALLBACK_INDEX = {
+	autorun: 0,
+	reaction: 0
+};
+const PROCESS_LIFETIME_WIRING_NAME_PATTERN = /^(?:register.*(?:reactions?|autoruns?)|init.*(?:stores?|reactions?|autoruns?)|setup.*(?:stores?|reactions?|autoruns?)|bootstrap(?:app(?:lication)?|stores?|reactions?|autoruns?))$/i;
+const resolveLeakingSubscriptionName = (callExpression, scopes) => {
+	const reference = resolveImportedApiReference(callExpression.callee, scopes);
+	if (reference?.source !== "mobx" || !reference.importedName || !LEAKING_SUBSCRIPTION_NAMES.has(reference.importedName)) return null;
+	return reference.importedName;
+};
+const isEvaluatedAtModuleScope = (node) => {
+	let ancestor = node.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "PropertyDefinition") || isNodeOfType(ancestor, "AccessorProperty")) {
+			if (!ancestor.static) return false;
+			ancestor = ancestor.parent ?? null;
+			continue;
+		}
+		if (isNodeOfType(ancestor, "StaticBlock")) {
+			ancestor = ancestor.parent ?? null;
+			continue;
+		}
+		if (isFunctionLike$1(ancestor)) {
+			const functionRoot = findTransparentExpressionRoot(ancestor);
+			const invocation = functionRoot.parent;
+			if (isNodeOfType(invocation, "CallExpression") && stripParenExpression(invocation.callee) === functionRoot) {
+				ancestor = invocation.parent ?? null;
+				continue;
+			}
+			return false;
+		}
+		ancestor = ancestor.parent ?? null;
+	}
+	return true;
+};
+const getFunctionName = (functionNode) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id.name;
+	const parent = functionNode.parent;
+	return isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier") ? parent.id.name : null;
+};
+const isModuleScopedFunction = (functionNode) => {
+	let ancestor = functionNode.parent;
+	while (ancestor) {
+		if (isFunctionLike$1(ancestor) || isNodeOfType(ancestor, "ClassBody")) return false;
+		if (isNodeOfType(ancestor, "Program")) return true;
+		ancestor = ancestor.parent ?? null;
+	}
+	return false;
+};
+const getDirectCalls = (functionNode, scopes) => {
+	const bindingIdentifier = isNodeOfType(functionNode, "FunctionDeclaration") ? functionNode.id : isNodeOfType(functionNode.parent, "VariableDeclarator") ? functionNode.parent.id : null;
+	if (!bindingIdentifier || !isNodeOfType(bindingIdentifier, "Identifier")) return [];
+	const symbol = scopes.scopeFor(functionNode).symbolsByName.get(bindingIdentifier.name);
+	if (!symbol) return [];
+	const calls = [];
+	const program = findProgramRoot(functionNode);
+	if (!program) return calls;
+	walkAst(program, (candidate) => {
+		if (!isNodeOfType(candidate, "CallExpression")) return;
+		const callee = stripParenExpression(candidate.callee);
+		if (!isNodeOfType(callee, "Identifier")) return;
+		if (resolveConstIdentifierAlias(callee, scopes)?.id === symbol.id) calls.push(candidate);
+	});
+	return calls;
+};
+const processLifetimeClassSymbolIdsByAnalysis = /* @__PURE__ */ new WeakMap();
+const getProcessLifetimeClassSymbolIds = (node, scopes) => {
+	const cached = processLifetimeClassSymbolIdsByAnalysis.get(scopes);
+	if (cached) return cached;
+	const instantiationScopeBySymbolId = /* @__PURE__ */ new Map();
+	const program = findProgramRoot(node);
+	if (program) walkAst(program, (candidate) => {
+		if (!isNodeOfType(candidate, "NewExpression")) return;
+		const callee = stripParenExpression(candidate.callee);
+		const symbol = isNodeOfType(callee, "Identifier") ? resolveConstIdentifierAlias(callee, scopes) : null;
+		if (!symbol) return;
+		const wasModuleOnly = instantiationScopeBySymbolId.get(symbol.id) ?? true;
+		instantiationScopeBySymbolId.set(symbol.id, wasModuleOnly && isEvaluatedAtModuleScope(candidate));
+	});
+	const processLifetimeSymbolIds = /* @__PURE__ */ new Set();
+	for (const [symbolId, isModuleOnly] of instantiationScopeBySymbolId) if (isModuleOnly) processLifetimeSymbolIds.add(symbolId);
+	processLifetimeClassSymbolIdsByAnalysis.set(scopes, processLifetimeSymbolIds);
+	return processLifetimeSymbolIds;
+};
+const isProcessLifetimeWiring = (node, scopes) => {
+	let ancestor = node.parent;
+	while (ancestor) {
+		if (!isFunctionLike$1(ancestor)) {
+			ancestor = ancestor.parent ?? null;
+			continue;
+		}
+		const functionName = getFunctionName(ancestor);
+		if (functionName && PROCESS_LIFETIME_WIRING_NAME_PATTERN.test(functionName) && isModuleScopedFunction(ancestor)) {
+			const calls = getDirectCalls(ancestor, scopes);
+			return calls.length > 0 && calls.every(isEvaluatedAtModuleScope);
+		}
+		const methodDefinition = ancestor.parent;
+		if (isNodeOfType(methodDefinition, "MethodDefinition") && methodDefinition.kind === "constructor") {
+			let classNode = methodDefinition.parent?.parent;
+			if (isNodeOfType(classNode, "ClassDeclaration") || isNodeOfType(classNode, "ClassExpression")) {
+				const classRoot = findTransparentExpressionRoot(classNode);
+				const classInstantiation = classRoot.parent;
+				if (isNodeOfType(classNode, "ClassExpression") && isNodeOfType(classInstantiation, "NewExpression") && stripParenExpression(classInstantiation.callee) === classRoot) return isEvaluatedAtModuleScope(classInstantiation);
+				const classSymbol = getClassBindingSymbol(classNode, scopes);
+				return Boolean(classSymbol && getProcessLifetimeClassSymbolIds(node, scopes).has(classSymbol.id));
+			}
+		}
+		return false;
+	}
+	return false;
+};
+const mayCarryAbortSignal = (optionsArgument, scopes) => {
+	if (!optionsArgument) return false;
+	const options = resolveStableOptionsObject(optionsArgument, ["signal"], scopes);
+	if (!options) return true;
+	return options.properties.some((property) => {
+		if (!isNodeOfType(property, "Property")) return true;
+		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+		if (propertyName === null) return true;
+		if (propertyName !== "signal") return false;
+		const value = property.value;
+		if (isNodeOfType(value, "Identifier") && value.name === "undefined") return false;
+		if (isNodeOfType(value, "Literal") && value.value == null) return false;
+		return !(isNodeOfType(value, "UnaryExpression") && value.operator === "void");
+	});
+};
+const callbackDisposesReaction = (callExpression, subscriptionName, scopes) => {
+	const callbackArgument = callExpression.arguments[REACTION_CALLBACK_INDEX[subscriptionName]];
+	if (!callbackArgument || isNodeOfType(callbackArgument, "SpreadElement")) return false;
+	const callback = resolveExactLocalFunction(callbackArgument, scopes);
+	if (!callback || !isFunctionLike$1(callback)) return false;
+	const reactionParameter = callback.params?.[REACTION_PARAMETER_INDEX[subscriptionName]];
+	if (!reactionParameter || !isNodeOfType(reactionParameter, "Identifier")) return false;
+	const reactionSymbol = scopes.symbolFor(reactionParameter);
+	if (!reactionSymbol) return false;
+	let doesDisposeReaction = false;
+	walkAst(callback, (candidate) => {
+		if (doesDisposeReaction || !isNodeOfType(candidate, "CallExpression")) return;
+		const callee = stripParenExpression(candidate.callee);
+		if (!isNodeOfType(callee, "MemberExpression")) return;
+		const receiver = stripParenExpression(callee.object);
+		if (isNodeOfType(receiver, "Identifier") && scopes.symbolFor(receiver)?.id === reactionSymbol.id && getStaticPropertyKeyName(callee, { allowComputedString: true }) === "dispose") doesDisposeReaction = true;
+	});
+	return doesDisposeReaction;
+};
+const getMemberReceiverRoot = (memberExpression) => {
+	let receiver = stripParenExpression(memberExpression);
+	while (isNodeOfType(receiver, "MemberExpression")) receiver = stripParenExpression(receiver.object);
+	return receiver;
+};
+const observesOnlyInstanceRootedState = (callExpression, subscriptionName, scopes) => {
+	const callbackArgument = callExpression.arguments[OBSERVATION_CALLBACK_INDEX[subscriptionName]];
+	if (!callbackArgument || isNodeOfType(callbackArgument, "SpreadElement")) return false;
+	const callback = resolveExactLocalFunction(callbackArgument, scopes);
+	if (!callback || !isFunctionLike$1(callback)) return false;
+	let observesExternalState = false;
+	walkAst(callback, (candidate) => {
+		if (candidate !== callback && isFunctionLike$1(candidate)) return false;
+		if (observesExternalState || !isNodeOfType(candidate, "MemberExpression")) return;
+		const receiver = getMemberReceiverRoot(candidate);
+		const candidateRoot = findTransparentExpressionRoot(candidate);
+		const parent = candidateRoot.parent;
+		const isDirectMethodCall = isNodeOfType(parent, "CallExpression") && parent.callee === candidateRoot;
+		if (isNodeOfType(receiver, "ThisExpression")) {
+			if (isDirectMethodCall) observesExternalState = true;
+			return;
+		}
+		if (!isNodeOfType(receiver, "Identifier")) {
+			observesExternalState = true;
+			return;
+		}
+		const receiverSymbol = scopes.symbolFor(receiver);
+		if (receiverSymbol && isAstDescendant(receiverSymbol.declarationNode, callback) || scopes.isGlobalReference(receiver) && NON_OBSERVABLE_GLOBAL_RECEIVER_NAMES.has(receiver.name)) return;
+		if (receiverSymbol?.kind === "import" && isDirectMethodCall && NON_OBSERVING_IMPORTED_METHOD_NAMES.has(getStaticPropertyKeyName(candidate, { allowComputedString: true }) ?? "")) return;
+		observesExternalState = true;
+	});
+	return !observesExternalState;
+};
+const isForwardedFromConciseArrow = (callExpression) => {
+	let expressionRoot = findTransparentExpressionRoot(callExpression);
+	let parent = expressionRoot.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === expressionRoot) return true;
+		if (isNodeOfType(parent, "LogicalExpression") && (parent.right === expressionRoot || parent.left === expressionRoot && parent.operator !== "&&") || isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === expressionRoot || parent.alternate === expressionRoot) || isNodeOfType(parent, "SequenceExpression") && parent.expressions[parent.expressions.length - 1] === expressionRoot) {
+			expressionRoot = findTransparentExpressionRoot(parent);
+			parent = expressionRoot.parent;
+			continue;
+		}
+		return false;
+	}
+	return false;
+};
+const isDisposerDiscarded = (callExpression) => {
+	if (isForwardedFromConciseArrow(callExpression)) return false;
+	const expressionRoot = findTransparentExpressionRoot(callExpression);
+	if (isResultDiscardedCall(callExpression)) return true;
+	const parent = expressionRoot.parent;
+	if (!parent) return false;
+	if (isNodeOfType(parent, "UnaryExpression") || isNodeOfType(parent, "BinaryExpression")) return true;
+	if ((isNodeOfType(parent, "IfStatement") || isNodeOfType(parent, "WhileStatement") || isNodeOfType(parent, "DoWhileStatement") || isNodeOfType(parent, "ForStatement")) && parent.test === expressionRoot) return true;
+	if (isNodeOfType(parent, "ConditionalExpression") && parent.test === expressionRoot || isNodeOfType(parent, "SwitchStatement") && parent.discriminant === expressionRoot) return true;
+	if (isNodeOfType(parent, "LogicalExpression") && parent.left === expressionRoot) return parent.operator === "&&" || isResultDiscardedCall(parent);
+	const callee = isNodeOfType(parent, "CallExpression") ? stripParenExpression(parent.callee) : null;
+	return Boolean(isNodeOfType(parent, "CallExpression") && parent.arguments.some((argument) => argument === expressionRoot) && isNodeOfType(callee, "Identifier") && DISPOSER_COERCION_NAMES.has(callee.name));
+};
+const mobxReactionDisposerDiscarded = defineRule({
+	id: "mobx-reaction-disposer-discarded",
+	title: "MobX reaction disposer discarded",
+	severity: "warn",
+	category: "Bugs",
+	requires: MOBX_RULE_GATES["mobx-reaction-disposer-discarded"].requires,
+	recommendation: "Keep the disposer returned by `reaction` or `autorun` and invoke it during teardown, or provide an AbortSignal.",
+	create: (context) => ({ CallExpression(callExpression) {
+		const subscriptionName = resolveLeakingSubscriptionName(callExpression, context.scopes);
+		if (!subscriptionName || !isDisposerDiscarded(callExpression)) return;
+		if (isEvaluatedAtModuleScope(callExpression)) return;
+		if (isProcessLifetimeWiring(callExpression, context.scopes)) return;
+		if (callbackDisposesReaction(callExpression, subscriptionName, context.scopes)) return;
+		if (observesOnlyInstanceRootedState(callExpression, subscriptionName, context.scopes)) return;
+		const optionsArgument = callExpression.arguments[OPTIONS_ARGUMENT_INDEX[subscriptionName]];
+		if (mayCarryAbortSignal(optionsArgument, context.scopes)) return;
+		context.report({
+			node: callExpression,
+			message: MESSAGE$41
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/utils/has-jsx-prop.ts
 const hasJsxProp = (attributes, targetProp) => {
 	for (const attribute of attributes) {
@@ -28976,11 +29515,11 @@ const hasEmailTemplateImport = (programRoot) => {
 	return found;
 };
 //#endregion
-//#region src/plugin/utils/build-generated-image-project-index.ts
-const GENERATED_IMAGE_SOURCE_FILE_PATTERN = /\.[cm]?[jt]sx?$/i;
-const GENERATED_IMAGE_DECLARATION_FILE_PATTERN = /\.d\.[cm]?[jt]s$/i;
-const GENERATED_IMAGE_MDX_FILE_PATTERN = /\.mdx$/i;
-const GENERATED_IMAGE_IGNORED_DIRECTORY_NAMES = new Set([
+//#region src/plugin/utils/build-source-project-index.ts
+const SOURCE_PROJECT_FILE_PATTERN = /\.[cm]?[jt]sx?$/i;
+const SOURCE_PROJECT_DECLARATION_FILE_PATTERN = /\.d\.[cm]?[jt]s$/i;
+const SOURCE_PROJECT_MDX_FILE_PATTERN = /\.mdx$/i;
+const SOURCE_PROJECT_IGNORED_DIRECTORY_NAMES = new Set([
 	".angular",
 	".astro",
 	".cache",
@@ -29001,12 +29540,12 @@ const GENERATED_IMAGE_IGNORED_DIRECTORY_NAMES = new Set([
 	"out",
 	"storybook-static"
 ]);
-const generatedImageScopeCache = /* @__PURE__ */ new WeakMap();
-const getGeneratedImageModuleScopes = (programNode) => {
-	const cachedScopes = generatedImageScopeCache.get(programNode);
+const sourceProjectScopeCache = /* @__PURE__ */ new WeakMap();
+const getSourceProjectModuleScopes = (programNode) => {
+	const cachedScopes = sourceProjectScopeCache.get(programNode);
 	if (cachedScopes) return cachedScopes;
 	const scopes = analyzeScopes(programNode);
-	generatedImageScopeCache.set(programNode, scopes);
+	sourceProjectScopeCache.set(programNode, scopes);
 	return scopes;
 };
 const listProductionSourceFiles = (rootDirectory) => {
@@ -29024,7 +29563,7 @@ const listProductionSourceFiles = (rootDirectory) => {
 		}
 		for (const entry of entries) {
 			const absolutePath = path.join(currentDirectory, entry.name);
-			const isIgnoredDirectoryName = GENERATED_IMAGE_IGNORED_DIRECTORY_NAMES.has(entry.name) || entry.name.startsWith(".") && entry.name !== ".dumi" && entry.name !== ".storybook";
+			const isIgnoredDirectoryName = SOURCE_PROJECT_IGNORED_DIRECTORY_NAMES.has(entry.name) || entry.name.startsWith(".") && entry.name !== ".dumi" && entry.name !== ".storybook";
 			if (entry.isSymbolicLink() && isIgnoredDirectoryName) continue;
 			if (entry.isSymbolicLink()) return null;
 			if (entry.isDirectory()) {
@@ -29033,12 +29572,12 @@ const listProductionSourceFiles = (rootDirectory) => {
 				continue;
 			}
 			if (!entry.isFile() || isTestlikeFilename(absolutePath)) continue;
-			if (GENERATED_IMAGE_MDX_FILE_PATTERN.test(entry.name)) {
+			if (SOURCE_PROJECT_MDX_FILE_PATTERN.test(entry.name)) {
 				hasOpaqueMdxConsumerSurface = true;
 				continue;
 			}
-			if (!GENERATED_IMAGE_SOURCE_FILE_PATTERN.test(entry.name)) continue;
-			if (GENERATED_IMAGE_DECLARATION_FILE_PATTERN.test(entry.name)) continue;
+			if (!SOURCE_PROJECT_FILE_PATTERN.test(entry.name)) continue;
+			if (SOURCE_PROJECT_DECLARATION_FILE_PATTERN.test(entry.name)) continue;
 			sourceFilePaths.push(normalizeFilename(absolutePath));
 		}
 	}
@@ -29083,7 +29622,7 @@ const indexModuleSources = (module, consumerModulesByFilePath, resolvedSourcePat
 		consumerModulesByFilePath.set(normalizedSourcePath, consumerModules);
 	});
 };
-const buildGeneratedImageProjectIndex = (rootDirectory, currentFilePath, currentProgramNode, currentScopes) => {
+const buildSourceProjectIndex = (rootDirectory, currentFilePath, currentProgramNode, currentScopes) => {
 	const productionSourceFiles = listProductionSourceFiles(rootDirectory);
 	if (!productionSourceFiles) return null;
 	const modulesByFilePath = /* @__PURE__ */ new Map();
@@ -29101,7 +29640,7 @@ const buildGeneratedImageProjectIndex = (rootDirectory, currentFilePath, current
 		modulesByFilePath.set(filePath, {
 			filePath,
 			programNode: parsedProgram,
-			scopes: getGeneratedImageModuleScopes(parsedProgram)
+			scopes: getSourceProjectModuleScopes(parsedProgram)
 		});
 	}
 	const consumerModulesByFilePath = /* @__PURE__ */ new Map();
@@ -29117,6 +29656,51 @@ const buildGeneratedImageProjectIndex = (rootDirectory, currentFilePath, current
 	};
 };
 //#endregion
+//#region src/plugin/utils/get-direct-function-binding-identifier.ts
+const getDirectFunctionBindingIdentifier = (functionNode) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
+	const functionValueRoot = findTransparentExpressionRoot(functionNode);
+	const parent = functionValueRoot.parent;
+	return isNodeOfType(parent, "VariableDeclarator") && parent.init === functionValueRoot && isNodeOfType(parent.id, "Identifier") ? parent.id : null;
+};
+//#endregion
+//#region src/plugin/utils/get-function-export-names.ts
+const getExportedSpecifierName$1 = (specifier) => {
+	const exported = specifier.exported;
+	if (isNodeOfType(exported, "Identifier")) return exported.name;
+	return isNodeOfType(exported, "Literal") && typeof exported.value === "string" ? exported.value : null;
+};
+const getLocalSpecifierName = (specifier) => {
+	const local = specifier.local;
+	if (isNodeOfType(local, "Identifier")) return local.name;
+	return isNodeOfType(local, "Literal") && typeof local.value === "string" ? local.value : null;
+};
+const getFunctionExportNames = (programNode, functionNode) => {
+	const functionValueRoot = findTransparentExpressionRoot(functionNode);
+	const bindingName = getDirectFunctionBindingIdentifier(functionNode)?.name ?? null;
+	const exportedNames = /* @__PURE__ */ new Set();
+	for (const statement of programNode.body) {
+		if (isNodeOfType(statement, "ExportDefaultDeclaration")) {
+			if (statement.declaration === functionValueRoot || bindingName && isNodeOfType(statement.declaration, "Identifier") && statement.declaration.name === bindingName) exportedNames.add("default");
+			continue;
+		}
+		if (!isNodeOfType(statement, "ExportNamedDeclaration")) continue;
+		const declaration = statement.declaration;
+		if (declaration === functionValueRoot && bindingName) exportedNames.add(bindingName);
+		if (declaration && isNodeOfType(declaration, "VariableDeclaration")) {
+			for (const declarator of declaration.declarations) if (declarator.init === functionValueRoot && isNodeOfType(declarator.id, "Identifier")) exportedNames.add(declarator.id.name);
+		}
+		if (!bindingName || statement.source) continue;
+		for (const specifier of statement.specifiers) {
+			if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
+			if (getLocalSpecifierName(specifier) !== bindingName) continue;
+			const exportedName = getExportedSpecifierName$1(specifier);
+			if (exportedName) exportedNames.add(exportedName);
+		}
+	}
+	return [...exportedNames];
+};
+//#endregion
 //#region src/plugin/utils/read-nearest-package-manifest.ts
 const cachedPackageDirectoryByFilename = /* @__PURE__ */ new Map();
 const cachedManifestByPackageDirectory = /* @__PURE__ */ new Map();
@@ -29201,37 +29785,6 @@ const getImportSpecifierName = (specifier) => {
 	if (isNodeOfType(imported, "Identifier")) return imported.name;
 	return isNodeOfType(imported, "Literal") && typeof imported.value === "string" ? imported.value : null;
 };
-const getDirectFunctionBindingIdentifier = (functionNode) => {
-	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
-	const functionValueRoot = findTransparentExpressionRoot(functionNode);
-	const parent = functionValueRoot.parent;
-	return isNodeOfType(parent, "VariableDeclarator") && parent.init === functionValueRoot && isNodeOfType(parent.id, "Identifier") ? parent.id : null;
-};
-const getExportNamesForFunction = (programNode, functionNode) => {
-	const functionValueRoot = findTransparentExpressionRoot(functionNode);
-	const bindingName = getDirectFunctionBindingIdentifier(functionNode)?.name ?? null;
-	const exportedNames = /* @__PURE__ */ new Set();
-	for (const statement of programNode.body) {
-		if (isNodeOfType(statement, "ExportDefaultDeclaration")) {
-			if (statement.declaration === functionValueRoot || bindingName && isNodeOfType(statement.declaration, "Identifier") && statement.declaration.name === bindingName) exportedNames.add("default");
-			continue;
-		}
-		if (!isNodeOfType(statement, "ExportNamedDeclaration")) continue;
-		const declaration = statement.declaration;
-		if (declaration === functionValueRoot && bindingName) exportedNames.add(bindingName);
-		if (declaration && isNodeOfType(declaration, "VariableDeclaration")) {
-			for (const declarator of declaration.declarations) if (declarator.init === functionValueRoot && isNodeOfType(declarator.id, "Identifier")) exportedNames.add(declarator.id.name);
-		}
-		if (!bindingName || statement.source) continue;
-		for (const specifier of statement.specifiers) {
-			if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
-			if (getImportedSpecifierName(specifier) !== bindingName) continue;
-			const exportedName = getExportedSpecifierName(specifier);
-			if (exportedName) exportedNames.add(exportedName);
-		}
-	}
-	return [...exportedNames];
-};
 const isTransparentGeneratedImageValueFlow = (expression, target) => {
 	let current = findTransparentExpressionRoot(expression);
 	while (current !== target) {
@@ -29290,7 +29843,7 @@ const classifyInvokedExpression = (module, expression, state) => {
 	}
 	const forwardingFunction = getForwardingFunction(expression);
 	if (!forwardingFunction) return false;
-	const exportedNames = getExportNamesForFunction(module.programNode, forwardingFunction);
+	const exportedNames = getFunctionExportNames(module.programNode, forwardingFunction);
 	if (exportedNames.length === 0) return false;
 	for (const exportedName of exportedNames) enqueueExport(state, module.filePath, exportedName);
 	return true;
@@ -29423,9 +29976,9 @@ const createExportedJsxGeneratedImageOwnershipAnalyzer = (context) => {
 		const programNode = findProgramRoot(jsxNode);
 		const enclosingFunction = findEnclosingFunction$1(jsxNode);
 		if (!programNode || !enclosingFunction) return false;
-		const initialExportNames = getExportNamesForFunction(programNode, enclosingFunction);
+		const initialExportNames = getFunctionExportNames(programNode, enclosingFunction);
 		if (initialExportNames.length === 0) return false;
-		if (projectIndex === void 0) projectIndex = buildGeneratedImageProjectIndex(rootDirectory, filename, programNode, context.scopes);
+		if (projectIndex === void 0) projectIndex = buildSourceProjectIndex(rootDirectory, filename, programNode, context.scopes);
 		if (!projectIndex || projectIndex.hasOpaqueMdxConsumerSurface) return false;
 		const state = {
 			projectIndex,
@@ -41733,18 +42286,10 @@ const isCompletionSinkAfterCancellationEarlyExit = (completionSink, cancellation
 	return false;
 };
 const isCompletionSinkGuardedByCancellationFlag = (completionSink, cancellationFlagKey, context) => isCompletionSinkInsideCancellationGuard(completionSink, cancellationFlagKey, context) || isCompletionSinkAfterCancellationEarlyExit(completionSink, cancellationFlagKey, context);
-const isDescendantOf = (node, ancestor) => {
-	let currentNode = node;
-	while (currentNode) {
-		if (currentNode === ancestor) return true;
-		currentNode = currentNode.parent ?? null;
-	}
-	return false;
-};
 const isPromiseContinuationForRequest = (functionNode, request) => {
 	const callNode = functionNode.parent;
 	if (!isNodeOfType(callNode, "CallExpression") || !callNode.arguments?.some((callArgument) => callArgument === functionNode) || !isNodeOfType(callNode.callee, "MemberExpression") || callNode.callee.computed || !isNodeOfType(callNode.callee.property, "Identifier") || !PROMISE_CONTINUATION_METHOD_NAMES$1.has(callNode.callee.property.name)) return false;
-	return isDescendantOf(request, callNode.callee.object);
+	return isAstDescendant(request, callNode.callee.object);
 };
 const isAwaitedInFunction = (request, functionNode) => {
 	let currentNode = request.parent;
@@ -45416,41 +45961,6 @@ const noMutableInDeps = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-result-discarded-call.ts
-const isResultDiscardedCall = (callExpression) => {
-	let node = callExpression;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "ExpressionStatement")) return true;
-		if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "void") return true;
-		if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === node) return true;
-		if (isNodeOfType(parent, "ChainExpression")) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "SequenceExpression")) {
-			const expressions = parent.expressions ?? [];
-			if (expressions[expressions.length - 1] !== node) return true;
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		return false;
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/lodash-mutator-call.ts
 const LODASH_MUTATOR_NAMES = new Set([
 	"set",
@@ -53688,7 +54198,7 @@ const isElementTypeJsxAttribute = (node) => {
 	const attributeName = node.name.name;
 	return ELEMENT_TYPE_PROP_NAMES.has(attributeName.toLowerCase()) || attributeName.endsWith("Component");
 };
-const isReactUseMemoCallback = (call, valueNode, scopes) => call.arguments[0] === valueNode && isReactApiCall(call, "useMemo", scopes, {
+const isReactUseMemoCallback$1 = (call, valueNode, scopes) => call.arguments[0] === valueNode && isReactApiCall(call, "useMemo", scopes, {
 	allowGlobalReactNamespace: true,
 	resolveNamedAliases: true
 });
@@ -53712,7 +54222,7 @@ const isRenderFlowingReadReference = (identifier, scopes, visitedSymbols = /* @_
 			case "ArrowFunctionExpression": return false;
 			case "CallExpression":
 				if (parent.callee === valueNode) return false;
-				if (isReactUseMemoCallback(parent, valueNode, scopes)) return false;
+				if (isReactUseMemoCallback$1(parent, valueNode, scopes)) return false;
 				if (isReactCreateElementCall(parent, scopes)) return true;
 				valueNode = parent;
 				parent = parent.parent;
@@ -58739,6 +59249,560 @@ const reduxUseselectorReturnsNewCollection = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/is-remotion-module-source.ts
+const isRemotionModuleSource = (moduleSource) => moduleSource === "remotion" || moduleSource.startsWith("@remotion/");
+//#endregion
+//#region src/plugin/utils/resolve-remotion-api.ts
+const resolveRemotionApi = (referenceNode, scopes) => {
+	const candidate = stripParenExpression(referenceNode);
+	if (isNodeOfType(candidate, "Identifier") || isNodeOfType(candidate, "JSXIdentifier")) {
+		const symbol = scopes.symbolFor(candidate);
+		if (symbol?.kind !== "import") return null;
+		const importBinding = getImportBindingForName(candidate, symbol.name);
+		if (!importBinding || importBinding.isNamespace || importBinding.exportedName === null || !isRemotionModuleSource(importBinding.source)) return null;
+		return {
+			apiName: importBinding.exportedName,
+			moduleSource: importBinding.source
+		};
+	}
+	if (isNodeOfType(candidate, "MemberExpression")) {
+		const apiName = getStaticPropertyKeyName(candidate, { allowComputedString: true });
+		const namespaceObject = stripParenExpression(candidate.object);
+		if (!apiName || !isNodeOfType(namespaceObject, "Identifier")) return null;
+		const symbol = scopes.symbolFor(namespaceObject);
+		if (symbol?.kind !== "import") return null;
+		const importBinding = getImportBindingForName(namespaceObject, symbol.name);
+		if (!importBinding?.isNamespace || !isRemotionModuleSource(importBinding.source)) return null;
+		return {
+			apiName,
+			moduleSource: importBinding.source
+		};
+	}
+	if (!isNodeOfType(candidate, "JSXMemberExpression") || !isNodeOfType(candidate.object, "JSXIdentifier") || !isNodeOfType(candidate.property, "JSXIdentifier")) return null;
+	const symbol = scopes.symbolFor(candidate.object);
+	if (symbol?.kind !== "import") return null;
+	const importBinding = getImportBindingForName(candidate.object, symbol.name);
+	if (!importBinding?.isNamespace || !isRemotionModuleSource(importBinding.source)) return null;
+	return {
+		apiName: candidate.property.name,
+		moduleSource: importBinding.source
+	};
+};
+//#endregion
+//#region src/plugin/utils/create-remotion-composition-ownership-analyzer.ts
+const compositionAttributeFunctionCacheBySettings = /* @__PURE__ */ new WeakMap();
+const getFunctionExportKeys = (filePath, programNode, functionNode) => getFunctionExportNames(programNode, functionNode).map((exportedName) => `${normalizeFilename(filePath)}\0${exportedName}`);
+const resolveImportedCompositionFunction = (expression, module) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	let importReference;
+	let exportedName;
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		const symbol = module.scopes.symbolFor(unwrappedExpression);
+		if (symbol?.kind !== "import") return null;
+		importReference = unwrappedExpression;
+		exportedName = getImportBindingForName(unwrappedExpression, symbol.name)?.exportedName ?? null;
+	} else if (isNodeOfType(unwrappedExpression, "MemberExpression") && isNodeOfType(stripParenExpression(unwrappedExpression.object), "Identifier")) {
+		const namespaceObject = stripParenExpression(unwrappedExpression.object);
+		if (!isNodeOfType(namespaceObject, "Identifier")) return null;
+		const symbol = module.scopes.symbolFor(namespaceObject);
+		if (symbol?.kind !== "import") return null;
+		if (!getImportBindingForName(namespaceObject, symbol.name)?.isNamespace) return null;
+		importReference = namespaceObject;
+		exportedName = getStaticPropertyKeyName(unwrappedExpression, { allowComputedString: true });
+	} else return null;
+	if (!exportedName) return null;
+	const importBinding = getImportBindingForName(importReference, importReference.name);
+	if (!importBinding) return null;
+	return resolveCrossFileFunctionExportWithFilePath(module.filePath, importBinding.source, exportedName);
+};
+const collectCompositionAttributeFunctionKeys = (context, currentProgram, attributeName) => {
+	const filename = context.filename ? normalizeFilename(context.filename) : "";
+	const rootDirectorySetting = getReactDoctorStringSetting(context.settings, "rootDirectory");
+	const rootDirectory = rootDirectorySetting ? normalizeFilename(rootDirectorySetting).replace(/\/$/, "") : "";
+	if (!filename || !rootDirectory || filename !== rootDirectory && !filename.startsWith(`${rootDirectory}/`)) return null;
+	const projectIndex = buildSourceProjectIndex(rootDirectory, filename, currentProgram, context.scopes);
+	if (!projectIndex) return null;
+	const functionKeys = /* @__PURE__ */ new Set();
+	for (const module of projectIndex.modulesByFilePath.values()) walkAst(module.programNode, (candidate) => {
+		if (!isNodeOfType(candidate, "JSXOpeningElement")) return;
+		const apiBinding = resolveRemotionApi(candidate.name, module.scopes);
+		if (apiBinding?.apiName !== "Composition" || apiBinding.moduleSource !== "remotion") return;
+		const functionAttribute = findJsxAttribute(candidate.attributes, attributeName);
+		if (!functionAttribute?.value || !isNodeOfType(functionAttribute.value, "JSXExpressionContainer") || !functionAttribute.value.expression) return;
+		const resolvedFunction = resolveImportedCompositionFunction(functionAttribute.value.expression, module);
+		if (!resolvedFunction || !isNodeOfType(resolvedFunction.programNode, "Program")) return;
+		for (const functionKey of getFunctionExportKeys(resolvedFunction.filePath, resolvedFunction.programNode, resolvedFunction.functionNode)) functionKeys.add(functionKey);
+	});
+	return functionKeys;
+};
+const createRemotionCompositionAttributeOwnershipAnalyzer = (context, attributeName) => {
+	const settings = context.settings;
+	return (functionNode) => {
+		const currentProgram = findProgramRoot(functionNode);
+		if (!currentProgram || !isNodeOfType(currentProgram, "Program") || !context.filename || !settings) return false;
+		const currentFunctionKeys = getFunctionExportKeys(context.filename, currentProgram, functionNode);
+		if (currentFunctionKeys.length === 0) return false;
+		let cacheByAttributeName = compositionAttributeFunctionCacheBySettings.get(settings);
+		if (!cacheByAttributeName) {
+			cacheByAttributeName = /* @__PURE__ */ new Map();
+			compositionAttributeFunctionCacheBySettings.set(settings, cacheByAttributeName);
+		}
+		let cache = cacheByAttributeName.get(attributeName);
+		if (!cache) {
+			cache = { failedFilenames: /* @__PURE__ */ new Set() };
+			cacheByAttributeName.set(attributeName, cache);
+		}
+		let functionKeys = cache.functionKeys;
+		if (!functionKeys) {
+			const filename = normalizeFilename(context.filename);
+			if (cache.failedFilenames.has(filename)) return false;
+			const collectedFunctionKeys = collectCompositionAttributeFunctionKeys(context, currentProgram, attributeName);
+			if (!collectedFunctionKeys) {
+				cache.failedFilenames.add(filename);
+				return false;
+			}
+			functionKeys = collectedFunctionKeys;
+			cache.functionKeys = collectedFunctionKeys;
+		}
+		return currentFunctionKeys.some((functionKey) => functionKeys.has(functionKey));
+	};
+};
+const createRemotionCompositionOwnershipAnalyzer = (context) => createRemotionCompositionAttributeOwnershipAnalyzer(context, "component");
+const createRemotionMetadataOwnershipAnalyzer = (context) => createRemotionCompositionAttributeOwnershipAnalyzer(context, "calculateMetadata");
+//#endregion
+//#region src/plugin/rules/correctness/remotion-calculate-metadata-fetch-signal.ts
+const getParameterIdentifier = (parameter) => {
+	if (isNodeOfType(parameter, "Identifier")) return parameter;
+	if (isNodeOfType(parameter, "AssignmentPattern") && isNodeOfType(parameter.left, "Identifier")) return parameter.left;
+	return null;
+};
+const getAbortSignalBinding = (functionNode) => {
+	if (!isFunctionLike$1(functionNode)) return {
+		parameterIdentifier: null,
+		signalIdentifier: null
+	};
+	const firstParameter = functionNode.params[0];
+	const parameterIdentifier = getParameterIdentifier(firstParameter);
+	if (parameterIdentifier) return {
+		parameterIdentifier,
+		signalIdentifier: null
+	};
+	if (!isNodeOfType(firstParameter, "ObjectPattern")) return {
+		parameterIdentifier: null,
+		signalIdentifier: null
+	};
+	for (const property of firstParameter.properties) {
+		if (!isNodeOfType(property, "Property")) continue;
+		if (getStaticPropertyKeyName(property) !== "abortSignal") continue;
+		const signalIdentifier = getParameterIdentifier(property.value);
+		if (signalIdentifier) return {
+			parameterIdentifier: null,
+			signalIdentifier
+		};
+	}
+	return {
+		parameterIdentifier: null,
+		signalIdentifier: null
+	};
+};
+const identifiersResolveToSameSymbol = (leftIdentifier, rightIdentifier, scopes) => {
+	if (!isNodeOfType(leftIdentifier, "Identifier") || !isNodeOfType(rightIdentifier, "Identifier")) return false;
+	const leftSymbol = scopes.symbolFor(leftIdentifier);
+	return Boolean(leftSymbol && leftSymbol === scopes.symbolFor(rightIdentifier));
+};
+const isMetadataAbortSignal = (expression, binding, scopes) => {
+	const candidate = stripParenExpression(expression);
+	if (binding.signalIdentifier && identifiersResolveToSameSymbol(candidate, binding.signalIdentifier, scopes)) return true;
+	return Boolean(binding.parameterIdentifier && isNodeOfType(candidate, "MemberExpression") && getStaticPropertyKeyName(candidate, { allowComputedString: true }) === "abortSignal" && identifiersResolveToSameSymbol(candidate.object, binding.parameterIdentifier, scopes));
+};
+const fetchUsesMetadataAbortSignal = (fetchCall, binding, scopes) => {
+	const optionsArgument = fetchCall.arguments[1];
+	if (!optionsArgument) return false;
+	const options = stripParenExpression(optionsArgument);
+	if (!isNodeOfType(options, "ObjectExpression")) return null;
+	if (options.properties.some((property) => isNodeOfType(property, "SpreadElement"))) return null;
+	for (let propertyIndex = options.properties.length - 1; propertyIndex >= 0; propertyIndex -= 1) {
+		const property = options.properties[propertyIndex];
+		if (isNodeOfType(property, "Property") && getStaticPropertyKeyName(property, { allowComputedString: true }) === "signal") return isMetadataAbortSignal(property.value, binding, scopes);
+	}
+	return false;
+};
+const reportFetchesWithoutAbortSignal = (functionNode, context) => {
+	const binding = getAbortSignalBinding(functionNode);
+	walkAst(functionNode, (candidate) => {
+		if (candidate !== functionNode && isFunctionLike$1(candidate)) return false;
+		if (!isNodeOfType(candidate, "CallExpression") || !isNodeOfType(candidate.callee, "Identifier") || candidate.callee.name !== "fetch" || !context.scopes.isGlobalReference(candidate.callee) || fetchUsesMetadataAbortSignal(candidate, binding, context.scopes) !== false) return;
+		context.report({
+			node: candidate,
+			message: "Pass Remotion's `abortSignal` to this fetch with `{signal: abortSignal}` so superseded metadata requests are cancelled."
+		});
+	});
+};
+const isCalculateMetadataFunctionType = (variableDeclarator) => {
+	if (!isNodeOfType(variableDeclarator.id, "Identifier")) return false;
+	const annotation = variableDeclarator.id.typeAnnotation;
+	if (!isNodeOfType(annotation, "TSTypeAnnotation") || !isNodeOfType(annotation.typeAnnotation, "TSTypeReference")) return false;
+	const typeName = annotation.typeAnnotation.typeName;
+	if (!isNodeOfType(typeName, "Identifier")) return false;
+	const apiBinding = getImportBindingForName(typeName, typeName.name);
+	return Boolean(apiBinding?.exportedName === "CalculateMetadataFunction" && apiBinding.source === "remotion");
+};
+const remotionCalculateMetadataFetchSignal = defineRule({
+	id: "remotion-calculate-metadata-fetch-signal",
+	title: "calculateMetadata fetch ignores abortSignal",
+	tags: ["react-jsx-only"],
+	requires: ["remotion:4"],
+	severity: "error",
+	recommendation: "Destructure `abortSignal` from the calculateMetadata argument and pass it to direct fetch calls as `{signal: abortSignal}`.",
+	create: (context) => {
+		const analyzedFunctions = /* @__PURE__ */ new WeakSet();
+		const isOwnedByCalculateMetadata = createRemotionMetadataOwnershipAnalyzer(context);
+		const analyzeFunction = (functionNode) => {
+			if (!functionNode || analyzedFunctions.has(functionNode)) return;
+			analyzedFunctions.add(functionNode);
+			reportFetchesWithoutAbortSignal(functionNode, context);
+		};
+		return {
+			CallExpression(node) {
+				if (!isNodeOfType(node.callee, "Identifier") || node.callee.name !== "fetch" || !context.scopes.isGlobalReference(node.callee)) return;
+				const functionNode = findEnclosingFunction$1(node);
+				if (functionNode && isOwnedByCalculateMetadata(functionNode)) analyzeFunction(functionNode);
+			},
+			JSXOpeningElement(node) {
+				const apiBinding = resolveRemotionApi(node.name, context.scopes);
+				if (apiBinding?.apiName !== "Composition" || apiBinding.moduleSource !== "remotion") return;
+				const calculateMetadataAttribute = findJsxAttribute(node.attributes, "calculateMetadata");
+				if (!calculateMetadataAttribute?.value || !isNodeOfType(calculateMetadataAttribute.value, "JSXExpressionContainer") || !calculateMetadataAttribute.value.expression) return;
+				analyzeFunction(resolveExactLocalFunction(calculateMetadataAttribute.value.expression, context.scopes));
+			},
+			VariableDeclarator(node) {
+				if (!node.init || !isCalculateMetadataFunctionType(node)) return;
+				analyzeFunction(resolveExactLocalFunction(node.init, context.scopes));
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugin/utils/create-remotion-render-evidence-checker.ts
+const REMOTION_RENDER_CALL_NAMES = new Set([
+	"continueRender",
+	"delayRender",
+	"getInputProps",
+	"random",
+	"spring",
+	"useCurrentFrame",
+	"useDelayRender",
+	"useVideoConfig"
+]);
+const REMOTION_RENDER_COMPONENT_MODULE_BY_NAME = new Map([
+	["Audio", "@remotion/media"],
+	["Freeze", "remotion"],
+	["IFrame", "remotion"],
+	["Img", "remotion"],
+	["Loop", "remotion"],
+	["OffthreadVideo", "remotion"],
+	["Sequence", "remotion"],
+	["Series", "remotion"],
+	["Video", "@remotion/media"]
+]);
+const createRemotionRenderEvidenceChecker = (context) => {
+	const scopes = context.scopes;
+	const evidenceByFunction = /* @__PURE__ */ new WeakMap();
+	const registeredCompositionFunctions = /* @__PURE__ */ new WeakSet();
+	const inspectedPrograms = /* @__PURE__ */ new WeakSet();
+	const isOwnedByRegisteredComposition = createRemotionCompositionOwnershipAnalyzer(context);
+	const collectRegisteredCompositionFunctions = (functionNode) => {
+		const program = findProgramRoot(functionNode);
+		if (!program || inspectedPrograms.has(program)) return;
+		inspectedPrograms.add(program);
+		walkAst(program, (candidate) => {
+			if (!isNodeOfType(candidate, "JSXOpeningElement")) return;
+			const apiBinding = resolveRemotionApi(candidate.name, scopes);
+			if (apiBinding?.apiName !== "Composition" || apiBinding.moduleSource !== "remotion") return;
+			const componentAttribute = findJsxAttribute(candidate.attributes, "component");
+			if (!componentAttribute?.value || !isNodeOfType(componentAttribute.value, "JSXExpressionContainer") || !componentAttribute.value.expression) return;
+			const registeredFunction = resolveExactLocalFunction(componentAttribute.value.expression, scopes);
+			if (registeredFunction) registeredCompositionFunctions.add(registeredFunction);
+		});
+	};
+	const functionUsesRemotionRenderApi = (functionNode) => {
+		let hasEvidence = false;
+		walkAst(functionNode, (candidate) => {
+			if (hasEvidence) return false;
+			if (!isNodeOfType(candidate, "CallExpression") && !isNodeOfType(candidate, "JSXOpeningElement")) return;
+			const apiBinding = resolveRemotionApi(isNodeOfType(candidate, "CallExpression") ? candidate.callee : candidate.name, scopes);
+			if (isNodeOfType(candidate, "CallExpression") && apiBinding?.moduleSource === "remotion" && REMOTION_RENDER_CALL_NAMES.has(apiBinding.apiName) || isNodeOfType(candidate, "JSXOpeningElement") && apiBinding !== null && REMOTION_RENDER_COMPONENT_MODULE_BY_NAME.get(apiBinding.apiName) === apiBinding.moduleSource) {
+				hasEvidence = true;
+				return false;
+			}
+		});
+		return hasEvidence;
+	};
+	return { functionHasEvidence: (functionNode) => {
+		const cachedEvidence = evidenceByFunction.get(functionNode);
+		if (cachedEvidence !== void 0) return cachedEvidence;
+		collectRegisteredCompositionFunctions(functionNode);
+		const hasEvidence = registeredCompositionFunctions.has(functionNode) || functionUsesRemotionRenderApi(functionNode) || isOwnedByRegisteredComposition(functionNode);
+		evidenceByFunction.set(functionNode, hasEvidence);
+		return hasEvidence;
+	} };
+};
+//#endregion
+//#region src/plugin/rules/correctness/remotion-deterministic-randomness.ts
+const isGlobalMathObject = (node, scopes) => {
+	const candidate = stripParenExpression(node);
+	if (isNodeOfType(candidate, "Identifier")) return candidate.name === "Math" && scopes.isGlobalReference(candidate);
+	return Boolean(isNodeOfType(candidate, "MemberExpression") && getStaticPropertyKeyName(candidate, { allowComputedString: true }) === "Math" && isNodeOfType(candidate.object, "Identifier") && candidate.object.name === "globalThis" && scopes.isGlobalReference(candidate.object));
+};
+const remotionDeterministicRandomness = defineRule({
+	id: "remotion-deterministic-randomness",
+	title: "Randomness changes between rendered frames",
+	tags: ["react-jsx-only"],
+	requires: ["remotion:4"],
+	severity: "error",
+	recommendation: "Use Remotion's seeded `random(seed)` helper so the same frame produces the same value in every render tab.",
+	create: (context) => {
+		const renderEvidence = createRemotionRenderEvidenceChecker(context);
+		return { CallExpression(node) {
+			const callee = stripParenExpression(node.callee);
+			if (!isNodeOfType(callee, "MemberExpression") || getStaticPropertyKeyName(callee, { allowComputedString: true }) !== "random" || !isGlobalMathObject(callee.object, context.scopes)) return;
+			const componentOrHook = findRenderPhaseComponentOrHook(node, context.scopes) ?? findEnclosingFunction$1(node);
+			if (!componentOrHook || !renderEvidence.functionHasEvidence(componentOrHook)) return;
+			const displayName = componentOrHookDisplayNameForFunction(componentOrHook);
+			if (displayName && !isReactHookName(displayName) && !functionHasReactComponentEvidence(componentOrHook, context.scopes, context.cfg)) return;
+			context.report({
+				node,
+				message: "`Math.random()` can return a different value in each parallel Remotion render tab, so the same frame is not deterministic. Use `random(seed)` from `remotion` instead."
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/utils/create-remotion-css-time-rule-visitors.ts
+const createRemotionCssTimeRuleVisitors = (context, options) => {
+	const renderEvidence = createRemotionRenderEvidenceChecker(context);
+	return {
+		Property(node) {
+			if (!options.stylePropertyNames.has(getStaticPropertyKeyName(node) ?? "")) return;
+			const styleObject = node.parent;
+			const expressionContainer = styleObject?.parent;
+			const styleAttribute = expressionContainer?.parent;
+			if (!isNodeOfType(styleObject, "ObjectExpression") || !isNodeOfType(expressionContainer, "JSXExpressionContainer") || expressionContainer.expression !== styleObject || !isNodeOfType(styleAttribute, "JSXAttribute") || !isNodeOfType(styleAttribute.name, "JSXIdentifier") || styleAttribute.name.name !== "style") return;
+			const renderFunction = findRenderPhaseComponentOrHook(node, context.scopes);
+			if (!renderFunction || !renderEvidence.functionHasEvidence(renderFunction)) return;
+			context.report({
+				node,
+				message: options.styleMessage
+			});
+		},
+		JSXAttribute(node) {
+			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "className") return;
+			const renderFunction = findRenderPhaseComponentOrHook(node, context.scopes);
+			if (!renderFunction || !renderEvidence.functionHasEvidence(renderFunction)) return;
+			const className = getJsxAttributeStaticString(node);
+			if (!className) return;
+			if (className.split(/\s+/).filter(Boolean).some((classToken) => options.classTokenIsForbidden(classToken.split(":").at(-1) ?? ""))) context.report({
+				node,
+				message: options.classMessage
+			});
+		}
+	};
+};
+//#endregion
+//#region src/plugin/rules/correctness/remotion-no-css-animation.ts
+const ANIMATION_STYLE_PROPERTY_NAMES = new Set(["animation", "animationName"]);
+const remotionNoCssAnimation = defineRule({
+	id: "remotion-no-css-animation",
+	title: "CSS animation is not frame-driven",
+	tags: ["react-jsx-only"],
+	requires: ["remotion:4"],
+	severity: "error",
+	recommendation: "Drive the property from `useCurrentFrame()` with `interpolate()` so every rendered frame is deterministic.",
+	create: (context) => createRemotionCssTimeRuleVisitors(context, {
+		classTokenIsForbidden: (classToken) => classToken.startsWith("animate-") && classToken !== "animate-none",
+		classMessage: "Tailwind animations advance on browser time, so Remotion can capture inconsistent frames. Drive the property from `useCurrentFrame()` instead.",
+		styleMessage: "CSS animations advance on browser time, so Remotion can capture inconsistent frames. Drive the property from `useCurrentFrame()` instead.",
+		stylePropertyNames: ANIMATION_STYLE_PROPERTY_NAMES
+	})
+});
+//#endregion
+//#region src/plugin/rules/correctness/remotion-no-css-transition.ts
+const TRANSITION_STYLE_PROPERTY_NAMES = new Set(["transition", "transitionProperty"]);
+const remotionNoCssTransition = defineRule({
+	id: "remotion-no-css-transition",
+	title: "CSS transition is not frame-driven",
+	tags: ["react-jsx-only"],
+	requires: ["remotion:4"],
+	severity: "error",
+	recommendation: "Drive the property from `useCurrentFrame()` with `interpolate()` so every rendered frame is deterministic.",
+	create: (context) => createRemotionCssTimeRuleVisitors(context, {
+		classTokenIsForbidden: (classToken) => (classToken === "transition" || classToken.startsWith("transition-")) && classToken !== "transition-none",
+		classMessage: "Tailwind transitions advance on browser time, so Remotion can capture inconsistent frames. Drive the property from `useCurrentFrame()` instead.",
+		styleMessage: "CSS transitions advance on browser time, so Remotion can capture inconsistent frames. Drive the property from `useCurrentFrame()` instead.",
+		stylePropertyNames: TRANSITION_STYLE_PROPERTY_NAMES
+	})
+});
+//#endregion
+//#region src/plugin/rules/correctness/remotion-no-css-url-assets.ts
+const CSS_URL_ASSET_PROPERTY_NAMES = new Set([
+	"backgroundImage",
+	"maskImage",
+	"WebkitMaskImage"
+]);
+const CSS_URL_PATTERN = /\burl\(\s*(["']?)([^"')]+)\1\s*\)/i;
+const isEmbeddedAssetSource = (assetSource) => assetSource.startsWith("data:") || assetSource.startsWith("#");
+const getStaticStringExpression = (node) => {
+	if (isNodeOfType(node, "Literal") && typeof node.value === "string") return node.value;
+	if (isNodeOfType(node, "TemplateLiteral") && node.expressions.length === 0 && node.quasis.length === 1) return node.quasis[0].value.raw;
+	return null;
+};
+const isReactUseMemoCallback = (node, scopes) => {
+	const parent = node.parent;
+	return Boolean(isNodeOfType(parent, "CallExpression") && parent.arguments[0] === node && isReactApiCall(parent, "useMemo", scopes, { resolveNamedAliases: true }));
+};
+const componentPreloadsStaticImage = (componentNode, assetSource, scopes) => {
+	let hasPreload = false;
+	walkAst(componentNode, (child) => {
+		if (hasPreload) return false;
+		if (child !== componentNode && isFunctionLike$1(child) && !isReactUseMemoCallback(child, scopes)) return false;
+		if (!isNodeOfType(child, "JSXOpeningElement")) return;
+		const apiBinding = resolveRemotionApi(child.name, scopes);
+		if (apiBinding?.apiName !== "Img" || apiBinding.moduleSource !== "remotion") return;
+		const sourceAttribute = findJsxAttribute(child.attributes, "src");
+		if (sourceAttribute && getJsxAttributeStaticString(sourceAttribute) === assetSource) {
+			hasPreload = true;
+			return false;
+		}
+	});
+	return hasPreload;
+};
+const remotionNoCssUrlAssets = defineRule({
+	id: "remotion-no-css-url-assets",
+	title: "CSS URL asset can flicker in Remotion",
+	tags: ["react-jsx-only"],
+	requires: ["remotion:4"],
+	severity: "error",
+	recommendation: "Render the asset with `Img` inside an `AbsoluteFill`, or preload the same source with a hidden `Img` when a CSS mask is required.",
+	create: (context) => {
+		const renderEvidence = createRemotionRenderEvidenceChecker(context);
+		return { Property(node) {
+			if (!CSS_URL_ASSET_PROPERTY_NAMES.has(getStaticPropertyKeyName(node) ?? "")) return;
+			const styleObject = node.parent;
+			const expressionContainer = styleObject?.parent;
+			const styleAttribute = expressionContainer?.parent;
+			if (!isNodeOfType(styleObject, "ObjectExpression") || !isNodeOfType(expressionContainer, "JSXExpressionContainer") || expressionContainer.expression !== styleObject || !isNodeOfType(styleAttribute, "JSXAttribute") || !isNodeOfType(styleAttribute.name, "JSXIdentifier") || styleAttribute.name.name !== "style") return;
+			const cssValue = getStaticStringExpression(node.value);
+			const urlMatch = cssValue ? CSS_URL_PATTERN.exec(cssValue) : null;
+			if (!urlMatch) return;
+			const assetSource = urlMatch[2].trim();
+			if (isEmbeddedAssetSource(assetSource)) return;
+			const componentNode = findRenderPhaseComponentOrHook(node, context.scopes);
+			if (!componentNode || !renderEvidence.functionHasEvidence(componentNode) || componentPreloadsStaticImage(componentNode, assetSource, context.scopes)) return;
+			context.report({
+				node,
+				message: "Remotion cannot detect when a CSS `url()` asset has loaded, so the rendered frame can flicker. Render or preload the source with <Img> instead."
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/correctness/remotion-no-module-scope-delay-render.ts
+const remotionNoModuleScopeDelayRender = defineRule({
+	id: "remotion-no-module-scope-delay-render",
+	title: "Module-scoped delayRender blocks every composition",
+	requires: ["remotion:4"],
+	severity: "error",
+	recommendation: "Create the handle once inside the component. Use `useDelayRender()` on Remotion 4.0.342 or newer, or lazy `useState(() => delayRender())` on earlier versions.",
+	create: (context) => ({ CallExpression(node) {
+		const apiBinding = resolveRemotionApi(node.callee, context.scopes);
+		if (apiBinding?.apiName !== "delayRender" || apiBinding.moduleSource !== "remotion" || findEnclosingFunction$1(node)) return;
+		context.report({
+			node,
+			message: "A module-scoped `delayRender()` handle blocks all compositions and composition discovery. Move it inside the component and create it once with `useDelayRender()` or a lazy `useState` initializer."
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/rules/correctness/remotion-no-native-media-elements.ts
+const REMOTION_MEDIA_REPLACEMENT_BY_TAG = new Map([
+	["audio", "`Audio` from `@remotion/media`"],
+	["iframe", "`IFrame` from `remotion`"],
+	["img", "`Img` from `remotion`"],
+	["video", "`Video` from `@remotion/media`"]
+]);
+const remotionNoNativeMediaElements = defineRule({
+	id: "remotion-no-native-media-elements",
+	title: "Native media element bypasses Remotion loading",
+	tags: ["react-jsx-only"],
+	requires: ["remotion:4"],
+	severity: "error",
+	recommendation: "Use Remotion's media components so rendering waits for assets and seeks media to the requested frame.",
+	create: (context) => {
+		const renderEvidence = createRemotionRenderEvidenceChecker(context);
+		return { JSXOpeningElement(node) {
+			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+			const renderFunction = findRenderPhaseComponentOrHook(node, context.scopes);
+			if (!renderFunction || !renderEvidence.functionHasEvidence(renderFunction)) return;
+			const replacement = REMOTION_MEDIA_REPLACEMENT_BY_TAG.get(node.name.name);
+			if (!replacement) return;
+			context.report({
+				node,
+				message: `Native <${node.name.name}> does not let Remotion reliably wait for and synchronize the asset. Use ${replacement} instead.`
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/correctness/remotion-no-next-image.ts
+const remotionNoNextImage = defineRule({
+	id: "remotion-no-next-image",
+	title: "Next.js Image can flicker in Remotion",
+	tags: ["react-jsx-only"],
+	requires: ["remotion:4"],
+	severity: "error",
+	recommendation: "Use `Img` from `remotion`, which delays rendering until the image is loaded.",
+	create: (context) => {
+		const renderEvidence = createRemotionRenderEvidenceChecker(context);
+		return { JSXOpeningElement(node) {
+			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+			const renderFunction = findRenderPhaseComponentOrHook(node, context.scopes);
+			if (!renderFunction || !renderEvidence.functionHasEvidence(renderFunction)) return;
+			const symbol = context.scopes.symbolFor(node.name);
+			if (symbol?.kind !== "import") return;
+			const importBinding = getImportBindingForName(node.name, symbol.name);
+			if (importBinding?.source !== "next/image" || importBinding.exportedName !== "default") return;
+			context.report({
+				node,
+				message: "Next.js <Image> does not expose a reliable loading signal to Remotion, so rendered frames can flicker. Use <Img> from `remotion` instead."
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugin/rules/correctness/remotion-stable-delay-render-handle.ts
+const isUseStateLazyInitializer = (node, scopes) => {
+	const enclosingFunction = findEnclosingFunction$1(node);
+	if (!enclosingFunction) return false;
+	const parent = enclosingFunction.parent;
+	return Boolean(isNodeOfType(parent, "CallExpression") && parent.arguments[0] === enclosingFunction && isReactApiCall(parent, "useState", scopes, { resolveNamedAliases: true }));
+};
+const remotionStableDelayRenderHandle = defineRule({
+	id: "remotion-stable-delay-render-handle",
+	title: "delayRender handle is recreated during render",
+	tags: ["react-jsx-only"],
+	requires: ["remotion:4"],
+	severity: "error",
+	recommendation: "Prefer `useDelayRender()`, or initialize `delayRender()` once with `useState(() => delayRender())`.",
+	create: (context) => ({ CallExpression(node) {
+		const apiBinding = resolveRemotionApi(node.callee, context.scopes);
+		if (apiBinding?.apiName !== "delayRender" || apiBinding.moduleSource !== "remotion" || !findRenderPhaseComponentOrHook(node, context.scopes) || isUseStateLazyInitializer(node, context.scopes)) return;
+		context.report({
+			node,
+			message: "Calling `delayRender()` during every component render creates another outstanding handle and can make rendering time out. Use `useDelayRender()` or a lazy `useState` initializer."
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/rules/performance/rendering-animate-svg-wrapper.ts
 const renderingAnimateSvgWrapper = defineRule({
 	id: "rendering-animate-svg-wrapper",
@@ -73902,6 +74966,39 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...mediaHasCaption.requires ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/mobx-no-make-auto-observable-in-inheritance",
+		id: "mobx-no-make-auto-observable-in-inheritance",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...mobxNoMakeAutoObservableInInheritance,
+			framework: "global",
+			category: "Bugs"
+		}
+	},
+	{
+		key: "react-doctor/mobx-no-observer-wrapped-memo",
+		id: "mobx-no-observer-wrapped-memo",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...mobxNoObserverWrappedMemo,
+			framework: "global",
+			category: "Bugs"
+		}
+	},
+	{
+		key: "react-doctor/mobx-reaction-disposer-discarded",
+		id: "mobx-reaction-disposer-discarded",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...mobxReactionDisposerDiscarded,
+			framework: "global",
+			category: "Bugs"
+		}
+	},
 	{
 		key: "react-doctor/mouse-events-have-key-events",
 		id: "mouse-events-have-key-events",
@@ -76084,6 +77181,105 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...reduxUseselectorReturnsNewCollection.requires ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/remotion-calculate-metadata-fetch-signal",
+		id: "remotion-calculate-metadata-fetch-signal",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...remotionCalculateMetadataFetchSignal,
+			framework: "global",
+			category: "Bugs"
+		}
+	},
+	{
+		key: "react-doctor/remotion-deterministic-randomness",
+		id: "remotion-deterministic-randomness",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...remotionDeterministicRandomness,
+			framework: "global",
+			category: "Bugs"
+		}
+	},
+	{
+		key: "react-doctor/remotion-no-css-animation",
+		id: "remotion-no-css-animation",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...remotionNoCssAnimation,
+			framework: "global",
+			category: "Bugs"
+		}
+	},
+	{
+		key: "react-doctor/remotion-no-css-transition",
+		id: "remotion-no-css-transition",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...remotionNoCssTransition,
+			framework: "global",
+			category: "Bugs"
+		}
+	},
+	{
+		key: "react-doctor/remotion-no-css-url-assets",
+		id: "remotion-no-css-url-assets",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...remotionNoCssUrlAssets,
+			framework: "global",
+			category: "Bugs"
+		}
+	},
+	{
+		key: "react-doctor/remotion-no-module-scope-delay-render",
+		id: "remotion-no-module-scope-delay-render",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...remotionNoModuleScopeDelayRender,
+			framework: "global",
+			category: "Bugs"
+		}
+	},
+	{
+		key: "react-doctor/remotion-no-native-media-elements",
+		id: "remotion-no-native-media-elements",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...remotionNoNativeMediaElements,
+			framework: "global",
+			category: "Bugs"
+		}
+	},
+	{
+		key: "react-doctor/remotion-no-next-image",
+		id: "remotion-no-next-image",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...remotionNoNextImage,
+			framework: "global",
+			category: "Bugs"
+		}
+	},
+	{
+		key: "react-doctor/remotion-stable-delay-render-handle",
+		id: "remotion-stable-delay-render-handle",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...remotionStableDelayRenderHandle,
+			framework: "global",
+			category: "Bugs"
+		}
+	},
 	{
 		key: "react-doctor/rendering-animate-svg-wrapper",
 		id: "rendering-animate-svg-wrapper",
@@ -77567,6 +78763,13 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"no-unguarded-browser-global-in-render-or-hook-init",
 	"prefer-dynamic-import",
 	"rendering-hydration-mismatch-time",
+	"remotion-calculate-metadata-fetch-signal",
+	"remotion-deterministic-randomness",
+	"remotion-no-css-animation",
+	"remotion-no-css-transition",
+	"remotion-no-css-url-assets",
+	"remotion-no-native-media-elements",
+	"remotion-no-next-image",
 	"rerender-memo-with-default-value",
 	"rn-no-legacy-shadow-styles",
 	"rn-no-raw-text",
@@ -77784,7 +78987,17 @@ const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 * `CROSS_FILE_DEPENDENCY_COLLECTORS` (the core guard test enforces the
 * partition), forcing a conscious classification.
 */
-const UNBOUNDED_CROSS_FILE_RULE_IDS = new Set(["nextjs-no-img-element", "only-export-components"]);
+const UNBOUNDED_CROSS_FILE_RULE_IDS = new Set([
+	"nextjs-no-img-element",
+	"only-export-components",
+	"remotion-calculate-metadata-fetch-signal",
+	"remotion-deterministic-randomness",
+	"remotion-no-css-animation",
+	"remotion-no-css-transition",
+	"remotion-no-css-url-assets",
+	"remotion-no-native-media-elements",
+	"remotion-no-next-image"
+]);
 /**
 * Runs the collectors for `ruleIds` over one file and returns every
 * filesystem probe they made — the file's cross-file dependency set.