@colrealpro/react-luau-doctor 0.17.5 → 0.18.0

package/dist/scan-worker.js

@@ -1290,16 +1290,175 @@ var INSTANCE_FACTORY_MEMBERS2 = new Set([
 function finalCallMember2(path3) {
   return path3.split(/[.:]/).at(-1) ?? path3;
 }
-function knownYieldReason(path3) {
+function declarationInitializer(node, name) {
+  if (node.type !== "variable_declaration")
+    return;
+  const assignment = node.namedChildren.find((child) => child.type === "assignment_statement");
+  const variables = assignment?.namedChildren.find((child) => child.type === "variable_list") ?? node.namedChildren.find((child) => child.type === "variable_list");
+  const expressions = assignment?.namedChildren.find((child) => child.type === "expression_list");
+  const names = variables?.namedChildren.filter((child) => child.type === "identifier") ?? [];
+  const index = names.findIndex((candidate) => candidate.text === name);
+  if (index < 0)
+    return;
+  return expressions?.namedChildren[index] ?? expressions?.namedChildren[0] ?? null;
+}
+function functionBindsName(node, name) {
+  if (node.type !== "function_definition" && node.type !== "function_declaration")
+    return false;
+  const parameters = node.childForFieldName("parameters");
+  if (!parameters)
+    return false;
+  return parameters.namedChildren.some((parameter) => parameter.namedChildren.some((child) => child.type === "identifier" && child.text === name) || parameter.type === "identifier" && parameter.text === name);
+}
+function loopBindsName(node, name) {
+  if (node.type !== "for_statement")
+    return false;
+  const header = node.text.split(/\bdo\b/s, 1)[0] ?? "";
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^\\s*for\\s+(?:${escaped}\\s*=|[^\\n]*\\b${escaped}\\b[^\\n]*\\bin\\b)`, "s").test(header);
+}
+function visibleInitializer(name, from, context) {
+  let current = from.parent;
+  while (current) {
+    if (current.type === "block" || current.id === context.root.id) {
+      const children = current.namedChildren;
+      for (let index = children.length - 1;index >= 0; index -= 1) {
+        const child = children[index];
+        if (child.startIndex >= from.startIndex)
+          continue;
+        const initializer = declarationInitializer(child, name);
+        if (initializer !== undefined)
+          return initializer;
+        if (child.type === "function_declaration") {
+          const declared = child.childForFieldName("name")?.text.replace(/\s+/g, "") ?? "";
+          if (declared === name)
+            return null;
+        }
+      }
+    }
+    if (functionBindsName(current, name) || loopBindsName(current, name))
+      return null;
+    current = current.parent;
+  }
+  return;
+}
+function expressionHasRobloxOrigin(expression, from, context, seen) {
+  if (!expression)
+    return false;
+  const normalized = expression.text.replace(/\s+/g, "");
+  if (/^(?:game|workspace|script)(?:[.:]|$)/.test(normalized) || /^Instance\.new\(/.test(normalized))
+    return true;
+  const root = normalized.match(/^([A-Za-z_][A-Za-z0-9_]*)/)?.[1];
+  if (!root || root === "require" || seen.has(root))
+    return false;
+  if (expression.type !== "identifier" && expression.type !== "function_call")
+    return false;
+  seen.add(root);
+  return expressionHasRobloxOrigin(visibleInitializer(root, from, context), from, context, seen);
+}
+function hasRobloxReceiver(path3, call, context) {
+  const normalized = path3.replace(/\s+/g, "");
+  if (/^(?:game|workspace|script)(?:[.:]|$)/.test(normalized))
+    return true;
+  const root = normalized.match(/^([A-Za-z_][A-Za-z0-9_]*)/)?.[1];
+  if (!root)
+    return false;
+  return expressionHasRobloxOrigin(visibleInitializer(root, call, context), call, context, new Set([root]));
+}
+var runServiceCallCache = new WeakMap;
+var runServiceExpressionCache = new WeakMap;
+function cachedNodeBoolean(cache, context, node, compute) {
+  let entries = cache.get(context);
+  if (!entries) {
+    entries = new Map;
+    cache.set(context, entries);
+  }
+  const cached = entries.get(node.id);
+  if (cached !== undefined)
+    return cached;
+  const value = compute();
+  entries.set(node.id, value);
+  return value;
+}
+var RUN_SERVICE_EVENTS = new Set([
+  "RenderStepped",
+  "Heartbeat",
+  "Stepped",
+  "PreRender",
+  "PreSimulation",
+  "PostSimulation"
+]);
+function expressionIsRunService(expression, from, context, seen) {
+  if (!expression)
+    return false;
+  const normalized = expression.text.replace(/\s+/g, "");
+  if (/^game:GetService\(["']RunService["']\)$/.test(normalized))
+    return true;
+  if (expression.type !== "identifier")
+    return false;
+  const name = expression.text;
+  if (seen.has(name))
+    return false;
+  seen.add(name);
+  return expressionIsRunService(visibleInitializer(name, from, context), from, context, seen);
+}
+function rootIsRunService(root, from, context) {
+  if (root === "game")
+    return false;
+  return expressionIsRunService(visibleInitializer(root, from, context), from, context, new Set([root]));
+}
+function isHighFrequencyRunServiceExpression(node, context) {
+  return cachedNodeBoolean(runServiceExpressionCache, context, node, () => {
+    const normalized = node.text.replace(/\s+/g, "");
+    if (/^game:GetService\(["']RunService["']\)\.(?:RenderStepped|Heartbeat|Stepped|PreRender|PreSimulation|PostSimulation)$/.test(normalized)) {
+      return true;
+    }
+    const match = normalized.match(/^([A-Za-z_][A-Za-z0-9_]*)\.(RenderStepped|Heartbeat|Stepped|PreRender|PreSimulation|PostSimulation)$/);
+    return Boolean(match && RUN_SERVICE_EVENTS.has(match[2]) && rootIsRunService(match[1], node, context));
+  });
+}
+function isHighFrequencyRunServiceCall(call, context) {
+  return cachedNodeBoolean(runServiceCallCache, context, call, () => {
+    const normalized = (context.getCallPath(call) ?? "").replace(/\s+/g, "");
+    const direct = call.text.replace(/\s+/g, "");
+    if (/^game:GetService\(["']RunService["']\)(?:\.(?:RenderStepped|Heartbeat|Stepped|PreRender|PreSimulation|PostSimulation):Connect|:BindToRenderStep|:BindToSimulation)\(/.test(direct)) {
+      return true;
+    }
+    const event = normalized.match(/^([A-Za-z_][A-Za-z0-9_]*)\.(RenderStepped|Heartbeat|Stepped|PreRender|PreSimulation|PostSimulation):Connect$/);
+    if (event)
+      return rootIsRunService(event[1], call, context);
+    const bind = normalized.match(/^([A-Za-z_][A-Za-z0-9_]*):(?:BindToRenderStep|BindToSimulation)$/);
+    return Boolean(bind && rootIsRunService(bind[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;
+  }
+  const aliases = 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*["']RunService["']\s*\)/g)) {
+    aliases.add(match[1]);
+  }
+  for (const alias of aliases) {
+    const escaped = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`\\b${escaped}\\s*(?:\\.\\s*(?:RenderStepped|Heartbeat|Stepped|PreRender|PreSimulation|PostSimulation)\\s*:\\s*Connect|:\\s*(?:BindToRenderStep|BindToSimulation))`);
+    if (pattern.test(source))
+      return true;
+  }
+  return false;
+}
+function knownYieldReason(path3, call, context) {
   const normalized = path3.replace(/\s+/g, "");
   if (normalized === "task.wait")
     return "task.wait";
   if (normalized === "coroutine.yield")
     return "coroutine.yield";
   const member = finalCallMember2(normalized);
-  if (YIELDING_ENGINE_MEMBERS.has(member))
-    return member;
-  return null;
+  if (!YIELDING_ENGINE_MEMBERS.has(member))
+    return null;
+  if (!call || !context)
+    return null;
+  return hasRobloxReceiver(normalized, call, context) ? member : null;
 }
 function functionYieldPoint(node, context) {
   for (const candidate of context.walk(node)) {
@@ -1310,7 +1469,7 @@ function functionYieldPoint(node, context) {
     if (owner && nearest !== owner)
       continue;
     const path3 = context.resolveCallPath(context.getCallPath(candidate) ?? "");
-    const reason = knownYieldReason(path3);
+    const reason = knownYieldReason(path3, candidate, context);
     if (reason)
       return { call: candidate, reason };
   }
@@ -1511,6 +1670,38 @@ function isNameShadowedBetween(node, boundary, name) {
   }
   return false;
 }
+var topLevelBindingsCache = new WeakMap;
+function topLevelBindings(boundary) {
+  const cached = topLevelBindingsCache.get(boundary);
+  if (cached)
+    return cached;
+  const result = new Map;
+  const add = (name, node) => {
+    const existing = result.get(name) ?? [];
+    existing.push(node);
+    result.set(name, existing);
+  };
+  for (const child of boundary.body?.namedChildren ?? []) {
+    if (child.type === "variable_declaration") {
+      for (const name of declarationNames2(child))
+        add(name, child);
+    } else if (child.type === "function_declaration") {
+      const declared = child.childForFieldName("name")?.text.replace(/\s+/g, "") ?? "";
+      if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(declared))
+        add(declared, child);
+    }
+  }
+  topLevelBindingsCache.set(boundary, result);
+  return result;
+}
+function isBindingShadowedBetween(node, boundary, name, declaration = null) {
+  if (isNameShadowedBetween(node, boundary, name))
+    return true;
+  if (!boundary.body)
+    return false;
+  const afterIndex = declaration?.endIndex ?? boundary.body.startIndex - 1;
+  return (topLevelBindings(boundary).get(name) ?? []).some((binding) => binding.startIndex > afterIndex && binding.startIndex < node.startIndex);
+}
 function containsUnshadowedIdentifier(node, name, context, boundary) {
   if (!node)
     return false;
@@ -3019,6 +3210,343 @@ 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;
+function declarationParts(node) {
+  if (node.type !== "variable_declaration")
+    return { names: [], expressions: [] };
+  const assignment = node.namedChildren.find((child) => child.type === "assignment_statement");
+  const variables = assignment?.namedChildren.find((child) => child.type === "variable_list") ?? node.namedChildren.find((child) => child.type === "variable_list");
+  const expressions = assignment?.namedChildren.find((child) => child.type === "expression_list");
+  return {
+    names: variables?.namedChildren.filter((child) => child.type === "identifier").map((child) => child.text) ?? [],
+    expressions: expressions?.namedChildren ?? []
+  };
+}
+function assignmentParts(node) {
+  if (node.type !== "assignment_statement" || node.parent?.type === "variable_declaration") {
+    return { names: [], expressions: [] };
+  }
+  const variables = node.namedChildren.find((child) => child.type === "variable_list");
+  const expressions = node.namedChildren.find((child) => child.type === "expression_list");
+  return {
+    names: variables?.namedChildren.filter((child) => child.type === "identifier").map((child) => child.text) ?? [],
+    expressions: expressions?.namedChildren ?? []
+  };
+}
+function expressionForName(node, name) {
+  const { names, expressions } = node.type === "variable_declaration" ? declarationParts(node) : assignmentParts(node);
+  const index = names.indexOf(name);
+  if (index < 0)
+    return;
+  return expressions[index] ?? expressions[0] ?? null;
+}
+function currentModuleSummary(context) {
+  for (const key of moduleKeys(context.relativePath)) {
+    const summary = context.project.sourceEffects.get(key);
+    if (summary)
+      return summary;
+  }
+  return null;
+}
+function topLevelImports(context) {
+  const result = new Map;
+  for (const node of context.root.namedChildren) {
+    if (node.type !== "variable_declaration")
+      continue;
+    const { names, expressions } = declarationParts(node);
+    for (let index = 0;index < names.length; index += 1) {
+      const expression = expressions[index] ?? expressions[0];
+      if (expression?.type !== "function_call")
+        continue;
+      const match = expression.text.match(/^\s*require\s*\((.*?)\)\s*$/s);
+      if (!match)
+        continue;
+      const summary = resolveModuleReference(normalizeRequireTarget(match[1]), context.project.sourceEffects);
+      if (summary)
+        result.set(names[index], { declaration: node, summary });
+    }
+  }
+  return result;
+}
+function analysisFor(context) {
+  const cached = analysisCache.get(context);
+  if (cached)
+    return cached;
+  const imports = topLevelImports(context);
+  const mutatingFactoryMembers = new Set;
+  for (const { summary } of imports.values()) {
+    if (summary.instanceFactories.size === 0)
+      continue;
+    for (const member of summary.mutatingMemberParameters.keys())
+      mutatingFactoryMembers.add(member);
+  }
+  const result = {
+    currentSummary: currentModuleSummary(context),
+    imports,
+    mutatingFactoryMembers,
+    callIndexes: new Map,
+    originCache: new Map
+  };
+  analysisCache.set(context, result);
+  return result;
+}
+function directChildContaining(block, node) {
+  for (const child of block.namedChildren) {
+    if (child.startIndex <= node.startIndex && child.endIndex >= node.endIndex)
+      return child;
+  }
+  return null;
+}
+function visibleBinding(name, node, owner) {
+  let current = node;
+  while (current && !sameNode(current, owner.node)) {
+    const parent = current.parent;
+    if (parent?.type === "block") {
+      const containing = directChildContaining(parent, node);
+      const beforeIndex = containing?.startIndex ?? node.startIndex;
+      const children = parent.namedChildren;
+      for (let index = children.length - 1;index >= 0; index -= 1) {
+        const child = children[index];
+        if (child.startIndex >= beforeIndex)
+          continue;
+        if (child.type !== "variable_declaration" && child.type !== "assignment_statement")
+          continue;
+        const expression = expressionForName(child, name);
+        if (expression !== undefined)
+          return { node: child, expression };
+      }
+    }
+    current = parent;
+  }
+  return null;
+}
+function isTopLevelFunctionVisible(context, name, owner) {
+  for (const node of context.root.namedChildren) {
+    if (node.startIndex >= owner.node.startIndex)
+      break;
+    if (node.type === "function_declaration") {
+      const declared = node.childForFieldName("name")?.text.replace(/\s+/g, "") ?? "";
+      if (declared === name)
+        return true;
+      continue;
+    }
+    if (node.type !== "variable_declaration")
+      continue;
+    const { names, expressions } = declarationParts(node);
+    const index = names.indexOf(name);
+    if (index < 0)
+      continue;
+    if ((expressions[index] ?? expressions[0])?.type === "function_definition")
+      return true;
+  }
+  return false;
+}
+function moduleBindingVisible(binding, name, call, owner) {
+  if (binding.declaration.startIndex >= owner.node.startIndex)
+    return false;
+  if (owner.parameters.includes(name))
+    return false;
+  return visibleBinding(name, call, owner) === null;
+}
+function builtinMutatedParameterIndexes(path4, argumentCount) {
+  switch (path4) {
+    case "rawset":
+    case "setmetatable":
+    case "table.clear":
+    case "table.freeze":
+    case "table.insert":
+    case "table.remove":
+    case "table.sort":
+      return argumentCount > 0 ? new Set([0]) : EMPTY_INDEXES;
+    case "table.move":
+      return argumentCount >= 5 ? new Set([4]) : argumentCount > 0 ? new Set([0]) : EMPTY_INDEXES;
+    default:
+      return EMPTY_INDEXES;
+  }
+}
+function importedFactorySummary(context, receiver, call, owner, analysis) {
+  const binding = visibleBinding(receiver, call, owner);
+  if (!binding?.expression)
+    return null;
+  const expression = binding.expression;
+  if (expression.type === "identifier") {
+    return importedFactorySummary(context, expression.text, expression, owner, analysis);
+  }
+  if (expression.type !== "function_call")
+    return null;
+  const path4 = normalizeExpressionText(context.getCallPath(expression) ?? "");
+  const match = path4.match(/^([A-Za-z_][A-Za-z0-9_]*)[.:]([A-Za-z_][A-Za-z0-9_]*)$/);
+  if (!match)
+    return null;
+  const imported = analysis.imports.get(match[1]);
+  if (!imported || !moduleBindingVisible(imported, match[1], expression, owner))
+    return null;
+  return imported.summary.instanceFactories.has(match[2]) ? imported.summary : null;
+}
+function mightMutateParameters(context, call) {
+  const path4 = normalizeExpressionText(context.getCallPath(call) ?? "");
+  if (builtinMutatedParameterIndexes(path4, context.callArguments(call).length).size > 0)
+    return true;
+  const analysis = analysisFor(context);
+  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(path4)) {
+    if ((analysis.currentSummary?.localMutatingParameters.get(path4)?.size ?? 0) > 0)
+      return true;
+    return (analysis.imports.get(path4)?.summary.mutatingExportParameters.size ?? 0) > 0;
+  }
+  const member = path4.match(/^([A-Za-z_][A-Za-z0-9_]*)[.:]([A-Za-z_][A-Za-z0-9_]*)$/);
+  if (!member)
+    return false;
+  if ((analysis.imports.get(member[1])?.summary.mutatingMemberParameters.get(member[2])?.size ?? 0) > 0)
+    return true;
+  return analysis.mutatingFactoryMembers.has(member[2]);
+}
+function mutatedParameterIndexesForCall(context, call, owner) {
+  const analysis = analysisFor(context);
+  const cached = analysis.callIndexes.get(call.id);
+  if (cached)
+    return cached;
+  const path4 = normalizeExpressionText(context.getCallPath(call) ?? "");
+  const builtin = builtinMutatedParameterIndexes(path4, context.callArguments(call).length);
+  if (builtin.size > 0) {
+    analysis.callIndexes.set(call.id, builtin);
+    return builtin;
+  }
+  let result = EMPTY_INDEXES;
+  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(path4)) {
+    const importBinding = analysis.imports.get(path4);
+    if (importBinding && moduleBindingVisible(importBinding, path4, call, owner)) {
+      result = importBinding.summary.mutatingExportParameters;
+    } else if (!owner.parameters.includes(path4) && visibleBinding(path4, call, owner) === null && isTopLevelFunctionVisible(context, path4, owner)) {
+      result = analysis.currentSummary?.localMutatingParameters.get(path4) ?? EMPTY_INDEXES;
+    }
+  } else {
+    const member = path4.match(/^([A-Za-z_][A-Za-z0-9_]*)([.:])([A-Za-z_][A-Za-z0-9_]*)$/);
+    if (member) {
+      const imported = analysis.imports.get(member[1]);
+      if (imported && moduleBindingVisible(imported, member[1], call, owner)) {
+        result = imported.summary.mutatingMemberParameters.get(member[3]) ?? EMPTY_INDEXES;
+      } else {
+        const factory = importedFactorySummary(context, member[1], call, owner, analysis);
+        result = factory?.mutatingMemberParameters.get(member[3]) ?? EMPTY_INDEXES;
+      }
+    }
+  }
+  analysis.callIndexes.set(call.id, result);
+  return result;
+}
+function freshExpression(context, expression) {
+  if (expression.type === "table_constructor" || expression.type === "function_definition")
+    return true;
+  if (expression.type !== "function_call")
+    return false;
+  const path4 = normalizeExpressionText(context.getCallPath(expression) ?? "");
+  if (path4 === "table.clone" || path4 === "table.create" || path4 === "table.pack")
+    return true;
+  if (path4 === "setmetatable") {
+    const first = context.callArguments(expression)[0];
+    return Boolean(first && freshExpression(context, first));
+  }
+  return false;
+}
+function stateBindingForName(context, owner, name, bindingNode) {
+  return context.model.stateBindings.find((binding) => binding.owner === owner && binding.valueName === name && sameNode(binding.declaration, bindingNode)) ?? null;
+}
+function resolveNameOrigin(context, name, atNode, owner, seen) {
+  const key = `${owner.node.id}:${name}:${atNode.startIndex}`;
+  if (seen.has(key))
+    return { kind: "unknown" };
+  seen.add(key);
+  const binding = visibleBinding(name, atNode, owner);
+  if (binding) {
+    const state = stateBindingForName(context, owner, name, binding.node);
+    if (state)
+      return { kind: "state", binding: state };
+    if (!binding.expression)
+      return { kind: "unknown" };
+    return resolveExpressionOriginInternal(context, binding.expression, owner, seen);
+  }
+  if (owner.isComponent && owner.parameters[0] === name)
+    return { kind: "props", name };
+  return { kind: "unknown" };
+}
+function resolveExpressionOriginInternal(context, expression, owner, seen) {
+  if (freshExpression(context, expression))
+    return { kind: "fresh" };
+  const root = rootIdentifier(expression.text);
+  if (!root)
+    return { kind: "unknown" };
+  return resolveNameOrigin(context, root, expression, owner, seen);
+}
+function mutationOriginForExpression(context, expression, owner) {
+  const analysis = analysisFor(context);
+  const key = `${owner.node.id}:${expression.id}`;
+  const cached = analysis.originCache.get(key);
+  if (cached)
+    return cached;
+  const result = resolveExpressionOriginInternal(context, expression, owner, new Set);
+  analysis.originCache.set(key, result);
+  return result;
+}
+
 // src/rules/no-prop-mutation.ts
 var noPropMutation = {
   id: "react-luau/no-prop-mutation",
@@ -3028,7 +3556,27 @@ var noPropMutation = {
   run(context) {
     const diagnostics = [];
     for (const node of context.walk()) {
-      if (node.type !== "assignment_statement" && node.type !== "update_statement")
+      if (node.type === "assignment_statement" || node.type === "update_statement") {
+        const component2 = context.containingComponent(node);
+        if (!component2 || !context.isDirectlyExecutedInFunction(node, component2))
+          continue;
+        const propsName2 = component2.parameters[0];
+        if (!propsName2)
+          continue;
+        if (isBindingShadowedBetween(node, component2, propsName2))
+          continue;
+        const left = assignmentLeft(node.text);
+        const escaped = propsName2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        if (!new RegExp(`^${escaped}\\s*(?:\\.|\\[)`).test(left))
+          continue;
+        diagnostics.push({
+          node: assignmentTargetNode(node),
+          message: `Component mutates ${propsName2} directly.`,
+          help: "Treat props as immutable. Derive a local value, clone a table you own, or update state in the owner instead."
+        });
+        continue;
+      }
+      if (node.type !== "function_call" || !mightMutateParameters(context, node))
         continue;
       const component = context.containingComponent(node);
       if (!component || !context.isDirectlyExecutedInFunction(node, component))
@@ -3036,16 +3584,27 @@ var noPropMutation = {
       const propsName = component.parameters[0];
       if (!propsName)
         continue;
-      if (isNameShadowedBetween(node, component, propsName))
-        continue;
-      const left = assignmentLeft(node.text);
-      const escaped = propsName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      if (!new RegExp(`^${escaped}\\s*(?:\\.|\\[)`).test(left))
+      const arguments_ = context.callArguments(node);
+      const mutatedIndexes = mutatedParameterIndexesForCall(context, node, component);
+      let mutatedArgument = null;
+      for (const index of mutatedIndexes) {
+        const argument = arguments_[index];
+        if (!argument)
+          continue;
+        const origin = mutationOriginForExpression(context, argument, component);
+        if (origin.kind !== "props" || origin.name !== propsName)
+          continue;
+        mutatedArgument = argument;
+        break;
+      }
+      if (!mutatedArgument)
         continue;
+      const path4 = context.resolveCallPath(context.getCallPath(node) ?? "") || "This call";
       diagnostics.push({
-        node: assignmentTargetNode(node),
-        message: `Component mutates ${propsName} directly.`,
-        help: "Treat props as immutable. Derive a local value, clone a table you own, or update state in the owner instead."
+        node: callNameNode(node),
+        highlights: [mutatedArgument],
+        message: `${path4} mutates an argument derived from ${propsName}.`,
+        help: "Treat props as immutable. Clone the table before passing it to a mutating helper, or move the mutation into the owner that controls the value."
       });
     }
     return diagnostics;
@@ -3069,9 +3628,9 @@ function freshDescription(node, context) {
   for (const child of context.walk(node)) {
     if (child.type !== "function_call")
       continue;
-    const path3 = context.getCallPath(child) ?? "";
-    if (FRESH_CALLS.some((pattern) => pattern.test(path3)) || /Random\.new\s*\([^)]*\)\s*:\s*Next(?:Integer|Number)/s.test(child.text)) {
-      return `${path3 || "fresh-value call"}()`;
+    const path4 = context.getCallPath(child) ?? "";
+    if (FRESH_CALLS.some((pattern) => pattern.test(path4)) || /Random\.new\s*\([^)]*\)\s*:\s*Next(?:Integer|Number)/s.test(child.text)) {
+      return `${path4 || "fresh-value call"}()`;
     }
   }
   return null;
@@ -3126,18 +3685,20 @@ var noSetStateInRender = {
     for (const component of context.model.functions) {
       if (!component.isComponent || !component.body)
         continue;
-      const setters = new Set(stateBindingsFor(context, component).map((binding) => binding.setterName));
+      const bindings = stateBindingsFor(context, component);
+      const setters = new Map(bindings.map((binding) => [binding.setterName, binding]));
       if (setters.size === 0)
         continue;
       for (const statement of component.body.namedChildren) {
         if (statement.type !== "function_call")
           continue;
-        const path3 = context.getCallPath(statement);
-        if (!path3 || !setters.has(path3))
+        const path4 = context.getCallPath(statement);
+        const binding = path4 ? setters.get(path4) : undefined;
+        if (!path4 || !binding || isBindingShadowedBetween(statement, component, path4, binding.declaration))
           continue;
         diagnostics.push({
           node: callNameNode(statement),
-          message: `${path3}() is called unconditionally during component render.`,
+          message: `${path4}() is called unconditionally during component render.`,
           help: "Move the update to the event or effect that owns it, or derive the value during render. An unconditional render-phase state update can continuously trigger new renders."
         });
       }
@@ -3168,115 +3729,57 @@ var TYPE_SYNTAX_ANCESTORS = new Set([
   "variadic_type_pack"
 ]);
 function incompleteDelimitedNode(node) {
-  const closer = REQUIRED_CLOSERS.get(node.type);
-  if (!closer)
-    return null;
-  return node.text.trimEnd().endsWith(closer) ? null : closer;
-}
-function isBundledGrammarTypeGap(node) {
-  let current = node;
-  while (current) {
-    if (TYPE_SYNTAX_ANCESTORS.has(current.type)) {
-      if (current.type !== "type_definition")
-        return true;
-      if (/^\s*(?:export\s+)?type\s+[A-Za-z_][A-Za-z0-9_]*/s.test(current.text))
-        return true;
-    }
-    current = current.parent;
-  }
-  return false;
-}
-var parseErrors = {
-  id: "react-luau/parse-error",
-  category: "Correctness",
-  severity: "error",
-  description: "Report executable Luau syntax that the bundled parser cannot form into a complete syntax tree.",
-  run(context) {
-    const diagnostics = [];
-    const covered = [];
-    for (const node of context.walk()) {
-      const missingCloser = incompleteDelimitedNode(node);
-      if (!node.isError && !node.isMissing && !missingCloser)
-        continue;
-      if (isBundledGrammarTypeGap(node))
-        continue;
-      if (covered.some((range) => node.startIndex >= range.start && node.endIndex <= range.end))
-        continue;
-      covered.push({ start: node.startIndex, end: node.endIndex });
-      let message = "Luau syntax could not be parsed cleanly at this location.";
-      if (node.isMissing)
-        message = `Luau syntax is missing ${node.type}.`;
-      else if (missingCloser)
-        message = `Luau syntax is missing closing ${missingCloser}.`;
-      diagnostics.push({
-        node,
-        message,
-        help: "Fix the syntax error before relying on downstream React-Luau diagnostics in this file."
-      });
-    }
-    return diagnostics;
-  }
-};
-
-// 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);
+  const closer = REQUIRED_CLOSERS.get(node.type);
+  if (!closer)
+    return null;
+  return node.text.trimEnd().endsWith(closer) ? null : closer;
+}
+function isBundledGrammarTypeGap(node) {
+  let current = node;
+  while (current) {
+    if (TYPE_SYNTAX_ANCESTORS.has(current.type)) {
+      if (current.type !== "type_definition")
+        return true;
+      if (/^\s*(?:export\s+)?type\s+[A-Za-z_][A-Za-z0-9_]*/s.test(current.text))
+        return true;
     }
+    current = current.parent;
   }
-  return aliases;
+  return false;
 }
-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);
+var parseErrors = {
+  id: "react-luau/parse-error",
+  category: "Correctness",
+  severity: "error",
+  description: "Report executable Luau syntax that the bundled parser cannot form into a complete syntax tree.",
+  run(context) {
+    const diagnostics = [];
+    const covered = [];
+    for (const node of context.walk()) {
+      const missingCloser = incompleteDelimitedNode(node);
+      if (!node.isError && !node.isMissing && !missingCloser)
+        continue;
+      if (isBundledGrammarTypeGap(node))
+        continue;
+      if (covered.some((range) => node.startIndex >= range.start && node.endIndex <= range.end))
+        continue;
+      covered.push({ start: node.startIndex, end: node.endIndex });
+      let message = "Luau syntax could not be parsed cleanly at this location.";
+      if (node.isMissing)
+        message = `Luau syntax is missing ${node.type}.`;
+      else if (missingCloser)
+        message = `Luau syntax is missing closing ${missingCloser}.`;
+      diagnostics.push({
+        node,
+        message,
+        help: "Fix the syntax error before relying on downstream React-Luau diagnostics in this file."
+      });
+    }
+    return diagnostics;
   }
-}
+};
 
 // src/rules/performance-rules.ts
-var HIGH_FREQUENCY = /(?:RenderStepped|Heartbeat|Stepped|PreRender|PreSimulation|PostSimulation)\s*:\s*Connect|BindToRenderStep|BindToSimulation/;
 var STATIC_DISCOVERY = /(?::|\.)(GetChildren|GetDescendants)$/;
 var PURE_TRIVIAL_CALLS = /^(?:tostring|tonumber|type|typeof|math\.[A-Za-z_][A-Za-z0-9_]*|string\.(?:lower|upper|format|len)|Color3\.(?:new|fromRGB|fromHSV)|Vector[23]\.new|UDim2?\.(?:new|fromOffset|fromScale)|CFrame\.new)$/;
 function declarationForCall(call) {
@@ -3314,7 +3817,7 @@ function identifierReferences(context, owner, name, declaration) {
       continue;
     if (isIdentifierPropertyName(node))
       continue;
-    if (isNameShadowedBetween(node, owner, name))
+    if (isBindingShadowedBetween(node, owner, name, declaration))
       continue;
     result.push(node);
   }
@@ -3329,17 +3832,14 @@ function nearestAncestor(node, stop, type) {
   }
   return null;
 }
-function highFrequencyCallback(node) {
+function highFrequencyCallback(node, context) {
   let current = node.parent;
   while (current) {
     if (current.type === "function_definition") {
       const argumentsNode = current.parent;
       const call = argumentsNode?.type === "arguments" ? argumentsNode.parent : null;
-      if (call?.type === "function_call") {
-        const name = call.childForFieldName("name")?.text ?? "";
-        if (HIGH_FREQUENCY.test(name))
-          return current;
-      }
+      if (call?.type === "function_call" && isHighFrequencyRunServiceCall(call, context))
+        return current;
     }
     current = current.parent;
   }
@@ -3477,7 +3977,7 @@ var rerenderHighFrequencyState = {
     const diagnostics = [];
     const seen = new Set;
     for (const call of context.findCalls()) {
-      const callback = highFrequencyCallback(call);
+      const callback = highFrequencyCallback(call, context);
       if (!callback)
         continue;
       const component = context.containingComponent(call);
@@ -3770,7 +4270,6 @@ var preferUseRefForMutableCell = {
 };
 
 // src/rules/prefer-binding-over-state.ts
-var HIGH_FREQUENCY2 = /(?:RenderStepped|Heartbeat|Stepped|PreRender|PreSimulation|PostSimulation)\s*:\s*Connect|BindToRenderStep|BindToSimulation/;
 var EXTERNAL_CALLBACK = /(?:^|[.:])(?:Connect|Once|Subscribe|Observe|Listen|Watch)$/i;
 var NON_BINDABLE_HOST_FIELDS = new Set(["ref", "key", "children"]);
 function replaceWithinNode(container, target, replacement) {
@@ -3925,7 +4424,7 @@ function isReadNode(node, valueName, owner, declaration) {
     return false;
   if (isIdentifierPropertyName2(node))
     return false;
-  if (isNameShadowedBetween(node, owner, valueName))
+  if (isBindingShadowedBetween(node, owner, valueName, declaration))
     return false;
   const parent = node.parent;
   if (parent?.type === "variable_list" || parent?.type === "typed_identifier")
@@ -4030,9 +4529,9 @@ function stateReadsAreBindingCompatible(valueName, owner, declaration, context,
   }
   return reads > 0;
 }
-function callbackSource(path4) {
-  const normalized = path4.replace(/\s+/g, "");
-  const highFrequency = HIGH_FREQUENCY2.test(normalized);
+function callbackSource(call, context) {
+  const normalized = (context.getCallPath(call) ?? "").replace(/\s+/g, "");
+  const highFrequency = isHighFrequencyRunServiceCall(call, context);
   const final = normalized.split(/[.:]/).at(-1) ?? normalized;
   const external = highFrequency || EXTERNAL_CALLBACK.test(normalized) || EXTERNAL_CALLBACK.test(final);
   return { highFrequency, external };
@@ -4047,7 +4546,7 @@ function importedCallbackSource(call, callbackArgument, importedCallbacks, conte
   if (callbackIndex < 0 || !summary.callbackParameterIndexes.includes(callbackIndex))
     return null;
   return {
-    highFrequency: summary.highFrequency || args.some((arg) => HIGH_FREQUENCY2.test(arg.text)),
+    highFrequency: summary.highFrequency || args.some((arg) => isHighFrequencyRunServiceExpression(arg, context)),
     external: true
   };
 }
@@ -4059,8 +4558,7 @@ function directCallbackSource(node, importedCallbacks, context) {
   const imported = importedCallbackSource(call, node, importedCallbacks, context);
   if (imported)
     return imported;
-  const raw = call.childForFieldName("name")?.text ?? "";
-  const source = callbackSource(raw);
+  const source = callbackSource(call, context);
   return source.external ? source : null;
 }
 function namedFunctionCallbackSource(fn, owner, importedCallbacks, context) {
@@ -4076,7 +4574,7 @@ function namedFunctionCallbackSource(fn, owner, importedCallbacks, context) {
     if (!callbackArg)
       continue;
     const imported = importedCallbackSource(call, callbackArg, importedCallbacks, context);
-    const source = imported ?? callbackSource(context.getCallPath(call) ?? "");
+    const source = imported ?? callbackSource(call, context);
     if (!source.external)
       continue;
     foundExternal = true;
@@ -4559,6 +5057,26 @@ function assignmentRight(text) {
   const match = text.match(/^(?:.*?)(?:\+=|-=|\*=|\/=|%=|\^=|\.\.=|=)\s*(.+)$/s);
   return match?.[1]?.trim() ?? null;
 }
+function refDeclaration(owner, refName, context) {
+  if (!owner.body)
+    return null;
+  for (const statement of owner.body.namedChildren) {
+    if (statement.type !== "variable_declaration")
+      continue;
+    const names = declarationNames2(statement);
+    const index = names.indexOf(refName);
+    if (index === -1)
+      continue;
+    const assignment = statement.namedChildren.find((child) => child.type === "assignment_statement");
+    const expressions = assignment?.namedChildren.find((child) => child.type === "expression_list")?.namedChildren ?? [];
+    const expression = expressions[index] ?? expressions[0];
+    if (!expression || expression.type !== "function_call")
+      continue;
+    if (context.resolveCallPath(context.getCallPath(expression) ?? "") === "React.useRef")
+      return statement;
+  }
+  return null;
+}
 function refInitializer(owner, refName, context) {
   if (!owner.body)
     return null;
@@ -4655,6 +5173,9 @@ var noRefCurrentInRender = {
       const refName = refRootFromTarget(target, refs);
       if (!refName || isNilGuardedLazyInit(node, refName))
         continue;
+      const declaration = refDeclaration(owner, refName, context);
+      if (isBindingShadowedBetween(node, owner, refName, declaration))
+        continue;
       const latestValueMirror = isLatestValueMirror(node, owner, refName, context);
       diagnostics.push({
         node: assignmentTargetNode(node),
@@ -4668,7 +5189,7 @@ var noRefCurrentInRender = {
 };
 
 // src/rules/render-side-effects.ts
-function declarationParts(node) {
+function declarationParts2(node) {
   if (node.type !== "variable_declaration")
     return { names: [], expressions: [] };
   const assignment = node.namedChildren.find((child) => child.type === "assignment_statement");
@@ -4679,17 +5200,103 @@ function declarationParts(node) {
     expressions: expressions?.namedChildren ?? []
   };
 }
+function assignmentParts2(node) {
+  if (node.type !== "assignment_statement" || node.parent?.type === "variable_declaration")
+    return { names: [], expressions: [] };
+  const variables = node.namedChildren.find((child) => child.type === "variable_list");
+  const expressions = node.namedChildren.find((child) => child.type === "expression_list");
+  return {
+    names: variables?.namedChildren.filter((child) => child.type === "identifier").map((child) => child.text) ?? [],
+    expressions: expressions?.namedChildren ?? []
+  };
+}
+function bindingParts(node) {
+  return node.type === "variable_declaration" ? declarationParts2(node) : assignmentParts2(node);
+}
+function addSourceBinding(bindings, name, declaration, value) {
+  const existing = bindings.get(name) ?? [];
+  existing.push({ declaration, value });
+  bindings.set(name, existing);
+}
+function nearestScopeContainer(node, context) {
+  const owner = context.nearestFunction(node);
+  let current = node.parent;
+  while (current) {
+    if (current.type === "block")
+      return current;
+    if (owner && current.id === owner.node.id)
+      return owner.body ?? owner.node;
+    current = current.parent;
+  }
+  return context.root;
+}
+function declarationVisibleAt(declaration, node, context) {
+  if (declaration.startIndex >= node.startIndex)
+    return false;
+  const container = nearestScopeContainer(declaration, context);
+  return node.startIndex >= container.startIndex && node.endIndex <= container.endIndex;
+}
+function functionParameterNames(node) {
+  const result = new Set;
+  const parameters = node.childForFieldName("parameters") ?? node.namedChildren.find((child) => child.type === "parameters");
+  for (const parameter of parameters?.namedChildren ?? []) {
+    if (parameter.type === "identifier")
+      result.add(parameter.text);
+    for (const child of parameter.namedChildren) {
+      if (child.type === "identifier")
+        result.add(child.text);
+    }
+  }
+  return result;
+}
+function loopBindsName2(node, name) {
+  if (node.type !== "for_statement")
+    return false;
+  const header = node.text.split(/\bdo\b/s, 1)[0] ?? "";
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^\\s*for\\s+(?:${escaped}\\s*=|[^\\n]*\\b${escaped}\\b[^\\n]*\\bin\\b)`, "s").test(header);
+}
+function bindingShadowedAfterDeclaration(declaration, node, name) {
+  let current = node.parent;
+  while (current) {
+    if (declaration.startIndex >= current.startIndex && declaration.endIndex <= current.endIndex)
+      return false;
+    if ((current.type === "function_definition" || current.type === "function_declaration") && functionParameterNames(current).has(name))
+      return true;
+    if (loopBindsName2(current, name))
+      return true;
+    current = current.parent;
+  }
+  return false;
+}
+function resolveSourceBinding(bindings, name, node, context) {
+  const candidates = bindings.get(name);
+  if (!candidates)
+    return null;
+  for (let index = candidates.length - 1;index >= 0; index -= 1) {
+    const candidate = candidates[index];
+    if (!declarationVisibleAt(candidate.declaration, node, context))
+      continue;
+    if (bindingShadowedAfterDeclaration(candidate.declaration, node, name))
+      return null;
+    return candidate.value;
+  }
+  return null;
+}
 function sourceEffectImports(context) {
   const result = new Map;
   for (const node of context.walk(context.root)) {
-    if (node.type !== "variable_declaration")
+    if (node.type !== "variable_declaration" && node.type !== "assignment_statement")
       continue;
-    const match = node.text.match(/^\s*local\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*require\s*\((.*?)\)\s*$/s);
-    if (!match)
+    if (node.type === "assignment_statement" && node.parent?.type === "variable_declaration")
       continue;
-    const summary = resolveModuleReference(normalizeRequireTarget(match[2]), context.project.sourceEffects);
-    if (summary)
-      result.set(match[1], summary);
+    const { names, expressions } = bindingParts(node);
+    for (let index = 0;index < names.length; index += 1) {
+      const expression = expressions[index] ?? expressions[0];
+      const requireMatch = expression?.type === "function_call" ? expression.text.match(/^\s*require\s*\((.*?)\)\s*$/s) : null;
+      const summary = requireMatch ? resolveModuleReference(normalizeRequireTarget(requireMatch[1]), context.project.sourceEffects) : null;
+      addSourceBinding(result, names[index], node, summary);
+    }
   }
   return result;
 }
@@ -4698,7 +5305,7 @@ function factorySummaryFromCall(call, context, imports) {
   const match = path4.match(/^([A-Za-z_][A-Za-z0-9_]*)[.:]([A-Za-z_][A-Za-z0-9_]*)$/);
   if (!match)
     return null;
-  const summary = imports.get(match[1]);
+  const summary = resolveSourceBinding(imports, match[1], call, context);
   if (!summary?.instanceFactories.has(match[2]))
     return null;
   return summary;
@@ -4719,61 +5326,57 @@ function returnedFactorySummary(callback, context, imports) {
 function sourceEffectInstances(context, imports) {
   const result = new Map;
   for (const node of context.walk(context.root)) {
-    if (node.type !== "variable_declaration")
+    if (node.type !== "variable_declaration" && node.type !== "assignment_statement")
       continue;
-    const { names, expressions } = declarationParts(node);
+    if (node.type === "assignment_statement" && node.parent?.type === "variable_declaration")
+      continue;
+    const { names, expressions } = bindingParts(node);
     for (let index = 0;index < names.length; index += 1) {
       const expression = expressions[index] ?? expressions[0];
-      if (!expression)
-        continue;
-      let summary = null;
-      if (expression.type === "function_call") {
-        summary = factorySummaryFromCall(expression, context, imports);
-        if (!summary && context.resolveCallPath(context.getCallPath(expression) ?? "") === "React.useMemo") {
+      let instance = null;
+      if (expression?.type === "function_call") {
+        const directFactory = factorySummaryFromCall(expression, context, imports);
+        if (directFactory) {
+          instance = {
+            summary: directFactory,
+            persistent: context.nearestFunction(node) === null
+          };
+        } else if (context.resolveCallPath(context.getCallPath(expression) ?? "") === "React.useMemo") {
           const callback = context.callArguments(expression)[0];
-          if (callback?.type === "function_definition")
-            summary = returnedFactorySummary(callback, context, imports);
+          if (callback?.type === "function_definition") {
+            const memoizedFactory = returnedFactorySummary(callback, context, imports);
+            if (memoizedFactory)
+              instance = { summary: memoizedFactory, persistent: true };
+          }
         }
-      } else if (expression.type === "identifier") {
-        summary = result.get(expression.text) ?? null;
-      }
-      if (summary)
-        result.set(names[index], summary);
-    }
-  }
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (const node of context.walk(context.root)) {
-      if (node.type !== "variable_declaration")
-        continue;
-      const { names, expressions } = declarationParts(node);
-      for (let index = 0;index < names.length; index += 1) {
-        if (result.has(names[index]))
-          continue;
-        const expression = expressions[index] ?? expressions[0];
-        if (expression?.type !== "identifier")
-          continue;
-        const summary = result.get(expression.text);
-        if (!summary)
-          continue;
-        result.set(names[index], summary);
-        changed = true;
+      } else if (expression?.type === "identifier") {
+        instance = resolveSourceBinding(result, expression.text, expression, context);
       }
+      addSourceBinding(result, names[index], node, instance);
     }
   }
   return result;
 }
 function sourceInferredEffectCall(call, context, imports, instances) {
   const path4 = context.getCallPath(call)?.replace(/\s+/g, "") ?? "";
-  const direct = imports.get(path4);
-  if (direct?.effectfulExport)
-    return true;
+  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(path4)) {
+    const direct = resolveSourceBinding(imports, path4, call, context);
+    if (direct?.effectfulExport)
+      return true;
+  }
   const member = path4.match(/^([A-Za-z_][A-Za-z0-9_]*)[.:]([A-Za-z_][A-Za-z0-9_]*)$/);
   if (!member)
     return false;
-  const summary = imports.get(member[1]) ?? instances.get(member[1]);
-  return summary?.effectfulMembers.has(member[2]) ?? false;
+  const instance = resolveSourceBinding(instances, member[1], call, context);
+  if (instance) {
+    if (instance.summary.effectfulMembers.has(member[2]))
+      return true;
+    return instance.persistent && instance.summary.mutatingMembers.has(member[2]);
+  }
+  const imported = resolveSourceBinding(imports, member[1], call, context);
+  if (!imported)
+    return false;
+  return imported.effectfulMembers.has(member[2]) || imported.mutatingMembers.has(member[2]);
 }
 var RENDER_EFFECT_PATTERNS = [
   /^Instance\.new$/,
@@ -4785,7 +5388,6 @@ var RENDER_EFFECT_PATTERNS = [
   /BindToRenderStep$/,
   /BindToSimulation$/,
   /:Destroy$/,
-  /:render$/,
   /:unmount$/
 ];
 function hasNestedKnownRenderSideEffect(call, context) {
@@ -4797,7 +5399,7 @@ function hasNestedKnownRenderSideEffect(call, context) {
     const path4 = context.resolveCallPath(context.getCallPath(node) ?? "");
     if (path4 === "task.spawn" || path4 === "task.defer" || path4 === "task.delay")
       return true;
-    if (knownYieldReason(path4) || RENDER_EFFECT_PATTERNS.some((pattern) => pattern.test(path4)))
+    if (knownYieldReason(path4, node, context) || RENDER_EFFECT_PATTERNS.some((pattern) => pattern.test(path4)))
       return true;
   }
   return false;
@@ -4814,7 +5416,7 @@ var noYieldInRender = {
       if (!component || !context.isDirectlyExecutedInFunction(call, component))
         continue;
       const path4 = context.resolveCallPath(context.getCallPath(call) ?? "");
-      const reason = knownYieldReason(path4);
+      const reason = knownYieldReason(path4, call, context);
       if (!reason)
         continue;
       diagnostics.push({
@@ -5447,7 +6049,7 @@ function directlyReadsValue(context, owner, binding) {
       continue;
     if (isNestedFunctionFromOwner(context, node, owner))
       continue;
-    if (isNameShadowedBetween(node, owner, binding.valueName))
+    if (isBindingShadowedBetween(node, owner, binding.valueName, binding.declaration))
       continue;
     return true;
   }
@@ -5455,7 +6057,7 @@ function directlyReadsValue(context, owner, binding) {
     if (!fn.body)
       continue;
     for (const node of context.walk(fn.body)) {
-      if (isIdentifierRead(node, binding.valueName) && !isNameShadowedBetween(node, owner, binding.valueName))
+      if (isIdentifierRead(node, binding.valueName) && !isBindingShadowedBetween(node, owner, binding.valueName, binding.declaration))
         return true;
     }
   }
@@ -5635,13 +6237,20 @@ var noDirectStateMutation = {
         let mutates = false;
         if (node.type === "assignment_statement" || node.type === "update_statement") {
           mutates = new RegExp(`^\\s*${escaped}\\s*(?:\\.|\\[)`).test(node.text);
-        } else if (node.type === "function_call") {
-          const path4 = context.getCallPath(node) ?? "";
-          if (["table.insert", "table.remove", "table.sort", "table.clear", "table.move"].includes(path4)) {
-            mutates = context.callArguments(node)[0]?.text.trim() === binding.valueName;
+        } else if (node.type === "function_call" && mightMutateParameters(context, node)) {
+          const arguments_ = context.callArguments(node);
+          for (const index of mutatedParameterIndexesForCall(context, node, owner)) {
+            const argument = arguments_[index];
+            if (!argument)
+              continue;
+            const origin = mutationOriginForExpression(context, argument, owner);
+            if (origin.kind === "state" && origin.binding === binding) {
+              mutates = true;
+              break;
+            }
           }
         }
-        if (!mutates || isNameShadowedBetween(node, owner, binding.valueName))
+        if (!mutates || isBindingShadowedBetween(node, owner, binding.valueName, binding.declaration))
           continue;
         const key = `${node.startIndex}:${binding.valueName}`;
         if (seen.has(key))
@@ -5834,6 +6443,27 @@ function topLevelReturnName(root) {
   }
   return null;
 }
+function topLevelImports2(root, moduleAliases) {
+  const imports = new Map;
+  for (const node of root.namedChildren) {
+    if (node.type !== "variable_declaration")
+      continue;
+    const { names, expressions } = declarationParts3(node);
+    for (let index = 0;index < names.length; index += 1) {
+      const expression = expressions[index] ?? expressions[0];
+      if (expression?.type !== "function_call")
+        continue;
+      const text = expression.text.trim();
+      const match = text.match(/^require\s*\((.*?)\)\s*$/s);
+      if (!match)
+        continue;
+      const moduleId = resolveModuleReference(normalizeRequireTarget(match[1]), moduleAliases);
+      if (moduleId)
+        imports.set(names[index], moduleId);
+    }
+  }
+  return imports;
+}
 function parameterNames3(node) {
   const parameters = child(node, "parameters");
   if (!parameters)
@@ -5848,7 +6478,7 @@ function parameterNames3(node) {
   }
   return result;
 }
-function declarationParts2(node) {
+function declarationParts3(node) {
   if (node.type !== "variable_declaration")
     return { names: [], expressions: [] };
   const assignment = child(node, "assignment_statement");
@@ -5884,6 +6514,45 @@ function rootIdentifier2(node) {
   const text = node.text.trim();
   return text.match(/^([A-Za-z_][A-Za-z0-9_]*)/)?.[1] ?? null;
 }
+function callArguments(node) {
+  if (node.type !== "function_call")
+    return [];
+  return node.childForFieldName("arguments")?.namedChildren ?? [];
+}
+function builtinMutatedArgumentIndexes(path5, argumentCount) {
+  switch (path5.replace(/\s+/g, "")) {
+    case "rawset":
+    case "setmetatable":
+    case "table.clear":
+    case "table.freeze":
+    case "table.insert":
+    case "table.remove":
+    case "table.sort":
+      return argumentCount > 0 ? [0] : [];
+    case "table.move":
+      return argumentCount >= 5 ? [4] : argumentCount > 0 ? [0] : [];
+    default:
+      return [];
+  }
+}
+function expressionCreatesOwnedValue(node, owned) {
+  if (node.type === "table_constructor" || node.type === "function_definition")
+    return true;
+  if (node.type !== "function_call")
+    return false;
+  const path5 = callPath(node)?.replace(/\s+/g, "") ?? "";
+  if (path5 === "table.clone" || path5 === "table.create" || path5 === "table.pack")
+    return true;
+  if (path5 !== "setmetatable" && path5 !== "table.freeze")
+    return false;
+  const first = callArguments(node)[0];
+  if (!first)
+    return false;
+  if (first.type === "table_constructor")
+    return true;
+  const root = rootIdentifier2(first);
+  return Boolean(root && owned.has(root));
+}
 function directNodes(body) {
   const result = [];
   const visit = (node) => {
@@ -5914,7 +6583,14 @@ function topLevelFunctionRecords(record) {
       body,
       parameters: parameterNames3(node),
       directEffect: false,
-      dependencies: new Set
+      mutatesReceiver: false,
+      mutatedParameterIndexes: new Set,
+      dependencies: new Set,
+      mutationCalls: [],
+      parameterOrigins: new Map,
+      externalRoots: new Set,
+      ownedRoots: new Set,
+      localNames: new Set
     });
   };
   for (const node of record.tree.rootNode.namedChildren) {
@@ -5931,7 +6607,7 @@ function topLevelFunctionRecords(record) {
       continue;
     }
     if (node.type === "variable_declaration") {
-      const { names, expressions } = declarationParts2(node);
+      const { names, expressions } = declarationParts3(node);
       for (let index = 0;index < names.length; index += 1) {
         const expression = expressions[index] ?? expressions[0];
         if (expression?.type !== "function_definition")
@@ -5983,7 +6659,7 @@ function moduleLevelInstanceAliases(record, summariesByModuleId) {
   for (const node of record.tree.rootNode.namedChildren) {
     if (node.type !== "variable_declaration")
       continue;
-    const { names, expressions } = declarationParts2(node);
+    const { names, expressions } = declarationParts3(node);
     for (let index = 0;index < names.length; index += 1) {
       const expression = expressions[index] ?? expressions[0];
       if (expression?.type !== "function_call")
@@ -6002,34 +6678,50 @@ function moduleLevelInstanceAliases(record, summariesByModuleId) {
 }
 function analyzeFunction(fn, record, localFunctions, memberFunctions, moduleSummaries, moduleInstances, exportedFunctions) {
   const parameters = new Set(fn.parameters);
-  if (fn.method)
+  const parameterOrigins = new Map(fn.parameters.map((name, index) => [name, index]));
+  if (fn.method) {
     parameters.add("self");
+    parameterOrigins.set("self", -1);
+  }
   const locals = new Set;
   const owned = new Set;
   const externalAliases = new Set;
+  const refLocals = new Set;
   const instanceAliases = new Map(moduleInstances);
   const nodes = directNodes(fn.body);
   for (const node of nodes) {
+    if (node.type === "function_declaration" && node.id !== fn.node.id) {
+      const declared = node.childForFieldName("name")?.text.replace(/\s+/g, "") ?? "";
+      if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(declared))
+        locals.add(declared);
+      continue;
+    }
     if (node.type !== "variable_declaration")
       continue;
-    const { names, expressions } = declarationParts2(node);
+    const { names, expressions } = declarationParts3(node);
     for (let index = 0;index < names.length; index += 1) {
       const name = names[index];
       const expression = expressions[index] ?? expressions[0];
       locals.add(name);
       if (!expression)
         continue;
-      if (expression.type === "table_constructor" || expression.type === "function_definition")
+      const createsOwnedValue = expressionCreatesOwnedValue(expression, owned);
+      if (createsOwnedValue)
         owned.add(name);
       const root = rootIdentifier2(expression);
-      if (root && (parameters.has(root) || externalAliases.has(root) || !locals.has(root) && root !== name)) {
+      const parameterOrigin = root ? parameterOrigins.get(root) : undefined;
+      if (!createsOwnedValue && root && parameterOrigin !== undefined) {
+        parameterOrigins.set(name, parameterOrigin);
+      } else if (!createsOwnedValue && root && (externalAliases.has(root) || !locals.has(root) && root !== name)) {
         externalAliases.add(name);
       } else if (root && owned.has(root)) {
         owned.add(name);
       }
       if (expression.type === "function_call") {
-        const path5 = callPath(expression);
-        const match = path5?.match(/^([A-Za-z_][A-Za-z0-9_]*)[.:]([A-Za-z_][A-Za-z0-9_]*)$/);
+        const path5 = callPath(expression)?.replace(/\s+/g, "") ?? "";
+        if (path5 === "React.useRef")
+          refLocals.add(name);
+        const match = path5.match(/^([A-Za-z_][A-Za-z0-9_]*)[.:]([A-Za-z_][A-Za-z0-9_]*)$/);
         if (match) {
           const moduleId = record.imports.get(match[1]);
           const summary = moduleId ? moduleSummaries.get(moduleId) : null;
@@ -6039,6 +6731,10 @@ function analyzeFunction(fn, record, localFunctions, memberFunctions, moduleSumm
       }
     }
   }
+  fn.parameterOrigins = parameterOrigins;
+  fn.externalRoots = externalAliases;
+  fn.ownedRoots = owned;
+  fn.localNames = locals;
   for (const node of nodes) {
     if (node.type === "assignment_statement" && node.parent?.type !== "variable_declaration") {
       const { left } = assignmentSides(node);
@@ -6053,7 +6749,17 @@ function analyzeFunction(fn, record, localFunctions, memberFunctions, moduleSumm
           continue;
         if (owned.has(root))
           continue;
-        if (parameters.has(root) || externalAliases.has(root) || !locals.has(root))
+        if (refLocals.has(root) && target.text.replace(/\s+/g, "") === `${root}.current`)
+          continue;
+        const parameterOrigin = parameterOrigins.get(root);
+        if (parameterOrigin !== undefined) {
+          if (parameterOrigin === -1)
+            fn.mutatesReceiver = true;
+          else
+            fn.mutatedParameterIndexes.add(parameterOrigin);
+          continue;
+        }
+        if (externalAliases.has(root) || !locals.has(root))
           fn.directEffect = true;
       }
       continue;
@@ -6063,39 +6769,174 @@ function analyzeFunction(fn, record, localFunctions, memberFunctions, moduleSumm
     const path5 = callPath(node);
     if (!path5)
       continue;
-    const localTarget = localFunctions.get(path5);
-    if (localTarget)
+    const arguments_ = callArguments(node);
+    for (const index of builtinMutatedArgumentIndexes(path5, arguments_.length)) {
+      markMutationThroughRoot(fn, rootIdentifier2(arguments_[index]));
+    }
+    const localTarget = !locals.has(path5) && !parameters.has(path5) ? localFunctions.get(path5) : null;
+    if (localTarget) {
       fn.dependencies.add(localTarget);
-    const sameMember = path5.match(/^(?:self|[A-Za-z_][A-Za-z0-9_]*)[:.]([A-Za-z_][A-Za-z0-9_]*)$/);
+      fn.mutationCalls.push({
+        targetId: localTarget,
+        receiverRoot: null,
+        argumentRoots: arguments_.map((argument) => rootIdentifier2(argument))
+      });
+    }
+    const sameMember = path5.match(/^([A-Za-z_][A-Za-z0-9_]*)([:.])([A-Za-z_][A-Za-z0-9_]*)$/);
     if (sameMember) {
-      const receiver = path5.split(/[.:]/, 1)[0];
-      if (receiver === "self" || receiver === record.exportName) {
-        const target = memberFunctions.get(sameMember[1]);
-        if (target)
+      const receiver = sameMember[1];
+      if (receiver === "self" || receiver === record.exportName && !locals.has(receiver) && !parameters.has(receiver)) {
+        const target = memberFunctions.get(sameMember[3]);
+        if (target) {
           fn.dependencies.add(target);
+          fn.mutationCalls.push({
+            targetId: target,
+            receiverRoot: sameMember[2] === ":" ? receiver : null,
+            argumentRoots: arguments_.map((argument) => rootIdentifier2(argument))
+          });
+        }
       }
     }
-    const importedMember = path5.match(/^([A-Za-z_][A-Za-z0-9_]*)[.:]([A-Za-z_][A-Za-z0-9_]*)$/);
+    const importedMember = path5.match(/^([A-Za-z_][A-Za-z0-9_]*)([.:])([A-Za-z_][A-Za-z0-9_]*)$/);
     if (importedMember) {
-      const moduleId = record.imports.get(importedMember[1]) ?? instanceAliases.get(importedMember[1]);
-      if (moduleId)
-        fn.dependencies.add(`${moduleId}::member:${importedMember[2]}`);
-    } else {
+      const root = importedMember[1];
+      const moduleId = instanceAliases.get(root) ?? (!locals.has(root) && !parameters.has(root) ? record.imports.get(root) : undefined);
+      if (moduleId) {
+        const target = `${moduleId}::member:${importedMember[3]}`;
+        fn.dependencies.add(target);
+        fn.mutationCalls.push({
+          targetId: target,
+          receiverRoot: importedMember[2] === ":" ? root : null,
+          argumentRoots: arguments_.map((argument) => rootIdentifier2(argument))
+        });
+      }
+    } else if (!locals.has(path5) && !parameters.has(path5)) {
       const moduleId = record.imports.get(path5);
       const target = moduleId ? exportedFunctions.get(moduleId) : null;
-      if (target)
+      if (target) {
         fn.dependencies.add(target);
+        fn.mutationCalls.push({
+          targetId: target,
+          receiverRoot: null,
+          argumentRoots: arguments_.map((argument) => rootIdentifier2(argument))
+        });
+      }
+    }
+  }
+}
+function markMutationThroughRoot(fn, root) {
+  if (!root)
+    return false;
+  const parameterOrigin = fn.parameterOrigins.get(root);
+  if (parameterOrigin !== undefined) {
+    if (parameterOrigin === -1) {
+      if (fn.mutatesReceiver)
+        return false;
+      fn.mutatesReceiver = true;
+      return true;
+    }
+    if (fn.mutatedParameterIndexes.has(parameterOrigin))
+      return false;
+    fn.mutatedParameterIndexes.add(parameterOrigin);
+    return true;
+  }
+  if (fn.ownedRoots.has(root))
+    return false;
+  if (fn.externalRoots.has(root) || !fn.localNames.has(root)) {
+    if (fn.directEffect)
+      return false;
+    fn.directEffect = true;
+    return true;
+  }
+  if (fn.localNames.has(root))
+    return false;
+  return false;
+}
+function propagateLocalMutationEffects(functions) {
+  const byId = new Map(functions.map((fn) => [fn.id, fn]));
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const fn of functions) {
+      for (const call of fn.mutationCalls) {
+        const target = byId.get(call.targetId);
+        if (!target)
+          continue;
+        if (target.mutatesReceiver && markMutationThroughRoot(fn, call.receiverRoot))
+          changed = true;
+        for (const index of target.mutatedParameterIndexes) {
+          if (markMutationThroughRoot(fn, call.argumentRoots[index] ?? null))
+            changed = true;
+        }
+      }
+    }
+  }
+}
+function mutationOriginForRoot(fn, root) {
+  if (!root)
+    return null;
+  const parameterOrigin = fn.parameterOrigins.get(root);
+  if (parameterOrigin === -1)
+    return { kind: "receiver" };
+  if (parameterOrigin !== undefined)
+    return { kind: "parameter", index: parameterOrigin };
+  if (fn.ownedRoots.has(root) || fn.localNames.has(root))
+    return { kind: "local" };
+  if (fn.externalRoots.has(root) || !fn.localNames.has(root))
+    return { kind: "external" };
+  return null;
+}
+function cachedMutationCalls(fn) {
+  return fn.mutationCalls.map((call) => ({
+    targetId: call.targetId,
+    receiverOrigin: mutationOriginForRoot(fn, call.receiverRoot),
+    argumentOrigins: call.argumentRoots.map((root) => mutationOriginForRoot(fn, root))
+  }));
+}
+function applyCachedMutationOrigin(fn, origin) {
+  if (!origin || origin.kind === "local")
+    return false;
+  if (origin.kind === "external") {
+    if (fn.directEffect)
+      return false;
+    fn.directEffect = true;
+    return true;
+  }
+  if (origin.kind === "receiver") {
+    if (fn.mutatesReceiver)
+      return false;
+    fn.mutatesReceiver = true;
+    return true;
+  }
+  if (fn.mutatedParameterIndexes.includes(origin.index))
+    return false;
+  fn.mutatedParameterIndexes.push(origin.index);
+  fn.mutatedParameterIndexes.sort((a, b) => a - b);
+  return true;
+}
+function propagateMutationEffects(functions) {
+  const byId = new Map(functions.map((fn) => [fn.id, fn]));
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const fn of functions) {
+      for (const call of fn.mutationCalls) {
+        const target = byId.get(call.targetId);
+        if (!target)
+          continue;
+        if (target.mutatesReceiver && applyCachedMutationOrigin(fn, call.receiverOrigin))
+          changed = true;
+        for (const index of target.mutatedParameterIndexes) {
+          if (applyCachedMutationOrigin(fn, call.argumentOrigins[index] ?? null))
+            changed = true;
+        }
+      }
     }
   }
 }
 async function indexEffectModuleForWorker(input, moduleAliases) {
   const tree = await parseLuau(input.source);
-  const imports = new Map;
-  for (const match of input.source.matchAll(/\blocal\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*require\s*\((.*?)\)/gs)) {
-    const moduleId = resolveModuleReference(normalizeRequireTarget(match[2]), moduleAliases);
-    if (moduleId)
-      imports.set(match[1], moduleId);
-  }
+  const imports = topLevelImports2(tree.rootNode, moduleAliases);
   const record = {
     id: input.id,
     keys: input.keys,
@@ -6136,6 +6977,7 @@ function analyzeEffectModuleForWorker(state, moduleSummaries, exportedFunctions)
   for (const fn of state.functions) {
     analyzeFunction(fn, state.record, localFunctions, memberFunctions, moduleSummaries, moduleInstances, exportedFunctions);
   }
+  propagateLocalMutationEffects(state.functions);
   return {
     id: state.record.id,
     functions: state.functions.map((fn) => ({
@@ -6145,7 +6987,10 @@ function analyzeEffectModuleForWorker(state, moduleSummaries, exportedFunctions)
       memberName: fn.memberName,
       exported: fn.exported,
       directEffect: fn.directEffect,
-      dependencies: [...fn.dependencies].sort()
+      mutatesReceiver: fn.mutatesReceiver,
+      mutatedParameterIndexes: [...fn.mutatedParameterIndexes].sort((a, b) => a - b),
+      dependencies: [...fn.dependencies].sort(),
+      mutationCalls: cachedMutationCalls(fn)
     }))
   };
 }
@@ -6222,6 +7067,10 @@ async function buildProjectSourceEffects(root, candidates, parseCache, onProgres
         summariesByModuleId.set(identity.id, {
           effectfulMembers: new Set,
           effectfulExport: false,
+          mutatingMembers: new Set,
+          mutatingExportParameters: new Set,
+          mutatingMemberParameters: new Map,
+          localMutatingParameters: new Map,
           instanceFactories: new Set(indexed.instanceFactories)
         });
         if (indexed.exportedFunctionId)
@@ -6234,6 +7083,10 @@ async function buildProjectSourceEffects(root, candidates, parseCache, onProgres
         summariesByModuleId.set(identity.id, {
           effectfulMembers: new Set,
           effectfulExport: false,
+          mutatingMembers: new Set,
+          mutatingExportParameters: new Set,
+          mutatingMemberParameters: new Map,
+          localMutatingParameters: new Map,
           instanceFactories: new Set(cached?.instanceFactories ?? [])
         });
         const exported = functions2.find((fn) => fn.exported && !fn.memberName);
@@ -6269,12 +7122,7 @@ async function buildProjectSourceEffects(root, candidates, parseCache, onProgres
         const source = candidate.source ?? fs3.readFileSync(candidate.absolutePath, "utf8");
         const tree = await parseLuau(source);
         parseCache?.set(relativePath, { source, tree });
-        const imports = new Map;
-        for (const match of source.matchAll(/\blocal\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*require\s*\((.*?)\)/gs)) {
-          const moduleId = resolveModuleReference(normalizeRequireTarget(match[2]), moduleAliases);
-          if (moduleId)
-            imports.set(match[1], moduleId);
-        }
+        const imports = topLevelImports2(tree.rootNode, moduleAliases);
         rawRecords.set(identity.id, {
           id: identity.id,
           keys: identity.keys,
@@ -6299,6 +7147,10 @@ async function buildProjectSourceEffects(root, candidates, parseCache, onProgres
         const summary = {
           effectfulMembers: new Set,
           effectfulExport: false,
+          mutatingMembers: new Set,
+          mutatingExportParameters: new Set,
+          mutatingMemberParameters: new Map,
+          localMutatingParameters: new Map,
           instanceFactories: new Set
         };
         for (const fn of functions2) {
@@ -6313,6 +7165,10 @@ async function buildProjectSourceEffects(root, candidates, parseCache, onProgres
         summariesByModuleId.set(identity.id, {
           effectfulMembers: new Set,
           effectfulExport: false,
+          mutatingMembers: new Set,
+          mutatingExportParameters: new Set,
+          mutatingMemberParameters: new Map,
+          localMutatingParameters: new Map,
           instanceFactories: new Set(cached?.instanceFactories ?? [])
         });
       }
@@ -6354,6 +7210,7 @@ async function buildProjectSourceEffects(root, candidates, parseCache, onProgres
       for (const fn of functions2) {
         analyzeFunction(fn, record, localFunctions, memberFunctions, summariesByModuleId, moduleInstances, exportedFunctions);
       }
+      propagateLocalMutationEffects(functions2);
       analyzedFunctionStatesByModule.set(moduleId, functions2.map((fn) => ({
         id: fn.id,
         moduleId: fn.moduleId,
@@ -6361,7 +7218,10 @@ async function buildProjectSourceEffects(root, candidates, parseCache, onProgres
         memberName: fn.memberName,
         exported: fn.exported,
         directEffect: fn.directEffect,
-        dependencies: [...fn.dependencies].sort()
+        mutatesReceiver: fn.mutatesReceiver,
+        mutatedParameterIndexes: [...fn.mutatedParameterIndexes].sort((a, b) => a - b),
+        dependencies: [...fn.dependencies].sort(),
+        mutationCalls: cachedMutationCalls(fn)
       })));
       analyzedModuleCount += 1;
       if ((analyzedModuleCount & 31) === 0 || analyzedModuleCount === rawRecords.size) {
@@ -6375,7 +7235,13 @@ async function buildProjectSourceEffects(root, candidates, parseCache, onProgres
   const cacheModulesResult = {};
   let assembledCount = 0;
   for (const identity of identities) {
-    const states = (analyzedFunctionStatesByModule.get(identity.id) ?? cachedFunctionStates.get(identity.id) ?? []).map((fn) => ({ ...fn, dependencies: [...fn.dependencies] }));
+    const states = (analyzedFunctionStatesByModule.get(identity.id) ?? cachedFunctionStates.get(identity.id) ?? []).map((fn) => ({
+      ...fn,
+      mutatesReceiver: fn.mutatesReceiver ?? false,
+      mutatedParameterIndexes: [...fn.mutatedParameterIndexes ?? []],
+      dependencies: [...fn.dependencies],
+      mutationCalls: [...fn.mutationCalls ?? []]
+    }));
     for (const fn of states)
       functionStates.set(fn.id, fn);
     const summary = summariesByModuleId.get(identity.id);
@@ -6392,6 +7258,7 @@ async function buildProjectSourceEffects(root, candidates, parseCache, onProgres
       onProgress?.({ phase: "assemble-graph", current: assembledCount, total: graphAssemblyTotal });
     }
   }
+  propagateMutationEffects([...functionStates.values()]);
   const reverseDependencies = new Map;
   const functions = [...functionStates.values()];
   onProgress?.({ phase: "resolve", current: 0, total: functions.length });
@@ -6438,17 +7305,33 @@ async function buildProjectSourceEffects(root, candidates, parseCache, onProgres
   for (const summary of summariesByModuleId.values()) {
     summary.effectfulMembers.clear();
     summary.effectfulExport = false;
+    summary.mutatingMembers.clear();
+    summary.mutatingExportParameters.clear();
+    summary.mutatingMemberParameters.clear();
+    summary.localMutatingParameters.clear();
   }
   for (let index = 0;index < functions.length; index += 1) {
     const fn = functions[index];
-    if (effectful.has(fn.id)) {
-      const summary = summariesByModuleId.get(fn.moduleId);
-      if (summary) {
-        if (fn.memberName)
-          summary.effectfulMembers.add(fn.memberName);
-        if (fn.exported)
-          summary.effectfulExport = true;
+    const summary = summariesByModuleId.get(fn.moduleId);
+    if (summary && fn.memberName && fn.mutatesReceiver)
+      summary.mutatingMembers.add(fn.memberName);
+    if (summary && fn.mutatedParameterIndexes.length > 0) {
+      if (fn.exported && !fn.memberName) {
+        for (const parameterIndex of fn.mutatedParameterIndexes)
+          summary.mutatingExportParameters.add(parameterIndex);
+      }
+      if (fn.memberName) {
+        summary.mutatingMemberParameters.set(fn.memberName, new Set(fn.mutatedParameterIndexes));
       }
+      if (fn.localName) {
+        summary.localMutatingParameters.set(fn.localName, new Set(fn.mutatedParameterIndexes));
+      }
+    }
+    if (summary && effectful.has(fn.id)) {
+      if (fn.memberName)
+        summary.effectfulMembers.add(fn.memberName);
+      if (fn.exported)
+        summary.effectfulExport = true;
     }
     if ((index & 127) === 127 || index + 1 === functions.length) {
       onProgress?.({ phase: "summarize", current: index + 1, total: summarizeTotal });
@@ -6506,5 +7389,5 @@ parentPort.on("message", async (request) => {
   }
 });
 
-//# debugId=3C9B971F9740996964756E2164756E21
+//# debugId=D3DA65AABFE680C664756E2164756E21
 //# sourceMappingURL=scan-worker.js.map