@colrealpro/react-luau-doctor 0.18.3 → 0.19.1

package/dist/cli.js

@@ -11,7 +11,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "0.18.3",
+  version: "0.19.1",
   description: "Static analysis for React-Luau hooks, effects, rendering, and performance.",
   license: "MIT",
   type: "module",
@@ -22,6 +22,7 @@ var package_default = {
     "dist",
     "vendor",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE",
     "THIRD_PARTY_NOTICES.md"
   ],
@@ -864,7 +865,7 @@ import crypto from "crypto";
 import fs4 from "fs";
 import os from "os";
 import path4 from "path";
-var CACHE_SCHEMA_VERSION = 1;
+import { fileURLToPath } from "url";
 var MAX_CACHED_REPORTS = 8;
 function normalizeRelative(value) {
   return value.split(path4.sep).join("/");
@@ -872,6 +873,54 @@ function normalizeRelative(value) {
 function hashText(value) {
   return crypto.createHash("sha256").update(value).digest("hex");
 }
+var analyzerHash = null;
+function hashAnalyzerFile(hash, root, filename) {
+  if (!fs4.existsSync(filename))
+    return;
+  hash.update(normalizeRelative(path4.relative(root, filename)));
+  hash.update("\x00");
+  hash.update(fs4.readFileSync(filename));
+  hash.update("\x00");
+}
+function sourceFiles(directory) {
+  if (!fs4.existsSync(directory))
+    return [];
+  const files = [];
+  for (const entry of fs4.readdirSync(directory, { withFileTypes: true })) {
+    const filename = path4.join(directory, entry.name);
+    if (entry.isDirectory())
+      files.push(...sourceFiles(filename));
+    else if (entry.isFile() && entry.name.endsWith(".ts"))
+      files.push(filename);
+  }
+  return files;
+}
+function currentAnalyzerHash() {
+  if (analyzerHash)
+    return analyzerHash;
+  const hash = crypto.createHash("sha256");
+  let packageRoot = path4.resolve(path4.dirname(fileURLToPath(import.meta.url)), "..");
+  let bundledCli = null;
+  try {
+    const entrypoint = process.argv[1] ? fs4.realpathSync(process.argv[1]) : null;
+    if (entrypoint && path4.basename(entrypoint) === "cli.js" && path4.basename(path4.dirname(entrypoint)) === "dist") {
+      bundledCli = entrypoint;
+      packageRoot = path4.dirname(path4.dirname(entrypoint));
+    }
+  } catch {}
+  if (bundledCli) {
+    hashAnalyzerFile(hash, packageRoot, bundledCli);
+    hashAnalyzerFile(hash, packageRoot, path4.join(path4.dirname(bundledCli), "scan-worker.js"));
+  } else {
+    for (const filename of sourceFiles(path4.join(packageRoot, "src")).sort()) {
+      hashAnalyzerFile(hash, packageRoot, filename);
+    }
+  }
+  hashAnalyzerFile(hash, packageRoot, path4.join(packageRoot, "package.json"));
+  hashAnalyzerFile(hash, packageRoot, path4.join(packageRoot, "vendor", "tree-sitter-luau.wasm"));
+  analyzerHash = hash.digest("hex");
+  return analyzerHash;
+}
 function stableValue(value) {
   if (Array.isArray(value))
     return value.map(stableValue);
@@ -901,7 +950,7 @@ function projectCacheFilename(root) {
 function readPayload(filename, root) {
   try {
     const parsed = JSON.parse(fs4.readFileSync(filename, "utf8"));
-    if (parsed.schemaVersion !== CACHE_SCHEMA_VERSION || parsed.analyzerVersion !== package_default.version || path4.resolve(parsed.root) !== path4.resolve(root) || !parsed.files || typeof parsed.fingerprint !== "string")
+    if (parsed.analyzerHash !== currentAnalyzerHash() || path4.resolve(parsed.root) !== path4.resolve(root) || !parsed.files || typeof parsed.fingerprint !== "string")
       return null;
     return parsed;
   } catch {
@@ -1022,6 +1071,7 @@ function serializeProjectModel(project) {
     bindingCompatibleComponentProps: [...project.bindingCompatibleComponentProps].map(([key, value]) => [key, [...value].sort()]),
     staticIterationTables: [...project.staticIterationTables].map(([key, value]) => [key, [...value].sort()]),
     conditionalHookModes: [...project.conditionalHookModes],
+    reactHookModules: [...project.reactHookModules],
     sourceEffects: [...project.sourceEffects].map(([key, value]) => [key, serializeSourceEffect(value)])
   };
 }
@@ -1034,6 +1084,7 @@ function deserializeProjectModel(project) {
     bindingCompatibleComponentProps: new Map(project.bindingCompatibleComponentProps.map(([key, value]) => [key, new Set(value)])),
     staticIterationTables: new Map(project.staticIterationTables.map(([key, value]) => [key, new Set(value)])),
     conditionalHookModes: new Map(project.conditionalHookModes),
+    reactHookModules: new Map(project.reactHookModules ?? []),
     sourceEffects: new Map(project.sourceEffects.map(([key, value]) => [key, deserializeSourceEffect(value)]))
   };
 }
@@ -1058,7 +1109,8 @@ function projectModelFeatureKey(project) {
     bindingApiAlternatives: serialized.bindingApiAlternatives,
     bindingCompatibleComponentProps: serialized.bindingCompatibleComponentProps,
     staticIterationTables: serialized.staticIterationTables,
-    conditionalHookModes: serialized.conditionalHookModes
+    conditionalHookModes: serialized.conditionalHookModes,
+    reactHookModules: serialized.reactHookModules
   });
 }
 function cachedProjectModel(session) {
@@ -1121,8 +1173,7 @@ function saveProjectCache(session, project, effectModules = session.previous?.ef
     reports[reportKey] = { ...report, lastUsedAt: Date.now() };
   const prunedReports = Object.fromEntries(Object.entries(reports).sort(([, left], [, right]) => right.lastUsedAt - left.lastUsedAt).slice(0, MAX_CACHED_REPORTS));
   writePayload(session.filename, {
-    schemaVersion: CACHE_SCHEMA_VERSION,
-    analyzerVersion: package_default.version,
+    analyzerHash: currentAnalyzerHash(),
     root: path4.resolve(session.root),
     fingerprint: session.fingerprint,
     files: session.files,
@@ -1150,6 +1201,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;
@@ -1278,6 +1342,63 @@ function createRuleContext(file) {
   };
 }
 
+// src/module-resolution.ts
+import path5 from "path";
+function normalizeRelative2(value) {
+  return value.split(path5.sep).join("/");
+}
+function moduleKeys(relativePath) {
+  let normalized = normalizeRelative2(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",
@@ -1308,18 +1429,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") {
@@ -1373,15 +1483,19 @@ function directCalls(node) {
 function hasDirectCreateElementCall(node, aliases, reactNamespaces, reactRobloxNamespaces) {
   return directCalls(node).some((call) => {
     const name = call.childForFieldName("name")?.text ?? "";
-    const path5 = resolvePath(name, aliases, reactNamespaces, reactRobloxNamespaces);
-    return path5 === "React.createElement" || path5 === "ReactRoblox.createPortal";
+    const path6 = resolvePath(name, aliases, reactNamespaces, reactRobloxNamespaces);
+    return path6 === "React.createElement" || path6 === "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 path5 = resolvePath(name, aliases, reactNamespaces, reactRobloxNamespaces);
-    const final = path5.split(/[.:]/).at(-1) ?? "";
+    const path6 = resolvePath(name, aliases, reactNamespaces, reactRobloxNamespaces);
+    const normalizedName = normalizeExpressionText(name);
+    const importedKind = importedHookKinds.get(normalizedName);
+    if (importedKind !== undefined)
+      return importedKind;
+    const final = path6.split(/[.:]/).at(-1) ?? "";
     return /^use[A-Z0-9_]/.test(final);
   });
 }
@@ -1467,8 +1581,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(path5) {
-  return path5.split(/[.:]/).at(-1) ?? path5;
+function finalCallMember(path6) {
+  return path6.split(/[.:]/).at(-1) ?? path6;
 }
 function expressionCreatesInstance(node, aliases, reactNamespaces, reactRobloxNamespaces) {
   if (!node)
@@ -1480,8 +1594,8 @@ function expressionCreatesInstance(node, aliases, reactNamespaces, reactRobloxNa
     if (candidate.type !== "function_call")
       continue;
     const rawPath = candidate.childForFieldName("name")?.text ?? "";
-    const path5 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
-    if (path5 === "Instance.new" || INSTANCE_FACTORY_MEMBERS.has(finalCallMember(path5)))
+    const path6 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+    if (path6 === "Instance.new" || INSTANCE_FACTORY_MEMBERS.has(finalCallMember(path6)))
       return true;
   }
   return false;
@@ -1493,8 +1607,8 @@ function expressionIsStableEngineObject(node, aliases, reactNamespaces, reactRob
   if (calls.length !== 1)
     return false;
   const rawPath = calls[0].childForFieldName("name")?.text ?? "";
-  const path5 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
-  return STABLE_ENGINE_FACTORY_MEMBERS.has(finalCallMember(path5));
+  const path6 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+  return STABLE_ENGINE_FACTORY_MEMBERS.has(finalCallMember(path6));
 }
 function memoReturnsInstance(callback, aliases, reactNamespaces, reactRobloxNamespaces) {
   if (!callback || callback.type !== "function_definition")
@@ -1510,7 +1624,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;
@@ -1526,6 +1654,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;
@@ -1600,7 +1729,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;
@@ -1612,8 +1741,8 @@ function buildReactModel(root) {
     if (call.type !== "function_call")
       continue;
     const rawPath = call.childForFieldName("name")?.text ?? "";
-    const path5 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
-    if (path5 !== "React.createElement")
+    const path6 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+    if (path6 !== "React.createElement")
       continue;
     const element = call.childForFieldName("arguments")?.namedChildren[0]?.text.trim() ?? "";
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(element))
@@ -1648,13 +1777,13 @@ function buildReactModel(root) {
     if (!call)
       continue;
     const rawPath = call.childForFieldName("name")?.text ?? "";
-    const path5 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+    const path6 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
     const args = call.childForFieldName("arguments")?.namedChildren ?? [];
-    if (path5 === "React.joinBindings" && names.length >= 1) {
+    if (path6 === "React.joinBindings" && names.length >= 1) {
       stableVariables.add(names[0]);
       addScopedVariable(stableVariablesByFunction, owner, names[0]);
       addScopedVariable(externalMutableVariablesByFunction, owner, names[0]);
-    } else if (path5 === "React.useState" && names.length >= 2) {
+    } else if (path6 === "React.useState" && names.length >= 2) {
       const [valueName, setterName] = names;
       stateSetters.set(setterName, valueName);
       stateValues.set(valueName, setterName);
@@ -1668,10 +1797,10 @@ function buildReactModel(root) {
         initializer: args[0] ?? null,
         owner
       });
-    } else if (path5 === "React.useReducer" && names.length >= 2) {
+    } else if (path6 === "React.useReducer" && names.length >= 2) {
       stableVariables.add(names[1]);
       addScopedVariable(stableVariablesByFunction, owner, names[1]);
-    } else if (path5 === "React.useBinding" && names.length >= 1) {
+    } else if (path6 === "React.useBinding" && names.length >= 1) {
       stableVariables.add(names[0]);
       addScopedVariable(stableVariablesByFunction, owner, names[0]);
       if (names.length >= 2) {
@@ -1679,7 +1808,7 @@ function buildReactModel(root) {
         bindingSetters.add(names[1]);
         addScopedVariable(stableVariablesByFunction, owner, names[1]);
       }
-    } else if (path5 === "React.useMemo" && names.length >= 1) {
+    } else if (path6 === "React.useMemo" && names.length >= 1) {
       if (isEmptyDependencyTable(args[1])) {
         stableVariables.add(names[0]);
         addScopedVariable(stableVariablesByFunction, owner, names[0]);
@@ -1688,16 +1817,16 @@ function buildReactModel(root) {
         addScopedVariable(externalMutableVariablesByFunction, owner, names[0]);
         addScopedVariable(instanceVariablesByFunction, owner, names[0]);
       }
-    } else if (path5 === "React.useCallback" && names.length >= 1 && isEmptyDependencyTable(args[1])) {
+    } else if (path6 === "React.useCallback" && names.length >= 1 && isEmptyDependencyTable(args[1])) {
       stableVariables.add(names[0]);
       addScopedVariable(stableVariablesByFunction, owner, names[0]);
-    } else if (path5 === "React.useRef" && names.length >= 1) {
+    } else if (path6 === "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 = path5.split(/[.:]/).at(-1) ?? "";
+      const final = path6.split(/[.:]/).at(-1) ?? "";
       if (/^use[A-Z0-9_]/.test(final)) {
         for (const name of names.slice(1)) {
           if (!STABLE_CUSTOM_HOOK_RETURN.test(name))
@@ -1721,11 +1850,11 @@ function buildReactModel(root) {
     if (!expression || expression.type !== "function_call")
       continue;
     const rawPath = expression.childForFieldName("name")?.text ?? "";
-    const path5 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
-    if (path5 === "React.useState" && names.length >= 2) {
+    const path6 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+    if (path6 === "React.useState" && names.length >= 2) {
       stableVariables.add(names[1]);
       addScopedVariable(stableVariablesByFunction, owner, names[1]);
-    } else if (path5 === "React.useBinding" && names.length >= 1) {
+    } else if (path6 === "React.useBinding" && names.length >= 1) {
       stableVariables.add(names[0]);
       addScopedVariable(stableVariablesByFunction, owner, names[0]);
       addScopedVariable(externalMutableVariablesByFunction, owner, names[0]);
@@ -1840,7 +1969,7 @@ function createInlineSuppressionChecker(source) {
 
 // src/parser.ts
 import fs5 from "fs";
-import path5 from "path";
+import path6 from "path";
 import { Language, Parser } from "web-tree-sitter";
 
 // src/parser-compat.ts
@@ -1979,6 +2108,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: lines2, offsets } = lineData(source);
   const ranges = [];
@@ -2186,6 +2332,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 = [];
@@ -2246,13 +2475,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");
 }
 
@@ -2260,7 +2491,7 @@ function parserCompatibleSource(source) {
 var parserPromise = null;
 async function createParser() {
   await Parser.init();
-  const grammarPath = path5.resolve(import.meta.dir, "../vendor/tree-sitter-luau.wasm");
+  const grammarPath = path6.resolve(import.meta.dir, "../vendor/tree-sitter-luau.wasm");
   const grammar = new Uint8Array(fs5.readFileSync(grammarPath));
   const language = await Language.load(grammar);
   const parser = new Parser;
@@ -2385,8 +2616,8 @@ var INSTANCE_FACTORY_MEMBERS2 = new Set([
   "GetService",
   "WaitForChild"
 ]);
-function finalCallMember2(path6) {
-  return path6.split(/[.:]/).at(-1) ?? path6;
+function finalCallMember2(path7) {
+  return path7.split(/[.:]/).at(-1) ?? path7;
 }
 function declarationInitializer(node, name) {
   if (node.type !== "variable_declaration")
@@ -2454,8 +2685,8 @@ function expressionHasRobloxOrigin(expression, from, context, seen) {
   seen.add(root);
   return expressionHasRobloxOrigin(visibleInitializer(root, from, context), from, context, seen);
 }
-function hasRobloxReceiver(path6, call, context) {
-  const normalized = path6.replace(/\s+/g, "");
+function hasRobloxReceiver(path7, call, context) {
+  const normalized = path7.replace(/\s+/g, "");
   if (/^(?:game|workspace|script)(?:[.:]|$)/.test(normalized))
     return true;
   const root = normalized.match(/^([A-Za-z_][A-Za-z0-9_]*)/)?.[1];
@@ -2465,6 +2696,8 @@ function hasRobloxReceiver(path6, 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) {
@@ -2529,6 +2762,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;
@@ -2545,8 +2805,38 @@ function sourceHasHighFrequencyRunService(source) {
   }
   return false;
 }
-function knownYieldReason(path6, call, context) {
-  const normalized = path6.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(path7, call, context) {
+  const normalized = path7.replace(/\s+/g, "");
   if (normalized === "task.wait")
     return "task.wait";
   if (normalized === "coroutine.yield")
@@ -2566,15 +2856,15 @@ function functionYieldPoint(node, context) {
     const owner = context.model.functionByNode.get(node.id);
     if (owner && nearest !== owner)
       continue;
-    const path6 = context.resolveCallPath(context.getCallPath(candidate) ?? "");
-    const reason = knownYieldReason(path6, candidate, context);
+    const path7 = context.resolveCallPath(context.getCallPath(candidate) ?? "");
+    const reason = knownYieldReason(path7, candidate, context);
     if (reason)
       return { call: candidate, reason };
   }
   return null;
 }
-function mutableDependencyBase(path6, externallyMutableRoots) {
-  const normalized = path6.replace(/\s+/g, "");
+function mutableDependencyBase(path7, externallyMutableRoots) {
+  const normalized = path7.replace(/\s+/g, "");
   if (/\.current(?:\.|$)/.test(normalized))
     return "";
   const segments = normalized.split(".");
@@ -2600,8 +2890,8 @@ var CONDITIONAL_TYPES = new Set([
   "while_statement",
   "repeat_statement"
 ]);
-function isHookPath(path6) {
-  const final = path6.split(/[.:]/).at(-1) ?? "";
+function isHookPath(path7) {
+  const final = path7.split(/[.:]/).at(-1) ?? "";
   return /^use[A-Z0-9_]/.test(final);
 }
 function assignmentTargetNode(statement) {
@@ -2677,8 +2967,8 @@ function functionInfoForNode(context, node) {
 function stateBindingsFor(context, owner) {
   return context.model.stateBindings.filter((binding) => binding.owner === owner);
 }
-function isEffectPath(path6) {
-  return path6 === "React.useEffect" || path6 === "React.useLayoutEffect";
+function isEffectPath(path7) {
+  return path7 === "React.useEffect" || path7 === "React.useLayoutEffect";
 }
 function dependencyExpressions(node) {
   if (!node || node.type !== "table_constructor")
@@ -2933,11 +3223,11 @@ function isManagedByCleanupContainer(call, context, callback) {
   let current = call.parent;
   while (current && !sameNode(current, callback.node)) {
     if (current.type === "function_call") {
-      const path6 = context.getCallPath(current) ?? "";
-      if (ALWAYS_MANAGED_METHOD.test(path6))
+      const path7 = context.getCallPath(current) ?? "";
+      if (ALWAYS_MANAGED_METHOD.test(path7))
         return true;
-      if (GENERIC_MANAGER_METHOD.test(path6)) {
-        const receiver = path6.split(":", 1)[0] ?? "";
+      if (GENERIC_MANAGER_METHOD.test(path7)) {
+        const receiver = path7.split(":", 1)[0] ?? "";
         if (MANAGER_ROOT.test(receiver))
           return true;
       }
@@ -3042,10 +3332,10 @@ function isCleanupOnlyTask(callbackNode, context) {
     return false;
   return calls.every((call) => /:(?:Destroy|Disconnect)$/.test(context.getCallPath(call) ?? ""));
 }
-function taskSeverity(path6, call, taskCallback, yieldPoint, context) {
-  if (path6 === "task.defer" && !yieldPoint)
+function taskSeverity(path7, call, taskCallback, yieldPoint, context) {
+  if (path7 === "task.defer" && !yieldPoint)
     return "suggestion";
-  if (path6 === "task.delay" && !yieldPoint) {
+  if (path7 === "task.delay" && !yieldPoint) {
     if (isCleanupOnlyTask(taskCallback, context))
       return "suggestion";
     const delay = numericTaskDelay(call, context);
@@ -3095,10 +3385,10 @@ end`,
     };
   }
   if ([...labels].every((label) => label.includes("task"))) {
-    const path6 = context.resolveCallPath(context.getCallPath(first.call) ?? "task.delay");
-    const taskCall = path6 === "task.defer" ? `task.defer(function()
+    const path7 = context.resolveCallPath(context.getCallPath(first.call) ?? "task.delay");
+    const taskCall = path7 === "task.defer" ? `task.defer(function()
 	doWork()
-end)` : path6 === "task.spawn" ? `task.spawn(function()
+end)` : path7 === "task.spawn" ? `task.spawn(function()
 	doWork()
 end)` : `task.delay(delaySeconds, function()
 	doWork()
@@ -3151,9 +3441,9 @@ end`,
 }
 function classifyResource(call, context, callback) {
   const rawPath = context.getCallPath(call) ?? "";
-  const path6 = context.resolveCallPath(rawPath);
+  const path7 = context.resolveCallPath(rawPath);
   const variable = assignedVariableName(call, callback);
-  const finalMember = path6.split(/[.:]/).at(-1) ?? path6;
+  const finalMember = path7.split(/[.:]/).at(-1) ?? path7;
   if (/:Connect$/.test(rawPath)) {
     const ownerExpression = connectionOwnerExpression(rawPath);
     const ownerIsInstance = isProvenInstanceExpression(ownerExpression, call, context, callback);
@@ -3222,7 +3512,7 @@ function classifyResource(call, context, callback) {
       }
     };
   }
-  if (path6 === "ReactRoblox.createRoot") {
+  if (path7 === "ReactRoblox.createRoot") {
     return {
       call,
       label: "React root",
@@ -3232,17 +3522,17 @@ function classifyResource(call, context, callback) {
       }
     };
   }
-  if (path6 === "task.delay" || path6 === "task.defer" || path6 === "task.spawn") {
+  if (path7 === "task.delay" || path7 === "task.defer" || path7 === "task.spawn") {
     const taskCallback = taskCallbackNode(call, context, callback);
     const yieldPoint = taskCallback ? functionYieldPoint(taskCallback, context) : null;
-    const outlivesEffect = path6 !== "task.spawn" || Boolean(yieldPoint);
+    const outlivesEffect = path7 !== "task.spawn" || Boolean(yieldPoint);
     if (!outlivesEffect)
       return null;
     return {
       call,
-      label: path6 === "task.spawn" ? "yielding spawned task" : path6 === "task.defer" ? "deferred task" : "delayed task",
+      label: path7 === "task.spawn" ? "yielding spawned task" : path7 === "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(path6, call, taskCallback, yieldPoint, context),
+      severity: taskSeverity(path7, call, taskCallback, yieldPoint, context),
       variable,
       cleanupMatches(text, name) {
         if (name) {
@@ -3269,8 +3559,8 @@ var effectNeedsCleanup = {
       const rawPath = context.getCallPath(call);
       if (!rawPath)
         continue;
-      const path6 = context.resolveCallPath(rawPath);
-      if (path6 !== "React.useEffect" && path6 !== "React.useLayoutEffect")
+      const path7 = context.resolveCallPath(rawPath);
+      if (path7 !== "React.useEffect" && path7 !== "React.useLayoutEffect")
         continue;
       const callbackNode = firstFunctionArgument(context, call);
       const callback = functionInfoForNode(context, callbackNode);
@@ -3324,10 +3614,22 @@ function ownerForHook(context, call) {
   const owner = context.nearestFunction(call);
   return owner && (owner.isComponent || owner.isHook) ? owner : null;
 }
+function effectCallbackWithoutDeps(context, call) {
+  const path7 = context.resolveCallPath(context.getCallPath(call) ?? "");
+  if (!isEffectPath(path7))
+    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 path6 = context.resolveCallPath(context.getCallPath(call) ?? "");
+  const path7 = context.resolveCallPath(context.getCallPath(call) ?? "");
   const args = context.callArguments(call);
-  if (path6 === "React.useImperativeHandle") {
+  if (path7 === "React.useImperativeHandle") {
     const callback2 = args[1];
     const deps2 = args[2];
     if (callback2?.type === "function_definition" && deps2?.type === "table_constructor")
@@ -3357,8 +3659,8 @@ function hasExternalSubscription(node, context) {
   for (const child of context.walk(node)) {
     if (child.type !== "function_call")
       continue;
-    const path6 = context.getCallPath(child) ?? "";
-    if (/:Connect$/.test(path6) || /BindToRenderStep$/.test(path6) || /:BindAction(?:AtPriority)?$/.test(path6))
+    const path7 = context.getCallPath(child) ?? "";
+    if (/:Connect$/.test(path7) || /BindToRenderStep$/.test(path7) || /:BindAction(?:AtPriority)?$/.test(path7))
       return true;
   }
   return false;
@@ -3392,6 +3694,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 path7 = context.resolveCallPath(context.getCallPath(argument) ?? "");
+    if (path7 === "table.clone" || path7 === "table.create" || path7 === "table.pack")
+      return true;
+  }
+  return false;
+}
 function freshDependencyKind(node, owner) {
   if (node.type === "table_constructor")
     return "table";
@@ -3414,8 +3743,8 @@ var noDerivedStateEffect = {
   run(context) {
     const diagnostics = [];
     for (const call of context.findCalls()) {
-      const path6 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (!isEffectPath(path6))
+      const path7 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (!isEffectPath(path7))
         continue;
       const owner = ownerForHook(context, call);
       const parts = callbackAndDeps(context, call);
@@ -3453,28 +3782,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 path6 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (!isEffectPath(path6))
+      const path7 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (!isEffectPath(path7))
         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."
           });
         }
       }
@@ -3490,8 +3839,8 @@ var noEffectWithFreshDeps = {
   run(context) {
     const diagnostics = [];
     for (const call of context.findCalls()) {
-      const path6 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (!HOOKS_WITH_DEPS.has(path6))
+      const path7 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (!HOOKS_WITH_DEPS.has(path7))
         continue;
       const owner = ownerForHook(context, call);
       const parts = callbackAndDeps(context, call);
@@ -3504,7 +3853,7 @@ var noEffectWithFreshDeps = {
         const label = dependency.type === "identifier" ? ` ${dependency.text}` : "";
         diagnostics.push({
           node: dependency,
-          message: `${path6} depends on${label || " an inline value"} that is a new ${kind} on every render.`,
+          message: `${path7} 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."
         });
       }
@@ -3520,8 +3869,8 @@ var noMutableInDeps = {
   run(context) {
     const diagnostics = [];
     for (const call of context.findCalls()) {
-      const path6 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (!HOOKS_WITH_DEPS.has(path6))
+      const path7 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (!HOOKS_WITH_DEPS.has(path7))
         continue;
       const owner = ownerForHook(context, call);
       const parts = callbackAndDeps(context, call);
@@ -3614,23 +3963,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) {
@@ -3706,8 +4093,8 @@ function rootIdentifierNode(node, root) {
   }
   return null;
 }
-function normalizeCapturedPath(path6, stableVariables, externallyMutableRoots) {
-  const normalized = normalizeExpressionText(path6);
+function normalizeCapturedPath(path7, stableVariables, externallyMutableRoots) {
+  const normalized = normalizeExpressionText(path7);
   const root = rootIdentifier(normalized);
   if (!root)
     return normalized;
@@ -3724,7 +4111,7 @@ function normalizeCapturedPath(path6, 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))
@@ -3793,21 +4180,94 @@ 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);
+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;
+  }
+  if (node.type !== "identifier" && node.type !== "dot_index_expression")
+    return null;
+  return normalizeExpressionText(node.text);
+}
+function immutableTransparentAliases(owner, context) {
+  const aliases = new Map;
+  if (!owner.body)
+    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(path7, aliases) {
+  let current = path7;
+  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 path6 = normalizeExpressionText(context.resolveCallPath(rawPath));
-    if (!PURE_DERIVED_CALL.test(path6))
+    const path7 = normalizeExpressionText(context.resolveCallPath(rawPath));
+    if (!PURE_DERIVED_CALL.test(path7))
       return false;
   }
   return true;
@@ -3886,8 +4346,8 @@ function hasDynamicUnpackDependencies(node, context) {
       const rawPath = context.getCallPath(candidate);
       if (!rawPath)
         continue;
-      const path6 = normalizeExpressionText(context.resolveCallPath(rawPath));
-      if (path6 === "unpack" || path6 === "table.unpack")
+      const path7 = normalizeExpressionText(context.resolveCallPath(rawPath));
+      if (path7 === "unpack" || path7 === "table.unpack")
         return true;
     }
   }
@@ -3912,8 +4372,8 @@ function memoizedProducerDependencies(owner, context) {
       const rawPath = context.getCallPath(expression);
       if (!rawPath)
         continue;
-      const path6 = context.resolveCallPath(rawPath);
-      if (path6 !== "React.useMemo" && path6 !== "React.useCallback")
+      const path7 = context.resolveCallPath(rawPath);
+      if (path7 !== "React.useMemo" && path7 !== "React.useCallback")
         continue;
       const args = context.callArguments(expression);
       const deps = args[1];
@@ -3972,9 +4432,9 @@ function directCallsInExpression(node) {
   return calls;
 }
 function isCustomHookCall(call, context) {
-  const path6 = context.resolveCallPath(context.getCallPath(call) ?? "");
-  const final = path6.split(/[.:]/).at(-1) ?? "";
-  return !path6.startsWith("React.") && /^use[A-Z0-9_]/.test(final);
+  const path7 = context.resolveCallPath(context.getCallPath(call) ?? "");
+  const final = path7.split(/[.:]/).at(-1) ?? "";
+  return !path7.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;
@@ -3984,8 +4444,8 @@ function isCalledAsFunction(owner, name, context) {
   for (const call of context.walk(owner.body)) {
     if (call.type !== "function_call")
       continue;
-    const path6 = normalizeExpressionText(context.getCallPath(call) ?? "");
-    if (path6 === name)
+    const path7 = normalizeExpressionText(context.getCallPath(call) ?? "");
+    if (path7 === name)
       return true;
   }
   return false;
@@ -4015,8 +4475,8 @@ function customHookDependencyHints(owner, context) {
         continue;
       const directHook = calls.find((call) => isCustomHookCall(call, context));
       if (directHook && expression.type === "function_call") {
-        const path6 = context.resolveCallPath(context.getCallPath(directHook) ?? "");
-        const final = path6.split(/[.:]/).at(-1) ?? "";
+        const path7 = context.resolveCallPath(context.getCallPath(directHook) ?? "");
+        const final = path7.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);
@@ -4026,14 +4486,14 @@ function customHookDependencyHints(owner, context) {
       }
       if (expression.type === "table_constructor") {
         const meaningfulCalls = calls.filter((call) => {
-          const path6 = context.resolveCallPath(context.getCallPath(call) ?? "");
-          return !/^(?:Color3|Vector2|Vector3|UDim|UDim2|CFrame|TweenInfo|NumberSequence|ColorSequence)\./.test(path6);
+          const path7 = context.resolveCallPath(context.getCallPath(call) ?? "");
+          return !/^(?:Color3|Vector2|Vector3|UDim|UDim2|CFrame|TweenInfo|NumberSequence|ColorSequence)\./.test(path7);
         });
         const allHandleHooks = meaningfulCalls.length > 0 && meaningfulCalls.every((call) => {
           if (!isCustomHookCall(call, context))
             return false;
-          const path6 = context.resolveCallPath(context.getCallPath(call) ?? "");
-          const final = path6.split(/[.:]/).at(-1) ?? "";
+          const path7 = context.resolveCallPath(context.getCallPath(call) ?? "");
+          const final = path7.split(/[.:]/).at(-1) ?? "";
           return HANDLE_HOOK_NAME.test(final);
         });
         if (allHandleHooks)
@@ -4063,12 +4523,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 path6 = context.resolveCallPath(rawPath);
-      const shape = HOOK_ARGUMENTS.get(path6);
+      const path7 = context.resolveCallPath(rawPath);
+      const shape = HOOK_ARGUMENTS.get(path7);
       if (!shape)
         continue;
       const args = context.callArguments(call);
@@ -4084,7 +4545,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);
@@ -4098,7 +4564,7 @@ var exhaustiveDeps = {
         diagnostics.push({
           node: tableStartNode(deps),
           severity: "suggestion",
-          message: `${path6} uses dynamic unpack(...) dependencies, so exhaustive dependency analysis is partial.`,
+          message: `${path7} 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;
@@ -4119,7 +4585,7 @@ var exhaustiveDeps = {
       if (reactiveMissing.length > 0) {
         diagnostics.push({
           node: tableStartNode(deps),
-          message: `${path6} dependency table is missing ${reactiveMissing.join(", ")}.`,
+          message: `${path7} 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.`
         });
       }
@@ -4127,7 +4593,7 @@ var exhaustiveDeps = {
         diagnostics.push({
           node: tableStartNode(deps),
           severity: "suggestion",
-          message: `${path6} 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: `${path7} 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."
         });
       }
@@ -4135,7 +4601,7 @@ var exhaustiveDeps = {
         diagnostics.push({
           node: tableStartNode(deps),
           severity: "suggestion",
-          message: `${path6} captures custom-hook handle ${uncertainHandles.join(", ")} without listing ${uncertainHandles.length === 1 ? "it as a dependency" : "them as dependencies"}.`,
+          message: `${path7} 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."
         });
       }
@@ -4169,8 +4635,8 @@ function createElementCallsInLoop(context, loop) {
   for (const node of context.walk(loop)) {
     if (node.type !== "function_call")
       continue;
-    const path6 = context.resolveCallPath(context.getCallPath(node) ?? "");
-    if (path6 === "React.createElement")
+    const path7 = context.resolveCallPath(context.getCallPath(node) ?? "");
+    if (path7 === "React.createElement")
       result.push(node);
   }
   return result;
@@ -4226,8 +4692,8 @@ var noCreateContextInRender = {
   run(context) {
     const diagnostics = [];
     for (const call of context.findCalls()) {
-      const path6 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (path6 !== "React.createContext")
+      const path7 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (path7 !== "React.createContext")
         continue;
       const owner = context.nearestFunction(call);
       if (!owner || !owner.isComponent && !owner.isHook)
@@ -4263,8 +4729,8 @@ function isRenderedBy(context, component, name) {
       continue;
     if (context.nearestFunction(call) !== component)
       continue;
-    const path6 = context.resolveCallPath(context.getCallPath(call) ?? "");
-    if (path6 !== "React.createElement")
+    const path7 = context.resolveCallPath(context.getCallPath(call) ?? "");
+    if (path7 !== "React.createElement")
       continue;
     if (context.callArguments(call)[0]?.text.trim() === name)
       return true;
@@ -4308,63 +4774,6 @@ var noNestedComponentDefinition = {
   }
 };
 
-// src/module-resolution.ts
-import path6 from "path";
-function normalizeRelative2(value) {
-  return value.split(path6.sep).join("/");
-}
-function moduleKeys(relativePath) {
-  let normalized = normalizeRelative2(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;
@@ -5091,7 +5500,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."
@@ -5368,7 +5777,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;
@@ -5491,13 +5902,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 path7 = context.resolveCallPath(context.getCallPath(call) ?? "").replace(/\s+/g, "");
+  return PURE_BINDING_DERIVATION_CALL.test(path7);
+}
+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 isInside2(node, ancestor) {
   let current = node;
   while (current) {
@@ -5581,13 +6043,59 @@ 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;
@@ -5597,7 +6105,30 @@ function derivedLocalDeclarationForRead(node) {
       return parent;
     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;
+  }
+  return null;
+}
+function opaqueDerivedLocalDeclarationForRead(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 (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 path7 = context.resolveCallPath(context.getCallPath(parent) ?? "");
+      if (/^React\.use(?:Memo|Callback|Effect|LayoutEffect)$/.test(path7))
+        return null;
+    }
+    if (!TRANSPARENT_PARENTS.has(parent.type) && parent.type !== "arguments" && parent.type !== "function_call")
       return null;
     current = parent;
   }
@@ -5617,7 +6148,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)))
@@ -5627,12 +6158,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 path7 = context.getCallPath(call) ?? "";
@@ -5643,12 +6208,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;
@@ -5656,14 +6223,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;
@@ -5671,14 +6241,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;
@@ -5692,25 +6260,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 path7 = context.getCallPath(node);
-    if (path7 !== binding.setterName)
+    if (path7 === 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;
@@ -5788,14 +6509,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) {
@@ -5824,7 +6539,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;
   }
@@ -5856,17 +6571,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;
   }
@@ -5879,11 +6594,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,
@@ -5895,9 +6610,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);
@@ -5920,11 +6671,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 path7 = context.resolveCallPath(context.getCallPath(call) ?? "");
+    if (path7 !== "React.useEffect" && path7 !== "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;
@@ -5941,75 +6775,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 ? `${path7} is using its React state mode for an externally changing GUI measurement, so ${localName} rerenders this consumer when the measurement changes.` : `${path7} returns React state for an externally changing GUI measurement, so ${localName} rerenders this consumer when the measurement changes.` : summary.sourceKind === "derived-external-state" ? `${path7} derives React state from another externally updated reactive value, so ${localName} adds another rerendering state layer.` : `${path7} 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 ? `${path7} mirrors ${observedProperty} through React state even though every analyzed use is presentation-only, so the measurement rerenders this consumer without needing reconciliation.` : likelyContinuousProperty ? `${path7} mirrors continuously mutable ${observedProperty} through React state, and ${localName} only feeds presentation updates that do not need reconciliation.` : `${path7} 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 path7 = context.getCallPath(call) ?? "";
-      const member = path7.split(/[.:]/).at(-1) ?? path7;
-      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: `${path7} 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: `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: 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: `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
         });
       }
     }
@@ -6030,27 +6861,49 @@ var preferBindingOverStateCandidate = {
     for (const call of context.findCalls()) {
       const path7 = context.getCallPath(call) ?? "";
       const summary = importedHooks.get(path7);
-      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 = `${path7} 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 = `${path7} 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 = `${path7} 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 = `${path7} 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 = `${path7} 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: `${path7} 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()) {
@@ -6064,39 +6917,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: `${path7} 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: `${path7} 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;
@@ -6602,6 +7496,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)) {
@@ -6649,30 +7557,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) {
@@ -6692,6 +7582,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;
@@ -6718,7 +7619,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;
       }
@@ -6745,7 +7646,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;
@@ -6798,6 +7699,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 path7 = context.resolveCallPath(rawPath);
+    if (!isHookPath(path7))
+      continue;
+    const nestedControl = findAncestorBetween(node, branch, (ancestor) => CONDITIONAL_TYPES.has(ancestor.type));
+    if (nestedControl)
+      return null;
+    hooks.push(path7);
+  }
+  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((path7, index) => path7 === elseHooks[index]))
+    return false;
+  return thenHooks.every((path7) => path7.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) {
@@ -6859,9 +7941,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) {
@@ -6869,7 +7951,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") {
@@ -6941,15 +8037,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 path7 = context.resolveCallPath(rawPath);
       if (!isHookPath(path7))
         continue;
@@ -6978,25 +8080,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;
@@ -7010,7 +8123,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 ${path7} may run after an earlier reachable return, so some renders can execute fewer hooks.`,
@@ -7455,6 +8569,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);
@@ -7473,7 +8597,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: [] };
   }
@@ -7512,11 +8636,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
   };
 }
 
@@ -7675,7 +8800,34 @@ class AnalysisWorkerPool {
 // src/project-model.ts
 import fs6 from "fs";
 import path7 from "path";
-var EXTERNAL_UPDATE_SOURCE = /(?::|\.)(?:Connect|Once|Subscribe|Observe|Listen|Watch)\s*\(|\b(?:subscribe|observe|listen|watch)[A-Za-z0-9_]*\s*\(|GetPropertyChangedSignal\s*\(|\.Changed\b/i;
+var EXTERNAL_UPDATE_SOURCE = /(?::|\.)(?:Connect|Once|Subscribe|Observe|Listen|Watch|onStep|onUpdate|onChange|onChanged)\s*\(|\b(?:subscribe|observe|listen|watch|onStep|onUpdate|onChange|onChanged)[A-Za-z0-9_]*\s*\(|GetPropertyChangedSignal\s*\(|GetAttributeChangedSignal\s*\(|\.Changed\b/i;
+var SEMANTIC_SNAPSHOT_EXPRESSION2 = /\b(?:getState|getSnapshot|snapshot|selector|select|table\s*\.\s*(?:clone|freeze|move))\b|(?:\.|\[\s*["'])State(?:\b|["']\s*\])/i;
+var PURE_MIRROR_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",
+  "true",
+  "false",
+  "nil"
+]);
 var CALLBACK_PARAMETER_NAME = /^(?:callback|handler|listener|subscriber|observer|effect|fn)$/i;
 function exportedFunctionName(source) {
   return source.match(/\breturn\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/)?.[1] ?? null;
@@ -7817,37 +8969,81 @@ function parameterName(parameter) {
 function branchContainsHookCall(text) {
   return /\b(?:[A-Za-z_][A-Za-z0-9_]*[.:])?use[A-Z0-9_][A-Za-z0-9_]*\s*\(/.test(text);
 }
+var BUILT_IN_REACT_HOOK_NAMES = new Set([
+  "useState",
+  "useEffect",
+  "useLayoutEffect",
+  "useMemo",
+  "useCallback",
+  "useContext",
+  "useReducer",
+  "useRef",
+  "useImperativeHandle",
+  "useBinding"
+]);
+function simpleBranchHookPaths(text) {
+  if (/\b(?:if|for|while|repeat|function)\b/.test(text))
+    return null;
+  return [...text.matchAll(/\b(React\.(use[A-Z0-9_][A-Za-z0-9_]*))\s*\(/g)].map((match) => match[2]);
+}
+function simpleIfHasEquivalentBuiltInTopology(source, ifStart) {
+  if (ifStart === undefined)
+    return false;
+  const statement = source.slice(ifStart).match(/^if\b[\s\S]*?\bthen\b([\s\S]*?)\belse\b([\s\S]*?)\bend\b/);
+  if (!statement)
+    return false;
+  const left = simpleBranchHookPaths(statement[1] ?? "");
+  const right = simpleBranchHookPaths(statement[2] ?? "");
+  if (!left || !right || left.length === 0 || left.length !== right.length)
+    return false;
+  return left.every((name, index) => name === right[index] && BUILT_IN_REACT_HOOK_NAMES.has(name));
+}
 function conditionAliasesForParameter(source, parameter) {
-  const aliases = new Set([parameter]);
+  const aliases = new Map([[parameter, ""]]);
   const escaped = parameter.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  for (const match of source.matchAll(new RegExp(`\\b${escaped}((?:\\.[A-Za-z_][A-Za-z0-9_]*)+)`, "g"))) {
+    aliases.set(`${parameter}${match[1]}`, match[1].slice(1));
+  }
   const directPatterns = [
-    new RegExp(`^\\s*local\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*${escaped}\\s*$`, "gm"),
-    new RegExp(`^\\s*local\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*not\\s+${escaped}\\s*$`, "gm"),
-    new RegExp(`^\\s*local\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*${escaped}\\s*(?:==|~=)\\s*(?:true|false|nil)\\s*$`, "gm"),
-    new RegExp(`^\\s*local\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*(?:true|false|nil)\\s*(?:==|~=)\\s*${escaped}\\s*$`, "gm"),
-    new RegExp(`^\\s*local\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*if\\s+${escaped}\\s*(?:==|~=)\\s*nil\\s+then\\s+(?:true|false)\\s+else\\s+${escaped}\\s*$`, "gm"),
-    new RegExp(`^\\s*local\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*if\\s+${escaped}\\s+then\\s+(?:true|false)\\s+else\\s+(?:true|false)\\s*$`, "gm")
+    new RegExp(`^\\s*local\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*(${escaped}(?:\\.[A-Za-z_][A-Za-z0-9_]*)*)\\s*$`, "gm"),
+    new RegExp(`^\\s*local\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*not\\s+(${escaped}(?:\\.[A-Za-z_][A-Za-z0-9_]*)*)\\s*$`, "gm"),
+    new RegExp(`^\\s*local\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*(${escaped}(?:\\.[A-Za-z_][A-Za-z0-9_]*)*)\\s*(?:==|~=)\\s*(?:true|false|nil)\\s*$`, "gm"),
+    new RegExp(`^\\s*local\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*(?:true|false|nil)\\s*(?:==|~=)\\s*(${escaped}(?:\\.[A-Za-z_][A-Za-z0-9_]*)*)\\s*$`, "gm")
   ];
   for (const pattern of directPatterns) {
-    for (const match of source.matchAll(pattern))
-      aliases.add(match[1]);
+    for (const match of source.matchAll(pattern)) {
+      const sourcePath = match[2];
+      const accessPath = sourcePath === parameter ? "" : sourcePath.slice(parameter.length + 1);
+      aliases.set(match[1], accessPath);
+    }
   }
-  return [...aliases];
+  for (const match of source.matchAll(new RegExp(`^\\s*local\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*if\\s+(${escaped}(?:\\.[A-Za-z_][A-Za-z0-9_]*)*)\\s*(?:==|~=)\\s*nil\\s+then\\s+(?:true|false)\\s+else\\s+\\2\\s*$`, "gm"))) {
+    const sourcePath = match[2];
+    aliases.set(match[1], sourcePath === parameter ? "" : sourcePath.slice(parameter.length + 1));
+  }
+  for (const match of source.matchAll(new RegExp(`^\\s*local\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*=\\s*if\\s+(${escaped}(?:\\.[A-Za-z_][A-Za-z0-9_]*)*)\\s+then\\s+(?:true|false)\\s+else\\s+(?:true|false)\\s*$`, "gm"))) {
+    const sourcePath = match[2];
+    aliases.set(match[1], sourcePath === parameter ? "" : sourcePath.slice(parameter.length + 1));
+  }
+  return aliases;
 }
 function findConditionalHookMode(source) {
   const exported = exportedFunctionParameters(source);
   if (!exported)
     return null;
+  if (exported.name && !/^use[A-Z0-9_]/.test(exported.name))
+    return null;
   const parameterNames3 = exported.parameters.map(parameterName);
   const controlledIndexes = [];
   const controlledNames = [];
   const conditionVariables = {};
+  const conditionAccessPaths = {};
   for (const [index, name] of parameterNames3.entries()) {
     if (!name)
       continue;
     const aliases = conditionAliasesForParameter(source, name);
     let controlsHook = false;
-    for (const alias of aliases) {
+    for (const [alias, accessPath] of aliases) {
       const escaped = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
       const patterns = [
         new RegExp(`\\bif\\s+${escaped}\\s+then([\\s\\S]*?)(?=\\belse\\b|\\bend\\b)`, "g"),
@@ -7859,8 +9055,11 @@ function findConditionalHookMode(source) {
         for (const match of source.matchAll(pattern)) {
           if (!branchContainsHookCall(match[1] ?? ""))
             continue;
+          if (simpleIfHasEquivalentBuiltInTopology(source, match.index))
+            continue;
           controlsHook = true;
           conditionVariables[alias] = index;
+          conditionAccessPaths[alias] = accessPath;
           break;
         }
         if (controlsHook)
@@ -7879,6 +9078,7 @@ function findConditionalHookMode(source) {
     parameterIndexes: controlledIndexes,
     parameterNames: controlledNames,
     conditionVariables,
+    conditionAccessPaths,
     knownCallSites: 0,
     dynamicCallSites: 0
   };
@@ -8011,9 +9211,62 @@ function findExternalCallbackFunction(source) {
   return {
     name,
     callbackParameterIndexes,
-    highFrequency: sourceHasHighFrequencyRunService(source)
+    highFrequency: sourceHasHighFrequencyRobloxEvent(source) || sourceHasLikelyContinuousSubscription(source)
   };
 }
+function sourceHasLikelyContinuousSubscription(source) {
+  return /(?::|\.)onStep\s*\(/i.test(source);
+}
+function expressionReferencesName(expression, name) {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\b${escaped}\\b`).test(expression);
+}
+function isLiteralStateTransitionExpression(expression) {
+  const text = expression.trim();
+  return /^(?:true|false|nil|[-+]?\d+(?:\.\d+)?|["'][^"']*["'])$/.test(text);
+}
+function expressionHasLikelyExternalInput(expression) {
+  const withoutMembers = expression.replace(/\.\s*[A-Za-z_][A-Za-z0-9_]*/g, "");
+  for (const match of withoutMembers.matchAll(/\b[A-Za-z_][A-Za-z0-9_]*\b/g)) {
+    if (!PURE_MIRROR_EXPRESSION_ROOTS.has(match[0]))
+      return true;
+  }
+  return false;
+}
+function subscriptionMirrorConfidence(source, setterName) {
+  const escapedSetter = setterName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const directSetter = new RegExp(`(?::|\\.)(Connect|Subscribe|Observe|Listen|Watch|onStep|onUpdate|onChange|onChanged)\\s*\\(\\s*${escapedSetter}\\b`, "i");
+  if (directSetter.test(source))
+    return "strong";
+  const callbackPattern = new RegExp(`(?::|\\.)(Connect|Subscribe|Observe|Listen|Watch|onStep|onUpdate|onChange|onChanged)\\s*\\(\\s*function\\s*\\(([^)]*)\\)[\\s\\S]{0,2400}?\\b${escapedSetter}\\s*\\(`, "gi");
+  let possible = false;
+  for (const match of source.matchAll(callbackPattern)) {
+    if (match.index === undefined)
+      continue;
+    const callbackParameters = splitTopLevelParameters(match[2] ?? "").map(parameterName).filter((name) => Boolean(name));
+    const setterOffset = match[0].lastIndexOf(setterName);
+    if (setterOffset < 0)
+      continue;
+    const setterStart = match.index + setterOffset;
+    const open = source.indexOf("(", setterStart + setterName.length);
+    const argumentsText = extractCallArguments(source, open);
+    if (argumentsText === null)
+      continue;
+    const setterArgs = splitTopLevelParameters(argumentsText);
+    const expression = setterArgs[0]?.trim() ?? "";
+    if (!expression || /^function\b/.test(expression) || isLiteralStateTransitionExpression(expression))
+      continue;
+    if (SEMANTIC_SNAPSHOT_EXPRESSION2.test(expression))
+      continue;
+    if (callbackParameters.some((name) => expressionReferencesName(expression, name))) {
+      return "strong";
+    }
+    if (!expressionHasLikelyExternalInput(expression))
+      continue;
+    possible = true;
+  }
+  return possible ? "possible" : "none";
+}
 function findBindingCandidateHook(source) {
   const exported = source.match(/\breturn\s+(use[A-Z0-9_][A-Za-z0-9_]*)\s*$/)?.[1];
   if (!exported)
@@ -8035,18 +9288,35 @@ function findBindingCandidateHook(source) {
   const setterPassedToSubscription = new RegExp(`(?::|\\.)(?:Connect|Once|Subscribe|Observe|Listen|Watch)\\s*\\(\\s*${escapedSetter}\\b`, "i").test(source);
   if (!setterCalled && !setterPassedToSubscription)
     return null;
-  const highFrequency = sourceHasHighFrequencyRunService(source);
+  const highFrequency = sourceHasHighFrequencyRobloxEvent(source) || sourceHasLikelyContinuousSubscription(source);
   const external = highFrequency || EXTERNAL_UPDATE_SOURCE.test(source);
   if (!external)
     return null;
-  const propertySignal = source.match(/GetPropertyChangedSignal\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)/);
-  const observedPropertyName = propertySignal?.[1] ?? null;
-  const measurement = Boolean(observedPropertyName && new RegExp(`\\[\\s*${observedPropertyName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\]`).test(source));
+  const literalPropertySignal = source.match(/GetPropertyChangedSignal\s*\(\s*["']([^"']+)["']\s*\)/);
+  const dynamicPropertySignal = literalPropertySignal ? null : source.match(/GetPropertyChangedSignal\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)/);
+  const literalPropertyName = literalPropertySignal?.[1] ?? null;
+  const dynamicPropertyName = dynamicPropertySignal?.[1] ?? null;
+  const readsObservedProperty = literalPropertyName ? new RegExp(`(?:\\.\\s*${literalPropertyName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b|\\[\\s*["']${literalPropertyName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*\\])`).test(source) : Boolean(dynamicPropertyName && new RegExp(`\\[\\s*${dynamicPropertyName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\]`).test(source));
+  const instanceProperty = Boolean((literalPropertyName || dynamicPropertyName) && readsObservedProperty);
+  const mirrorConfidence = instanceProperty ? "strong" : subscriptionMirrorConfidence(source, setterName);
+  let observedPropertyParameterIndex;
+  if (instanceProperty && dynamicPropertyName) {
+    const parameters = findFunctionParameters(source, exported);
+    if (parameters !== null) {
+      const parameterNames3 = splitTopLevelParameters(parameters).map((parameter) => parameter.match(/^([A-Za-z_][A-Za-z0-9_]*)/)?.[1] ?? "");
+      const index = parameterNames3.indexOf(dynamicPropertyName);
+      if (index >= 0)
+        observedPropertyParameterIndex = index;
+    }
+  }
   return {
     name: exported,
     highFrequency,
     external,
-    sourceKind: measurement ? "measurement" : "external-state",
+    sourceKind: instanceProperty ? "instance-property" : "external-state",
+    mirrorConfidence,
+    ...instanceProperty && literalPropertyName ? { observedPropertyName: literalPropertyName } : {},
+    ...observedPropertyParameterIndex !== undefined ? { observedPropertyParameterIndex } : {},
     ...dualMode ? {
       bindingModeParameterIndex: dualMode.bindingModeParameterIndex,
       bindingModeParameterName: dualMode.bindingModeParameterName,
@@ -8084,7 +9354,8 @@ function findDerivedBindingCandidateHook(source, bindingCandidateHooks) {
       name: exported,
       highFrequency: summary.highFrequency,
       external: true,
-      sourceKind: "derived-external-state"
+      sourceKind: "derived-external-state",
+      mirrorConfidence: summary.mirrorConfidence
     };
   }
   return null;
@@ -8448,12 +9719,73 @@ function findBindingCompatibleComponentProps(source) {
   }
   const compatible = new Set;
   for (const [property, offsets] of reads) {
-    if (offsets.length > 0 && offsets.every((offset) => ranges.some((range) => offset >= range.start && offset < range.end))) {
+    if (offsets.length > 0 && offsets.every((offset) => ranges.some((range) => {
+      if (offset < range.start || offset >= range.end)
+        return false;
+      return !/\bfunction\b/.test(source.slice(range.start, offset));
+    }))) {
       compatible.add(property);
     }
   }
   return compatible.size > 0 ? compatible : null;
 }
+function exportedUseFunctionName(source) {
+  const name = exportedFunctionName(source);
+  return name && /^use[A-Z0-9_]/.test(name) ? name : null;
+}
+function directReactHookUsage(source) {
+  const namespaces = new Set(["React"]);
+  const requirePattern = /\blocal\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*require\s*\((.*?)\)/gs;
+  for (const match of source.matchAll(requirePattern)) {
+    const target = normalizeRequireTarget(match[2]);
+    if (target.split(".").includes("react"))
+      namespaces.add(match[1]);
+  }
+  for (const namespace of namespaces) {
+    const escaped = namespace.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    if (new RegExp(`\\b${escaped}\\.use[A-Z0-9_][A-Za-z0-9_]*\\b`).test(source))
+      return true;
+  }
+  return false;
+}
+function calledRequiredModules(source) {
+  const result = [];
+  const requirePattern = /\blocal\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*require\s*\((.*?)\)/gs;
+  for (const match of source.matchAll(requirePattern)) {
+    const localName = match[1];
+    const escaped = localName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    if (!new RegExp(`\\b${escaped}\\s*\\(`).test(source.slice(match.index + match[0].length)))
+      continue;
+    result.push({ localName, target: normalizeRequireTarget(match[2]) });
+  }
+  return result;
+}
+function findReactHookModules(records) {
+  const hookRecords = records.filter((record) => exportedUseFunctionName(record.source));
+  const provenReact = new Map;
+  for (const record of hookRecords) {
+    if (directReactHookUsage(record.source))
+      provenReact.set(record.id, true);
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const aliases = buildUniqueFeatureAliases(records, provenReact);
+    for (const record of hookRecords) {
+      if (provenReact.has(record.id))
+        continue;
+      const callsReactHookModule = calledRequiredModules(record.source).some(({ target }) => resolveModuleReference(target, aliases) === true);
+      if (!callsReactHookModule)
+        continue;
+      provenReact.set(record.id, true);
+      changed = true;
+    }
+  }
+  const result = new Map;
+  for (const record of hookRecords)
+    result.set(record.id, provenReact.has(record.id));
+  return result;
+}
 function findStaticIterationTables(source) {
   const match = /^return\s*\{/m.exec(source);
   if (!match || match.index === undefined)
@@ -8529,11 +9861,13 @@ function buildProjectModel(root, candidates, options = {}) {
         parameterIndexes: [...analysis.conditionalHookMode.parameterIndexes],
         parameterNames: [...analysis.conditionalHookMode.parameterNames],
         conditionVariables: { ...analysis.conditionalHookMode.conditionVariables },
+        conditionAccessPaths: { ...analysis.conditionalHookMode.conditionAccessPaths },
         knownCallSites: 0,
         dynamicCallSites: 0
       });
   }
   const conditionalHookModes = buildUniqueFeatureAliases(records, conditionalHookModesByModule);
+  const reactHookModules = buildUniqueFeatureAliases(records, findReactHookModules(records));
   collectConditionalHookModeCallSites(records, conditionalHookModes);
   let changed = true;
   while (changed) {
@@ -8557,6 +9891,7 @@ function buildProjectModel(root, candidates, options = {}) {
     bindingCompatibleComponentProps: buildUniqueFeatureAliases(records, bindingCompatibleComponentPropsByModule),
     staticIterationTables: buildUniqueFeatureAliases(records, staticIterationTablesByModule),
     conditionalHookModes,
+    reactHookModules,
     sourceEffects: new Map
   };
 }
@@ -10771,6 +12106,7 @@ import path12 from "path";
 var UPDATE_CHECK_INTERVAL_MS = 2 * 60 * 60 * 1000;
 var UPDATE_REQUEST_TIMEOUT_MS = 5000;
 var UPDATE_CACHE_FILENAME = "update-check.json";
+var CHANGELOG_URL = "https://raw.githubusercontent.com/ColRealPro/react-luau-doctor/refs/heads/main/CHANGELOG.md";
 function updateCacheFilename() {
   return path12.join(cacheBaseDirectory(), UPDATE_CACHE_FILENAME);
 }
@@ -10852,6 +12188,9 @@ function updateRegistryUrl() {
   const base = registry.endsWith("/") ? registry : `${registry}/`;
   return new URL(`${encodeURIComponent(package_default.name)}/latest`, base).toString();
 }
+function changelogUrl() {
+  return process.env.REACT_LUAU_DOCTOR_CHANGELOG_URL ?? CHANGELOG_URL;
+}
 async function fetchLatestVersion() {
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), UPDATE_REQUEST_TIMEOUT_MS);
@@ -10872,6 +12211,50 @@ async function fetchLatestVersion() {
     clearTimeout(timer);
   }
 }
+function changelogReleasesBetween(markdown, currentVersion, latestVersion) {
+  const releases = [];
+  let active = null;
+  const flush = () => {
+    if (!active)
+      return;
+    const afterCurrent = compareVersions(active.version, currentVersion);
+    const atOrBeforeLatest = compareVersions(active.version, latestVersion);
+    if (afterCurrent !== null && atOrBeforeLatest !== null && afterCurrent > 0 && atOrBeforeLatest <= 0) {
+      releases.push({ version: active.version, notes: active.lines.join(`
+`).trim() });
+    }
+    active = null;
+  };
+  for (const line of markdown.split(/\r?\n/)) {
+    if (/^##\s+/.test(line.trim())) {
+      flush();
+      const match = /^##\s+\[?v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\]?(?:\s+-.*)?\s*$/.exec(line.trim());
+      if (match)
+        active = { version: match[1], lines: [] };
+      continue;
+    }
+    active?.lines.push(line);
+  }
+  flush();
+  releases.sort((left, right) => compareVersions(right.version, left.version) ?? 0);
+  return releases;
+}
+async function fetchChangelogReleases(currentVersion, latestVersion) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), UPDATE_REQUEST_TIMEOUT_MS);
+  timer.unref?.();
+  try {
+    const response = await fetch(changelogUrl(), {
+      headers: { accept: "text/markdown, text/plain;q=0.9, */*;q=0.1" },
+      signal: controller.signal
+    });
+    if (!response.ok)
+      throw new Error(`changelog returned HTTP ${response.status}`);
+    return changelogReleasesBetween(await response.text(), currentVersion, latestVersion);
+  } finally {
+    clearTimeout(timer);
+  }
+}
 function updateCacheIsStale(now = Date.now()) {
   const cache = readUpdateCache();
   return !cache || now - cache.checkedAt >= UPDATE_CHECK_INTERVAL_MS;
@@ -10927,7 +12310,7 @@ async function checkForUpdatesNow(currentVersion) {
 
 // src/update-install.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function normalizedPath(filename) {
   return filename.replaceAll("\\", "/");
 }
@@ -10955,7 +12338,7 @@ function updateInstallCommandForPath(filename) {
   return null;
 }
 function currentUpdateInstallCommand() {
-  return updateInstallCommandForPath(fileURLToPath(import.meta.url));
+  return updateInstallCommandForPath(fileURLToPath2(import.meta.url));
 }
 function installLatestVersion(command) {
   const result = spawnSync3(command.command, command.args, {
@@ -11063,10 +12446,12 @@ end, {})`,
   },
   "react-luau/prefer-binding-over-state-candidate": {
     before: `local value, setValue = React.useState(0)
--- value drives both visual and structural work`,
-    after: `local visualValue, setVisualValue = React.useBinding(0)
-local structuralValue, setStructuralValue = React.useState(0)`,
-    note: "A common fix is to split high-frequency visual updates from the smaller value that truly needs reconciliation."
+signal:Connect(setValue)
+-- value is used for presentation`,
+    after: `local value, setValue = React.useBinding(0)
+signal:Connect(setValue)
+-- keep separate React state too if structure depends on it`,
+    note: "Use a Binding when this is really an external presentation stream. Keep or split React state when the event represents semantic UI state or needs reconciliation."
   },
   "react-luau/rerender-unstable-memo-props": {
     before: `return React.createElement(MemoizedButton, {
@@ -11498,7 +12883,7 @@ CI commands:
 
 Update commands:
   update                                 Update the global installation to the latest release
-  update --check                         Check npm for a newer release without updating
+  update --check                         Check npm and show release notes without updating
 
 Rules commands:
   rules list [--category <name>] [--configured] [--json]
@@ -11515,12 +12900,67 @@ Config:
 function automaticUpdateNoticeEnabled(options, machineReadable) {
   return !options.noUpdateCheck && !machineReadable && Boolean(process.stdout.isTTY) && !process.env.CI && process.env.NO_UPDATE_NOTIFIER === undefined && process.env.REACT_LUAU_DOCTOR_NO_UPDATE_CHECK === undefined;
 }
-function renderUpdateNotice(current, latest, colorized) {
+function renderUpdateHeader(current, latest, colorized) {
   const label = whyPaint(colorized, "Update available:", WHY_ANSI.bold, WHY_ANSI.yellow);
   const oldVersion = whyPaint(colorized, `v${current}`, WHY_ANSI.dim);
   const newVersion = whyPaint(colorized, `v${latest}`, WHY_ANSI.bold);
-  return `${label} ${oldVersion} \u2192 ${newVersion}
-Run \`react-luau-doctor update\` to update.`;
+  return `${label} ${oldVersion} \u2192 ${newVersion}`;
+}
+function renderUpdateNotice(current, latest, colorized) {
+  return `${renderUpdateHeader(current, latest, colorized)}
+Run \`react-luau-doctor update --check\` to see what's new.`;
+}
+function renderChangelogInline(value, colorized, ...baseCodes) {
+  if (!colorized)
+    return value;
+  const parts = [];
+  let offset = 0;
+  for (const match of value.matchAll(/`([^`\n]+)`/g)) {
+    const index = match.index ?? 0;
+    if (index > offset)
+      parts.push(whyPaint(true, value.slice(offset, index), ...baseCodes));
+    parts.push(whyPaint(true, match[1], WHY_THEME.variable));
+    offset = index + match[0].length;
+  }
+  if (parts.length === 0)
+    return whyPaint(true, value, ...baseCodes);
+  if (offset < value.length)
+    parts.push(whyPaint(true, value.slice(offset), ...baseCodes));
+  return parts.join("");
+}
+function renderChangelogNotes(notes, colorized) {
+  return notes.split(/\r?\n/).map((line) => {
+    const heading = /^#{3,6}\s+(.+)$/.exec(line.trim());
+    if (heading)
+      return renderChangelogInline(heading[1], colorized, WHY_ANSI.bold);
+    const bullet = /^(\s*)[-*]\s+(.+)$/.exec(line);
+    if (bullet)
+      return `${bullet[1] || "  "}\u2022 ${renderChangelogInline(bullet[2], colorized)}`;
+    return renderChangelogInline(line, colorized);
+  }).join(`
+`).trim();
+}
+function renderUpdateCheck(current, latest, releases, releaseNotesUnavailable, colorized) {
+  const lines2 = [
+    renderUpdateHeader(current, latest, colorized),
+    "",
+    whyPaint(colorized, "What's new", WHY_ANSI.bold)
+  ];
+  if (releaseNotesUnavailable) {
+    lines2.push("  Release notes could not be loaded from GitHub.");
+  } else if (releases.length === 0) {
+    lines2.push("  No changelog entries were found between these versions.");
+  } else {
+    for (const release of releases) {
+      lines2.push("", whyPaint(colorized, `v${release.version}`, WHY_ANSI.bold));
+      const notes = renderChangelogNotes(release.notes, colorized);
+      if (notes)
+        lines2.push(notes);
+    }
+  }
+  lines2.push("", "Run `react-luau-doctor update` to update.");
+  return lines2.join(`
+`);
 }
 async function runUpdateCommand(argv) {
   if (argv.includes("--help") || argv.includes("-h")) {
@@ -11539,7 +12979,14 @@ async function runUpdateCommand(argv) {
   }
   const colorized = shouldUseColor(false, false);
   if (argv[0] === "--check") {
-    process.stdout.write(`${renderUpdateNotice(VERSION2, result.latest, colorized)}
+    let releases = [];
+    let releaseNotesUnavailable = false;
+    try {
+      releases = await fetchChangelogReleases(VERSION2, result.latest);
+    } catch {
+      releaseNotesUnavailable = true;
+    }
+    process.stdout.write(`${renderUpdateCheck(VERSION2, result.latest, releases, releaseNotesUnavailable, colorized)}
 `);
     return;
   }
@@ -12476,14 +13923,14 @@ function renderWhyCodeFrame(filename, diagnostic, colorized) {
 }
 function whySeverityMeaning(severity) {
   if (severity === "error")
-    return "This can violate React or Luau correctness rules and should normally be fixed.";
+    return "This can cause incorrect behavior or violate React's rules and should normally be fixed.";
   if (severity === "warning")
     return "This pattern is very likely to be a real issue in the code shown and is normally worth fixing.";
   return "This may be intentional. Doctor found a plausible improvement, but the right choice depends on how this value or pattern is meant to affect rendering.";
 }
 function whyRuleSpecificContext(diagnostic) {
   if (diagnostic.rule === "react-luau/prefer-binding-over-state-candidate") {
-    return "A Binding can update visual values without rerendering the component. Here, at least one use may be structural or otherwise depend on a rerender, so replacing all of the state with a Binding is not automatically safe.";
+    return "A Binding can update visual values without rerendering the component. Doctor found an external reactive mirror or presentation branch, but it cannot fully prove the source's update pressure, conversion safety, or that every consumer can leave React state.";
   }
   if (diagnostic.rule === "react-luau/prefer-binding-over-state") {
     return "A Binding can update these values without rerendering the component, and every use of the value only needs that kind of update. React state is therefore doing extra reconciliation work here.";
@@ -12498,7 +13945,7 @@ function whyRuleSpecificContext(diagnostic) {
 }
 function whyRuleCaveat(diagnostic) {
   if (diagnostic.rule === "react-luau/prefer-binding-over-state-candidate") {
-    return "Keep React state when the value genuinely changes component structure, conditional children, hook inputs, or other behavior that must go through React reconciliation. Mixed cases often benefit from splitting visual Binding updates from a smaller structural state value.";
+    return "Keep React state when the external event represents semantic UI state, changes component structure, drives hook/effect behavior, or is infrequent enough that a Binding would only make the code harder to follow. Mixed cases can split visual Binding updates from the smaller value that truly needs reconciliation.";
   }
   if (diagnostic.rule === "react-luau/prefer-binding-over-state") {
     return "Keep React state if changing the value must rebuild component structure rather than only update Roblox Instance properties or other Binding-aware consumers.";
@@ -12818,5 +14265,5 @@ ${renderUpdateNotice(update.current, update.latest, colorized)}
 }
 main();
 
-//# debugId=32BB85E7FBDD457564756E2164756E21
+//# debugId=C71A438CE8D868EF64756E2164756E21
 //# sourceMappingURL=cli.js.map