@colrealpro/react-luau-doctor 0.18.3 → 0.19.1

package/dist/scan-worker.js

@@ -19,6 +19,19 @@ function walk(node) {
   }
   return result;
 }
+function parameterBindingNames(parameters) {
+  if (!parameters)
+    return [];
+  const result = [];
+  for (const parameter of parameters.namedChildren) {
+    if (parameter.type !== "parameter")
+      continue;
+    const identifier = parameter.namedChildren.find((child) => child.type === "identifier");
+    if (identifier)
+      result.push(identifier.text);
+  }
+  return [...new Set(result)];
+}
 function rootIdentifier(text) {
   const match = text.trim().match(/^([A-Za-z_][A-Za-z0-9_]*)/);
   return match?.[1] ?? null;
@@ -147,6 +160,63 @@ function createRuleContext(file) {
   };
 }
 
+// src/module-resolution.ts
+import path from "path";
+function normalizeRelative(value) {
+  return value.split(path.sep).join("/");
+}
+function moduleKeys(relativePath) {
+  let normalized = normalizeRelative(relativePath).replace(/\.(?:lua|luau)$/i, "");
+  if (normalized.endsWith("/init"))
+    normalized = normalized.slice(0, -"/init".length);
+  const segments = normalized.split("/").filter(Boolean);
+  if (segments[0]?.toLowerCase() === "src")
+    segments.shift();
+  const keys = new Set;
+  for (let index = 0;index < segments.length; index += 1) {
+    const suffix = segments.slice(index).join(".").toLowerCase();
+    if (suffix)
+      keys.add(suffix);
+  }
+  return [...keys];
+}
+function normalizeRequireTarget(text) {
+  return (text.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? []).join(".").toLowerCase();
+}
+function buildUniqueFeatureAliases(modules, featureByModuleId) {
+  const owners = new Map;
+  for (const module of modules) {
+    for (const key of module.keys) {
+      const ids = owners.get(key) ?? new Set;
+      ids.add(module.id);
+      owners.set(key, ids);
+    }
+  }
+  const aliases = new Map;
+  for (const module of modules) {
+    const value = featureByModuleId.get(module.id);
+    if (value === undefined)
+      continue;
+    for (const key of module.keys) {
+      const ids = owners.get(key);
+      if (ids?.size === 1 && ids.has(module.id))
+        aliases.set(key, value);
+    }
+  }
+  return aliases;
+}
+function resolveModuleReference(target, aliases) {
+  let candidate = target;
+  while (true) {
+    if (aliases.has(candidate))
+      return aliases.get(candidate);
+    const separator = candidate.indexOf(".");
+    if (separator < 0)
+      return null;
+    candidate = candidate.slice(separator + 1);
+  }
+}
+
 // src/ast/react-model.ts
 var REACT_HOOKS = new Set([
   "useState",
@@ -177,18 +247,7 @@ var INSTANCE_FACTORY_MEMBERS = new Set([
 ]);
 var STABLE_ENGINE_FACTORY_MEMBERS = new Set(["GetMouse", "GetService"]);
 function identifiersFromParameters(node) {
-  if (!node)
-    return [];
-  const result = [];
-  for (const child of walk(node)) {
-    if (child.type !== "identifier")
-      continue;
-    const parentType = child.parent?.type;
-    if (parentType === "parameters" || parentType === "parameter" || parentType === "typed_identifier") {
-      result.push(child.text);
-    }
-  }
-  return [...new Set(result)];
+  return parameterBindingNames(node);
 }
 function getFunctionName(node) {
   if (node.type === "function_declaration") {
@@ -242,15 +301,19 @@ function directCalls(node) {
 function hasDirectCreateElementCall(node, aliases, reactNamespaces, reactRobloxNamespaces) {
   return directCalls(node).some((call) => {
     const name = call.childForFieldName("name")?.text ?? "";
-    const path = resolvePath(name, aliases, reactNamespaces, reactRobloxNamespaces);
-    return path === "React.createElement" || path === "ReactRoblox.createPortal";
+    const path2 = resolvePath(name, aliases, reactNamespaces, reactRobloxNamespaces);
+    return path2 === "React.createElement" || path2 === "ReactRoblox.createPortal";
   });
 }
-function hasDirectHookCall(node, aliases, reactNamespaces, reactRobloxNamespaces) {
+function hasDirectHookCall(node, aliases, reactNamespaces, reactRobloxNamespaces, importedHookKinds) {
   return directCalls(node).some((call) => {
     const name = call.childForFieldName("name")?.text ?? "";
-    const path = resolvePath(name, aliases, reactNamespaces, reactRobloxNamespaces);
-    const final = path.split(/[.:]/).at(-1) ?? "";
+    const path2 = resolvePath(name, aliases, reactNamespaces, reactRobloxNamespaces);
+    const normalizedName = normalizeExpressionText(name);
+    const importedKind = importedHookKinds.get(normalizedName);
+    if (importedKind !== undefined)
+      return importedKind;
+    const final = path2.split(/[.:]/).at(-1) ?? "";
     return /^use[A-Z0-9_]/.test(final);
   });
 }
@@ -336,8 +399,8 @@ function isSyntacticallyStableInitializer(node) {
     return false;
   return ["nil", "true", "false", "number", "string", "string_content"].includes(node.type) || /^(?:nil|true|false|-?\d+(?:\.\d+)?(?:e[+-]?\d+)?)$/i.test(node.text.trim());
 }
-function finalCallMember(path) {
-  return path.split(/[.:]/).at(-1) ?? path;
+function finalCallMember(path2) {
+  return path2.split(/[.:]/).at(-1) ?? path2;
 }
 function expressionCreatesInstance(node, aliases, reactNamespaces, reactRobloxNamespaces) {
   if (!node)
@@ -349,8 +412,8 @@ function expressionCreatesInstance(node, aliases, reactNamespaces, reactRobloxNa
     if (candidate.type !== "function_call")
       continue;
     const rawPath = candidate.childForFieldName("name")?.text ?? "";
-    const path = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
-    if (path === "Instance.new" || INSTANCE_FACTORY_MEMBERS.has(finalCallMember(path)))
+    const path2 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+    if (path2 === "Instance.new" || INSTANCE_FACTORY_MEMBERS.has(finalCallMember(path2)))
       return true;
   }
   return false;
@@ -362,8 +425,8 @@ function expressionIsStableEngineObject(node, aliases, reactNamespaces, reactRob
   if (calls.length !== 1)
     return false;
   const rawPath = calls[0].childForFieldName("name")?.text ?? "";
-  const path = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
-  return STABLE_ENGINE_FACTORY_MEMBERS.has(finalCallMember(path));
+  const path2 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+  return STABLE_ENGINE_FACTORY_MEMBERS.has(finalCallMember(path2));
 }
 function memoReturnsInstance(callback, aliases, reactNamespaces, reactRobloxNamespaces) {
   if (!callback || callback.type !== "function_definition")
@@ -379,7 +442,21 @@ function memoReturnsInstance(callback, aliases, reactNamespaces, reactRobloxName
 function isEmptyDependencyTable(node) {
   return Boolean(node?.type === "table_constructor" && node.namedChildren.every((child) => child.type !== "field"));
 }
-function buildReactModel(root) {
+function importedHookKinds(declarations, project) {
+  const result = new Map;
+  if (!project)
+    return result;
+  for (const declaration of declarations) {
+    const match = declaration.text.match(/^\s*local\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*require\s*\((.*?)\)\s*$/s);
+    if (!match || !/^use[A-Z0-9_]/.test(match[1]))
+      continue;
+    const kind = resolveModuleReference(normalizeRequireTarget(match[2]), project.reactHookModules);
+    if (kind !== null)
+      result.set(match[1], kind);
+  }
+  return result;
+}
+function buildReactModel(root, project) {
   const reactNamespaces = new Set;
   const reactRobloxNamespaces = new Set;
   const aliases = new Map;
@@ -395,6 +472,7 @@ function buildReactModel(root) {
   const instanceVariablesByFunction = new Map;
   const allNodes = [...walk(root)];
   const declarations = allNodes.filter((node) => node.type === "variable_declaration");
+  const projectHookKinds = importedHookKinds(declarations, project);
   let isReactFile = false;
   for (const declaration of declarations) {
     const text = declaration.text;
@@ -469,7 +547,7 @@ function buildReactModel(root) {
     if (!isReactFile || !info.body || info.isHook)
       continue;
     const simplePascalName = Boolean(info.name && /^[A-Z][A-Za-z0-9_]*$/.test(info.name));
-    const hasHooks = hasDirectHookCall(info.body, aliases, reactNamespaces, reactRobloxNamespaces);
+    const hasHooks = hasDirectHookCall(info.body, aliases, reactNamespaces, reactRobloxNamespaces, projectHookKinds);
     const renders = hasDirectCreateElementCall(info.body, aliases, reactNamespaces, reactRobloxNamespaces);
     if (hasHooks || isMemoWrappedFunction(info.node, aliases, reactNamespaces) || simplePascalName && renders) {
       info.isComponent = true;
@@ -481,8 +559,8 @@ function buildReactModel(root) {
     if (call.type !== "function_call")
       continue;
     const rawPath = call.childForFieldName("name")?.text ?? "";
-    const path = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
-    if (path !== "React.createElement")
+    const path2 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+    if (path2 !== "React.createElement")
       continue;
     const element = call.childForFieldName("arguments")?.namedChildren[0]?.text.trim() ?? "";
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(element))
@@ -517,13 +595,13 @@ function buildReactModel(root) {
     if (!call)
       continue;
     const rawPath = call.childForFieldName("name")?.text ?? "";
-    const path = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+    const path2 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
     const args = call.childForFieldName("arguments")?.namedChildren ?? [];
-    if (path === "React.joinBindings" && names.length >= 1) {
+    if (path2 === "React.joinBindings" && names.length >= 1) {
       stableVariables.add(names[0]);
       addScopedVariable(stableVariablesByFunction, owner, names[0]);
       addScopedVariable(externalMutableVariablesByFunction, owner, names[0]);
-    } else if (path === "React.useState" && names.length >= 2) {
+    } else if (path2 === "React.useState" && names.length >= 2) {
       const [valueName, setterName] = names;
       stateSetters.set(setterName, valueName);
       stateValues.set(valueName, setterName);
@@ -537,10 +615,10 @@ function buildReactModel(root) {
         initializer: args[0] ?? null,
         owner
       });
-    } else if (path === "React.useReducer" && names.length >= 2) {
+    } else if (path2 === "React.useReducer" && names.length >= 2) {
       stableVariables.add(names[1]);
       addScopedVariable(stableVariablesByFunction, owner, names[1]);
-    } else if (path === "React.useBinding" && names.length >= 1) {
+    } else if (path2 === "React.useBinding" && names.length >= 1) {
       stableVariables.add(names[0]);
       addScopedVariable(stableVariablesByFunction, owner, names[0]);
       if (names.length >= 2) {
@@ -548,7 +626,7 @@ function buildReactModel(root) {
         bindingSetters.add(names[1]);
         addScopedVariable(stableVariablesByFunction, owner, names[1]);
       }
-    } else if (path === "React.useMemo" && names.length >= 1) {
+    } else if (path2 === "React.useMemo" && names.length >= 1) {
       if (isEmptyDependencyTable(args[1])) {
         stableVariables.add(names[0]);
         addScopedVariable(stableVariablesByFunction, owner, names[0]);
@@ -557,16 +635,16 @@ function buildReactModel(root) {
         addScopedVariable(externalMutableVariablesByFunction, owner, names[0]);
         addScopedVariable(instanceVariablesByFunction, owner, names[0]);
       }
-    } else if (path === "React.useCallback" && names.length >= 1 && isEmptyDependencyTable(args[1])) {
+    } else if (path2 === "React.useCallback" && names.length >= 1 && isEmptyDependencyTable(args[1])) {
       stableVariables.add(names[0]);
       addScopedVariable(stableVariablesByFunction, owner, names[0]);
-    } else if (path === "React.useRef" && names.length >= 1) {
+    } else if (path2 === "React.useRef" && names.length >= 1) {
       stableVariables.add(names[0]);
       refVariables.add(names[0]);
       addScopedVariable(stableVariablesByFunction, owner, names[0]);
       addScopedVariable(refVariablesByFunction, owner, names[0]);
     } else {
-      const final = path.split(/[.:]/).at(-1) ?? "";
+      const final = path2.split(/[.:]/).at(-1) ?? "";
       if (/^use[A-Z0-9_]/.test(final)) {
         for (const name of names.slice(1)) {
           if (!STABLE_CUSTOM_HOOK_RETURN.test(name))
@@ -590,11 +668,11 @@ function buildReactModel(root) {
     if (!expression || expression.type !== "function_call")
       continue;
     const rawPath = expression.childForFieldName("name")?.text ?? "";
-    const path = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
-    if (path === "React.useState" && names.length >= 2) {
+    const path2 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+    if (path2 === "React.useState" && names.length >= 2) {
       stableVariables.add(names[1]);
       addScopedVariable(stableVariablesByFunction, owner, names[1]);
-    } else if (path === "React.useBinding" && names.length >= 1) {
+    } else if (path2 === "React.useBinding" && names.length >= 1) {
       stableVariables.add(names[0]);
       addScopedVariable(stableVariablesByFunction, owner, names[0]);
       addScopedVariable(externalMutableVariablesByFunction, owner, names[0]);
@@ -654,14 +732,14 @@ function buildReactModel(root) {
 
 // src/config.ts
 import fs from "fs";
-import path from "path";
+import path2 from "path";
 var CONFIG_NAME = "react-luau-doctor.config.json";
 var SEVERITIES = new Set(["off", "error", "warning", "suggestion"]);
 var SCOPES = new Set(["full", "files", "changed", "lines"]);
 var BLOCKING_LEVELS = new Set(["error", "warning", "none"]);
 var CATEGORIES = new Set(["Correctness", "Hooks", "Effects", "Performance", "Roblox", "Architecture"]);
 function loadConfigWithSource(root) {
-  const candidate = path.join(root, CONFIG_NAME);
+  const candidate = path2.join(root, CONFIG_NAME);
   if (!fs.existsSync(candidate))
     return { config: {}, filename: null };
   const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
@@ -721,14 +799,14 @@ function effectiveSeverity(defaultSeverity, ruleId, config) {
 }
 function configPathForWrite(root) {
   const loaded = loadConfigWithSource(root);
-  return loaded.filename ?? path.join(root, CONFIG_NAME);
+  return loaded.filename ?? path2.join(root, CONFIG_NAME);
 }
 function writeConfig(root, update) {
   const loaded = loadConfigWithSource(root);
   const next = update(structuredClone(loaded.config));
   validateConfig(next, loaded.filename ?? CONFIG_NAME);
   const filename = loaded.filename ?? configPathForWrite(root);
-  fs.mkdirSync(path.dirname(filename), { recursive: true });
+  fs.mkdirSync(path2.dirname(filename), { recursive: true });
   fs.writeFileSync(filename, `${JSON.stringify(next, null, 2)}
 `);
   return filename;
@@ -808,7 +886,7 @@ function createInlineSuppressionChecker(source) {
 
 // src/parser.ts
 import fs2 from "fs";
-import path2 from "path";
+import path3 from "path";
 import { Language, Parser } from "web-tree-sitter";
 
 // src/parser-compat.ts
@@ -947,6 +1025,23 @@ function isCode(mask, start, end = start + 1) {
   }
   return true;
 }
+function matchingCodeDelimiterEnd(source, mask, start, opener, closer) {
+  if (source[start] !== opener || !isCode(mask, start))
+    return null;
+  let depth = 0;
+  for (let cursor = start;cursor < source.length; cursor += 1) {
+    if (!isCode(mask, cursor))
+      continue;
+    if (source[cursor] === opener)
+      depth += 1;
+    else if (source[cursor] === closer) {
+      depth -= 1;
+      if (depth === 0)
+        return cursor + 1;
+    }
+  }
+  return null;
+}
 function maskTypeAliases(source, mask) {
   const { lines, offsets } = lineData(source);
   const ranges = [];
@@ -1154,6 +1249,89 @@ function genericFunctionParameterRanges(source, mask) {
   }
   return ranges;
 }
+function genericFunctionReturnPrefixRanges(source, mask) {
+  const ranges = [];
+  const functionPattern = /\bfunction\b/g;
+  for (const match of source.matchAll(functionPattern)) {
+    const start = match.index;
+    if (!isCode(mask, start, start + match[0].length))
+      continue;
+    let cursor = start + match[0].length;
+    let genericDepth = 0;
+    while (cursor < source.length) {
+      if (!isCode(mask, cursor)) {
+        cursor += 1;
+        continue;
+      }
+      if (source[cursor] === "<")
+        genericDepth += 1;
+      else if (source[cursor] === ">" && genericDepth > 0)
+        genericDepth -= 1;
+      else if (source[cursor] === "(" && genericDepth === 0)
+        break;
+      cursor += 1;
+    }
+    if (source[cursor] !== "(")
+      continue;
+    const parameterEnd = matchingCodeDelimiterEnd(source, mask, cursor, "(", ")");
+    if (parameterEnd === null)
+      continue;
+    cursor = parameterEnd;
+    while (cursor < source.length && /\s/.test(source[cursor]))
+      cursor += 1;
+    if (source[cursor] !== ":" || !isCode(mask, cursor))
+      continue;
+    cursor += 1;
+    while (cursor < source.length && /\s/.test(source[cursor]))
+      cursor += 1;
+    if (source[cursor] !== "<")
+      continue;
+    const rangeStart = cursor;
+    const genericEnd = matchingCodeDelimiterEnd(source, mask, cursor, "<", ">");
+    if (genericEnd === null)
+      continue;
+    cursor = genericEnd;
+    while (cursor < source.length && /\s/.test(source[cursor]))
+      cursor += 1;
+    const typeParametersEnd = matchingCodeDelimiterEnd(source, mask, cursor, "(", ")");
+    if (typeParametersEnd === null)
+      continue;
+    cursor = typeParametersEnd;
+    while (cursor < source.length && /\s/.test(source[cursor]))
+      cursor += 1;
+    if (source.slice(cursor, cursor + 2) !== "->" || !isCode(mask, cursor, cursor + 2))
+      continue;
+    cursor += 2;
+    while (cursor < source.length && /[ \t]/.test(source[cursor]))
+      cursor += 1;
+    ranges.push({ start: rangeStart, end: cursor });
+  }
+  return ranges;
+}
+function normalizeLocalTypeofAnnotations(source, mask) {
+  const replacements = [];
+  const pattern = /\blocal\s+[A-Za-z_][A-Za-z0-9_]*\s*:\s*typeof\s*\(/g;
+  for (const match of source.matchAll(pattern)) {
+    const matchStart = match.index;
+    if (!isCode(mask, matchStart, matchStart + match[0].length))
+      continue;
+    const typeofStart = matchStart + match[0].lastIndexOf("typeof");
+    const open = source.indexOf("(", typeofStart + 6);
+    if (open < 0)
+      continue;
+    const end = matchingCodeDelimiterEnd(source, mask, open, "(", ")");
+    if (end === null)
+      continue;
+    const original = source.slice(typeofStart, end);
+    const padding = blankPreservingUtf8Bytes(original).slice(3);
+    replacements.push({ start: typeofStart, end, value: `any${padding}` });
+  }
+  let output = source;
+  for (const replacement of replacements.sort((a, b) => b.start - a.start)) {
+    output = `${output.slice(0, replacement.start)}${replacement.value}${output.slice(replacement.end)}`;
+  }
+  return output;
+}
 function normalizeGenericTypePackUses(source, mask) {
   const declarationRanges = genericFunctionParameterRanges(source, mask);
   const replacements = [];
@@ -1214,13 +1392,15 @@ function parserCompatibleSource(source) {
   const keywordCompatible = replaceContextualKeywords(source, mask);
   const literalCompatible = normalizeIntegerLiteralSuffixes(keywordCompatible, mask);
   const packCompatible = normalizeGenericTypePackUses(literalCompatible, mask);
+  const typeofCompatible = normalizeLocalTypeofAnnotations(packCompatible, mask);
   const ranges = [
     ...maskTypeAliases(source, mask),
     ...maskTypeLevelBlocks(source, mask),
     ...attributeRanges(source, mask),
-    ...explicitTypeArgumentRanges(source, mask)
+    ...explicitTypeArgumentRanges(source, mask),
+    ...genericFunctionReturnPrefixRanges(source, mask)
   ];
-  const masked = applyMasks(packCompatible, ranges);
+  const masked = applyMasks(typeofCompatible, ranges);
   return masked.replace(/^(\s*)type(?=\s*(?:\+=|-=|\*=|\/=|%=|\^=|\.\.=|=(?!=)))/gm, "$1_typ");
 }
 
@@ -1228,7 +1408,7 @@ function parserCompatibleSource(source) {
 var parserPromise = null;
 async function createParser() {
   await Parser.init();
-  const grammarPath = path2.resolve(import.meta.dir, "../vendor/tree-sitter-luau.wasm");
+  const grammarPath = path3.resolve(import.meta.dir, "../vendor/tree-sitter-luau.wasm");
   const grammar = new Uint8Array(fs2.readFileSync(grammarPath));
   const language = await Language.load(grammar);
   const parser = new Parser;
@@ -1353,8 +1533,8 @@ var INSTANCE_FACTORY_MEMBERS2 = new Set([
   "GetService",
   "WaitForChild"
 ]);
-function finalCallMember2(path3) {
-  return path3.split(/[.:]/).at(-1) ?? path3;
+function finalCallMember2(path4) {
+  return path4.split(/[.:]/).at(-1) ?? path4;
 }
 function declarationInitializer(node, name) {
   if (node.type !== "variable_declaration")
@@ -1422,8 +1602,8 @@ function expressionHasRobloxOrigin(expression, from, context, seen) {
   seen.add(root);
   return expressionHasRobloxOrigin(visibleInitializer(root, from, context), from, context, seen);
 }
-function hasRobloxReceiver(path3, call, context) {
-  const normalized = path3.replace(/\s+/g, "");
+function hasRobloxReceiver(path4, call, context) {
+  const normalized = path4.replace(/\s+/g, "");
   if (/^(?:game|workspace|script)(?:[.:]|$)/.test(normalized))
     return true;
   const root = normalized.match(/^([A-Za-z_][A-Za-z0-9_]*)/)?.[1];
@@ -1433,6 +1613,8 @@ function hasRobloxReceiver(path3, call, context) {
 }
 var runServiceCallCache = new WeakMap;
 var runServiceExpressionCache = new WeakMap;
+var highFrequencyRobloxCallCache = new WeakMap;
+var highFrequencyRobloxExpressionCache = new WeakMap;
 function cachedNodeBoolean(cache, context, node, compute) {
   let entries = cache.get(context);
   if (!entries) {
@@ -1497,6 +1679,33 @@ function isHighFrequencyRunServiceCall(call, context) {
     return Boolean(bind && rootIsRunService(bind[1], call, context));
   });
 }
+var HIGH_FREQUENCY_ROBLOX_EVENTS = new Set([
+  "InputChanged",
+  "TouchMoved",
+  "Move"
+]);
+function isHighFrequencyRobloxExpression(node, context) {
+  return cachedNodeBoolean(highFrequencyRobloxExpressionCache, context, node, () => {
+    if (isHighFrequencyRunServiceExpression(node, context))
+      return true;
+    const normalized = node.text.replace(/\s+/g, "");
+    const match = normalized.match(/^(.+)\.(InputChanged|TouchMoved|Move)$/);
+    if (!match || !HIGH_FREQUENCY_ROBLOX_EVENTS.has(match[2]))
+      return false;
+    return hasRobloxReceiver(match[1], node, context);
+  });
+}
+function isHighFrequencyRobloxCall(call, context) {
+  return cachedNodeBoolean(highFrequencyRobloxCallCache, context, call, () => {
+    if (isHighFrequencyRunServiceCall(call, context))
+      return true;
+    const normalized = (context.getCallPath(call) ?? "").replace(/\s+/g, "");
+    const event = normalized.match(/^(.+)\.(InputChanged|TouchMoved|Move):Connect$/);
+    if (!event || !HIGH_FREQUENCY_ROBLOX_EVENTS.has(event[2]))
+      return false;
+    return hasRobloxReceiver(event[1], call, context);
+  });
+}
 function sourceHasHighFrequencyRunService(source) {
   if (/game\s*:\s*GetService\s*\(\s*["']RunService["']\s*\)\s*(?:\.\s*(?:RenderStepped|Heartbeat|Stepped|PreRender|PreSimulation|PostSimulation)\s*:\s*Connect|:\s*(?:BindToRenderStep|BindToSimulation))/.test(source)) {
     return true;
@@ -1513,8 +1722,38 @@ function sourceHasHighFrequencyRunService(source) {
   }
   return false;
 }
-function knownYieldReason(path3, call, context) {
-  const normalized = path3.replace(/\s+/g, "");
+function sourceHasHighFrequencyRobloxEvent(source) {
+  if (sourceHasHighFrequencyRunService(source))
+    return true;
+  if (/game\s*:\s*GetService\s*\(\s*["']UserInputService["']\s*\)\s*\.\s*(?:InputChanged|TouchMoved)\s*:\s*Connect/.test(source)) {
+    return true;
+  }
+  const serviceAliases = new Set;
+  for (const match of source.matchAll(/\blocal\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*game\s*:\s*GetService\s*\(\s*["']UserInputService["']\s*\)/g)) {
+    serviceAliases.add(match[1]);
+  }
+  for (const alias of serviceAliases) {
+    const escaped = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    if (new RegExp(`\\b${escaped}\\s*\\.\\s*(?:InputChanged|TouchMoved)\\s*:\\s*Connect`).test(source)) {
+      return true;
+    }
+  }
+  const playersAliases = new Set;
+  for (const match of source.matchAll(/\blocal\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*game\s*:\s*GetService\s*\(\s*["']Players["']\s*\)/g)) {
+    playersAliases.add(match[1]);
+  }
+  for (const players of playersAliases) {
+    const escapedPlayers = players.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    for (const match of source.matchAll(new RegExp(`\\blocal\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*${escapedPlayers}\\s*\\.\\s*LocalPlayer\\s*:\\s*GetMouse\\s*\\(\\s*\\)`, "g"))) {
+      const mouse = match[1].replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      if (new RegExp(`\\b${mouse}\\s*\\.\\s*Move\\s*:\\s*Connect`).test(source))
+        return true;
+    }
+  }
+  return false;
+}
+function knownYieldReason(path4, call, context) {
+  const normalized = path4.replace(/\s+/g, "");
   if (normalized === "task.wait")
     return "task.wait";
   if (normalized === "coroutine.yield")
@@ -1534,15 +1773,15 @@ function functionYieldPoint(node, context) {
     const owner = context.model.functionByNode.get(node.id);
     if (owner && nearest !== owner)
       continue;
-    const path3 = context.resolveCallPath(context.getCallPath(candidate) ?? "");
-    const reason = knownYieldReason(path3, candidate, context);
+    const path4 = context.resolveCallPath(context.getCallPath(candidate) ?? "");
+    const reason = knownYieldReason(path4, candidate, context);
     if (reason)
       return { call: candidate, reason };
   }
   return null;
 }
-function mutableDependencyBase(path3, externallyMutableRoots) {
-  const normalized = path3.replace(/\s+/g, "");
+function mutableDependencyBase(path4, externallyMutableRoots) {
+  const normalized = path4.replace(/\s+/g, "");
   if (/\.current(?:\.|$)/.test(normalized))
     return "";
   const segments = normalized.split(".");
@@ -1568,8 +1807,8 @@ var CONDITIONAL_TYPES = new Set([
   "while_statement",
   "repeat_statement"
 ]);
-function isHookPath(path3) {
-  const final = path3.split(/[.:]/).at(-1) ?? "";
+function isHookPath(path4) {
+  const final = path4.split(/[.:]/).at(-1) ?? "";
   return /^use[A-Z0-9_]/.test(final);
 }
 function assignmentTargetNode(statement) {
@@ -1645,8 +1884,8 @@ function functionInfoForNode(context, node) {
 function stateBindingsFor(context, owner) {
   return context.model.stateBindings.filter((binding) => binding.owner === owner);
 }
-function isEffectPath(path3) {
-  return path3 === "React.useEffect" || path3 === "React.useLayoutEffect";
+function isEffectPath(path4) {
+  return path4 === "React.useEffect" || path4 === "React.useLayoutEffect";
 }
 function dependencyExpressions(node) {
   if (!node || node.type !== "table_constructor")
@@ -1901,11 +2140,11 @@ function isManagedByCleanupContainer(call, context, callback) {
   let current = call.parent;
   while (current && !sameNode(current, callback.node)) {
     if (current.type === "function_call") {
-      const path3 = context.getCallPath(current) ?? "";
-      if (ALWAYS_MANAGED_METHOD.test(path3))
+      const path4 = context.getCallPath(current) ?? "";
+      if (ALWAYS_MANAGED_METHOD.test(path4))
         return true;
-      if (GENERIC_MANAGER_METHOD.test(path3)) {
-        const receiver = path3.split(":", 1)[0] ?? "";
+      if (GENERIC_MANAGER_METHOD.test(path4)) {
+        const receiver = path4.split(":", 1)[0] ?? "";
         if (MANAGER_ROOT.test(receiver))
           return true;
       }
@@ -2010,10 +2249,10 @@ function isCleanupOnlyTask(callbackNode, context) {
     return false;
   return calls.every((call) => /:(?:Destroy|Disconnect)$/.test(context.getCallPath(call) ?? ""));
 }
-function taskSeverity(path3, call, taskCallback, yieldPoint, context) {
-  if (path3 === "task.defer" && !yieldPoint)
+function taskSeverity(path4, call, taskCallback, yieldPoint, context) {
+  if (path4 === "task.defer" && !yieldPoint)
     return "suggestion";
-  if (path3 === "task.delay" && !yieldPoint) {
+  if (path4 === "task.delay" && !yieldPoint) {
     if (isCleanupOnlyTask(taskCallback, context))
       return "suggestion";
     const delay = numericTaskDelay(call, context);
@@ -2063,10 +2302,10 @@ end`,
     };
   }
   if ([...labels].every((label) => label.includes("task"))) {
-    const path3 = context.resolveCallPath(context.getCallPath(first.call) ?? "task.delay");
-    const taskCall = path3 === "task.defer" ? `task.defer(function()
+    const path4 = context.resolveCallPath(context.getCallPath(first.call) ?? "task.delay");
+    const taskCall = path4 === "task.defer" ? `task.defer(function()
 	doWork()
-end)` : path3 === "task.spawn" ? `task.spawn(function()
+end)` : path4 === "task.spawn" ? `task.spawn(function()
 	doWork()
 end)` : `task.delay(delaySeconds, function()
 	doWork()
@@ -2119,9 +2358,9 @@ end`,
 }
 function classifyResource(call, context, callback) {
   const rawPath = context.getCallPath(call) ?? "";
-  const path3 = context.resolveCallPath(rawPath);
+  const path4 = context.resolveCallPath(rawPath);
   const variable = assignedVariableName(call, callback);
-  const finalMember = path3.split(/[.:]/).at(-1) ?? path3;
+  const finalMember = path4.split(/[.:]/).at(-1) ?? path4;
   if (/:Connect$/.test(rawPath)) {
     const ownerExpression = connectionOwnerExpression(rawPath);
     const ownerIsInstance = isProvenInstanceExpression(ownerExpression, call, context, callback);
@@ -2190,7 +2429,7 @@ function classifyResource(call, context, callback) {
       }
     };
   }
-  if (path3 === "ReactRoblox.createRoot") {
+  if (path4 === "ReactRoblox.createRoot") {
     return {
       call,
       label: "React root",
@@ -2200,17 +2439,17 @@ function classifyResource(call, context, callback) {
       }
     };
   }
-  if (path3 === "task.delay" || path3 === "task.defer" || path3 === "task.spawn") {
+  if (path4 === "task.delay" || path4 === "task.defer" || path4 === "task.spawn") {
     const taskCallback = taskCallbackNode(call, context, callback);
     const yieldPoint = taskCallback ? functionYieldPoint(taskCallback, context) : null;
-    const outlivesEffect = path3 !== "task.spawn" || Boolean(yieldPoint);
+    const outlivesEffect = path4 !== "task.spawn" || Boolean(yieldPoint);
     if (!outlivesEffect)
       return null;
     return {
       call,
-      label: path3 === "task.spawn" ? "yielding spawned task" : path3 === "task.defer" ? "deferred task" : "delayed task",
+      label: path4 === "task.spawn" ? "yielding spawned task" : path4 === "task.defer" ? "deferred task" : "delayed task",
       detail: yieldPoint ? `The task can outlive the effect because it yields at ${yieldPoint.reason}.` : "The task is scheduled to run after the effect callback can finish.",
-      severity: taskSeverity(path3, call, taskCallback, yieldPoint, context),
+      severity: taskSeverity(path4, call, taskCallback, yieldPoint, context),
       variable,
       cleanupMatches(text, name) {
         if (name) {
@@ -2237,8 +2476,8 @@ var effectNeedsCleanup = {
       const rawPath = context.getCallPath(call);
       if (!rawPath)
         continue;
-      const path3 = context.resolveCallPath(rawPath);
-      if (path3 !== "React.useEffect" && path3 !== "React.useLayoutEffect")
+      const path4 = context.resolveCallPath(rawPath);
+      if (path4 !== "React.useEffect" && path4 !== "React.useLayoutEffect")
         continue;
       const callbackNode = firstFunctionArgument(context, call);
       const callback = functionInfoForNode(context, callbackNode);
@@ -2292,10 +2531,22 @@ function ownerForHook(context, call) {
   const owner = context.nearestFunction(call);
   return owner && (owner.isComponent || owner.isHook) ? owner : null;
 }
+function effectCallbackWithoutDeps(context, call) {
+  const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+  if (!isEffectPath(path4))
+    return null;
+  const args = context.callArguments(call);
+  const callback = args[0];
+  if (callback?.type !== "function_definition")
+    return null;
+  if (args.length < 2 || args[1]?.type === "nil")
+    return callback;
+  return null;
+}
 function callbackAndDeps(context, call) {
-  const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
+  const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
   const args = context.callArguments(call);
-  if (path3 === "React.useImperativeHandle") {
+  if (path4 === "React.useImperativeHandle") {
     const callback2 = args[1];
     const deps2 = args[2];
     if (callback2?.type === "function_definition" && deps2?.type === "table_constructor")
@@ -2325,8 +2576,8 @@ function hasExternalSubscription(node, context) {
   for (const child of context.walk(node)) {
     if (child.type !== "function_call")
       continue;
-    const path3 = context.getCallPath(child) ?? "";
-    if (/:Connect$/.test(path3) || /BindToRenderStep$/.test(path3) || /:BindAction(?:AtPriority)?$/.test(path3))
+    const path4 = context.getCallPath(child) ?? "";
+    if (/:Connect$/.test(path4) || /BindToRenderStep$/.test(path4) || /:BindAction(?:AtPriority)?$/.test(path4))
       return true;
   }
   return false;
@@ -2360,6 +2611,33 @@ function setterCalledOutsideCallback(context, owner, callback, setterName) {
   }
   return false;
 }
+function guaranteedRepeatedStateChange(argument, stateName, context) {
+  if (argument.type === "table_constructor")
+    return true;
+  if (argument.type === "function_definition") {
+    const updater = functionInfoForNode(context, argument);
+    const previousName = updater?.parameters[0];
+    const returnStatement = updater?.body?.namedChildren.find((child) => child.type === "return_statement");
+    const returnValue = returnStatement?.namedChildren[0];
+    if (previousName && returnValue && guaranteedRepeatedStateChange(returnValue, previousName, context))
+      return true;
+    return false;
+  }
+  const text = argument.text.trim();
+  const escaped = stateName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  if (new RegExp(`^not\\s+${escaped}$`).test(text))
+    return true;
+  if (new RegExp(`^${escaped}\\s*[+-]\\s*(?:[1-9]\\d*(?:\\.\\d+)?|0?\\.\\d*[1-9]\\d*)$`).test(text))
+    return true;
+  if (new RegExp(`^(?:[1-9]\\d*(?:\\.\\d+)?|0?\\.\\d*[1-9]\\d*)\\s*\\+\\s*${escaped}$`).test(text))
+    return true;
+  if (argument.type === "function_call") {
+    const path4 = context.resolveCallPath(context.getCallPath(argument) ?? "");
+    if (path4 === "table.clone" || path4 === "table.create" || path4 === "table.pack")
+      return true;
+  }
+  return false;
+}
 function freshDependencyKind(node, owner) {
   if (node.type === "table_constructor")
     return "table";
@@ -2382,8 +2660,8 @@ var noDerivedStateEffect = {
   run(context) {
     const diagnostics = [];
     for (const call of context.findCalls()) {
-      const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (!isEffectPath(path3))
+      const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (!isEffectPath(path4))
         continue;
       const owner = ownerForHook(context, call);
       const parts = callbackAndDeps(context, call);
@@ -2421,28 +2699,48 @@ var noSelfUpdatingEffect = {
   id: "react-luau/no-self-updating-effect",
   category: "Effects",
   severity: "warning",
-  description: "Effects should not unconditionally update state that is also one of their dependencies.",
+  description: "Effects should not unconditionally update state in a way that schedules themselves again.",
   run(context) {
     const diagnostics = [];
     for (const call of context.findCalls()) {
-      const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (!isEffectPath(path3))
+      const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (!isEffectPath(path4))
         continue;
       const owner = ownerForHook(context, call);
+      if (!owner)
+        continue;
       const parts = callbackAndDeps(context, call);
-      if (!owner || !parts)
+      if (parts) {
+        const deps = parseDependencyRoots(parts.deps);
+        for (const binding of stateBindingsFor(context, owner)) {
+          if (!deps.has(binding.valueName))
+            continue;
+          for (const setterCall of directTopLevelCalls(context, parts.callback)) {
+            if (context.getCallPath(setterCall) !== binding.setterName)
+              continue;
+            diagnostics.push({
+              node: callNameNode(setterCall),
+              message: `${binding.setterName}() updates ${binding.valueName}, which is also in this effect's dependency table.`,
+              help: "Guard the update so it converges, move it to the originating event, or derive the value during render."
+            });
+          }
+        }
+        continue;
+      }
+      const callback = effectCallbackWithoutDeps(context, call);
+      if (!callback)
         continue;
-      const deps = parseDependencyRoots(parts.deps);
       for (const binding of stateBindingsFor(context, owner)) {
-        if (!deps.has(binding.valueName))
-          continue;
-        for (const setterCall of directTopLevelCalls(context, parts.callback)) {
+        for (const setterCall of directTopLevelCalls(context, callback)) {
           if (context.getCallPath(setterCall) !== binding.setterName)
             continue;
+          const argument = context.callArguments(setterCall)[0];
+          if (!argument || !guaranteedRepeatedStateChange(argument, binding.valueName, context))
+            continue;
           diagnostics.push({
             node: callNameNode(setterCall),
-            message: `${binding.setterName}() updates ${binding.valueName}, which is also in this effect's dependency table.`,
-            help: "Guard the update so it converges, move it to the originating event, or derive the value during render."
+            message: `${binding.setterName}() unconditionally changes ${binding.valueName} in an effect that runs after every render.`,
+            help: "Add a dependency table or convergence guard, move the update to the event that owns it, or derive the value during render."
           });
         }
       }
@@ -2458,8 +2756,8 @@ var noEffectWithFreshDeps = {
   run(context) {
     const diagnostics = [];
     for (const call of context.findCalls()) {
-      const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (!HOOKS_WITH_DEPS.has(path3))
+      const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (!HOOKS_WITH_DEPS.has(path4))
         continue;
       const owner = ownerForHook(context, call);
       const parts = callbackAndDeps(context, call);
@@ -2472,7 +2770,7 @@ var noEffectWithFreshDeps = {
         const label = dependency.type === "identifier" ? ` ${dependency.text}` : "";
         diagnostics.push({
           node: dependency,
-          message: `${path3} depends on${label || " an inline value"} that is a new ${kind} on every render.`,
+          message: `${path4} depends on${label || " an inline value"} that is a new ${kind} on every render.`,
           help: "Move the value inside the hook callback and depend on its simple inputs, or intentionally stabilize the value with useMemo/useCallback when identity is part of the contract."
         });
       }
@@ -2488,8 +2786,8 @@ var noMutableInDeps = {
   run(context) {
     const diagnostics = [];
     for (const call of context.findCalls()) {
-      const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (!HOOKS_WITH_DEPS.has(path3))
+      const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (!HOOKS_WITH_DEPS.has(path4))
         continue;
       const owner = ownerForHook(context, call);
       const parts = callbackAndDeps(context, call);
@@ -2582,23 +2880,61 @@ var HOOK_ARGUMENTS = new Map([
   ["React.useImperativeHandle", { callbackIndex: 1, depsIndex: 2 }]
 ]);
 function parameterNames2(functionNode) {
-  const names = new Set;
-  const parameters = functionNode.childForFieldName("parameters");
-  if (!parameters)
-    return names;
-  for (const node of parameters.namedChildren) {
-    for (const candidate of descendants(node)) {
-      if (candidate.type === "identifier")
-        names.add(candidate.text);
-    }
-  }
-  return names;
+  return new Set(parameterBindingNames(functionNode.childForFieldName("parameters")));
 }
 function* descendants(node) {
   yield node;
   for (const child of node.namedChildren)
     yield* descendants(child);
 }
+var TYPE_ONLY_NODES = new Set([
+  "type_definition",
+  "type_annotation",
+  "type_parameters",
+  "generic_type_list",
+  "generic_type",
+  "function_type",
+  "optional_type",
+  "object_type",
+  "union_type",
+  "intersection_type",
+  "tuple_type",
+  "singleton_type",
+  "variadic_type",
+  "variadic_type_pack"
+]);
+function isTypeOnlyChild(parent, child) {
+  if (TYPE_ONLY_NODES.has(child.type))
+    return true;
+  if (TYPE_ONLY_NODES.has(parent.type))
+    return true;
+  if (parent.type === "parameter") {
+    return !sameNode(parent.namedChildren.find((candidate) => candidate.type === "identifier"), child);
+  }
+  if (parent.type === "cast_expression" || parent.type === "type_cast_expression") {
+    return !sameNode(parent.namedChildren[0], child);
+  }
+  if (parent.type === "function_definition" || parent.type === "function_declaration") {
+    const name = parent.childForFieldName("name");
+    const parameters = parent.childForFieldName("parameters");
+    const body = parent.childForFieldName("body");
+    if (sameNode(child, name) || sameNode(child, parameters) || sameNode(child, body))
+      return false;
+    return true;
+  }
+  if (parent.type === "variable_list" && parent.parent?.parent?.type === "variable_declaration") {
+    return true;
+  }
+  return false;
+}
+function* runtimeDescendants(node) {
+  yield node;
+  for (const child of node.namedChildren) {
+    if (isTypeOnlyChild(node, child))
+      continue;
+    yield* runtimeDescendants(child);
+  }
+}
 function directBlockBindingNames(block, beforeIndex) {
   const names = new Set;
   for (const child of block.namedChildren) {
@@ -2674,8 +3010,8 @@ function rootIdentifierNode(node, root) {
   }
   return null;
 }
-function normalizeCapturedPath(path3, stableVariables, externallyMutableRoots) {
-  const normalized = normalizeExpressionText(path3);
+function normalizeCapturedPath(path4, stableVariables, externallyMutableRoots) {
+  const normalized = normalizeExpressionText(path4);
   const root = rootIdentifier(normalized);
   if (!root)
     return normalized;
@@ -2692,7 +3028,7 @@ function normalizeCapturedPath(path3, stableVariables, externallyMutableRoots) {
 }
 function capturedDependencyPaths(callback, available, stableVariables, externallyMutableRoots) {
   const captured = new Set;
-  for (const node of descendants(callback)) {
+  for (const node of runtimeDescendants(callback)) {
     if (node.type === "dot_index_expression" && outermostDotPath(node)) {
       const root = rootIdentifier(node.text);
       if (!root || !available.has(root) || GLOBALS.has(root) || stableVariables.has(root))
@@ -2761,33 +3097,106 @@ function expandLocalFunctionCaptures(captured, owner, available, stableVariables
     addCapture(capture);
   return result;
 }
+function dependencyCoveragePath(node) {
+  if (node.type === "cast_expression" || node.type === "type_cast_expression" || node.type === "parenthesized_expression") {
+    const expression = node.namedChildren[0];
+    if (expression)
+      return dependencyCoveragePath(expression);
+  }
+  if (node.type === "binary_expression") {
+    const left = node.childForFieldName("left") ?? node.namedChildren[0];
+    const right = node.childForFieldName("right") ?? node.namedChildren[1];
+    const isOr = node.children.some((child) => child.type === "or");
+    if (isOr && left && right?.type === "false")
+      return dependencyCoveragePath(left);
+  }
+  return normalizeExpressionText(node.text);
+}
 function dependencyPaths(node) {
-  return new Set(dependencyExpressions(node).map((dependency) => normalizeExpressionText(dependency.text)));
+  return new Set(dependencyExpressions(node).map(dependencyCoveragePath));
 }
-var PURE_DERIVED_CALL = /^(?:math\.(?!random(?:seed)?$)[A-Za-z_][A-Za-z0-9_]*|string\.[A-Za-z_][A-Za-z0-9_]*|table\.(?:find|concat|clone|create|isfrozen)|(?:Color3|Vector2|Vector3|UDim|UDim2|CFrame|BrickColor|Rect|NumberRange|NumberSequence|ColorSequence|TweenInfo|Font|Ray|Region3|PhysicalProperties)\.[A-Za-z_][A-Za-z0-9_]*|[^:]+:(?:ToHSV|Lerp|Dot|Cross|FuzzyEq|Inverse|ToObjectSpace|ToWorldSpace))$/;
-function isPureDerivedExpression(node, context) {
-  for (const candidate of context.walk(node)) {
-    if (candidate !== node && (candidate.type === "function_definition" || candidate.type === "function_declaration"))
-      return false;
-    if (candidate.type !== "function_call")
-      continue;
-    const rawPath = context.getCallPath(candidate);
-    if (!rawPath)
-      return false;
-    const path3 = normalizeExpressionText(context.resolveCallPath(rawPath));
-    if (!PURE_DERIVED_CALL.test(path3))
-      return false;
+function transparentAliasPath(node) {
+  if (node.type === "cast_expression" || node.type === "type_cast_expression" || node.type === "parenthesized_expression") {
+    const expression = node.namedChildren[0];
+    return expression ? transparentAliasPath(expression) : null;
   }
-  return true;
+  if (node.type !== "identifier" && node.type !== "dot_index_expression")
+    return null;
+  return normalizeExpressionText(node.text);
 }
-function mutatedOwnerLocals(owner, context) {
-  const mutated = new Set;
+function immutableTransparentAliases(owner, context) {
+  const aliases = new Map;
   if (!owner.body)
-    return mutated;
-  for (const node of context.walk(owner.body)) {
-    if (node.type !== "assignment_statement" && node.type !== "update_statement")
-      continue;
-    if (node.parent?.type === "variable_declaration")
+    return aliases;
+  const mutated = mutatedOwnerLocals(owner, context);
+  for (const statement of owner.body.namedChildren) {
+    if (statement.type !== "variable_declaration")
+      continue;
+    const names = declarationNames2(statement);
+    const expressions = declarationExpressions3(statement);
+    for (let index = 0;index < names.length; index += 1) {
+      const name = names[index];
+      const expression = expressions[index];
+      if (!expression || mutated.has(name))
+        continue;
+      const source = transparentAliasPath(expression);
+      if (!source || source === name)
+        continue;
+      const sourceRoot = rootIdentifier(source);
+      if (!sourceRoot || mutated.has(sourceRoot))
+        continue;
+      aliases.set(name, source);
+    }
+  }
+  return aliases;
+}
+function resolveAliasPath(path4, aliases) {
+  let current = path4;
+  const visiting = new Set;
+  while (true) {
+    const root = rootIdentifier(current);
+    if (!root || visiting.has(root))
+      return current;
+    const source = aliases.get(root);
+    if (!source)
+      return current;
+    visiting.add(root);
+    current = `${source}${current.slice(root.length)}`;
+  }
+}
+function dependencyPathsWithAliases(node, aliases) {
+  const dependencies = dependencyPaths(node);
+  for (const dependency of [...dependencies]) {
+    const resolved = resolveAliasPath(dependency, aliases);
+    if (resolved !== dependency)
+      dependencies.add(resolved);
+  }
+  return dependencies;
+}
+var PURE_DERIVED_CALL = /^(?:math\.(?!random(?:seed)?$)[A-Za-z_][A-Za-z0-9_]*|string\.[A-Za-z_][A-Za-z0-9_]*|table\.(?:find|concat|clone|create|isfrozen)|(?:Color3|Vector2|Vector3|UDim|UDim2|CFrame|BrickColor|Rect|NumberRange|NumberSequence|ColorSequence|TweenInfo|Font|Ray|Region3|PhysicalProperties)\.[A-Za-z_][A-Za-z0-9_]*|[^:]+:(?:ToHSV|Lerp|Dot|Cross|FuzzyEq|Inverse|ToObjectSpace|ToWorldSpace))$/;
+function isPureDerivedExpression(node, context) {
+  for (const candidate of context.walk(node)) {
+    if (candidate !== node && (candidate.type === "function_definition" || candidate.type === "function_declaration"))
+      return false;
+    if (candidate.type !== "function_call")
+      continue;
+    const rawPath = context.getCallPath(candidate);
+    if (!rawPath)
+      return false;
+    const path4 = normalizeExpressionText(context.resolveCallPath(rawPath));
+    if (!PURE_DERIVED_CALL.test(path4))
+      return false;
+  }
+  return true;
+}
+function mutatedOwnerLocals(owner, context) {
+  const mutated = new Set;
+  if (!owner.body)
+    return mutated;
+  for (const node of context.walk(owner.body)) {
+    if (node.type !== "assignment_statement" && node.type !== "update_statement")
+      continue;
+    if (node.parent?.type === "variable_declaration")
       continue;
     const variables = node.namedChildren.find((child) => child.type === "variable_list");
     if (!variables)
@@ -2854,8 +3263,8 @@ function hasDynamicUnpackDependencies(node, context) {
       const rawPath = context.getCallPath(candidate);
       if (!rawPath)
         continue;
-      const path3 = normalizeExpressionText(context.resolveCallPath(rawPath));
-      if (path3 === "unpack" || path3 === "table.unpack")
+      const path4 = normalizeExpressionText(context.resolveCallPath(rawPath));
+      if (path4 === "unpack" || path4 === "table.unpack")
         return true;
     }
   }
@@ -2880,8 +3289,8 @@ function memoizedProducerDependencies(owner, context) {
       const rawPath = context.getCallPath(expression);
       if (!rawPath)
         continue;
-      const path3 = context.resolveCallPath(rawPath);
-      if (path3 !== "React.useMemo" && path3 !== "React.useCallback")
+      const path4 = context.resolveCallPath(rawPath);
+      if (path4 !== "React.useMemo" && path4 !== "React.useCallback")
         continue;
       const args = context.callArguments(expression);
       const deps = args[1];
@@ -2940,9 +3349,9 @@ function directCallsInExpression(node) {
   return calls;
 }
 function isCustomHookCall(call, context) {
-  const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-  const final = path3.split(/[.:]/).at(-1) ?? "";
-  return !path3.startsWith("React.") && /^use[A-Z0-9_]/.test(final);
+  const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+  const final = path4.split(/[.:]/).at(-1) ?? "";
+  return !path4.startsWith("React.") && /^use[A-Z0-9_]/.test(final);
 }
 var HANDLE_VALUE_NAME = /(?:ref|binding|tween|spring|motion|animation|controller|handle|connection|signal)$/i;
 var HANDLE_HOOK_NAME = /(?:Tween|Spring|Binding|Motion|Animated|Animation|Sound)$/i;
@@ -2952,8 +3361,8 @@ function isCalledAsFunction(owner, name, context) {
   for (const call of context.walk(owner.body)) {
     if (call.type !== "function_call")
       continue;
-    const path3 = normalizeExpressionText(context.getCallPath(call) ?? "");
-    if (path3 === name)
+    const path4 = normalizeExpressionText(context.getCallPath(call) ?? "");
+    if (path4 === name)
       return true;
   }
   return false;
@@ -2983,8 +3392,8 @@ function customHookDependencyHints(owner, context) {
         continue;
       const directHook = calls.find((call) => isCustomHookCall(call, context));
       if (directHook && expression.type === "function_call") {
-        const path3 = context.resolveCallPath(context.getCallPath(directHook) ?? "");
-        const final = path3.split(/[.:]/).at(-1) ?? "";
+        const path4 = context.resolveCallPath(context.getCallPath(directHook) ?? "");
+        const final = path4.split(/[.:]/).at(-1) ?? "";
         const likelyHandle = HANDLE_VALUE_NAME.test(name) || HANDLE_HOOK_NAME.test(final) || isCalledAsFunction(owner, name, context);
         if (likelyHandle) {
           hints.memberHandleRoots.add(name);
@@ -2994,14 +3403,14 @@ function customHookDependencyHints(owner, context) {
       }
       if (expression.type === "table_constructor") {
         const meaningfulCalls = calls.filter((call) => {
-          const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-          return !/^(?:Color3|Vector2|Vector3|UDim|UDim2|CFrame|TweenInfo|NumberSequence|ColorSequence)\./.test(path3);
+          const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+          return !/^(?:Color3|Vector2|Vector3|UDim|UDim2|CFrame|TweenInfo|NumberSequence|ColorSequence)\./.test(path4);
         });
         const allHandleHooks = meaningfulCalls.length > 0 && meaningfulCalls.every((call) => {
           if (!isCustomHookCall(call, context))
             return false;
-          const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-          const final = path3.split(/[.:]/).at(-1) ?? "";
+          const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+          const final = path4.split(/[.:]/).at(-1) ?? "";
           return HANDLE_HOOK_NAME.test(final);
         });
         if (allHandleHooks)
@@ -3031,12 +3440,13 @@ var exhaustiveDeps = {
     const derivedDependenciesByOwner = new Map;
     const dependencyHintsByOwner = new Map;
     const memoizedProducersByOwner = new Map;
+    const transparentAliasesByOwner = new Map;
     for (const call of context.findCalls()) {
       const rawPath = context.getCallPath(call);
       if (!rawPath)
         continue;
-      const path3 = context.resolveCallPath(rawPath);
-      const shape = HOOK_ARGUMENTS.get(path3);
+      const path4 = context.resolveCallPath(rawPath);
+      const shape = HOOK_ARGUMENTS.get(path4);
       if (!shape)
         continue;
       const args = context.callArguments(call);
@@ -3052,7 +3462,12 @@ var exhaustiveDeps = {
       const stableVariables = context.model.stableVariablesByFunction.get(ownerKey) ?? new Set;
       const externallyMutableRoots = context.model.externalMutableVariablesByFunction.get(ownerKey) ?? new Set;
       const functionExpandedCaptures = expandLocalFunctionCaptures(capturedDependencyPaths(callback, available, stableVariables, externallyMutableRoots), owner, available, stableVariables, externallyMutableRoots, context);
-      const dependencies = dependencyPaths(deps);
+      let transparentAliases = transparentAliasesByOwner.get(ownerKey);
+      if (!transparentAliases) {
+        transparentAliases = immutableTransparentAliases(owner, context);
+        transparentAliasesByOwner.set(ownerKey, transparentAliases);
+      }
+      const dependencies = dependencyPathsWithAliases(deps, transparentAliases);
       let derivedDependencies = derivedDependenciesByOwner.get(ownerKey);
       if (!derivedDependencies) {
         derivedDependencies = derivedLocalDependencies(owner, available, stableVariables, externallyMutableRoots, context);
@@ -3066,7 +3481,7 @@ var exhaustiveDeps = {
         diagnostics.push({
           node: tableStartNode(deps),
           severity: "suggestion",
-          message: `${path3} uses dynamic unpack(...) dependencies, so exhaustive dependency analysis is partial.`,
+          message: `${path4} uses dynamic unpack(...) dependencies, so exhaustive dependency analysis is partial.`,
           help: "The analyzer cannot prove which values unpack(...) contributes. Review the explicit dependencies and the custom hook contract."
         });
         continue;
@@ -3087,7 +3502,7 @@ var exhaustiveDeps = {
       if (reactiveMissing.length > 0) {
         diagnostics.push({
           node: tableStartNode(deps),
-          message: `${path3} dependency table is missing ${reactiveMissing.join(", ")}.`,
+          message: `${path4} dependency table is missing ${reactiveMissing.join(", ")}.`,
           help: `Add ${reactiveMissing.join(", ")} to the dependency table, or stop capturing ${reactiveMissing.length === 1 ? "that value" : "those values"} in the callback.`
         });
       }
@@ -3095,7 +3510,7 @@ var exhaustiveDeps = {
         diagnostics.push({
           node: tableStartNode(deps),
           severity: "suggestion",
-          message: `${path3} captures memoized value ${transitivelyCoveredMemoized.join(", ")} without listing ${transitivelyCoveredMemoized.length === 1 ? "it directly" : "them directly"}, but ${transitivelyCoveredMemoized.length === 1 ? "its memo dependencies are" : "their memo dependencies are"} already covered.`,
+          message: `${path4} captures memoized value ${transitivelyCoveredMemoized.join(", ")} without listing ${transitivelyCoveredMemoized.length === 1 ? "it directly" : "them directly"}, but ${transitivelyCoveredMemoized.length === 1 ? "its memo dependencies are" : "their memo dependencies are"} already covered.`,
           help: "The producing memo dependencies are already covered. Listing the memoized value directly can make the dependency relationship clearer."
         });
       }
@@ -3103,7 +3518,7 @@ var exhaustiveDeps = {
         diagnostics.push({
           node: tableStartNode(deps),
           severity: "suggestion",
-          message: `${path3} captures custom-hook handle ${uncertainHandles.join(", ")} without listing ${uncertainHandles.length === 1 ? "it as a dependency" : "them as dependencies"}.`,
+          message: `${path4} captures custom-hook handle ${uncertainHandles.join(", ")} without listing ${uncertainHandles.length === 1 ? "it as a dependency" : "them as dependencies"}.`,
           help: "The analyzer cannot prove this custom-hook return is stable. Check the hook contract before changing the dependency table."
         });
       }
@@ -3137,8 +3552,8 @@ function createElementCallsInLoop(context, loop) {
   for (const node of context.walk(loop)) {
     if (node.type !== "function_call")
       continue;
-    const path3 = context.resolveCallPath(context.getCallPath(node) ?? "");
-    if (path3 === "React.createElement")
+    const path4 = context.resolveCallPath(context.getCallPath(node) ?? "");
+    if (path4 === "React.createElement")
       result.push(node);
   }
   return result;
@@ -3194,8 +3609,8 @@ var noCreateContextInRender = {
   run(context) {
     const diagnostics = [];
     for (const call of context.findCalls()) {
-      const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (path3 !== "React.createContext")
+      const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (path4 !== "React.createContext")
         continue;
       const owner = context.nearestFunction(call);
       if (!owner || !owner.isComponent && !owner.isHook)
@@ -3231,8 +3646,8 @@ function isRenderedBy(context, component, name) {
       continue;
     if (context.nearestFunction(call) !== component)
       continue;
-    const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-    if (path3 !== "React.createElement")
+    const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+    if (path4 !== "React.createElement")
       continue;
     if (context.callArguments(call)[0]?.text.trim() === name)
       return true;
@@ -3276,63 +3691,6 @@ var noNestedComponentDefinition = {
   }
 };
 
-// src/module-resolution.ts
-import path3 from "path";
-function normalizeRelative(value) {
-  return value.split(path3.sep).join("/");
-}
-function moduleKeys(relativePath) {
-  let normalized = normalizeRelative(relativePath).replace(/\.(?:lua|luau)$/i, "");
-  if (normalized.endsWith("/init"))
-    normalized = normalized.slice(0, -"/init".length);
-  const segments = normalized.split("/").filter(Boolean);
-  if (segments[0]?.toLowerCase() === "src")
-    segments.shift();
-  const keys = new Set;
-  for (let index = 0;index < segments.length; index += 1) {
-    const suffix = segments.slice(index).join(".").toLowerCase();
-    if (suffix)
-      keys.add(suffix);
-  }
-  return [...keys];
-}
-function normalizeRequireTarget(text) {
-  return (text.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? []).join(".").toLowerCase();
-}
-function buildUniqueFeatureAliases(modules, featureByModuleId) {
-  const owners = new Map;
-  for (const module of modules) {
-    for (const key of module.keys) {
-      const ids = owners.get(key) ?? new Set;
-      ids.add(module.id);
-      owners.set(key, ids);
-    }
-  }
-  const aliases = new Map;
-  for (const module of modules) {
-    const value = featureByModuleId.get(module.id);
-    if (value === undefined)
-      continue;
-    for (const key of module.keys) {
-      const ids = owners.get(key);
-      if (ids?.size === 1 && ids.has(module.id))
-        aliases.set(key, value);
-    }
-  }
-  return aliases;
-}
-function resolveModuleReference(target, aliases) {
-  let candidate = target;
-  while (true) {
-    if (aliases.has(candidate))
-      return aliases.get(candidate);
-    const separator = candidate.indexOf(".");
-    if (separator < 0)
-      return null;
-    candidate = candidate.slice(separator + 1);
-  }
-}
-
 // src/rules/parameter-mutations.ts
 var analysisCache = new WeakMap;
 var EMPTY_INDEXES = new Set;
@@ -4059,7 +4417,7 @@ var rerenderHighFrequencyState = {
       seen.add(key);
       const renderCost = componentRenderCost(context, component);
       diagnostics.push({
-        node: callNameNode(call),
+        node: callNameNode(binding.call),
         severity: "warning",
         message: `${binding.valueName} has a state setter called from a per-frame callback and may cause frequent rerenders when its value changes.`,
         help: renderCost.length > 0 ? `This render also performs ${renderCost.join(" and ")}. Isolate or throttle the high-frequency state, or use Bindings for host-property-only updates.` : "Isolate or throttle the high-frequency state. Use React.useBinding when the value only drives host Instance properties."
@@ -4336,7 +4694,9 @@ var preferUseRefForMutableCell = {
 };
 
 // src/rules/prefer-binding-over-state.ts
-var EXTERNAL_CALLBACK = /(?:^|[.:])(?:Connect|Once|Subscribe|Observe|Listen|Watch)$/i;
+var EXTERNAL_CALLBACK = /(?:^|[.:])(?:Connect|Subscribe|Observe|Listen|Watch|onStep|onUpdate|onChange|onChanged)$/i;
+var PERSISTENT_MIRROR_CALLBACK = /(?:^|[.:])(?:Connect|Subscribe|Observe|Listen|Watch|onStep|onUpdate|onChange|onChanged)$/i;
+var LIKELY_CONTINUOUS_CALLBACK = /(?:^|[.:])onStep$/i;
 var NON_BINDABLE_HOST_FIELDS = new Set(["ref", "key", "children"]);
 function replaceWithinNode(container, target, replacement) {
   const start = target.startIndex - container.startIndex;
@@ -4459,13 +4819,64 @@ var TRANSPARENT_PARENTS = new Set([
   "string_interpolation",
   "expression_list",
   "assignment_statement",
-  "arguments",
-  "function_call",
   "dot_index_expression",
   "method_index_expression",
   "table_constructor",
   "field"
 ]);
+var PURE_BINDING_DERIVATION_CALL = /^(?:tostring|tonumber|type|typeof|math\.[A-Za-z_][A-Za-z0-9_]*|string\.[A-Za-z_][A-Za-z0-9_]*|utf8\.[A-Za-z_][A-Za-z0-9_]*|bit32\.[A-Za-z_][A-Za-z0-9_]*|(?:UDim|UDim2|Vector2|Vector3|Color3|CFrame|Rect|NumberRange|NumberSequence|ColorSequence|BrickColor|Font)\.[A-Za-z_][A-Za-z0-9_]*)$/;
+var HOST_FEEDBACK_PROPERTIES = new Set([
+  "AbsoluteSize",
+  "AbsolutePosition",
+  "AbsoluteRotation",
+  "AbsoluteContentSize",
+  "AbsoluteCanvasSize",
+  "AbsoluteCellSize",
+  "AbsoluteCellCount",
+  "TextBounds",
+  "CanvasPosition"
+]);
+var LIKELY_CONTINUOUS_PROPERTIES = new Set([
+  "CFrame",
+  "WorldCFrame",
+  "Position",
+  "WorldPosition",
+  "Rotation",
+  "Orientation",
+  "CanvasPosition",
+  "PlaybackLoudness",
+  "TimePosition"
+]);
+var SEMANTIC_SNAPSHOT_EXPRESSION = /\b(?:getState|getSnapshot|snapshot|selector|select|table\s*\.\s*(?:clone|freeze|move))\b|(?:\.|\[\s*["'])State(?:\b|["']\s*\])/i;
+function isBindingMapSafeCall(call, context) {
+  if (call.type !== "function_call")
+    return false;
+  const path4 = context.resolveCallPath(context.getCallPath(call) ?? "").replace(/\s+/g, "");
+  return PURE_BINDING_DERIVATION_CALL.test(path4);
+}
+function isTransparentParent(parent, context) {
+  if (parent.type === "function_call")
+    return isBindingMapSafeCall(parent, context);
+  if (parent.type === "arguments") {
+    return parent.parent?.type === "function_call" && isBindingMapSafeCall(parent.parent, context);
+  }
+  return TRANSPARENT_PARENTS.has(parent.type);
+}
+function stringLiteralValue(node) {
+  if (!node)
+    return null;
+  return node.text.trim().match(/^["']([^"']+)["']$/)?.[1] ?? null;
+}
+function observedPropertyForCall(summary, call, context) {
+  if (summary.observedPropertyName)
+    return summary.observedPropertyName;
+  if (summary.observedPropertyParameterIndex === undefined)
+    return null;
+  return stringLiteralValue(context.callArguments(call)[summary.observedPropertyParameterIndex]);
+}
+function isStrongHostFeedbackProperty(property) {
+  return Boolean(property && HOST_FEEDBACK_PROPERTIES.has(property));
+}
 function isInside(node, ancestor) {
   let current = node;
   while (current) {
@@ -4549,13 +4960,75 @@ function isTransparentUsage(node, context, compatibleComponentProps) {
     }
     if (parent.type === "function_definition" || parent.type === "function_declaration")
       return false;
-    if (!TRANSPARENT_PARENTS.has(parent.type))
+    if (!isTransparentParent(parent, context))
       return false;
     current = parent;
   }
   return false;
 }
-function derivedLocalDeclarationForRead(node) {
+function isDirectBindingValueUsage(node, context, compatibleComponentProps) {
+  let current = node;
+  while (current) {
+    const parent = current.parent;
+    if (!parent)
+      return false;
+    if (parent.type === "parenthesized_expression" || parent.type === "cast_expression" || parent.type === "type_cast_expression") {
+      current = parent;
+      continue;
+    }
+    if (parent.type !== "field")
+      return false;
+    const value = fieldValue(parent);
+    if (!value || !sameNode(value, current))
+      return false;
+    const property = fieldName(parent);
+    if (!property || NON_BINDABLE_HOST_FIELDS.has(property))
+      return false;
+    const table = parent.parent;
+    const args = table?.parent;
+    const call = args?.parent;
+    if (table?.type !== "table_constructor" || args?.type !== "arguments" || !call || !isCreateElementCall2(call, context)) {
+      return false;
+    }
+    if (!sameNode(context.callArguments(call)[1], table))
+      return false;
+    if (isHostCreateElementCall(call, context))
+      return true;
+    const component = context.callArguments(call)[0]?.text.trim() ?? "";
+    return compatibleComponentProps.get(component)?.has(property) ?? false;
+  }
+  return false;
+}
+function allReadsDirectlyBindingSubstitutable(valueName, owner, declaration, context, compatibleComponentProps) {
+  if (!owner.body)
+    return false;
+  let reads = 0;
+  for (const node of context.walk(owner.body)) {
+    if (!isReadNode(node, valueName, owner, declaration))
+      continue;
+    reads += 1;
+    if (!isDirectBindingValueUsage(node, context, compatibleComponentProps))
+      return false;
+  }
+  return reads > 0;
+}
+function derivedLocalDeclarationForRead(node, context) {
+  let current = node;
+  while (current) {
+    const parent = current.parent;
+    if (!parent)
+      return null;
+    if (parent.type === "variable_declaration")
+      return parent;
+    if (parent.type === "function_definition" || parent.type === "function_declaration")
+      return null;
+    if (!isTransparentParent(parent, context))
+      return null;
+    current = parent;
+  }
+  return null;
+}
+function opaqueDerivedLocalDeclarationForRead(node, context) {
   let current = node;
   while (current) {
     const parent = current.parent;
@@ -4565,7 +5038,14 @@ function derivedLocalDeclarationForRead(node) {
       return parent;
     if (parent.type === "function_definition" || parent.type === "function_declaration")
       return null;
-    if (!TRANSPARENT_PARENTS.has(parent.type))
+    if (parent.type === "if_statement" || parent.type === "elseif_clause" || parent.type === "while_statement" || parent.type === "repeat_statement" || parent.type === "for_statement" || parent.type === "for_in_statement" || parent.type === "return_statement")
+      return null;
+    if (parent.type === "function_call") {
+      const path4 = context.resolveCallPath(context.getCallPath(parent) ?? "");
+      if (/^React\.use(?:Memo|Callback|Effect|LayoutEffect)$/.test(path4))
+        return null;
+    }
+    if (!TRANSPARENT_PARENTS.has(parent.type) && parent.type !== "arguments" && parent.type !== "function_call")
       return null;
     current = parent;
   }
@@ -4585,7 +5065,7 @@ function stateReadsAreBindingCompatible(valueName, owner, declaration, context,
     reads += 1;
     if (isTransparentUsage(node, context, compatibleComponentProps))
       continue;
-    const derivedDeclaration = derivedLocalDeclarationForRead(node);
+    const derivedDeclaration = derivedLocalDeclarationForRead(node, context);
     const derivedNames = derivedDeclaration ? declarationNames2(derivedDeclaration) : [];
     if (derivedDeclaration && derivedNames.length === 1) {
       if (stateReadsAreBindingCompatible(derivedNames[0], owner, derivedDeclaration, context, compatibleComponentProps, new Set(visited)))
@@ -4595,12 +5075,46 @@ function stateReadsAreBindingCompatible(valueName, owner, declaration, context,
   }
   return reads > 0;
 }
+function propertyChangedSignalProperty(text) {
+  return text.match(/GetPropertyChangedSignal\s*\(\s*["']([^"']+)["']\s*\)/)?.[1] ?? null;
+}
+function reactChangePropertyForCallback(node) {
+  let current = node.parent;
+  while (current && current.type !== "function_definition" && current.type !== "function_declaration") {
+    if (current.type === "field") {
+      return current.text.match(/React\s*\.\s*Change\s*\.\s*([A-Za-z_][A-Za-z0-9_]*)/)?.[1] ?? null;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+function evidenceForExternalSource(highFrequency, hostFeedbackProperty) {
+  const hostFeedbackProperties = new Set;
+  if (hostFeedbackProperty)
+    hostFeedbackProperties.add(hostFeedbackProperty);
+  return {
+    highFrequency,
+    external: true,
+    hostFeedbackProperties,
+    genericExternal: !highFrequency && !hostFeedbackProperty
+  };
+}
+function mergeSourceEvidence(target, source) {
+  target.highFrequency ||= source.highFrequency;
+  target.external ||= source.external;
+  target.genericExternal ||= source.genericExternal;
+  for (const property of source.hostFeedbackProperties)
+    target.hostFeedbackProperties.add(property);
+}
 function callbackSource(call, context) {
   const normalized = (context.getCallPath(call) ?? "").replace(/\s+/g, "");
-  const highFrequency = isHighFrequencyRunServiceCall(call, context);
+  const highFrequency = isHighFrequencyRobloxCall(call, context) || LIKELY_CONTINUOUS_CALLBACK.test(normalized);
+  const hostFeedbackProperty = propertyChangedSignalProperty(call.text);
   const final = normalized.split(/[.:]/).at(-1) ?? normalized;
-  const external = highFrequency || EXTERNAL_CALLBACK.test(normalized) || EXTERNAL_CALLBACK.test(final);
-  return { highFrequency, external };
+  const external = highFrequency || Boolean(hostFeedbackProperty) || EXTERNAL_CALLBACK.test(normalized) || EXTERNAL_CALLBACK.test(final);
+  if (!external)
+    return null;
+  return evidenceForExternalSource(highFrequency, hostFeedbackProperty);
 }
 function importedCallbackSource(call, callbackArgument, importedCallbacks, context) {
   const path4 = context.getCallPath(call) ?? "";
@@ -4611,12 +5125,14 @@ function importedCallbackSource(call, callbackArgument, importedCallbacks, conte
   const callbackIndex = args.findIndex((arg) => sameNode(arg, callbackArgument));
   if (callbackIndex < 0 || !summary.callbackParameterIndexes.includes(callbackIndex))
     return null;
-  return {
-    highFrequency: summary.highFrequency || args.some((arg) => isHighFrequencyRunServiceExpression(arg, context)),
-    external: true
-  };
+  const highFrequency = summary.highFrequency || args.some((arg) => isHighFrequencyRobloxExpression(arg, context));
+  const hostFeedbackProperty = args.map((arg) => propertyChangedSignalProperty(arg.text)).find((property) => Boolean(property));
+  return evidenceForExternalSource(highFrequency, hostFeedbackProperty);
 }
 function directCallbackSource(node, importedCallbacks, context) {
+  const reactChangeProperty = reactChangePropertyForCallback(node);
+  if (reactChangeProperty)
+    return evidenceForExternalSource(false, reactChangeProperty);
   const parent = node.parent;
   if (parent?.type !== "arguments" || parent.parent?.type !== "function_call")
     return null;
@@ -4624,14 +5140,17 @@ function directCallbackSource(node, importedCallbacks, context) {
   const imported = importedCallbackSource(call, node, importedCallbacks, context);
   if (imported)
     return imported;
-  const source = callbackSource(call, context);
-  return source.external ? source : null;
+  return callbackSource(call, context);
 }
 function namedFunctionCallbackSource(fn, owner, importedCallbacks, context) {
   if (!fn.name || !owner.body)
     return null;
-  let foundExternal = false;
-  let foundHighFrequency = false;
+  const result = {
+    highFrequency: false,
+    external: false,
+    hostFeedbackProperties: new Set,
+    genericExternal: false
+  };
   for (const call of context.walk(owner.body)) {
     if (call.type !== "function_call")
       continue;
@@ -4639,14 +5158,12 @@ function namedFunctionCallbackSource(fn, owner, importedCallbacks, context) {
     const callbackArg = args.find((arg) => arg.type === "identifier" && arg.text === fn.name);
     if (!callbackArg)
       continue;
-    const imported = importedCallbackSource(call, callbackArg, importedCallbacks, context);
-    const source = imported ?? callbackSource(call, context);
-    if (!source.external)
+    const source = importedCallbackSource(call, callbackArg, importedCallbacks, context) ?? callbackSource(call, context);
+    if (!source)
       continue;
-    foundExternal = true;
-    foundHighFrequency ||= source.highFrequency;
+    mergeSourceEvidence(result, source);
   }
-  return foundExternal ? { highFrequency: foundHighFrequency, external: true } : null;
+  return result.external ? result : null;
 }
 function setterCallbackSource(call, binding, importedCallbacks, context) {
   const owner = binding.owner;
@@ -4660,25 +5177,178 @@ function setterCallbackSource(call, binding, importedCallbacks, context) {
     return direct;
   return namedFunctionCallbackSource(nearest, owner, importedCallbacks, context);
 }
-function bindingHasExternalOrHighFrequencyUpdates(binding, importedCallbacks, context) {
+function mirrorConfidenceRank(confidence) {
+  if (confidence === "strong")
+    return 2;
+  if (confidence === "possible")
+    return 1;
+  return 0;
+}
+function mergeMirrorConfidence(a, b) {
+  return mirrorConfidenceRank(b) > mirrorConfidenceRank(a) ? b : a;
+}
+function isLiteralStateTransition(node) {
+  if (!node)
+    return true;
+  const text = node.text.trim();
+  return /^(?:true|false|nil|[-+]?\d+(?:\.\d+)?|["'][^"']*["'])$/.test(text);
+}
+function isSemanticSnapshotExpression(node) {
+  return Boolean(node && SEMANTIC_SNAPSHOT_EXPRESSION.test(node.text));
+}
+function expressionReferencesCallbackParameter(expression, callback, context) {
+  if (callback.parameters.length === 0)
+    return false;
+  const parameters = new Set(callback.parameters);
+  return [...context.walk(expression)].some((node) => node.type === "identifier" && parameters.has(node.text));
+}
+var PURE_EXPRESSION_ROOTS = new Set([
+  "math",
+  "string",
+  "utf8",
+  "bit32",
+  "UDim",
+  "UDim2",
+  "Vector2",
+  "Vector3",
+  "Color3",
+  "CFrame",
+  "Rect",
+  "NumberRange",
+  "NumberSequence",
+  "ColorSequence",
+  "BrickColor",
+  "Font",
+  "Enum",
+  "tostring",
+  "tonumber",
+  "type",
+  "typeof"
+]);
+function callbackLocalNamesBefore(callback, before, context) {
+  const names = new Set;
+  if (!callback.body)
+    return names;
+  for (const node of context.walk(callback.body)) {
+    if (node.startIndex >= before.startIndex)
+      continue;
+    if (context.nearestFunction(node) !== callback || node.type !== "variable_declaration")
+      continue;
+    for (const name of declarationNames2(node))
+      names.add(name);
+  }
+  return names;
+}
+function expressionHasExternalInput(expression, callback, setterCall, context) {
+  const callbackLocals = callbackLocalNamesBefore(callback, setterCall, context);
+  const callbackParameters = new Set(callback.parameters);
+  for (const node of context.walk(expression)) {
+    if (node.type !== "identifier" || isIdentifierPropertyName2(node))
+      continue;
+    const name = node.text;
+    if (callbackParameters.has(name))
+      return true;
+    if (callbackLocals.has(name))
+      continue;
+    if (context.model.stateValues.has(name))
+      continue;
+    if (PURE_EXPRESSION_ROOTS.has(name))
+      continue;
+    return true;
+  }
+  return false;
+}
+function setterHasDistinctValuesInCallback(call, callback, context) {
+  if (!callback.body)
+    return false;
+  const setterPath = context.getCallPath(call);
+  const distinctValues = new Set;
+  for (const sibling of context.walk(callback.body)) {
+    if (sibling.type !== "function_call" || context.nearestFunction(sibling) !== callback)
+      continue;
+    if (context.getCallPath(sibling) !== setterPath)
+      continue;
+    const argument = context.callArguments(sibling)[0];
+    if (argument)
+      distinctValues.add(argument.text.trim());
+  }
+  return distinctValues.size > 1;
+}
+function setterCallMirrorConfidence(call, callback, source, context) {
+  const value = context.callArguments(call)[0];
+  if (!value || value.type === "function_definition")
+    return "none";
+  if (isLiteralStateTransition(value)) {
+    return source.highFrequency && setterHasDistinctValuesInCallback(call, callback, context) ? "strong" : "none";
+  }
+  if (isSemanticSnapshotExpression(value))
+    return "none";
+  if (expressionReferencesCallbackParameter(value, callback, context))
+    return "strong";
+  if (source.hostFeedbackProperties.size > 0) {
+    const text = value.text;
+    if ([...source.hostFeedbackProperties].some((property) => new RegExp(`(?:\\.|["'])${property.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(text))) {
+      return "strong";
+    }
+  }
+  if (!expressionHasExternalInput(value, callback, call, context)) {
+    return source.highFrequency && setterHasDistinctValuesInCallback(call, callback, context) ? "strong" : "none";
+  }
+  if (source.highFrequency)
+    return "strong";
+  return source.genericExternal ? "possible" : "strong";
+}
+function mergeBindingUpdateEvidence(target, source, mirrorConfidence) {
+  if (mirrorConfidence === "none")
+    return;
+  mergeSourceEvidence(target, source);
+  target.mirrorConfidence = mergeMirrorConfidence(target.mirrorConfidence, mirrorConfidence);
+}
+function bindingUpdateEvidence(binding, importedCallbacks, context) {
   const owner = binding.owner;
   if (!owner?.body)
     return null;
-  let highFrequency = false;
-  let external = false;
+  const result = {
+    highFrequency: false,
+    external: false,
+    hostFeedbackProperties: new Set,
+    genericExternal: false,
+    mirrorConfidence: "none"
+  };
   for (const node of context.walk(owner.body)) {
     if (node.type !== "function_call")
       continue;
     const path4 = context.getCallPath(node);
-    if (path4 !== binding.setterName)
+    if (path4 === binding.setterName) {
+      const source2 = setterCallbackSource(node, binding, importedCallbacks, context);
+      const callback = context.nearestFunction(node);
+      if (!source2 || !callback || callback === owner)
+        continue;
+      mergeBindingUpdateEvidence(result, source2, setterCallMirrorConfidence(node, callback, source2, context));
+      continue;
+    }
+    const args = context.callArguments(node);
+    const setterArg = args.find((arg) => arg.type === "identifier" && arg.text === binding.setterName);
+    if (!setterArg)
       continue;
-    const source = setterCallbackSource(node, binding, importedCallbacks, context);
+    const normalized = (context.getCallPath(node) ?? "").replace(/\s+/g, "");
+    const imported = importedCallbackSource(node, setterArg, importedCallbacks, context);
+    const source = imported ?? (PERSISTENT_MIRROR_CALLBACK.test(normalized) ? callbackSource(node, context) : null);
     if (!source)
       continue;
-    highFrequency ||= source.highFrequency;
-    external ||= source.external;
+    mergeBindingUpdateEvidence(result, source, "strong");
   }
-  return highFrequency || external ? { highFrequency, external } : null;
+  return result.external && result.mirrorConfidence !== "none" ? result : null;
+}
+function hasStrongHostFeedbackEvidence(source) {
+  if (source.genericExternal || source.hostFeedbackProperties.size === 0)
+    return false;
+  return [...source.hostFeedbackProperties].every((property) => isStrongHostFeedbackProperty(property));
+}
+function hasLikelyContinuousPropertyEvidence(source) {
+  if (source.hostFeedbackProperties.size === 0)
+    return false;
+  return [...source.hostFeedbackProperties].every((property) => LIKELY_CONTINUOUS_PROPERTIES.has(property));
 }
 function returnedHookValues(binding, context) {
   const owner = binding.owner;
@@ -4756,14 +5426,8 @@ function callDefinitelyUsesBindingMode(summary, call, context) {
     return false;
   return truthy === summary.bindingWhenTruthy;
 }
-function shouldRecommendImportedHook(summary, call, localName, owner, declaration, context, compatibleComponentProps) {
-  if (!summary.external || callDefinitelyUsesBindingMode(summary, call, context))
-    return false;
-  if (!hasAnyRead(localName, owner, declaration, context))
-    return false;
-  if (summary.sourceKind === "measurement")
-    return true;
-  return stateReadsAreBindingCompatible(localName, owner, declaration, context, compatibleComponentProps);
+function hasExplicitBindingMode(summary) {
+  return summary.bindingModeParameterIndex !== undefined && summary.bindingWhenTruthy !== undefined;
 }
 var LIKELY_VISUAL_PROP = /(?:position|size|rotation|transparency|opacity|color|image|text|anchor|visible|enabled|layout|scale|offset|zindex|canvas|viewport|cframe|width|height|radius|stroke|padding|spacing|angle|alpha|progress)/i;
 function createElementPropUsage(node, context) {
@@ -4792,7 +5456,7 @@ function createElementPropUsage(node, context) {
     }
     if (parent.type === "function_definition" || parent.type === "function_declaration")
       return null;
-    if (!TRANSPARENT_PARENTS.has(parent.type))
+    if (!isTransparentParent(parent, context))
       return null;
     current = parent;
   }
@@ -4824,17 +5488,17 @@ function isEffectUsage(node, context) {
   }
   return false;
 }
-function isStructuralUsage(node) {
+function isStructuralUsage(node, context) {
   let current = node;
   while (current) {
     const parent = current.parent;
     if (!parent)
       return false;
-    if (parent.type === "if_statement" || parent.type === "elseif_clause" || parent.type === "while_statement" || parent.type === "repeat_statement" || parent.type === "return_statement")
+    if (parent.type === "if_statement" || parent.type === "elseif_clause" || parent.type === "while_statement" || parent.type === "repeat_statement" || parent.type === "for_statement" || parent.type === "for_in_statement" || parent.type === "return_statement")
       return true;
     if (parent.type === "function_definition" || parent.type === "function_declaration")
       return false;
-    if (!TRANSPARENT_PARENTS.has(parent.type))
+    if (!isTransparentParent(parent, context))
       return false;
     current = parent;
   }
@@ -4847,11 +5511,11 @@ function classifyBindingUsage(node, context, compatibleComponentProps) {
     return "custom-component";
   if (isEffectUsage(node, context))
     return "effect";
-  if (isStructuralUsage(node))
+  if (isStructuralUsage(node, context))
     return "structural";
   return "unknown";
 }
-function bindingUsageSummary(valueName, owner, declaration, context, compatibleComponentProps) {
+function bindingUsageSummary(valueName, owner, declaration, context, compatibleComponentProps, visited = new Set) {
   const summary = {
     reads: 0,
     compatible: 0,
@@ -4863,9 +5527,45 @@ function bindingUsageSummary(valueName, owner, declaration, context, compatibleC
   };
   if (!owner.body)
     return summary;
+  const visitKey = `${declaration.startIndex}:${valueName}`;
+  if (visited.has(visitKey))
+    return summary;
+  visited.add(visitKey);
   for (const node of context.walk(owner.body)) {
     if (!isReadNode(node, valueName, owner, declaration))
       continue;
+    if (!isTransparentUsage(node, context, compatibleComponentProps)) {
+      const derivedDeclaration = derivedLocalDeclarationForRead(node, context);
+      const derivedNames = derivedDeclaration ? declarationNames2(derivedDeclaration) : [];
+      if (derivedDeclaration && derivedNames.length === 1) {
+        const derived = bindingUsageSummary(derivedNames[0], owner, derivedDeclaration, context, compatibleComponentProps, new Set(visited));
+        if (derived.reads > 0) {
+          summary.reads += derived.reads;
+          summary.compatible += derived.compatible;
+          summary.customComponent += derived.customComponent;
+          summary.visualCustomComponent += derived.visualCustomComponent;
+          summary.effect += derived.effect;
+          summary.structural += derived.structural;
+          summary.unknown += derived.unknown;
+          continue;
+        }
+      }
+      const opaqueDeclaration = opaqueDerivedLocalDeclarationForRead(node, context);
+      const opaqueNames = opaqueDeclaration ? declarationNames2(opaqueDeclaration) : [];
+      if (opaqueDeclaration && opaqueNames.length === 1) {
+        const derived = bindingUsageSummary(opaqueNames[0], owner, opaqueDeclaration, context, compatibleComponentProps, new Set(visited));
+        if (derived.reads > 0) {
+          summary.reads += derived.reads + 1;
+          summary.compatible += derived.compatible;
+          summary.customComponent += derived.customComponent;
+          summary.visualCustomComponent += derived.visualCustomComponent;
+          summary.effect += derived.effect;
+          summary.structural += derived.structural;
+          summary.unknown += derived.unknown + 1;
+          continue;
+        }
+      }
+    }
     summary.reads += 1;
     const customComponentUsage = createElementPropUsage(node, context);
     const kind = classifyBindingUsage(node, context, compatibleComponentProps);
@@ -4888,11 +5588,94 @@ function bindingUsageSummary(valueName, owner, declaration, context, compatibleC
 function hasCandidatePresentationEvidence(summary) {
   return summary.compatible > 0 || summary.visualCustomComponent > 0;
 }
+function isPresentationOnly(summary) {
+  return summary.reads > 0 && summary.compatible === summary.reads;
+}
+function stateBindingForSetter(setterName, context) {
+  const valueName = context.model.stateSetters.get(setterName);
+  if (!valueName)
+    return null;
+  return context.model.stateBindings.find((binding) => binding.setterName === setterName && binding.valueName === valueName) ?? null;
+}
+function effectOnlyDerivesPresentation(valueName, owner, declaration, context, compatibleComponentProps) {
+  if (!owner.body)
+    return false;
+  let foundRelevantEffect = false;
+  for (const call of context.walk(owner.body)) {
+    if (call.type !== "function_call" || context.nearestFunction(call) !== owner)
+      continue;
+    const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+    if (path4 !== "React.useEffect" && path4 !== "React.useLayoutEffect")
+      continue;
+    const callbackNode = context.callArguments(call)[0];
+    if (callbackNode?.type !== "function_definition")
+      continue;
+    const callback = context.model.functionByNode.get(callbackNode.id);
+    if (!callback?.body)
+      continue;
+    const usesValue = [...context.walk(callback.body)].some((node) => context.nearestFunction(node) === callback && isReadNode(node, valueName, owner, declaration));
+    if (!usesValue)
+      continue;
+    foundRelevantEffect = true;
+    let presentationSetter = false;
+    for (const nested of context.walk(callback.body)) {
+      if (nested.type !== "function_call" || context.nearestFunction(nested) !== callback)
+        continue;
+      if (isBindingMapSafeCall(nested, context))
+        continue;
+      const nestedPath = context.resolveCallPath(context.getCallPath(nested) ?? "");
+      if (nestedPath === "debug.profilebegin" || nestedPath === "debug.profileend")
+        continue;
+      if (context.model.bindingSetters.has(nestedPath)) {
+        presentationSetter = true;
+        continue;
+      }
+      const target = stateBindingForSetter(nestedPath, context);
+      if (target?.owner && stateReadsAreBindingCompatible(target.valueName, target.owner, target.declaration, context, compatibleComponentProps)) {
+        presentationSetter = true;
+        continue;
+      }
+      return false;
+    }
+    if (!presentationSetter)
+      return false;
+  }
+  return foundRelevantEffect;
+}
+function importedHookRecommendation(summary, call, localName, owner, declaration, context, compatibleComponentProps) {
+  if (!summary.external || callDefinitelyUsesBindingMode(summary, call, context))
+    return null;
+  const usage = bindingUsageSummary(localName, owner, declaration, context, compatibleComponentProps);
+  if (usage.reads === 0)
+    return null;
+  const presentationOnly = isPresentationOnly(usage);
+  const explicitBindingMode = hasExplicitBindingMode(summary);
+  const observedProperty = observedPropertyForCall(summary, call, context);
+  const strongHostFeedback = summary.sourceKind === "instance-property" && isStrongHostFeedbackProperty(observedProperty);
+  const likelyContinuousProperty = summary.sourceKind === "instance-property" && Boolean(observedProperty && LIKELY_CONTINUOUS_PROPERTIES.has(observedProperty));
+  const mirrorsExternalValue = summary.mirrorConfidence !== "none";
+  if (presentationOnly && (summary.highFrequency || likelyContinuousProperty))
+    return "warning";
+  if (presentationOnly && strongHostFeedback && explicitBindingMode)
+    return "warning";
+  if (presentationOnly && (explicitBindingMode || strongHostFeedback || mirrorsExternalValue))
+    return "candidate";
+  if (strongHostFeedback && usage.effect > 0 && effectOnlyDerivesPresentation(localName, owner, declaration, context, compatibleComponentProps)) {
+    return "candidate";
+  }
+  if (!hasCandidatePresentationEvidence(usage))
+    return null;
+  if (summary.highFrequency || likelyContinuousProperty)
+    return "candidate";
+  if (strongHostFeedback && explicitBindingMode && usage.effect === 0)
+    return "candidate";
+  return null;
+}
 var preferBindingOverState = {
   id: "react-luau/prefer-binding-over-state",
   category: "Performance",
   severity: "warning",
-  description: "Prefer React.useBinding when externally updated values do not need React reconciliation on every change.",
+  description: "Prefer React.useBinding when proven external presentation streams do not need React reconciliation.",
   run(context) {
     const diagnostics = [];
     const seen = new Set;
@@ -4909,75 +5692,72 @@ var preferBindingOverState = {
       const owner = context.containingComponent(call) ?? context.nearestFunction(call);
       if (!declaration || !localName || !owner)
         continue;
-      if (!shouldRecommendImportedHook(summary, call, localName, owner, declaration, context, compatibleComponentProps))
+      if (importedHookRecommendation(summary, call, localName, owner, declaration, context, compatibleComponentProps) !== "warning")
         continue;
       const key = `imported:${call.startIndex}:${call.endIndex}:${localName}`;
       if (seen.has(key))
         continue;
       seen.add(key);
-      const hasBindingMode = summary.bindingModeParameterIndex !== undefined && summary.bindingWhenTruthy !== undefined;
-      const message = summary.sourceKind === "measurement" ? hasBindingMode ? `${path4} is using its React state mode for an externally changing GUI measurement, so ${localName} rerenders this consumer when the measurement changes.` : `${path4} returns React state for an externally changing GUI measurement, so ${localName} rerenders this consumer when the measurement changes.` : summary.sourceKind === "derived-external-state" ? `${path4} derives React state from another externally updated reactive value, so ${localName} adds another rerendering state layer.` : `${path4} returns state updated${summary.highFrequency ? " from a high-frequency source" : " from an external callback"}, and ${localName} only flows into bindable host properties.`;
-      const bindingModeInstruction = hasBindingMode ? `Use the hook's Binding-returning mode${summary.bindingModeParameterName ? ` by passing ${summary.bindingWhenTruthy ? "true" : "false"} for ${summary.bindingModeParameterName}` : ""}. ` : "Prefer a Binding-returning measurement hook. ";
-      const help = summary.sourceKind === "measurement" ? `${bindingModeInstruction}Use Binding:map for derived visual values or a binding-aware effect for imperative reactions; keep React state only when the measurement truly needs to rebuild component structure.` : "Prefer a Binding-returning hook API so host properties can update without rerendering the consumer.";
+      const hasBindingMode = hasExplicitBindingMode(summary);
+      const observedProperty = observedPropertyForCall(summary, call, context);
+      const hostFeedback = summary.sourceKind === "instance-property" && isStrongHostFeedbackProperty(observedProperty);
+      const likelyContinuousProperty = summary.sourceKind === "instance-property" && Boolean(observedProperty && LIKELY_CONTINUOUS_PROPERTIES.has(observedProperty));
+      const message = hostFeedback ? `${path4} mirrors ${observedProperty} through React state even though every analyzed use is presentation-only, so the measurement rerenders this consumer without needing reconciliation.` : likelyContinuousProperty ? `${path4} mirrors continuously mutable ${observedProperty} through React state, and ${localName} only feeds presentation updates that do not need reconciliation.` : `${path4} returns state updated from a high-frequency source, and ${localName} only feeds presentation updates that do not need React reconciliation.`;
+      const help = hasBindingMode ? `Use the hook's Binding-returning mode${summary.bindingModeParameterName ? ` by passing ${summary.bindingWhenTruthy ? "true" : "false"} for ${summary.bindingModeParameterName}` : ""}. Binding:map can keep pure visual derivations outside the render cycle.` : "Prefer a Binding-returning hook API so continuous presentation updates can reach host properties without rerendering the consumer.";
       diagnostics.push({
         node: callNameNode(call),
         message,
         help,
-        fixPreview: hasBindingMode ? bindingModeFixPreview(summary, call, context) : undefined
-      });
-    }
-    for (const call of context.findCalls()) {
-      const path4 = context.getCallPath(call) ?? "";
-      const member = path4.split(/[.:]/).at(-1) ?? path4;
-      const bindingAlternative = context.project.bindingApiAlternatives.get(member);
-      if (!bindingAlternative)
-        continue;
-      const declaration = declarationForCall2(call);
-      const localName = declaration ? declarationNames2(declaration)[0] ?? null : null;
-      const owner = context.containingComponent(call) ?? context.nearestFunction(call);
-      if (!declaration || !localName || !owner || !hasAnyRead(localName, owner, declaration, context))
-        continue;
-      if (!stateReadsAreBindingCompatible(localName, owner, declaration, context, compatibleComponentProps))
-        continue;
-      const field = selectorFieldName(call, context);
-      const key = `state-api:${call.startIndex}:${call.endIndex}:${localName}`;
-      if (seen.has(key))
-        continue;
-      seen.add(key);
-      diagnostics.push({
-        node: callNameNode(call),
-        message: `${path4} subscribes ${localName} through React state${field ? ` for ${field}` : ""}, but ${bindingAlternative} is available and every use of the value only updates bindable host properties.`,
-        help: `Use ${bindingAlternative} so the host property can update without rerendering the component.`,
-        fixPreview: callMemberFixPreview(call, bindingAlternative)
+        fixPreview: hasBindingMode && allReadsDirectlyBindingSubstitutable(localName, owner, declaration, context, compatibleComponentProps) ? bindingModeFixPreview(summary, call, context) : undefined
       });
     }
     for (const binding of context.model.stateBindings) {
       const owner = binding.owner;
       if (!owner || !owner.isComponent && !owner.isHook)
         continue;
-      const updateKind = bindingHasExternalOrHighFrequencyUpdates(binding, importedCallbacks, context);
-      if (!updateKind)
+      const update = bindingUpdateEvidence(binding, importedCallbacks, context);
+      if (!update)
         continue;
       const localCompatible = stateReadsAreBindingCompatible(binding.valueName, owner, binding.declaration, context, compatibleComponentProps);
       const hookCompatible = owner.isHook ? hookCallSitesAreBindingCompatible(binding, context, compatibleComponentProps) : false;
-      if (owner.isHook ? !hookCompatible : !localCompatible)
+      const strongHostFeedback = hasStrongHostFeedbackEvidence(update);
+      const likelyContinuousProperty = hasLikelyContinuousPropertyEvidence(update);
+      const shouldWarn = owner.isHook ? hookCompatible && (update.highFrequency || likelyContinuousProperty) : localCompatible && (update.highFrequency || strongHostFeedback || likelyContinuousProperty);
+      if (!shouldWarn)
         continue;
       const key = `${binding.call.startIndex}:${binding.call.endIndex}:${binding.valueName}`;
       if (seen.has(key))
         continue;
       seen.add(key);
       if (owner.isHook && hookCompatible) {
+        const properties = likelyContinuousProperty ? [...update.hostFeedbackProperties].sort().join(", ") : "";
+        diagnostics.push({
+          node: callNameNode(binding.call),
+          message: likelyContinuousProperty && !update.highFrequency ? `Hook state ${binding.valueName} mirrors continuously mutable ${properties} and is only consumed by presentation properties at analyzed call sites.` : `Hook state ${binding.valueName} is updated from a high-frequency source and is only consumed by presentation properties at analyzed call sites.`,
+          help: "Consider returning a Binding, or adding a Binding-returning variant of this hook, so continuous presentation updates do not rerender every consumer."
+        });
+      } else if (strongHostFeedback && !update.highFrequency) {
+        const properties = [...update.hostFeedbackProperties].sort().join(", ");
+        diagnostics.push({
+          node: callNameNode(binding.call),
+          message: `State ${binding.valueName} mirrors ${properties} and only feeds presentation updates, so React reconciliation is acting as an unnecessary host-property feedback step.`,
+          help: "Prefer React.useBinding for this host feedback path. Use Binding:map for pure visual derivations and keep React state only when a change needs to affect component structure or React effects.",
+          fixPreview: allReadsDirectlyBindingSubstitutable(binding.valueName, owner, binding.declaration, context, compatibleComponentProps) ? useBindingFixPreview(binding.call) : undefined
+        });
+      } else if (likelyContinuousProperty && !update.highFrequency) {
+        const properties = [...update.hostFeedbackProperties].sort().join(", ");
         diagnostics.push({
           node: callNameNode(binding.call),
-          message: `Hook state ${binding.valueName} is updated${updateKind.highFrequency ? " from a high-frequency source" : " from an external callback"} and is only consumed by host properties at analyzed call sites.`,
-          help: "Consider returning a Binding, or adding a Binding-returning variant of this hook, so consumers can update host properties without rerendering."
+          message: `State ${binding.valueName} mirrors continuously mutable ${properties} and only feeds presentation updates that do not need React reconciliation.`,
+          help: "Prefer React.useBinding so external visual property changes can reach presentation without routing every update through component state.",
+          fixPreview: allReadsDirectlyBindingSubstitutable(binding.valueName, owner, binding.declaration, context, compatibleComponentProps) ? useBindingFixPreview(binding.call) : undefined
         });
       } else {
         diagnostics.push({
           node: callNameNode(binding.call),
-          message: `State ${binding.valueName} is updated${updateKind.highFrequency ? " from a high-frequency callback" : " from an external callback"} and is read by the component render path.`,
-          help: "Prefer React.useBinding when the update is visual and does not need React to rebuild component structure.",
-          fixPreview: useBindingFixPreview(binding.call)
+          message: `State ${binding.valueName} is updated from a high-frequency callback and only feeds presentation updates that do not need React reconciliation.`,
+          help: "Prefer React.useBinding so continuous visual updates can reach host properties without rerendering the component.",
+          fixPreview: allReadsDirectlyBindingSubstitutable(binding.valueName, owner, binding.declaration, context, compatibleComponentProps) ? useBindingFixPreview(binding.call) : undefined
         });
       }
     }
@@ -4998,27 +5778,49 @@ var preferBindingOverStateCandidate = {
     for (const call of context.findCalls()) {
       const path4 = context.getCallPath(call) ?? "";
       const summary = importedHooks.get(path4);
-      if (!summary || !summary.external || callDefinitelyUsesBindingMode(summary, call, context))
+      if (!summary)
         continue;
       const declaration = declarationForCall2(call);
       const localName = declaration ? declarationNames2(declaration)[0] ?? null : null;
       const owner = context.containingComponent(call) ?? context.nearestFunction(call);
-      if (!declaration || !localName || !owner || !hasAnyRead(localName, owner, declaration, context))
+      if (!declaration || !localName || !owner)
         continue;
-      if (shouldRecommendImportedHook(summary, call, localName, owner, declaration, context, compatibleComponentProps))
+      if (importedHookRecommendation(summary, call, localName, owner, declaration, context, compatibleComponentProps) !== "candidate")
         continue;
       const usage = bindingUsageSummary(localName, owner, declaration, context, compatibleComponentProps);
-      const hasPresentationEvidence = hasCandidatePresentationEvidence(usage) || summary.sourceKind === "derived-external-state" && usage.effect > 0;
-      if (!summary.highFrequency && !hasPresentationEvidence)
-        continue;
+      const presentationOnly = isPresentationOnly(usage);
+      const observedProperty = observedPropertyForCall(summary, call, context);
+      const strongHostFeedback = summary.sourceKind === "instance-property" && isStrongHostFeedbackProperty(observedProperty);
+      const hasBindingMode = hasExplicitBindingMode(summary);
+      const mirrorsExternalValue = summary.mirrorConfidence !== "none";
+      const visualEffectBridge = strongHostFeedback && usage.effect > 0 && effectOnlyDerivesPresentation(localName, owner, declaration, context, compatibleComponentProps);
       const key = `imported:${call.startIndex}:${call.endIndex}:${localName}`;
       if (seen.has(key))
         continue;
       seen.add(key);
+      let message;
+      let help;
+      if (presentationOnly && hasBindingMode) {
+        message = `${path4} has a Binding-returning mode and ${localName} is only used for presentation, but Doctor cannot prove the updates are frequent enough to make the Binding version clearly preferable.`;
+        help = "Consider the Binding mode when this value changes often enough that avoiding reconciliation matters; ordinary React state may be clearer for infrequent semantic updates.";
+      } else if (presentationOnly && strongHostFeedback) {
+        message = `${path4} mirrors ${observedProperty} through React state only for presentation, but the hook does not expose a proven low-friction Binding mode.`;
+        help = "Consider a Binding-returning variant if this host feedback path is performance-sensitive. Keep state when the simpler API is more valuable than avoiding occasional rerenders.";
+      } else if (presentationOnly && mirrorsExternalValue) {
+        message = `${path4} mirrors an external reactive value through React state, and ${localName} is only used for presentation.`;
+        help = "Consider a Binding-returning hook API if this source changes often enough that rerendering is unnecessary. Doctor cannot prove the source's update pressure, so ordinary state may still be the clearer choice.";
+      } else if (visualEffectBridge) {
+        message = `${path4} mirrors ${observedProperty} through React state, and the dependent React effect only derives presentation state or Bindings from ${localName}.`;
+        help = hasBindingMode ? "Consider the hook's Binding mode and move the visual derivation into Binding:map/joinBindings so the measurement does not need an intermediate React rerender." : "Consider a Binding-returning hook variant if this visual feedback path is performance-sensitive; the current effect appears to use React state only as an intermediate presentation step.";
+      } else {
+        message = `${path4} updates ${localName} through React state and some consumers are presentation-only, but other consumers may still require React reconciliation.`;
+        help = "Inspect whether the presentation branch can move to a Binding while structural or effect-driven consumers keep React state. Avoid replacing the value wholesale when React still needs to react to it.";
+      }
       diagnostics.push({
         node: callNameNode(call),
-        message: `${path4} updates ${localName} through React state when outside data changes. Some uses of ${localName} may need a rerender, so switching it entirely to a Binding could change behavior.`,
-        help: "Inspect whether the value can become a Binding, use Binding:map for visual derivation, or split visual updates from the smaller part of the value that truly needs React state."
+        message,
+        help,
+        fixPreview: presentationOnly && hasBindingMode && allReadsDirectlyBindingSubstitutable(localName, owner, declaration, context, compatibleComponentProps) ? bindingModeFixPreview(summary, call, context) : undefined
       });
     }
     for (const call of context.findCalls()) {
@@ -5032,39 +5834,80 @@ var preferBindingOverStateCandidate = {
       const owner = context.containingComponent(call) ?? context.nearestFunction(call);
       if (!declaration || !localName || !owner || !hasAnyRead(localName, owner, declaration, context))
         continue;
-      if (stateReadsAreBindingCompatible(localName, owner, declaration, context, compatibleComponentProps))
+      const usage = bindingUsageSummary(localName, owner, declaration, context, compatibleComponentProps);
+      const presentationOnly = isPresentationOnly(usage);
+      if (!presentationOnly)
         continue;
+      const field = selectorFieldName(call, context);
       const key = `state-api:${call.startIndex}:${call.endIndex}:${localName}`;
       if (seen.has(key))
         continue;
       seen.add(key);
       diagnostics.push({
         node: callNameNode(call),
-        message: `${path4} uses React state even though ${bindingAlternative} is available. Some uses of ${localName} may need a rerender, so replacing it entirely with the Binding API could change behavior.`,
-        help: `Inspect whether ${bindingAlternative}, Binding:map, or splitting visual and structural consumers would avoid unnecessary rerenders.`,
-        fixPreview: callMemberFixPreview(call, bindingAlternative)
+        message: `${path4} subscribes ${localName} through React state${field ? ` for ${field}` : ""}, while ${bindingAlternative} is also available and every analyzed consumer is presentation-only.`,
+        help: `Consider ${bindingAlternative} when this value updates frequently enough that avoiding reconciliation matters; state remains reasonable for ordinary semantic store updates.`,
+        fixPreview: allReadsDirectlyBindingSubstitutable(localName, owner, declaration, context, compatibleComponentProps) ? callMemberFixPreview(call, bindingAlternative) : undefined
       });
     }
     for (const binding of context.model.stateBindings) {
       const owner = binding.owner;
-      if (!owner || !owner.isComponent || !owner.body)
+      if (!owner || !owner.isComponent && !owner.isHook || !owner.body)
         continue;
-      const updateKind = bindingHasExternalOrHighFrequencyUpdates(binding, importedCallbacks, context);
-      if (!updateKind)
+      const update = bindingUpdateEvidence(binding, importedCallbacks, context);
+      if (!update)
         continue;
-      if (stateReadsAreBindingCompatible(binding.valueName, owner, binding.declaration, context, compatibleComponentProps))
+      const localCompatible = stateReadsAreBindingCompatible(binding.valueName, owner, binding.declaration, context, compatibleComponentProps);
+      const hookCompatible = owner.isHook ? hookCallSitesAreBindingCompatible(binding, context, compatibleComponentProps) : false;
+      const strongHostFeedback = hasStrongHostFeedbackEvidence(update);
+      const likelyContinuousProperty = hasLikelyContinuousPropertyEvidence(update);
+      const mirrorsExternalValue = update.mirrorConfidence !== "none";
+      if (owner.isHook) {
+        if (hookCompatible && (update.highFrequency || likelyContinuousProperty))
+          continue;
+        if (!(hookCompatible && (strongHostFeedback || mirrorsExternalValue)))
+          continue;
+        const key2 = `hook-state:${binding.call.startIndex}:${binding.call.endIndex}:${binding.valueName}`;
+        if (seen.has(key2))
+          continue;
+        seen.add(key2);
+        const measurement = strongHostFeedback ? "a presentation measurement" : "an external reactive value";
+        diagnostics.push({
+          node: callNameNode(binding.call),
+          message: `Hook state ${binding.valueName} mirrors ${measurement} and is only consumed by presentation properties at analyzed call sites, but converting it requires changing the hook API.`,
+          help: "Consider adding a Binding-returning variant when this reactive path updates often enough that avoiding reconciliation matters; keeping the state API is reasonable when ordinary React state is simpler."
+        });
         continue;
+      }
       const usage = bindingUsageSummary(binding.valueName, owner, binding.declaration, context, compatibleComponentProps);
       if (!hasCandidatePresentationEvidence(usage))
         continue;
+      if (localCompatible && (update.highFrequency || strongHostFeedback || likelyContinuousProperty))
+        continue;
+      if (localCompatible && mirrorsExternalValue) {
+        const key2 = `state:${binding.call.startIndex}:${binding.call.endIndex}:${binding.valueName}`;
+        if (seen.has(key2))
+          continue;
+        seen.add(key2);
+        diagnostics.push({
+          node: callNameNode(binding.call),
+          message: `State ${binding.valueName} mirrors an external reactive value and only feeds presentation updates, but Doctor cannot prove the source changes frequently enough for Binding to be clearly preferable.`,
+          help: "Consider React.useBinding when this source is a stream of presentation values rather than semantic React state. Keep useState when the external event represents an infrequent UI state transition."
+        });
+        continue;
+      }
+      const mixedHighFrequency = update.highFrequency || likelyContinuousProperty;
+      const mixedHostFeedback = strongHostFeedback && usage.structural > 0 && usage.effect === 0;
+      if (!mixedHighFrequency && !mixedHostFeedback)
+        continue;
       const key = `state:${binding.call.startIndex}:${binding.call.endIndex}:${binding.valueName}`;
       if (seen.has(key))
         continue;
       seen.add(key);
       diagnostics.push({
         node: callNameNode(binding.call),
-        message: `State ${binding.valueName} is updated${updateKind.highFrequency ? " from a high-frequency source" : " from an external callback"} and appears at least partly presentation-oriented, but some consumers may still require React state.`,
-        help: "Inspect whether visual consumers can move to React.useBinding while structural consumers keep a smaller state value. Splitting the responsibilities can remove rerenders without changing component behavior."
+        message: `State ${binding.valueName} has presentation-oriented consumers, but other uses still appear to need React reconciliation.`,
+        help: "Inspect whether the presentation branch can move to React.useBinding while structural consumers keep a smaller semantic state value. Splitting the responsibilities can remove hot-path rerenders without forcing Binding semantics onto the whole value."
       });
     }
     return diagnostics;
@@ -5570,6 +6413,20 @@ function staticIterationImports(context) {
   }
   return result;
 }
+function nonReactHookImports(context) {
+  const result = new Set;
+  for (const node of context.walk(context.root)) {
+    if (node.type !== "variable_declaration")
+      continue;
+    const match = node.text.match(/^\s*local\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*require\s*\((.*?)\)\s*$/s);
+    if (!match || !/^use[A-Z0-9_]/.test(match[1]))
+      continue;
+    const kind = resolveModuleReference(normalizeRequireTarget(match[2]), context.project.reactHookModules);
+    if (kind === false)
+      result.add(match[1]);
+  }
+  return result;
+}
 function conditionalHookModeImports(context) {
   const result = new Map;
   for (const node of context.walk(context.root)) {
@@ -5617,30 +6474,12 @@ function controlledParameterIndex(controlFlow, fn, summary) {
   }
   return null;
 }
-function isStableModeArgument(node, context) {
-  if (!node)
-    return true;
-  const text = node.text.trim();
-  if (["true", "false", "nil"].includes(text))
-    return true;
-  if ([
-    "number",
-    "string",
-    "string_content",
-    "table_constructor",
-    "function_definition"
-  ].includes(node.type))
-    return true;
-  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(text) && context.model.stableVariables.has(text))
-    return true;
-  return false;
-}
 function dynamicHookModeFixPreview(hookName, argumentText) {
   return {
     kind: "pattern",
     before: `local value = ${hookName}(${argumentText})`,
-    after: `local value = ${hookName}(true) -- or false; keep this mode fixed for this call site`,
-    note: "A custom hook may choose different internal hooks only when this mode is stable for the lifetime of the component instance."
+    after: `local value = ${hookName}(${argumentText}) -- keep the hook-topology mode stable for this instance`,
+    note: "A custom hook may choose different internal hooks only when the value controlling that choice stays stable for the lifetime of the component instance."
   };
 }
 function unwrapIteratorExpression(text) {
@@ -5660,6 +6499,17 @@ function declarationExpressions4(node) {
 function isEmptyTable(node) {
   return Boolean(node?.type === "table_constructor" && node.namedChildren.every((child) => child.type !== "field"));
 }
+function tableConstructorHasStableArity(node) {
+  if (node.type !== "table_constructor")
+    return false;
+  const fields = node.namedChildren.filter((child) => child.type === "field");
+  if (fields.length === 0)
+    return true;
+  if (fields.some((field) => [...field.namedChildren].some((child) => child.type === "vararg_expression")))
+    return false;
+  const last = fields.at(-1);
+  return !last?.namedChildren.some((child) => child.type === "function_call");
+}
 function stableShapeVariablesByFunction(context) {
   const stable = new Map;
   const functionsByName = new Map;
@@ -5686,7 +6536,7 @@ function stableShapeVariablesByFunction(context) {
       const expression = expressions[index] ?? expressions[0];
       if (!expression)
         continue;
-      if (expression.type === "table_constructor") {
+      if (expression.type === "table_constructor" && tableConstructorHasStableArity(expression)) {
         namesFor(owner).add(names[index]);
         continue;
       }
@@ -5713,7 +6563,7 @@ function stableShapeVariablesByFunction(context) {
     if (!expression)
       return false;
     if (expression.type === "table_constructor")
-      return true;
+      return tableConstructorHasStableArity(expression);
     const text = expression.text.trim();
     if (!owner || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(text))
       return false;
@@ -5766,6 +6616,187 @@ function stableShapeVariablesByFunction(context) {
   }
   return stable;
 }
+function moduleInvariantVariables(context) {
+  const declarations = new Map;
+  const reassigned = new Set;
+  for (const node of context.walk(context.root)) {
+    if (node.type === "variable_declaration" && !context.nearestFunction(node)) {
+      for (const name of declarationNames2(node))
+        declarations.set(name, node);
+      continue;
+    }
+    if (node.type !== "assignment_statement" || node.parent?.type === "variable_declaration")
+      continue;
+    const variableList = node.namedChildren.find((child) => child.type === "variable_list");
+    for (const target of variableList?.namedChildren ?? []) {
+      if (target.type === "identifier")
+        reassigned.add(target.text);
+    }
+  }
+  return new Set([...declarations.keys()].filter((name) => !reassigned.has(name)));
+}
+function simpleConditionRoot(controlFlow) {
+  if (controlFlow.type !== "if_statement" && controlFlow.type !== "if_expression")
+    return null;
+  const condition = controlFlow.namedChildren[0];
+  if (!condition)
+    return null;
+  const text = condition.text.trim();
+  const match = text.match(/^(?:not\s+)?([A-Za-z_][A-Za-z0-9_]*)(?:\s*(?:==|~=)\s*(?:true|false|nil))?$/);
+  return match?.[1] ?? null;
+}
+function conditionIsProvablyInvariant(controlFlow, fn, context, moduleInvariants) {
+  const condition = controlFlow.namedChildren[0];
+  if (!condition)
+    return false;
+  if (["true", "false", "nil", "number", "string"].includes(condition.type))
+    return true;
+  const root = simpleConditionRoot(controlFlow);
+  if (!root)
+    return false;
+  if (moduleInvariants.has(root))
+    return true;
+  return Boolean(context.model.stableVariablesByFunction.get(nodeKey(fn.node))?.has(root));
+}
+function branchHookSequence(branch, fn, context) {
+  const hooks = [];
+  for (const node of context.walk(branch)) {
+    if (node.type !== "function_call")
+      continue;
+    if (context.nearestFunction(node) !== fn)
+      continue;
+    const rawPath = context.getCallPath(node);
+    if (!rawPath)
+      continue;
+    const path4 = context.resolveCallPath(rawPath);
+    if (!isHookPath(path4))
+      continue;
+    const nestedControl = findAncestorBetween(node, branch, (ancestor) => CONDITIONAL_TYPES.has(ancestor.type));
+    if (nestedControl)
+      return null;
+    hooks.push(path4);
+  }
+  return hooks;
+}
+function ifBranchesHaveEquivalentBuiltInTopology(controlFlow, fn, context) {
+  if (controlFlow.type !== "if_statement")
+    return false;
+  const thenBlock = controlFlow.namedChildren.find((child) => child.type === "block");
+  const elseStatement = controlFlow.namedChildren.find((child) => child.type === "else_statement");
+  const elseBlock = elseStatement?.namedChildren.find((child) => child.type === "block");
+  if (!thenBlock || !elseBlock)
+    return false;
+  const thenHooks = branchHookSequence(thenBlock, fn, context);
+  const elseHooks = branchHookSequence(elseBlock, fn, context);
+  if (!thenHooks || !elseHooks || thenHooks.length !== elseHooks.length)
+    return false;
+  if (!thenHooks.every((path4, index) => path4 === elseHooks[index]))
+    return false;
+  return thenHooks.every((path4) => path4.startsWith("React."));
+}
+function stateModeStability(name, owner, context) {
+  const binding = context.model.stateBindings.find((candidate) => candidate.owner === owner && candidate.valueName === name);
+  if (!binding || !owner.body)
+    return null;
+  const initializerText = binding.initializer?.text.trim() ?? "nil";
+  const stableLiteral = /^(?:true|false|nil|-?\d+(?:\.\d+)?|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')$/;
+  let sawIndirectSetterReference = false;
+  for (const node of context.walk(owner.body)) {
+    if (node.type === "function_call" && context.getCallPath(node) === binding.setterName) {
+      const argument = context.callArguments(node)[0];
+      if (!argument || !stableLiteral.test(initializerText) || argument.text.trim() !== initializerText)
+        return "unstable";
+      continue;
+    }
+    if (node.type !== "identifier" || node.text !== binding.setterName)
+      continue;
+    if (node.startIndex >= binding.declaration.startIndex && node.endIndex <= binding.declaration.endIndex)
+      continue;
+    if (node.parent?.type === "function_call")
+      continue;
+    sawIndirectSetterReference = true;
+  }
+  if (sawIndirectSetterReference)
+    return "unknown";
+  return "stable";
+}
+function localAliasExpression(name, owner, context) {
+  if (!owner.body)
+    return null;
+  let result = null;
+  for (const node of context.walk(owner.body)) {
+    if (node.type !== "variable_declaration" || context.nearestFunction(node) !== owner)
+      continue;
+    const names = declarationNames2(node);
+    const index = names.indexOf(name);
+    if (index < 0)
+      continue;
+    const expressions = declarationExpressions4(node);
+    const expression = expressions[index] ?? expressions[0] ?? null;
+    if (result)
+      return null;
+    result = expression;
+  }
+  return result;
+}
+function modeValueStability(node, owner, context, moduleInvariants, depth = 0) {
+  if (!node)
+    return "stable";
+  if (depth > 4)
+    return "unknown";
+  const text = node.text.trim();
+  if (["true", "false", "nil"].includes(text))
+    return "stable";
+  if (["number", "string", "string_content", "function_definition"].includes(node.type))
+    return "stable";
+  const root = text.match(/^([A-Za-z_][A-Za-z0-9_]*)/)?.[1];
+  if (!root)
+    return "unknown";
+  const stateStability = stateModeStability(root, owner, context);
+  if (stateStability)
+    return stateStability;
+  if (moduleInvariants.has(root))
+    return "stable";
+  if (context.model.stableVariablesByFunction.get(nodeKey(owner.node))?.has(root))
+    return "stable";
+  if (text === root) {
+    const alias = localAliasExpression(root, owner, context);
+    if (alias && alias.text.trim() !== root)
+      return modeValueStability(alias, owner, context, moduleInvariants, depth + 1);
+  }
+  return "unknown";
+}
+function tableFieldValue(table, accessPath) {
+  if (!table || accessPath === "")
+    return table;
+  if (table.type !== "table_constructor")
+    return;
+  let current = table;
+  for (const part of accessPath.split(".")) {
+    if (!current || current.type !== "table_constructor")
+      return;
+    const field = current.namedChildren.find((child) => {
+      if (child.type !== "field")
+        return false;
+      return child.namedChildren[0]?.type === "identifier" && child.namedChildren[0]?.text === part;
+    });
+    if (!field)
+      return;
+    current = field.namedChildren[1];
+  }
+  return current;
+}
+function controlledAccessPaths(summary, parameterIndex) {
+  const paths = new Set;
+  for (const [conditionName, index] of Object.entries(summary.conditionVariables)) {
+    if (index !== parameterIndex)
+      continue;
+    paths.add(summary.conditionAccessPaths?.[conditionName] ?? "");
+  }
+  if (paths.size === 0)
+    paths.add("");
+  return [...paths];
+}
 function loopIterationIsProvablyStable(loop, imports, owner, stableShapes) {
   const numeric = loop.namedChildren.find((child) => child.type === "for_numeric_clause");
   if (numeric) {
@@ -5827,9 +6858,9 @@ function impossibleNilGuardReturn(node, fn, parameterTypes) {
   }
   return false;
 }
-function hasReachableReturnBefore(call, fn, context, cache) {
+function reachableReturnsBefore(call, fn, context, cache) {
   if (!fn.body)
-    return false;
+    return [];
   const key = nodeKey(fn.node);
   let returns = cache.get(key);
   if (!returns) {
@@ -5837,7 +6868,21 @@ function hasReachableReturnBefore(call, fn, context, cache) {
     returns = [...context.walk(fn.body)].filter((node) => node.type === "return_statement" && !isNestedInsideFunction(node, fn.node) && !impossibleNilGuardReturn(node, fn, parameterTypes));
     cache.set(key, returns);
   }
-  return returns.some((node) => node.endIndex <= call.startIndex);
+  return returns.filter((node) => node.endIndex <= call.startIndex);
+}
+function returnIsControlledByStableTopologyMode(node, fn, summary, context, moduleInvariants) {
+  let current = node.parent;
+  while (current && current !== fn.node) {
+    if (current.type === "if_statement" || current.type === "if_expression") {
+      if (summary && controlledParameterIndex(current, fn, summary) !== null)
+        return true;
+      if (conditionIsProvablyInvariant(current, fn, context, moduleInvariants))
+        return true;
+      return false;
+    }
+    current = current.parent;
+  }
+  return false;
 }
 function conditionalFixPreview(kind, hookName) {
   if (kind === "for statement") {
@@ -5909,15 +6954,21 @@ var rulesOfHooks = {
   description: "Hooks must run in the same order on every render of a React component or custom hook.",
   run(context) {
     const diagnostics = [];
+    if (!context.model.isReactFile)
+      return diagnostics;
     const staticImports = staticIterationImports(context);
     const stableShapes = stableShapeVariablesByFunction(context);
+    const moduleInvariants = moduleInvariantVariables(context);
     const modeImports = conditionalHookModeImports(context);
+    const ignoredHookImports = nonReactHookImports(context);
     const currentModeSummary = currentConditionalHookMode(context);
     const reachableReturns = new Map;
     for (const call of context.findCalls()) {
       const rawPath = context.getCallPath(call);
       if (!rawPath)
         continue;
+      if (ignoredHookImports.has(rawPath))
+        continue;
       const path4 = context.resolveCallPath(rawPath);
       if (!isHookPath(path4))
         continue;
@@ -5946,25 +6997,36 @@ end`,
       const importedMode = modeImports.get(rawPath);
       if (importedMode) {
         const args = context.callArguments(call);
-        const dynamicIndexes = importedMode.parameterIndexes.filter((index) => !isStableModeArgument(args[index], context));
-        if (dynamicIndexes.length > 0) {
-          const firstIndex = dynamicIndexes[0];
-          const argument = args[firstIndex];
+        const unstableControls = importedMode.parameterIndexes.flatMap((index) => controlledAccessPaths(importedMode, index).map((accessPath) => {
+          const argument = args[index];
+          const value = tableFieldValue(argument, accessPath);
+          const stability = accessPath !== "" ? argument?.type === "table_constructor" ? value ? modeValueStability(value, fn, context, moduleInvariants) : "stable" : "unknown" : modeValueStability(argument, fn, context, moduleInvariants);
+          return { index, accessPath, argument, value, stability };
+        }).filter((control) => control.stability === "unstable"));
+        if (unstableControls.length > 0) {
+          const first = unstableControls[0];
+          const firstIndex = first.index;
+          const argument = first.argument;
           const parameterOffset = importedMode.parameterIndexes.indexOf(firstIndex);
-          const parameterName = importedMode.parameterNames[parameterOffset] ?? `argument ${firstIndex + 1}`;
-          const argumentText = argument?.text.trim() || "<omitted>";
+          const baseParameterName = importedMode.parameterNames[parameterOffset] ?? `argument ${firstIndex + 1}`;
+          const parameterName = first.accessPath ? `${baseParameterName}.${first.accessPath}` : baseParameterName;
+          const argumentText = first.value?.text.trim() || argument?.text.trim() || "<omitted>";
           diagnostics.push({
-            node: argument ?? callNameNode(call),
-            highlights: dynamicIndexes.map((index) => args[index]).filter((node) => Boolean(node)),
-            message: `Hook ${rawPath} receives render-varying hook mode ${parameterName} from ${argumentText}; if it changes between renders, the custom hook can execute a different hook sequence.`,
-            help: `Pass a stable mode at this call site, or refactor ${rawPath} so it always calls the same hooks regardless of ${parameterName}.`,
+            node: first.value ?? argument ?? callNameNode(call),
+            highlights: unstableControls.map((control) => control.value ?? control.argument).filter((node) => Boolean(node)),
+            message: `Hook ${rawPath} receives hook-topology mode ${parameterName} from ${argumentText}, which is updated between renders and can make the custom hook execute a different hook sequence.`,
+            help: `Keep ${parameterName} stable for this hook instance, or refactor ${rawPath} so it always calls the same hooks regardless of that mode.`,
             fixPreview: dynamicHookModeFixPreview(rawPath, argumentText)
           });
         }
       }
       const controlFlow = findAncestorBetween(call, fn.node, (node) => CONDITIONAL_TYPES.has(node.type));
       if (controlFlow) {
-        if (currentModeSummary && currentModeSummary.knownCallSites > 0 && controlledParameterIndex(controlFlow, fn, currentModeSummary) !== null)
+        if (currentModeSummary && controlledParameterIndex(controlFlow, fn, currentModeSummary) !== null)
+          continue;
+        if (conditionIsProvablyInvariant(controlFlow, fn, context, moduleInvariants))
+          continue;
+        if (ifBranchesHaveEquivalentBuiltInTopology(controlFlow, fn, context))
           continue;
         if (controlFlow.type === "for_statement" && loopIterationIsProvablyStable(controlFlow, staticImports, fn, stableShapes))
           continue;
@@ -5978,7 +7040,8 @@ end`,
         });
         continue;
       }
-      if (hasReachableReturnBefore(call, fn, context, reachableReturns)) {
+      const earlierReturns = reachableReturnsBefore(call, fn, context, reachableReturns);
+      if (earlierReturns.length > 0 && !earlierReturns.every((node) => returnIsControlledByStableTopologyMode(node, fn, currentModeSummary, context, moduleInvariants))) {
         diagnostics.push({
           node: callNameNode(call),
           message: `Hook ${path4} may run after an earlier reachable return, so some renders can execute fewer hooks.`,
@@ -6423,6 +7486,16 @@ function nodeLocation(node) {
     endColumn: node.endPosition.column + 1
   };
 }
+function sameLocation(left, right) {
+  return left.line === right.line && left.column === right.column && left.endLine === right.endLine && left.endColumn === right.endColumn;
+}
+function removeSupersededDiagnostics(diagnostics) {
+  return diagnostics.filter((diagnostic) => {
+    if (diagnostic.rule !== "react-luau/rerender-high-frequency-state")
+      return true;
+    return !diagnostics.some((candidate) => candidate.rule === "react-luau/prefer-binding-over-state" && sameLocation(candidate.location, diagnostic.location) && SEVERITY_RANK[candidate.severity] >= SEVERITY_RANK[diagnostic.severity]);
+  });
+}
 function toDiagnostic(file, ruleId, category, severity, input) {
   const node = input.node;
   const highlights = input.highlights?.map(nodeLocation);
@@ -6441,7 +7514,7 @@ function toDiagnostic(file, ruleId, category, severity, input) {
 }
 async function analyzeReactFile(input, tree) {
   const parsedTree = tree ?? await parseLuau(input.source);
-  const model = buildReactModel(parsedTree.rootNode);
+  const model = buildReactModel(parsedTree.rootNode, input.project);
   if (!input.forceScan && !model.isReactFile) {
     return { relativePath: input.relativePath, isReactFile: false, scanned: false, diagnostics: [] };
   }
@@ -6480,11 +7553,12 @@ async function analyzeReactFile(input, tree) {
     if (rule.id === "react-luau/parse-error" && findings.length > 0)
       break;
   }
+  const filteredDiagnostics = removeSupersededDiagnostics(diagnostics);
   return {
     relativePath: input.relativePath,
     isReactFile: model.isReactFile,
     scanned: true,
-    diagnostics
+    diagnostics: filteredDiagnostics
   };
 }
 
@@ -7455,5 +8529,5 @@ parentPort.on("message", async (request) => {
   }
 });
 
-//# debugId=CD648BE1625A701464756E2164756E21
+//# debugId=3696D560D93E93D364756E2164756E21
 //# sourceMappingURL=scan-worker.js.map