@colrealpro/react-luau-doctor 0.19.0 → 0.19.1

package/dist/scan-worker.js

@@ -19,6 +19,19 @@ function walk(node) {
   }
   return result;
 }
+function parameterBindingNames(parameters) {
+  if (!parameters)
+    return [];
+  const result = [];
+  for (const parameter of parameters.namedChildren) {
+    if (parameter.type !== "parameter")
+      continue;
+    const identifier = parameter.namedChildren.find((child) => child.type === "identifier");
+    if (identifier)
+      result.push(identifier.text);
+  }
+  return [...new Set(result)];
+}
 function rootIdentifier(text) {
   const match = text.trim().match(/^([A-Za-z_][A-Za-z0-9_]*)/);
   return match?.[1] ?? null;
@@ -147,6 +160,63 @@ function createRuleContext(file) {
   };
 }
 
+// src/module-resolution.ts
+import path from "path";
+function normalizeRelative(value) {
+  return value.split(path.sep).join("/");
+}
+function moduleKeys(relativePath) {
+  let normalized = normalizeRelative(relativePath).replace(/\.(?:lua|luau)$/i, "");
+  if (normalized.endsWith("/init"))
+    normalized = normalized.slice(0, -"/init".length);
+  const segments = normalized.split("/").filter(Boolean);
+  if (segments[0]?.toLowerCase() === "src")
+    segments.shift();
+  const keys = new Set;
+  for (let index = 0;index < segments.length; index += 1) {
+    const suffix = segments.slice(index).join(".").toLowerCase();
+    if (suffix)
+      keys.add(suffix);
+  }
+  return [...keys];
+}
+function normalizeRequireTarget(text) {
+  return (text.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? []).join(".").toLowerCase();
+}
+function buildUniqueFeatureAliases(modules, featureByModuleId) {
+  const owners = new Map;
+  for (const module of modules) {
+    for (const key of module.keys) {
+      const ids = owners.get(key) ?? new Set;
+      ids.add(module.id);
+      owners.set(key, ids);
+    }
+  }
+  const aliases = new Map;
+  for (const module of modules) {
+    const value = featureByModuleId.get(module.id);
+    if (value === undefined)
+      continue;
+    for (const key of module.keys) {
+      const ids = owners.get(key);
+      if (ids?.size === 1 && ids.has(module.id))
+        aliases.set(key, value);
+    }
+  }
+  return aliases;
+}
+function resolveModuleReference(target, aliases) {
+  let candidate = target;
+  while (true) {
+    if (aliases.has(candidate))
+      return aliases.get(candidate);
+    const separator = candidate.indexOf(".");
+    if (separator < 0)
+      return null;
+    candidate = candidate.slice(separator + 1);
+  }
+}
+
 // src/ast/react-model.ts
 var REACT_HOOKS = new Set([
   "useState",
@@ -177,18 +247,7 @@ var INSTANCE_FACTORY_MEMBERS = new Set([
 ]);
 var STABLE_ENGINE_FACTORY_MEMBERS = new Set(["GetMouse", "GetService"]);
 function identifiersFromParameters(node) {
-  if (!node)
-    return [];
-  const result = [];
-  for (const child of walk(node)) {
-    if (child.type !== "identifier")
-      continue;
-    const parentType = child.parent?.type;
-    if (parentType === "parameters" || parentType === "parameter" || parentType === "typed_identifier") {
-      result.push(child.text);
-    }
-  }
-  return [...new Set(result)];
+  return parameterBindingNames(node);
 }
 function getFunctionName(node) {
   if (node.type === "function_declaration") {
@@ -242,15 +301,19 @@ function directCalls(node) {
 function hasDirectCreateElementCall(node, aliases, reactNamespaces, reactRobloxNamespaces) {
   return directCalls(node).some((call) => {
     const name = call.childForFieldName("name")?.text ?? "";
-    const path = resolvePath(name, aliases, reactNamespaces, reactRobloxNamespaces);
-    return path === "React.createElement" || path === "ReactRoblox.createPortal";
+    const path2 = resolvePath(name, aliases, reactNamespaces, reactRobloxNamespaces);
+    return path2 === "React.createElement" || path2 === "ReactRoblox.createPortal";
   });
 }
-function hasDirectHookCall(node, aliases, reactNamespaces, reactRobloxNamespaces) {
+function hasDirectHookCall(node, aliases, reactNamespaces, reactRobloxNamespaces, importedHookKinds) {
   return directCalls(node).some((call) => {
     const name = call.childForFieldName("name")?.text ?? "";
-    const path = resolvePath(name, aliases, reactNamespaces, reactRobloxNamespaces);
-    const final = path.split(/[.:]/).at(-1) ?? "";
+    const path2 = resolvePath(name, aliases, reactNamespaces, reactRobloxNamespaces);
+    const normalizedName = normalizeExpressionText(name);
+    const importedKind = importedHookKinds.get(normalizedName);
+    if (importedKind !== undefined)
+      return importedKind;
+    const final = path2.split(/[.:]/).at(-1) ?? "";
     return /^use[A-Z0-9_]/.test(final);
   });
 }
@@ -336,8 +399,8 @@ function isSyntacticallyStableInitializer(node) {
     return false;
   return ["nil", "true", "false", "number", "string", "string_content"].includes(node.type) || /^(?:nil|true|false|-?\d+(?:\.\d+)?(?:e[+-]?\d+)?)$/i.test(node.text.trim());
 }
-function finalCallMember(path) {
-  return path.split(/[.:]/).at(-1) ?? path;
+function finalCallMember(path2) {
+  return path2.split(/[.:]/).at(-1) ?? path2;
 }
 function expressionCreatesInstance(node, aliases, reactNamespaces, reactRobloxNamespaces) {
   if (!node)
@@ -349,8 +412,8 @@ function expressionCreatesInstance(node, aliases, reactNamespaces, reactRobloxNa
     if (candidate.type !== "function_call")
       continue;
     const rawPath = candidate.childForFieldName("name")?.text ?? "";
-    const path = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
-    if (path === "Instance.new" || INSTANCE_FACTORY_MEMBERS.has(finalCallMember(path)))
+    const path2 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+    if (path2 === "Instance.new" || INSTANCE_FACTORY_MEMBERS.has(finalCallMember(path2)))
       return true;
   }
   return false;
@@ -362,8 +425,8 @@ function expressionIsStableEngineObject(node, aliases, reactNamespaces, reactRob
   if (calls.length !== 1)
     return false;
   const rawPath = calls[0].childForFieldName("name")?.text ?? "";
-  const path = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
-  return STABLE_ENGINE_FACTORY_MEMBERS.has(finalCallMember(path));
+  const path2 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+  return STABLE_ENGINE_FACTORY_MEMBERS.has(finalCallMember(path2));
 }
 function memoReturnsInstance(callback, aliases, reactNamespaces, reactRobloxNamespaces) {
   if (!callback || callback.type !== "function_definition")
@@ -379,7 +442,21 @@ function memoReturnsInstance(callback, aliases, reactNamespaces, reactRobloxName
 function isEmptyDependencyTable(node) {
   return Boolean(node?.type === "table_constructor" && node.namedChildren.every((child) => child.type !== "field"));
 }
-function buildReactModel(root) {
+function importedHookKinds(declarations, project) {
+  const result = new Map;
+  if (!project)
+    return result;
+  for (const declaration of declarations) {
+    const match = declaration.text.match(/^\s*local\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*require\s*\((.*?)\)\s*$/s);
+    if (!match || !/^use[A-Z0-9_]/.test(match[1]))
+      continue;
+    const kind = resolveModuleReference(normalizeRequireTarget(match[2]), project.reactHookModules);
+    if (kind !== null)
+      result.set(match[1], kind);
+  }
+  return result;
+}
+function buildReactModel(root, project) {
   const reactNamespaces = new Set;
   const reactRobloxNamespaces = new Set;
   const aliases = new Map;
@@ -395,6 +472,7 @@ function buildReactModel(root) {
   const instanceVariablesByFunction = new Map;
   const allNodes = [...walk(root)];
   const declarations = allNodes.filter((node) => node.type === "variable_declaration");
+  const projectHookKinds = importedHookKinds(declarations, project);
   let isReactFile = false;
   for (const declaration of declarations) {
     const text = declaration.text;
@@ -469,7 +547,7 @@ function buildReactModel(root) {
     if (!isReactFile || !info.body || info.isHook)
       continue;
     const simplePascalName = Boolean(info.name && /^[A-Z][A-Za-z0-9_]*$/.test(info.name));
-    const hasHooks = hasDirectHookCall(info.body, aliases, reactNamespaces, reactRobloxNamespaces);
+    const hasHooks = hasDirectHookCall(info.body, aliases, reactNamespaces, reactRobloxNamespaces, projectHookKinds);
     const renders = hasDirectCreateElementCall(info.body, aliases, reactNamespaces, reactRobloxNamespaces);
     if (hasHooks || isMemoWrappedFunction(info.node, aliases, reactNamespaces) || simplePascalName && renders) {
       info.isComponent = true;
@@ -481,8 +559,8 @@ function buildReactModel(root) {
     if (call.type !== "function_call")
       continue;
     const rawPath = call.childForFieldName("name")?.text ?? "";
-    const path = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
-    if (path !== "React.createElement")
+    const path2 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+    if (path2 !== "React.createElement")
       continue;
     const element = call.childForFieldName("arguments")?.namedChildren[0]?.text.trim() ?? "";
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(element))
@@ -517,13 +595,13 @@ function buildReactModel(root) {
     if (!call)
       continue;
     const rawPath = call.childForFieldName("name")?.text ?? "";
-    const path = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+    const path2 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
     const args = call.childForFieldName("arguments")?.namedChildren ?? [];
-    if (path === "React.joinBindings" && names.length >= 1) {
+    if (path2 === "React.joinBindings" && names.length >= 1) {
       stableVariables.add(names[0]);
       addScopedVariable(stableVariablesByFunction, owner, names[0]);
       addScopedVariable(externalMutableVariablesByFunction, owner, names[0]);
-    } else if (path === "React.useState" && names.length >= 2) {
+    } else if (path2 === "React.useState" && names.length >= 2) {
       const [valueName, setterName] = names;
       stateSetters.set(setterName, valueName);
       stateValues.set(valueName, setterName);
@@ -537,10 +615,10 @@ function buildReactModel(root) {
         initializer: args[0] ?? null,
         owner
       });
-    } else if (path === "React.useReducer" && names.length >= 2) {
+    } else if (path2 === "React.useReducer" && names.length >= 2) {
       stableVariables.add(names[1]);
       addScopedVariable(stableVariablesByFunction, owner, names[1]);
-    } else if (path === "React.useBinding" && names.length >= 1) {
+    } else if (path2 === "React.useBinding" && names.length >= 1) {
       stableVariables.add(names[0]);
       addScopedVariable(stableVariablesByFunction, owner, names[0]);
       if (names.length >= 2) {
@@ -548,7 +626,7 @@ function buildReactModel(root) {
         bindingSetters.add(names[1]);
         addScopedVariable(stableVariablesByFunction, owner, names[1]);
       }
-    } else if (path === "React.useMemo" && names.length >= 1) {
+    } else if (path2 === "React.useMemo" && names.length >= 1) {
       if (isEmptyDependencyTable(args[1])) {
         stableVariables.add(names[0]);
         addScopedVariable(stableVariablesByFunction, owner, names[0]);
@@ -557,16 +635,16 @@ function buildReactModel(root) {
         addScopedVariable(externalMutableVariablesByFunction, owner, names[0]);
         addScopedVariable(instanceVariablesByFunction, owner, names[0]);
       }
-    } else if (path === "React.useCallback" && names.length >= 1 && isEmptyDependencyTable(args[1])) {
+    } else if (path2 === "React.useCallback" && names.length >= 1 && isEmptyDependencyTable(args[1])) {
       stableVariables.add(names[0]);
       addScopedVariable(stableVariablesByFunction, owner, names[0]);
-    } else if (path === "React.useRef" && names.length >= 1) {
+    } else if (path2 === "React.useRef" && names.length >= 1) {
       stableVariables.add(names[0]);
       refVariables.add(names[0]);
       addScopedVariable(stableVariablesByFunction, owner, names[0]);
       addScopedVariable(refVariablesByFunction, owner, names[0]);
     } else {
-      const final = path.split(/[.:]/).at(-1) ?? "";
+      const final = path2.split(/[.:]/).at(-1) ?? "";
       if (/^use[A-Z0-9_]/.test(final)) {
         for (const name of names.slice(1)) {
           if (!STABLE_CUSTOM_HOOK_RETURN.test(name))
@@ -590,11 +668,11 @@ function buildReactModel(root) {
     if (!expression || expression.type !== "function_call")
       continue;
     const rawPath = expression.childForFieldName("name")?.text ?? "";
-    const path = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
-    if (path === "React.useState" && names.length >= 2) {
+    const path2 = resolvePath(rawPath, aliases, reactNamespaces, reactRobloxNamespaces);
+    if (path2 === "React.useState" && names.length >= 2) {
       stableVariables.add(names[1]);
       addScopedVariable(stableVariablesByFunction, owner, names[1]);
-    } else if (path === "React.useBinding" && names.length >= 1) {
+    } else if (path2 === "React.useBinding" && names.length >= 1) {
       stableVariables.add(names[0]);
       addScopedVariable(stableVariablesByFunction, owner, names[0]);
       addScopedVariable(externalMutableVariablesByFunction, owner, names[0]);
@@ -654,14 +732,14 @@ function buildReactModel(root) {
 
 // src/config.ts
 import fs from "fs";
-import path from "path";
+import path2 from "path";
 var CONFIG_NAME = "react-luau-doctor.config.json";
 var SEVERITIES = new Set(["off", "error", "warning", "suggestion"]);
 var SCOPES = new Set(["full", "files", "changed", "lines"]);
 var BLOCKING_LEVELS = new Set(["error", "warning", "none"]);
 var CATEGORIES = new Set(["Correctness", "Hooks", "Effects", "Performance", "Roblox", "Architecture"]);
 function loadConfigWithSource(root) {
-  const candidate = path.join(root, CONFIG_NAME);
+  const candidate = path2.join(root, CONFIG_NAME);
   if (!fs.existsSync(candidate))
     return { config: {}, filename: null };
   const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
@@ -721,14 +799,14 @@ function effectiveSeverity(defaultSeverity, ruleId, config) {
 }
 function configPathForWrite(root) {
   const loaded = loadConfigWithSource(root);
-  return loaded.filename ?? path.join(root, CONFIG_NAME);
+  return loaded.filename ?? path2.join(root, CONFIG_NAME);
 }
 function writeConfig(root, update) {
   const loaded = loadConfigWithSource(root);
   const next = update(structuredClone(loaded.config));
   validateConfig(next, loaded.filename ?? CONFIG_NAME);
   const filename = loaded.filename ?? configPathForWrite(root);
-  fs.mkdirSync(path.dirname(filename), { recursive: true });
+  fs.mkdirSync(path2.dirname(filename), { recursive: true });
   fs.writeFileSync(filename, `${JSON.stringify(next, null, 2)}
 `);
   return filename;
@@ -808,7 +886,7 @@ function createInlineSuppressionChecker(source) {
 
 // src/parser.ts
 import fs2 from "fs";
-import path2 from "path";
+import path3 from "path";
 import { Language, Parser } from "web-tree-sitter";
 
 // src/parser-compat.ts
@@ -947,6 +1025,23 @@ function isCode(mask, start, end = start + 1) {
   }
   return true;
 }
+function matchingCodeDelimiterEnd(source, mask, start, opener, closer) {
+  if (source[start] !== opener || !isCode(mask, start))
+    return null;
+  let depth = 0;
+  for (let cursor = start;cursor < source.length; cursor += 1) {
+    if (!isCode(mask, cursor))
+      continue;
+    if (source[cursor] === opener)
+      depth += 1;
+    else if (source[cursor] === closer) {
+      depth -= 1;
+      if (depth === 0)
+        return cursor + 1;
+    }
+  }
+  return null;
+}
 function maskTypeAliases(source, mask) {
   const { lines, offsets } = lineData(source);
   const ranges = [];
@@ -1154,6 +1249,89 @@ function genericFunctionParameterRanges(source, mask) {
   }
   return ranges;
 }
+function genericFunctionReturnPrefixRanges(source, mask) {
+  const ranges = [];
+  const functionPattern = /\bfunction\b/g;
+  for (const match of source.matchAll(functionPattern)) {
+    const start = match.index;
+    if (!isCode(mask, start, start + match[0].length))
+      continue;
+    let cursor = start + match[0].length;
+    let genericDepth = 0;
+    while (cursor < source.length) {
+      if (!isCode(mask, cursor)) {
+        cursor += 1;
+        continue;
+      }
+      if (source[cursor] === "<")
+        genericDepth += 1;
+      else if (source[cursor] === ">" && genericDepth > 0)
+        genericDepth -= 1;
+      else if (source[cursor] === "(" && genericDepth === 0)
+        break;
+      cursor += 1;
+    }
+    if (source[cursor] !== "(")
+      continue;
+    const parameterEnd = matchingCodeDelimiterEnd(source, mask, cursor, "(", ")");
+    if (parameterEnd === null)
+      continue;
+    cursor = parameterEnd;
+    while (cursor < source.length && /\s/.test(source[cursor]))
+      cursor += 1;
+    if (source[cursor] !== ":" || !isCode(mask, cursor))
+      continue;
+    cursor += 1;
+    while (cursor < source.length && /\s/.test(source[cursor]))
+      cursor += 1;
+    if (source[cursor] !== "<")
+      continue;
+    const rangeStart = cursor;
+    const genericEnd = matchingCodeDelimiterEnd(source, mask, cursor, "<", ">");
+    if (genericEnd === null)
+      continue;
+    cursor = genericEnd;
+    while (cursor < source.length && /\s/.test(source[cursor]))
+      cursor += 1;
+    const typeParametersEnd = matchingCodeDelimiterEnd(source, mask, cursor, "(", ")");
+    if (typeParametersEnd === null)
+      continue;
+    cursor = typeParametersEnd;
+    while (cursor < source.length && /\s/.test(source[cursor]))
+      cursor += 1;
+    if (source.slice(cursor, cursor + 2) !== "->" || !isCode(mask, cursor, cursor + 2))
+      continue;
+    cursor += 2;
+    while (cursor < source.length && /[ \t]/.test(source[cursor]))
+      cursor += 1;
+    ranges.push({ start: rangeStart, end: cursor });
+  }
+  return ranges;
+}
+function normalizeLocalTypeofAnnotations(source, mask) {
+  const replacements = [];
+  const pattern = /\blocal\s+[A-Za-z_][A-Za-z0-9_]*\s*:\s*typeof\s*\(/g;
+  for (const match of source.matchAll(pattern)) {
+    const matchStart = match.index;
+    if (!isCode(mask, matchStart, matchStart + match[0].length))
+      continue;
+    const typeofStart = matchStart + match[0].lastIndexOf("typeof");
+    const open = source.indexOf("(", typeofStart + 6);
+    if (open < 0)
+      continue;
+    const end = matchingCodeDelimiterEnd(source, mask, open, "(", ")");
+    if (end === null)
+      continue;
+    const original = source.slice(typeofStart, end);
+    const padding = blankPreservingUtf8Bytes(original).slice(3);
+    replacements.push({ start: typeofStart, end, value: `any${padding}` });
+  }
+  let output = source;
+  for (const replacement of replacements.sort((a, b) => b.start - a.start)) {
+    output = `${output.slice(0, replacement.start)}${replacement.value}${output.slice(replacement.end)}`;
+  }
+  return output;
+}
 function normalizeGenericTypePackUses(source, mask) {
   const declarationRanges = genericFunctionParameterRanges(source, mask);
   const replacements = [];
@@ -1214,13 +1392,15 @@ function parserCompatibleSource(source) {
   const keywordCompatible = replaceContextualKeywords(source, mask);
   const literalCompatible = normalizeIntegerLiteralSuffixes(keywordCompatible, mask);
   const packCompatible = normalizeGenericTypePackUses(literalCompatible, mask);
+  const typeofCompatible = normalizeLocalTypeofAnnotations(packCompatible, mask);
   const ranges = [
     ...maskTypeAliases(source, mask),
     ...maskTypeLevelBlocks(source, mask),
     ...attributeRanges(source, mask),
-    ...explicitTypeArgumentRanges(source, mask)
+    ...explicitTypeArgumentRanges(source, mask),
+    ...genericFunctionReturnPrefixRanges(source, mask)
   ];
-  const masked = applyMasks(packCompatible, ranges);
+  const masked = applyMasks(typeofCompatible, ranges);
   return masked.replace(/^(\s*)type(?=\s*(?:\+=|-=|\*=|\/=|%=|\^=|\.\.=|=(?!=)))/gm, "$1_typ");
 }
 
@@ -1228,7 +1408,7 @@ function parserCompatibleSource(source) {
 var parserPromise = null;
 async function createParser() {
   await Parser.init();
-  const grammarPath = path2.resolve(import.meta.dir, "../vendor/tree-sitter-luau.wasm");
+  const grammarPath = path3.resolve(import.meta.dir, "../vendor/tree-sitter-luau.wasm");
   const grammar = new Uint8Array(fs2.readFileSync(grammarPath));
   const language = await Language.load(grammar);
   const parser = new Parser;
@@ -1353,8 +1533,8 @@ var INSTANCE_FACTORY_MEMBERS2 = new Set([
   "GetService",
   "WaitForChild"
 ]);
-function finalCallMember2(path3) {
-  return path3.split(/[.:]/).at(-1) ?? path3;
+function finalCallMember2(path4) {
+  return path4.split(/[.:]/).at(-1) ?? path4;
 }
 function declarationInitializer(node, name) {
   if (node.type !== "variable_declaration")
@@ -1422,8 +1602,8 @@ function expressionHasRobloxOrigin(expression, from, context, seen) {
   seen.add(root);
   return expressionHasRobloxOrigin(visibleInitializer(root, from, context), from, context, seen);
 }
-function hasRobloxReceiver(path3, call, context) {
-  const normalized = path3.replace(/\s+/g, "");
+function hasRobloxReceiver(path4, call, context) {
+  const normalized = path4.replace(/\s+/g, "");
   if (/^(?:game|workspace|script)(?:[.:]|$)/.test(normalized))
     return true;
   const root = normalized.match(/^([A-Za-z_][A-Za-z0-9_]*)/)?.[1];
@@ -1572,8 +1752,8 @@ function sourceHasHighFrequencyRobloxEvent(source) {
   }
   return false;
 }
-function knownYieldReason(path3, call, context) {
-  const normalized = path3.replace(/\s+/g, "");
+function knownYieldReason(path4, call, context) {
+  const normalized = path4.replace(/\s+/g, "");
   if (normalized === "task.wait")
     return "task.wait";
   if (normalized === "coroutine.yield")
@@ -1593,15 +1773,15 @@ function functionYieldPoint(node, context) {
     const owner = context.model.functionByNode.get(node.id);
     if (owner && nearest !== owner)
       continue;
-    const path3 = context.resolveCallPath(context.getCallPath(candidate) ?? "");
-    const reason = knownYieldReason(path3, candidate, context);
+    const path4 = context.resolveCallPath(context.getCallPath(candidate) ?? "");
+    const reason = knownYieldReason(path4, candidate, context);
     if (reason)
       return { call: candidate, reason };
   }
   return null;
 }
-function mutableDependencyBase(path3, externallyMutableRoots) {
-  const normalized = path3.replace(/\s+/g, "");
+function mutableDependencyBase(path4, externallyMutableRoots) {
+  const normalized = path4.replace(/\s+/g, "");
   if (/\.current(?:\.|$)/.test(normalized))
     return "";
   const segments = normalized.split(".");
@@ -1627,8 +1807,8 @@ var CONDITIONAL_TYPES = new Set([
   "while_statement",
   "repeat_statement"
 ]);
-function isHookPath(path3) {
-  const final = path3.split(/[.:]/).at(-1) ?? "";
+function isHookPath(path4) {
+  const final = path4.split(/[.:]/).at(-1) ?? "";
   return /^use[A-Z0-9_]/.test(final);
 }
 function assignmentTargetNode(statement) {
@@ -1704,8 +1884,8 @@ function functionInfoForNode(context, node) {
 function stateBindingsFor(context, owner) {
   return context.model.stateBindings.filter((binding) => binding.owner === owner);
 }
-function isEffectPath(path3) {
-  return path3 === "React.useEffect" || path3 === "React.useLayoutEffect";
+function isEffectPath(path4) {
+  return path4 === "React.useEffect" || path4 === "React.useLayoutEffect";
 }
 function dependencyExpressions(node) {
   if (!node || node.type !== "table_constructor")
@@ -1960,11 +2140,11 @@ function isManagedByCleanupContainer(call, context, callback) {
   let current = call.parent;
   while (current && !sameNode(current, callback.node)) {
     if (current.type === "function_call") {
-      const path3 = context.getCallPath(current) ?? "";
-      if (ALWAYS_MANAGED_METHOD.test(path3))
+      const path4 = context.getCallPath(current) ?? "";
+      if (ALWAYS_MANAGED_METHOD.test(path4))
         return true;
-      if (GENERIC_MANAGER_METHOD.test(path3)) {
-        const receiver = path3.split(":", 1)[0] ?? "";
+      if (GENERIC_MANAGER_METHOD.test(path4)) {
+        const receiver = path4.split(":", 1)[0] ?? "";
         if (MANAGER_ROOT.test(receiver))
           return true;
       }
@@ -2069,10 +2249,10 @@ function isCleanupOnlyTask(callbackNode, context) {
     return false;
   return calls.every((call) => /:(?:Destroy|Disconnect)$/.test(context.getCallPath(call) ?? ""));
 }
-function taskSeverity(path3, call, taskCallback, yieldPoint, context) {
-  if (path3 === "task.defer" && !yieldPoint)
+function taskSeverity(path4, call, taskCallback, yieldPoint, context) {
+  if (path4 === "task.defer" && !yieldPoint)
     return "suggestion";
-  if (path3 === "task.delay" && !yieldPoint) {
+  if (path4 === "task.delay" && !yieldPoint) {
     if (isCleanupOnlyTask(taskCallback, context))
       return "suggestion";
     const delay = numericTaskDelay(call, context);
@@ -2122,10 +2302,10 @@ end`,
     };
   }
   if ([...labels].every((label) => label.includes("task"))) {
-    const path3 = context.resolveCallPath(context.getCallPath(first.call) ?? "task.delay");
-    const taskCall = path3 === "task.defer" ? `task.defer(function()
+    const path4 = context.resolveCallPath(context.getCallPath(first.call) ?? "task.delay");
+    const taskCall = path4 === "task.defer" ? `task.defer(function()
 	doWork()
-end)` : path3 === "task.spawn" ? `task.spawn(function()
+end)` : path4 === "task.spawn" ? `task.spawn(function()
 	doWork()
 end)` : `task.delay(delaySeconds, function()
 	doWork()
@@ -2178,9 +2358,9 @@ end`,
 }
 function classifyResource(call, context, callback) {
   const rawPath = context.getCallPath(call) ?? "";
-  const path3 = context.resolveCallPath(rawPath);
+  const path4 = context.resolveCallPath(rawPath);
   const variable = assignedVariableName(call, callback);
-  const finalMember = path3.split(/[.:]/).at(-1) ?? path3;
+  const finalMember = path4.split(/[.:]/).at(-1) ?? path4;
   if (/:Connect$/.test(rawPath)) {
     const ownerExpression = connectionOwnerExpression(rawPath);
     const ownerIsInstance = isProvenInstanceExpression(ownerExpression, call, context, callback);
@@ -2249,7 +2429,7 @@ function classifyResource(call, context, callback) {
       }
     };
   }
-  if (path3 === "ReactRoblox.createRoot") {
+  if (path4 === "ReactRoblox.createRoot") {
     return {
       call,
       label: "React root",
@@ -2259,17 +2439,17 @@ function classifyResource(call, context, callback) {
       }
     };
   }
-  if (path3 === "task.delay" || path3 === "task.defer" || path3 === "task.spawn") {
+  if (path4 === "task.delay" || path4 === "task.defer" || path4 === "task.spawn") {
     const taskCallback = taskCallbackNode(call, context, callback);
     const yieldPoint = taskCallback ? functionYieldPoint(taskCallback, context) : null;
-    const outlivesEffect = path3 !== "task.spawn" || Boolean(yieldPoint);
+    const outlivesEffect = path4 !== "task.spawn" || Boolean(yieldPoint);
     if (!outlivesEffect)
       return null;
     return {
       call,
-      label: path3 === "task.spawn" ? "yielding spawned task" : path3 === "task.defer" ? "deferred task" : "delayed task",
+      label: path4 === "task.spawn" ? "yielding spawned task" : path4 === "task.defer" ? "deferred task" : "delayed task",
       detail: yieldPoint ? `The task can outlive the effect because it yields at ${yieldPoint.reason}.` : "The task is scheduled to run after the effect callback can finish.",
-      severity: taskSeverity(path3, call, taskCallback, yieldPoint, context),
+      severity: taskSeverity(path4, call, taskCallback, yieldPoint, context),
       variable,
       cleanupMatches(text, name) {
         if (name) {
@@ -2296,8 +2476,8 @@ var effectNeedsCleanup = {
       const rawPath = context.getCallPath(call);
       if (!rawPath)
         continue;
-      const path3 = context.resolveCallPath(rawPath);
-      if (path3 !== "React.useEffect" && path3 !== "React.useLayoutEffect")
+      const path4 = context.resolveCallPath(rawPath);
+      if (path4 !== "React.useEffect" && path4 !== "React.useLayoutEffect")
         continue;
       const callbackNode = firstFunctionArgument(context, call);
       const callback = functionInfoForNode(context, callbackNode);
@@ -2351,10 +2531,22 @@ function ownerForHook(context, call) {
   const owner = context.nearestFunction(call);
   return owner && (owner.isComponent || owner.isHook) ? owner : null;
 }
+function effectCallbackWithoutDeps(context, call) {
+  const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+  if (!isEffectPath(path4))
+    return null;
+  const args = context.callArguments(call);
+  const callback = args[0];
+  if (callback?.type !== "function_definition")
+    return null;
+  if (args.length < 2 || args[1]?.type === "nil")
+    return callback;
+  return null;
+}
 function callbackAndDeps(context, call) {
-  const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
+  const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
   const args = context.callArguments(call);
-  if (path3 === "React.useImperativeHandle") {
+  if (path4 === "React.useImperativeHandle") {
     const callback2 = args[1];
     const deps2 = args[2];
     if (callback2?.type === "function_definition" && deps2?.type === "table_constructor")
@@ -2384,8 +2576,8 @@ function hasExternalSubscription(node, context) {
   for (const child of context.walk(node)) {
     if (child.type !== "function_call")
       continue;
-    const path3 = context.getCallPath(child) ?? "";
-    if (/:Connect$/.test(path3) || /BindToRenderStep$/.test(path3) || /:BindAction(?:AtPriority)?$/.test(path3))
+    const path4 = context.getCallPath(child) ?? "";
+    if (/:Connect$/.test(path4) || /BindToRenderStep$/.test(path4) || /:BindAction(?:AtPriority)?$/.test(path4))
       return true;
   }
   return false;
@@ -2419,6 +2611,33 @@ function setterCalledOutsideCallback(context, owner, callback, setterName) {
   }
   return false;
 }
+function guaranteedRepeatedStateChange(argument, stateName, context) {
+  if (argument.type === "table_constructor")
+    return true;
+  if (argument.type === "function_definition") {
+    const updater = functionInfoForNode(context, argument);
+    const previousName = updater?.parameters[0];
+    const returnStatement = updater?.body?.namedChildren.find((child) => child.type === "return_statement");
+    const returnValue = returnStatement?.namedChildren[0];
+    if (previousName && returnValue && guaranteedRepeatedStateChange(returnValue, previousName, context))
+      return true;
+    return false;
+  }
+  const text = argument.text.trim();
+  const escaped = stateName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  if (new RegExp(`^not\\s+${escaped}$`).test(text))
+    return true;
+  if (new RegExp(`^${escaped}\\s*[+-]\\s*(?:[1-9]\\d*(?:\\.\\d+)?|0?\\.\\d*[1-9]\\d*)$`).test(text))
+    return true;
+  if (new RegExp(`^(?:[1-9]\\d*(?:\\.\\d+)?|0?\\.\\d*[1-9]\\d*)\\s*\\+\\s*${escaped}$`).test(text))
+    return true;
+  if (argument.type === "function_call") {
+    const path4 = context.resolveCallPath(context.getCallPath(argument) ?? "");
+    if (path4 === "table.clone" || path4 === "table.create" || path4 === "table.pack")
+      return true;
+  }
+  return false;
+}
 function freshDependencyKind(node, owner) {
   if (node.type === "table_constructor")
     return "table";
@@ -2441,8 +2660,8 @@ var noDerivedStateEffect = {
   run(context) {
     const diagnostics = [];
     for (const call of context.findCalls()) {
-      const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (!isEffectPath(path3))
+      const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (!isEffectPath(path4))
         continue;
       const owner = ownerForHook(context, call);
       const parts = callbackAndDeps(context, call);
@@ -2480,28 +2699,48 @@ var noSelfUpdatingEffect = {
   id: "react-luau/no-self-updating-effect",
   category: "Effects",
   severity: "warning",
-  description: "Effects should not unconditionally update state that is also one of their dependencies.",
+  description: "Effects should not unconditionally update state in a way that schedules themselves again.",
   run(context) {
     const diagnostics = [];
     for (const call of context.findCalls()) {
-      const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (!isEffectPath(path3))
+      const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (!isEffectPath(path4))
         continue;
       const owner = ownerForHook(context, call);
+      if (!owner)
+        continue;
       const parts = callbackAndDeps(context, call);
-      if (!owner || !parts)
+      if (parts) {
+        const deps = parseDependencyRoots(parts.deps);
+        for (const binding of stateBindingsFor(context, owner)) {
+          if (!deps.has(binding.valueName))
+            continue;
+          for (const setterCall of directTopLevelCalls(context, parts.callback)) {
+            if (context.getCallPath(setterCall) !== binding.setterName)
+              continue;
+            diagnostics.push({
+              node: callNameNode(setterCall),
+              message: `${binding.setterName}() updates ${binding.valueName}, which is also in this effect's dependency table.`,
+              help: "Guard the update so it converges, move it to the originating event, or derive the value during render."
+            });
+          }
+        }
+        continue;
+      }
+      const callback = effectCallbackWithoutDeps(context, call);
+      if (!callback)
         continue;
-      const deps = parseDependencyRoots(parts.deps);
       for (const binding of stateBindingsFor(context, owner)) {
-        if (!deps.has(binding.valueName))
-          continue;
-        for (const setterCall of directTopLevelCalls(context, parts.callback)) {
+        for (const setterCall of directTopLevelCalls(context, callback)) {
           if (context.getCallPath(setterCall) !== binding.setterName)
             continue;
+          const argument = context.callArguments(setterCall)[0];
+          if (!argument || !guaranteedRepeatedStateChange(argument, binding.valueName, context))
+            continue;
           diagnostics.push({
             node: callNameNode(setterCall),
-            message: `${binding.setterName}() updates ${binding.valueName}, which is also in this effect's dependency table.`,
-            help: "Guard the update so it converges, move it to the originating event, or derive the value during render."
+            message: `${binding.setterName}() unconditionally changes ${binding.valueName} in an effect that runs after every render.`,
+            help: "Add a dependency table or convergence guard, move the update to the event that owns it, or derive the value during render."
           });
         }
       }
@@ -2517,8 +2756,8 @@ var noEffectWithFreshDeps = {
   run(context) {
     const diagnostics = [];
     for (const call of context.findCalls()) {
-      const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (!HOOKS_WITH_DEPS.has(path3))
+      const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (!HOOKS_WITH_DEPS.has(path4))
         continue;
       const owner = ownerForHook(context, call);
       const parts = callbackAndDeps(context, call);
@@ -2531,7 +2770,7 @@ var noEffectWithFreshDeps = {
         const label = dependency.type === "identifier" ? ` ${dependency.text}` : "";
         diagnostics.push({
           node: dependency,
-          message: `${path3} depends on${label || " an inline value"} that is a new ${kind} on every render.`,
+          message: `${path4} depends on${label || " an inline value"} that is a new ${kind} on every render.`,
           help: "Move the value inside the hook callback and depend on its simple inputs, or intentionally stabilize the value with useMemo/useCallback when identity is part of the contract."
         });
       }
@@ -2547,8 +2786,8 @@ var noMutableInDeps = {
   run(context) {
     const diagnostics = [];
     for (const call of context.findCalls()) {
-      const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (!HOOKS_WITH_DEPS.has(path3))
+      const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (!HOOKS_WITH_DEPS.has(path4))
         continue;
       const owner = ownerForHook(context, call);
       const parts = callbackAndDeps(context, call);
@@ -2641,23 +2880,61 @@ var HOOK_ARGUMENTS = new Map([
   ["React.useImperativeHandle", { callbackIndex: 1, depsIndex: 2 }]
 ]);
 function parameterNames2(functionNode) {
-  const names = new Set;
-  const parameters = functionNode.childForFieldName("parameters");
-  if (!parameters)
-    return names;
-  for (const node of parameters.namedChildren) {
-    for (const candidate of descendants(node)) {
-      if (candidate.type === "identifier")
-        names.add(candidate.text);
-    }
-  }
-  return names;
+  return new Set(parameterBindingNames(functionNode.childForFieldName("parameters")));
 }
 function* descendants(node) {
   yield node;
   for (const child of node.namedChildren)
     yield* descendants(child);
 }
+var TYPE_ONLY_NODES = new Set([
+  "type_definition",
+  "type_annotation",
+  "type_parameters",
+  "generic_type_list",
+  "generic_type",
+  "function_type",
+  "optional_type",
+  "object_type",
+  "union_type",
+  "intersection_type",
+  "tuple_type",
+  "singleton_type",
+  "variadic_type",
+  "variadic_type_pack"
+]);
+function isTypeOnlyChild(parent, child) {
+  if (TYPE_ONLY_NODES.has(child.type))
+    return true;
+  if (TYPE_ONLY_NODES.has(parent.type))
+    return true;
+  if (parent.type === "parameter") {
+    return !sameNode(parent.namedChildren.find((candidate) => candidate.type === "identifier"), child);
+  }
+  if (parent.type === "cast_expression" || parent.type === "type_cast_expression") {
+    return !sameNode(parent.namedChildren[0], child);
+  }
+  if (parent.type === "function_definition" || parent.type === "function_declaration") {
+    const name = parent.childForFieldName("name");
+    const parameters = parent.childForFieldName("parameters");
+    const body = parent.childForFieldName("body");
+    if (sameNode(child, name) || sameNode(child, parameters) || sameNode(child, body))
+      return false;
+    return true;
+  }
+  if (parent.type === "variable_list" && parent.parent?.parent?.type === "variable_declaration") {
+    return true;
+  }
+  return false;
+}
+function* runtimeDescendants(node) {
+  yield node;
+  for (const child of node.namedChildren) {
+    if (isTypeOnlyChild(node, child))
+      continue;
+    yield* runtimeDescendants(child);
+  }
+}
 function directBlockBindingNames(block, beforeIndex) {
   const names = new Set;
   for (const child of block.namedChildren) {
@@ -2733,8 +3010,8 @@ function rootIdentifierNode(node, root) {
   }
   return null;
 }
-function normalizeCapturedPath(path3, stableVariables, externallyMutableRoots) {
-  const normalized = normalizeExpressionText(path3);
+function normalizeCapturedPath(path4, stableVariables, externallyMutableRoots) {
+  const normalized = normalizeExpressionText(path4);
   const root = rootIdentifier(normalized);
   if (!root)
     return normalized;
@@ -2751,7 +3028,7 @@ function normalizeCapturedPath(path3, stableVariables, externallyMutableRoots) {
 }
 function capturedDependencyPaths(callback, available, stableVariables, externallyMutableRoots) {
   const captured = new Set;
-  for (const node of descendants(callback)) {
+  for (const node of runtimeDescendants(callback)) {
     if (node.type === "dot_index_expression" && outermostDotPath(node)) {
       const root = rootIdentifier(node.text);
       if (!root || !available.has(root) || GLOBALS.has(root) || stableVariables.has(root))
@@ -2820,8 +3097,81 @@ 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));
+}
+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(path4, aliases) {
+  let current = path4;
+  const visiting = new Set;
+  while (true) {
+    const root = rootIdentifier(current);
+    if (!root || visiting.has(root))
+      return current;
+    const source = aliases.get(root);
+    if (!source)
+      return current;
+    visiting.add(root);
+    current = `${source}${current.slice(root.length)}`;
+  }
+}
+function dependencyPathsWithAliases(node, aliases) {
+  const dependencies = dependencyPaths(node);
+  for (const dependency of [...dependencies]) {
+    const resolved = resolveAliasPath(dependency, aliases);
+    if (resolved !== dependency)
+      dependencies.add(resolved);
+  }
+  return dependencies;
 }
 var PURE_DERIVED_CALL = /^(?:math\.(?!random(?:seed)?$)[A-Za-z_][A-Za-z0-9_]*|string\.[A-Za-z_][A-Za-z0-9_]*|table\.(?:find|concat|clone|create|isfrozen)|(?:Color3|Vector2|Vector3|UDim|UDim2|CFrame|BrickColor|Rect|NumberRange|NumberSequence|ColorSequence|TweenInfo|Font|Ray|Region3|PhysicalProperties)\.[A-Za-z_][A-Za-z0-9_]*|[^:]+:(?:ToHSV|Lerp|Dot|Cross|FuzzyEq|Inverse|ToObjectSpace|ToWorldSpace))$/;
 function isPureDerivedExpression(node, context) {
@@ -2833,8 +3183,8 @@ function isPureDerivedExpression(node, context) {
     const rawPath = context.getCallPath(candidate);
     if (!rawPath)
       return false;
-    const path3 = normalizeExpressionText(context.resolveCallPath(rawPath));
-    if (!PURE_DERIVED_CALL.test(path3))
+    const path4 = normalizeExpressionText(context.resolveCallPath(rawPath));
+    if (!PURE_DERIVED_CALL.test(path4))
       return false;
   }
   return true;
@@ -2913,8 +3263,8 @@ function hasDynamicUnpackDependencies(node, context) {
       const rawPath = context.getCallPath(candidate);
       if (!rawPath)
         continue;
-      const path3 = normalizeExpressionText(context.resolveCallPath(rawPath));
-      if (path3 === "unpack" || path3 === "table.unpack")
+      const path4 = normalizeExpressionText(context.resolveCallPath(rawPath));
+      if (path4 === "unpack" || path4 === "table.unpack")
         return true;
     }
   }
@@ -2939,8 +3289,8 @@ function memoizedProducerDependencies(owner, context) {
       const rawPath = context.getCallPath(expression);
       if (!rawPath)
         continue;
-      const path3 = context.resolveCallPath(rawPath);
-      if (path3 !== "React.useMemo" && path3 !== "React.useCallback")
+      const path4 = context.resolveCallPath(rawPath);
+      if (path4 !== "React.useMemo" && path4 !== "React.useCallback")
         continue;
       const args = context.callArguments(expression);
       const deps = args[1];
@@ -2999,9 +3349,9 @@ function directCallsInExpression(node) {
   return calls;
 }
 function isCustomHookCall(call, context) {
-  const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-  const final = path3.split(/[.:]/).at(-1) ?? "";
-  return !path3.startsWith("React.") && /^use[A-Z0-9_]/.test(final);
+  const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+  const final = path4.split(/[.:]/).at(-1) ?? "";
+  return !path4.startsWith("React.") && /^use[A-Z0-9_]/.test(final);
 }
 var HANDLE_VALUE_NAME = /(?:ref|binding|tween|spring|motion|animation|controller|handle|connection|signal)$/i;
 var HANDLE_HOOK_NAME = /(?:Tween|Spring|Binding|Motion|Animated|Animation|Sound)$/i;
@@ -3011,8 +3361,8 @@ function isCalledAsFunction(owner, name, context) {
   for (const call of context.walk(owner.body)) {
     if (call.type !== "function_call")
       continue;
-    const path3 = normalizeExpressionText(context.getCallPath(call) ?? "");
-    if (path3 === name)
+    const path4 = normalizeExpressionText(context.getCallPath(call) ?? "");
+    if (path4 === name)
       return true;
   }
   return false;
@@ -3042,8 +3392,8 @@ function customHookDependencyHints(owner, context) {
         continue;
       const directHook = calls.find((call) => isCustomHookCall(call, context));
       if (directHook && expression.type === "function_call") {
-        const path3 = context.resolveCallPath(context.getCallPath(directHook) ?? "");
-        const final = path3.split(/[.:]/).at(-1) ?? "";
+        const path4 = context.resolveCallPath(context.getCallPath(directHook) ?? "");
+        const final = path4.split(/[.:]/).at(-1) ?? "";
         const likelyHandle = HANDLE_VALUE_NAME.test(name) || HANDLE_HOOK_NAME.test(final) || isCalledAsFunction(owner, name, context);
         if (likelyHandle) {
           hints.memberHandleRoots.add(name);
@@ -3053,14 +3403,14 @@ function customHookDependencyHints(owner, context) {
       }
       if (expression.type === "table_constructor") {
         const meaningfulCalls = calls.filter((call) => {
-          const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-          return !/^(?:Color3|Vector2|Vector3|UDim|UDim2|CFrame|TweenInfo|NumberSequence|ColorSequence)\./.test(path3);
+          const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+          return !/^(?:Color3|Vector2|Vector3|UDim|UDim2|CFrame|TweenInfo|NumberSequence|ColorSequence)\./.test(path4);
         });
         const allHandleHooks = meaningfulCalls.length > 0 && meaningfulCalls.every((call) => {
           if (!isCustomHookCall(call, context))
             return false;
-          const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-          const final = path3.split(/[.:]/).at(-1) ?? "";
+          const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+          const final = path4.split(/[.:]/).at(-1) ?? "";
           return HANDLE_HOOK_NAME.test(final);
         });
         if (allHandleHooks)
@@ -3090,12 +3440,13 @@ var exhaustiveDeps = {
     const derivedDependenciesByOwner = new Map;
     const dependencyHintsByOwner = new Map;
     const memoizedProducersByOwner = new Map;
+    const transparentAliasesByOwner = new Map;
     for (const call of context.findCalls()) {
       const rawPath = context.getCallPath(call);
       if (!rawPath)
         continue;
-      const path3 = context.resolveCallPath(rawPath);
-      const shape = HOOK_ARGUMENTS.get(path3);
+      const path4 = context.resolveCallPath(rawPath);
+      const shape = HOOK_ARGUMENTS.get(path4);
       if (!shape)
         continue;
       const args = context.callArguments(call);
@@ -3111,7 +3462,12 @@ var exhaustiveDeps = {
       const stableVariables = context.model.stableVariablesByFunction.get(ownerKey) ?? new Set;
       const externallyMutableRoots = context.model.externalMutableVariablesByFunction.get(ownerKey) ?? new Set;
       const functionExpandedCaptures = expandLocalFunctionCaptures(capturedDependencyPaths(callback, available, stableVariables, externallyMutableRoots), owner, available, stableVariables, externallyMutableRoots, context);
-      const dependencies = dependencyPaths(deps);
+      let transparentAliases = transparentAliasesByOwner.get(ownerKey);
+      if (!transparentAliases) {
+        transparentAliases = immutableTransparentAliases(owner, context);
+        transparentAliasesByOwner.set(ownerKey, transparentAliases);
+      }
+      const dependencies = dependencyPathsWithAliases(deps, transparentAliases);
       let derivedDependencies = derivedDependenciesByOwner.get(ownerKey);
       if (!derivedDependencies) {
         derivedDependencies = derivedLocalDependencies(owner, available, stableVariables, externallyMutableRoots, context);
@@ -3125,7 +3481,7 @@ var exhaustiveDeps = {
         diagnostics.push({
           node: tableStartNode(deps),
           severity: "suggestion",
-          message: `${path3} uses dynamic unpack(...) dependencies, so exhaustive dependency analysis is partial.`,
+          message: `${path4} uses dynamic unpack(...) dependencies, so exhaustive dependency analysis is partial.`,
           help: "The analyzer cannot prove which values unpack(...) contributes. Review the explicit dependencies and the custom hook contract."
         });
         continue;
@@ -3146,7 +3502,7 @@ var exhaustiveDeps = {
       if (reactiveMissing.length > 0) {
         diagnostics.push({
           node: tableStartNode(deps),
-          message: `${path3} dependency table is missing ${reactiveMissing.join(", ")}.`,
+          message: `${path4} dependency table is missing ${reactiveMissing.join(", ")}.`,
           help: `Add ${reactiveMissing.join(", ")} to the dependency table, or stop capturing ${reactiveMissing.length === 1 ? "that value" : "those values"} in the callback.`
         });
       }
@@ -3154,7 +3510,7 @@ var exhaustiveDeps = {
         diagnostics.push({
           node: tableStartNode(deps),
           severity: "suggestion",
-          message: `${path3} captures memoized value ${transitivelyCoveredMemoized.join(", ")} without listing ${transitivelyCoveredMemoized.length === 1 ? "it directly" : "them directly"}, but ${transitivelyCoveredMemoized.length === 1 ? "its memo dependencies are" : "their memo dependencies are"} already covered.`,
+          message: `${path4} captures memoized value ${transitivelyCoveredMemoized.join(", ")} without listing ${transitivelyCoveredMemoized.length === 1 ? "it directly" : "them directly"}, but ${transitivelyCoveredMemoized.length === 1 ? "its memo dependencies are" : "their memo dependencies are"} already covered.`,
           help: "The producing memo dependencies are already covered. Listing the memoized value directly can make the dependency relationship clearer."
         });
       }
@@ -3162,7 +3518,7 @@ var exhaustiveDeps = {
         diagnostics.push({
           node: tableStartNode(deps),
           severity: "suggestion",
-          message: `${path3} captures custom-hook handle ${uncertainHandles.join(", ")} without listing ${uncertainHandles.length === 1 ? "it as a dependency" : "them as dependencies"}.`,
+          message: `${path4} captures custom-hook handle ${uncertainHandles.join(", ")} without listing ${uncertainHandles.length === 1 ? "it as a dependency" : "them as dependencies"}.`,
           help: "The analyzer cannot prove this custom-hook return is stable. Check the hook contract before changing the dependency table."
         });
       }
@@ -3196,8 +3552,8 @@ function createElementCallsInLoop(context, loop) {
   for (const node of context.walk(loop)) {
     if (node.type !== "function_call")
       continue;
-    const path3 = context.resolveCallPath(context.getCallPath(node) ?? "");
-    if (path3 === "React.createElement")
+    const path4 = context.resolveCallPath(context.getCallPath(node) ?? "");
+    if (path4 === "React.createElement")
       result.push(node);
   }
   return result;
@@ -3253,8 +3609,8 @@ var noCreateContextInRender = {
   run(context) {
     const diagnostics = [];
     for (const call of context.findCalls()) {
-      const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      if (path3 !== "React.createContext")
+      const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+      if (path4 !== "React.createContext")
         continue;
       const owner = context.nearestFunction(call);
       if (!owner || !owner.isComponent && !owner.isHook)
@@ -3290,8 +3646,8 @@ function isRenderedBy(context, component, name) {
       continue;
     if (context.nearestFunction(call) !== component)
       continue;
-    const path3 = context.resolveCallPath(context.getCallPath(call) ?? "");
-    if (path3 !== "React.createElement")
+    const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
+    if (path4 !== "React.createElement")
       continue;
     if (context.callArguments(call)[0]?.text.trim() === name)
       return true;
@@ -3335,63 +3691,6 @@ var noNestedComponentDefinition = {
   }
 };
 
-// src/module-resolution.ts
-import path3 from "path";
-function normalizeRelative(value) {
-  return value.split(path3.sep).join("/");
-}
-function moduleKeys(relativePath) {
-  let normalized = normalizeRelative(relativePath).replace(/\.(?:lua|luau)$/i, "");
-  if (normalized.endsWith("/init"))
-    normalized = normalized.slice(0, -"/init".length);
-  const segments = normalized.split("/").filter(Boolean);
-  if (segments[0]?.toLowerCase() === "src")
-    segments.shift();
-  const keys = new Set;
-  for (let index = 0;index < segments.length; index += 1) {
-    const suffix = segments.slice(index).join(".").toLowerCase();
-    if (suffix)
-      keys.add(suffix);
-  }
-  return [...keys];
-}
-function normalizeRequireTarget(text) {
-  return (text.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? []).join(".").toLowerCase();
-}
-function buildUniqueFeatureAliases(modules, featureByModuleId) {
-  const owners = new Map;
-  for (const module of modules) {
-    for (const key of module.keys) {
-      const ids = owners.get(key) ?? new Set;
-      ids.add(module.id);
-      owners.set(key, ids);
-    }
-  }
-  const aliases = new Map;
-  for (const module of modules) {
-    const value = featureByModuleId.get(module.id);
-    if (value === undefined)
-      continue;
-    for (const key of module.keys) {
-      const ids = owners.get(key);
-      if (ids?.size === 1 && ids.has(module.id))
-        aliases.set(key, value);
-    }
-  }
-  return aliases;
-}
-function resolveModuleReference(target, aliases) {
-  let candidate = target;
-  while (true) {
-    if (aliases.has(candidate))
-      return aliases.get(candidate);
-    const separator = candidate.indexOf(".");
-    if (separator < 0)
-      return null;
-    candidate = candidate.slice(separator + 1);
-  }
-}
-
 // src/rules/parameter-mutations.ts
 var analysisCache = new WeakMap;
 var EMPTY_INDEXES = new Set;
@@ -6114,6 +6413,20 @@ function staticIterationImports(context) {
   }
   return result;
 }
+function nonReactHookImports(context) {
+  const result = new Set;
+  for (const node of context.walk(context.root)) {
+    if (node.type !== "variable_declaration")
+      continue;
+    const match = node.text.match(/^\s*local\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*require\s*\((.*?)\)\s*$/s);
+    if (!match || !/^use[A-Z0-9_]/.test(match[1]))
+      continue;
+    const kind = resolveModuleReference(normalizeRequireTarget(match[2]), context.project.reactHookModules);
+    if (kind === false)
+      result.add(match[1]);
+  }
+  return result;
+}
 function conditionalHookModeImports(context) {
   const result = new Map;
   for (const node of context.walk(context.root)) {
@@ -6161,30 +6474,12 @@ function controlledParameterIndex(controlFlow, fn, summary) {
   }
   return null;
 }
-function isStableModeArgument(node, context) {
-  if (!node)
-    return true;
-  const text = node.text.trim();
-  if (["true", "false", "nil"].includes(text))
-    return true;
-  if ([
-    "number",
-    "string",
-    "string_content",
-    "table_constructor",
-    "function_definition"
-  ].includes(node.type))
-    return true;
-  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(text) && context.model.stableVariables.has(text))
-    return true;
-  return false;
-}
 function dynamicHookModeFixPreview(hookName, argumentText) {
   return {
     kind: "pattern",
     before: `local value = ${hookName}(${argumentText})`,
-    after: `local value = ${hookName}(true) -- or false; keep this mode fixed for this call site`,
-    note: "A custom hook may choose different internal hooks only when this mode is stable for the lifetime of the component instance."
+    after: `local value = ${hookName}(${argumentText}) -- keep the hook-topology mode stable for this instance`,
+    note: "A custom hook may choose different internal hooks only when the value controlling that choice stays stable for the lifetime of the component instance."
   };
 }
 function unwrapIteratorExpression(text) {
@@ -6204,6 +6499,17 @@ function declarationExpressions4(node) {
 function isEmptyTable(node) {
   return Boolean(node?.type === "table_constructor" && node.namedChildren.every((child) => child.type !== "field"));
 }
+function tableConstructorHasStableArity(node) {
+  if (node.type !== "table_constructor")
+    return false;
+  const fields = node.namedChildren.filter((child) => child.type === "field");
+  if (fields.length === 0)
+    return true;
+  if (fields.some((field) => [...field.namedChildren].some((child) => child.type === "vararg_expression")))
+    return false;
+  const last = fields.at(-1);
+  return !last?.namedChildren.some((child) => child.type === "function_call");
+}
 function stableShapeVariablesByFunction(context) {
   const stable = new Map;
   const functionsByName = new Map;
@@ -6230,7 +6536,7 @@ function stableShapeVariablesByFunction(context) {
       const expression = expressions[index] ?? expressions[0];
       if (!expression)
         continue;
-      if (expression.type === "table_constructor") {
+      if (expression.type === "table_constructor" && tableConstructorHasStableArity(expression)) {
         namesFor(owner).add(names[index]);
         continue;
       }
@@ -6257,7 +6563,7 @@ function stableShapeVariablesByFunction(context) {
     if (!expression)
       return false;
     if (expression.type === "table_constructor")
-      return true;
+      return tableConstructorHasStableArity(expression);
     const text = expression.text.trim();
     if (!owner || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(text))
       return false;
@@ -6310,6 +6616,187 @@ function stableShapeVariablesByFunction(context) {
   }
   return stable;
 }
+function moduleInvariantVariables(context) {
+  const declarations = new Map;
+  const reassigned = new Set;
+  for (const node of context.walk(context.root)) {
+    if (node.type === "variable_declaration" && !context.nearestFunction(node)) {
+      for (const name of declarationNames2(node))
+        declarations.set(name, node);
+      continue;
+    }
+    if (node.type !== "assignment_statement" || node.parent?.type === "variable_declaration")
+      continue;
+    const variableList = node.namedChildren.find((child) => child.type === "variable_list");
+    for (const target of variableList?.namedChildren ?? []) {
+      if (target.type === "identifier")
+        reassigned.add(target.text);
+    }
+  }
+  return new Set([...declarations.keys()].filter((name) => !reassigned.has(name)));
+}
+function simpleConditionRoot(controlFlow) {
+  if (controlFlow.type !== "if_statement" && controlFlow.type !== "if_expression")
+    return null;
+  const condition = controlFlow.namedChildren[0];
+  if (!condition)
+    return null;
+  const text = condition.text.trim();
+  const match = text.match(/^(?:not\s+)?([A-Za-z_][A-Za-z0-9_]*)(?:\s*(?:==|~=)\s*(?:true|false|nil))?$/);
+  return match?.[1] ?? null;
+}
+function conditionIsProvablyInvariant(controlFlow, fn, context, moduleInvariants) {
+  const condition = controlFlow.namedChildren[0];
+  if (!condition)
+    return false;
+  if (["true", "false", "nil", "number", "string"].includes(condition.type))
+    return true;
+  const root = simpleConditionRoot(controlFlow);
+  if (!root)
+    return false;
+  if (moduleInvariants.has(root))
+    return true;
+  return Boolean(context.model.stableVariablesByFunction.get(nodeKey(fn.node))?.has(root));
+}
+function branchHookSequence(branch, fn, context) {
+  const hooks = [];
+  for (const node of context.walk(branch)) {
+    if (node.type !== "function_call")
+      continue;
+    if (context.nearestFunction(node) !== fn)
+      continue;
+    const rawPath = context.getCallPath(node);
+    if (!rawPath)
+      continue;
+    const path4 = context.resolveCallPath(rawPath);
+    if (!isHookPath(path4))
+      continue;
+    const nestedControl = findAncestorBetween(node, branch, (ancestor) => CONDITIONAL_TYPES.has(ancestor.type));
+    if (nestedControl)
+      return null;
+    hooks.push(path4);
+  }
+  return hooks;
+}
+function ifBranchesHaveEquivalentBuiltInTopology(controlFlow, fn, context) {
+  if (controlFlow.type !== "if_statement")
+    return false;
+  const thenBlock = controlFlow.namedChildren.find((child) => child.type === "block");
+  const elseStatement = controlFlow.namedChildren.find((child) => child.type === "else_statement");
+  const elseBlock = elseStatement?.namedChildren.find((child) => child.type === "block");
+  if (!thenBlock || !elseBlock)
+    return false;
+  const thenHooks = branchHookSequence(thenBlock, fn, context);
+  const elseHooks = branchHookSequence(elseBlock, fn, context);
+  if (!thenHooks || !elseHooks || thenHooks.length !== elseHooks.length)
+    return false;
+  if (!thenHooks.every((path4, index) => path4 === elseHooks[index]))
+    return false;
+  return thenHooks.every((path4) => path4.startsWith("React."));
+}
+function stateModeStability(name, owner, context) {
+  const binding = context.model.stateBindings.find((candidate) => candidate.owner === owner && candidate.valueName === name);
+  if (!binding || !owner.body)
+    return null;
+  const initializerText = binding.initializer?.text.trim() ?? "nil";
+  const stableLiteral = /^(?:true|false|nil|-?\d+(?:\.\d+)?|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')$/;
+  let sawIndirectSetterReference = false;
+  for (const node of context.walk(owner.body)) {
+    if (node.type === "function_call" && context.getCallPath(node) === binding.setterName) {
+      const argument = context.callArguments(node)[0];
+      if (!argument || !stableLiteral.test(initializerText) || argument.text.trim() !== initializerText)
+        return "unstable";
+      continue;
+    }
+    if (node.type !== "identifier" || node.text !== binding.setterName)
+      continue;
+    if (node.startIndex >= binding.declaration.startIndex && node.endIndex <= binding.declaration.endIndex)
+      continue;
+    if (node.parent?.type === "function_call")
+      continue;
+    sawIndirectSetterReference = true;
+  }
+  if (sawIndirectSetterReference)
+    return "unknown";
+  return "stable";
+}
+function localAliasExpression(name, owner, context) {
+  if (!owner.body)
+    return null;
+  let result = null;
+  for (const node of context.walk(owner.body)) {
+    if (node.type !== "variable_declaration" || context.nearestFunction(node) !== owner)
+      continue;
+    const names = declarationNames2(node);
+    const index = names.indexOf(name);
+    if (index < 0)
+      continue;
+    const expressions = declarationExpressions4(node);
+    const expression = expressions[index] ?? expressions[0] ?? null;
+    if (result)
+      return null;
+    result = expression;
+  }
+  return result;
+}
+function modeValueStability(node, owner, context, moduleInvariants, depth = 0) {
+  if (!node)
+    return "stable";
+  if (depth > 4)
+    return "unknown";
+  const text = node.text.trim();
+  if (["true", "false", "nil"].includes(text))
+    return "stable";
+  if (["number", "string", "string_content", "function_definition"].includes(node.type))
+    return "stable";
+  const root = text.match(/^([A-Za-z_][A-Za-z0-9_]*)/)?.[1];
+  if (!root)
+    return "unknown";
+  const stateStability = stateModeStability(root, owner, context);
+  if (stateStability)
+    return stateStability;
+  if (moduleInvariants.has(root))
+    return "stable";
+  if (context.model.stableVariablesByFunction.get(nodeKey(owner.node))?.has(root))
+    return "stable";
+  if (text === root) {
+    const alias = localAliasExpression(root, owner, context);
+    if (alias && alias.text.trim() !== root)
+      return modeValueStability(alias, owner, context, moduleInvariants, depth + 1);
+  }
+  return "unknown";
+}
+function tableFieldValue(table, accessPath) {
+  if (!table || accessPath === "")
+    return table;
+  if (table.type !== "table_constructor")
+    return;
+  let current = table;
+  for (const part of accessPath.split(".")) {
+    if (!current || current.type !== "table_constructor")
+      return;
+    const field = current.namedChildren.find((child) => {
+      if (child.type !== "field")
+        return false;
+      return child.namedChildren[0]?.type === "identifier" && child.namedChildren[0]?.text === part;
+    });
+    if (!field)
+      return;
+    current = field.namedChildren[1];
+  }
+  return current;
+}
+function controlledAccessPaths(summary, parameterIndex) {
+  const paths = new Set;
+  for (const [conditionName, index] of Object.entries(summary.conditionVariables)) {
+    if (index !== parameterIndex)
+      continue;
+    paths.add(summary.conditionAccessPaths?.[conditionName] ?? "");
+  }
+  if (paths.size === 0)
+    paths.add("");
+  return [...paths];
+}
 function loopIterationIsProvablyStable(loop, imports, owner, stableShapes) {
   const numeric = loop.namedChildren.find((child) => child.type === "for_numeric_clause");
   if (numeric) {
@@ -6371,9 +6858,9 @@ function impossibleNilGuardReturn(node, fn, parameterTypes) {
   }
   return false;
 }
-function hasReachableReturnBefore(call, fn, context, cache) {
+function reachableReturnsBefore(call, fn, context, cache) {
   if (!fn.body)
-    return false;
+    return [];
   const key = nodeKey(fn.node);
   let returns = cache.get(key);
   if (!returns) {
@@ -6381,7 +6868,21 @@ function hasReachableReturnBefore(call, fn, context, cache) {
     returns = [...context.walk(fn.body)].filter((node) => node.type === "return_statement" && !isNestedInsideFunction(node, fn.node) && !impossibleNilGuardReturn(node, fn, parameterTypes));
     cache.set(key, returns);
   }
-  return returns.some((node) => node.endIndex <= call.startIndex);
+  return returns.filter((node) => node.endIndex <= call.startIndex);
+}
+function returnIsControlledByStableTopologyMode(node, fn, summary, context, moduleInvariants) {
+  let current = node.parent;
+  while (current && current !== fn.node) {
+    if (current.type === "if_statement" || current.type === "if_expression") {
+      if (summary && controlledParameterIndex(current, fn, summary) !== null)
+        return true;
+      if (conditionIsProvablyInvariant(current, fn, context, moduleInvariants))
+        return true;
+      return false;
+    }
+    current = current.parent;
+  }
+  return false;
 }
 function conditionalFixPreview(kind, hookName) {
   if (kind === "for statement") {
@@ -6453,15 +6954,21 @@ var rulesOfHooks = {
   description: "Hooks must run in the same order on every render of a React component or custom hook.",
   run(context) {
     const diagnostics = [];
+    if (!context.model.isReactFile)
+      return diagnostics;
     const staticImports = staticIterationImports(context);
     const stableShapes = stableShapeVariablesByFunction(context);
+    const moduleInvariants = moduleInvariantVariables(context);
     const modeImports = conditionalHookModeImports(context);
+    const ignoredHookImports = nonReactHookImports(context);
     const currentModeSummary = currentConditionalHookMode(context);
     const reachableReturns = new Map;
     for (const call of context.findCalls()) {
       const rawPath = context.getCallPath(call);
       if (!rawPath)
         continue;
+      if (ignoredHookImports.has(rawPath))
+        continue;
       const path4 = context.resolveCallPath(rawPath);
       if (!isHookPath(path4))
         continue;
@@ -6490,25 +6997,36 @@ end`,
       const importedMode = modeImports.get(rawPath);
       if (importedMode) {
         const args = context.callArguments(call);
-        const dynamicIndexes = importedMode.parameterIndexes.filter((index) => !isStableModeArgument(args[index], context));
-        if (dynamicIndexes.length > 0) {
-          const firstIndex = dynamicIndexes[0];
-          const argument = args[firstIndex];
+        const unstableControls = importedMode.parameterIndexes.flatMap((index) => controlledAccessPaths(importedMode, index).map((accessPath) => {
+          const argument = args[index];
+          const value = tableFieldValue(argument, accessPath);
+          const stability = accessPath !== "" ? argument?.type === "table_constructor" ? value ? modeValueStability(value, fn, context, moduleInvariants) : "stable" : "unknown" : modeValueStability(argument, fn, context, moduleInvariants);
+          return { index, accessPath, argument, value, stability };
+        }).filter((control) => control.stability === "unstable"));
+        if (unstableControls.length > 0) {
+          const first = unstableControls[0];
+          const firstIndex = first.index;
+          const argument = first.argument;
           const parameterOffset = importedMode.parameterIndexes.indexOf(firstIndex);
-          const parameterName = importedMode.parameterNames[parameterOffset] ?? `argument ${firstIndex + 1}`;
-          const argumentText = argument?.text.trim() || "<omitted>";
+          const baseParameterName = importedMode.parameterNames[parameterOffset] ?? `argument ${firstIndex + 1}`;
+          const parameterName = first.accessPath ? `${baseParameterName}.${first.accessPath}` : baseParameterName;
+          const argumentText = first.value?.text.trim() || argument?.text.trim() || "<omitted>";
           diagnostics.push({
-            node: argument ?? callNameNode(call),
-            highlights: dynamicIndexes.map((index) => args[index]).filter((node) => Boolean(node)),
-            message: `Hook ${rawPath} receives render-varying hook mode ${parameterName} from ${argumentText}; if it changes between renders, the custom hook can execute a different hook sequence.`,
-            help: `Pass a stable mode at this call site, or refactor ${rawPath} so it always calls the same hooks regardless of ${parameterName}.`,
+            node: first.value ?? argument ?? callNameNode(call),
+            highlights: unstableControls.map((control) => control.value ?? control.argument).filter((node) => Boolean(node)),
+            message: `Hook ${rawPath} receives hook-topology mode ${parameterName} from ${argumentText}, which is updated between renders and can make the custom hook execute a different hook sequence.`,
+            help: `Keep ${parameterName} stable for this hook instance, or refactor ${rawPath} so it always calls the same hooks regardless of that mode.`,
             fixPreview: dynamicHookModeFixPreview(rawPath, argumentText)
           });
         }
       }
       const controlFlow = findAncestorBetween(call, fn.node, (node) => CONDITIONAL_TYPES.has(node.type));
       if (controlFlow) {
-        if (currentModeSummary && currentModeSummary.knownCallSites > 0 && controlledParameterIndex(controlFlow, fn, currentModeSummary) !== null)
+        if (currentModeSummary && controlledParameterIndex(controlFlow, fn, currentModeSummary) !== null)
+          continue;
+        if (conditionIsProvablyInvariant(controlFlow, fn, context, moduleInvariants))
+          continue;
+        if (ifBranchesHaveEquivalentBuiltInTopology(controlFlow, fn, context))
           continue;
         if (controlFlow.type === "for_statement" && loopIterationIsProvablyStable(controlFlow, staticImports, fn, stableShapes))
           continue;
@@ -6522,7 +7040,8 @@ end`,
         });
         continue;
       }
-      if (hasReachableReturnBefore(call, fn, context, reachableReturns)) {
+      const earlierReturns = reachableReturnsBefore(call, fn, context, reachableReturns);
+      if (earlierReturns.length > 0 && !earlierReturns.every((node) => returnIsControlledByStableTopologyMode(node, fn, currentModeSummary, context, moduleInvariants))) {
         diagnostics.push({
           node: callNameNode(call),
           message: `Hook ${path4} may run after an earlier reachable return, so some renders can execute fewer hooks.`,
@@ -6995,7 +7514,7 @@ function toDiagnostic(file, ruleId, category, severity, input) {
 }
 async function analyzeReactFile(input, tree) {
   const parsedTree = tree ?? await parseLuau(input.source);
-  const model = buildReactModel(parsedTree.rootNode);
+  const model = buildReactModel(parsedTree.rootNode, input.project);
   if (!input.forceScan && !model.isReactFile) {
     return { relativePath: input.relativePath, isReactFile: false, scanned: false, diagnostics: [] };
   }
@@ -8010,5 +8529,5 @@ parentPort.on("message", async (request) => {
   }
 });
 
-//# debugId=07C5601A473D8F7164756E2164756E21
+//# debugId=3696D560D93E93D364756E2164756E21
 //# sourceMappingURL=scan-worker.js.map