babel-plugin-react-compiler 0.0.0-experimental-fe484b5-20240912 → 0.0.0-experimental-23b8160-20240916

package/dist/index.js

@@ -135625,6 +135625,31 @@ function getOrInsertDefault(m, key, defaultValue) {
     return defaultValue;
   }
 }
+function Set_union(a, b) {
+  const union = new Set(a);
+  for (const item of b) {
+    union.add(item);
+  }
+  return union;
+}
+function Set_intersect(sets) {
+  if (sets.length === 0 || sets.some(s => s.size === 0)) {
+    return new Set();
+  } else if (sets.length === 1) {
+    return new Set(sets[0]);
+  }
+  const result = new Set();
+  const first = sets[0];
+  outer: for (const e of first) {
+    for (let i = 1; i < sets.length; i++) {
+      if (!sets[i].has(e)) {
+        continue outer;
+      }
+    }
+    result.add(e);
+  }
+  return result;
+}
 function Iterable_some(iter, pred) {
   for (const item of iter) {
     if (pred(item)) {
@@ -140998,6 +141023,7 @@ function getFunctionName$1(instrValue, defaultValue) {
       return defaultValue;
   }
 }
+var _ScopeBlockTraversal_activeScopes;
 function* eachInstructionLValue(instr) {
   if (instr.lvalue !== null) {
     yield instr.lvalue;
@@ -142052,6 +142078,93 @@ function* eachTerminalOperand(terminal) {
     }
   }
 }
+class ScopeBlockTraversal {
+  constructor() {
+    _ScopeBlockTraversal_activeScopes.set(this, []);
+    this.blockInfos = new Map();
+  }
+  recordScopes(block) {
+    var _a, _b;
+    const blockInfo = this.blockInfos.get(block.id);
+    if (
+      (blockInfo === null || blockInfo === void 0 ? void 0 : blockInfo.kind) ===
+      'begin'
+    ) {
+      __classPrivateFieldGet(this, _ScopeBlockTraversal_activeScopes, 'f').push(
+        blockInfo.scope.id
+      );
+    } else if (
+      (blockInfo === null || blockInfo === void 0 ? void 0 : blockInfo.kind) ===
+      'end'
+    ) {
+      const top = __classPrivateFieldGet(
+        this,
+        _ScopeBlockTraversal_activeScopes,
+        'f'
+      ).at(-1);
+      CompilerError.invariant(blockInfo.scope.id === top, {
+        reason:
+          'Expected traversed block fallthrough to match top-most active scope',
+        loc:
+          (_b =
+            (_a = block.instructions[0]) === null || _a === void 0
+              ? void 0
+              : _a.loc) !== null && _b !== void 0
+            ? _b
+            : block.terminal.id,
+      });
+      __classPrivateFieldGet(
+        this,
+        _ScopeBlockTraversal_activeScopes,
+        'f'
+      ).pop();
+    }
+    if (
+      block.terminal.kind === 'scope' ||
+      block.terminal.kind === 'pruned-scope'
+    ) {
+      CompilerError.invariant(
+        !this.blockInfos.has(block.terminal.block) &&
+          !this.blockInfos.has(block.terminal.fallthrough),
+        {
+          reason: 'Expected unique scope blocks and fallthroughs',
+          loc: block.terminal.loc,
+        }
+      );
+      this.blockInfos.set(block.terminal.block, {
+        kind: 'begin',
+        scope: block.terminal.scope,
+        pruned: block.terminal.kind === 'pruned-scope',
+        fallthrough: block.terminal.fallthrough,
+      });
+      this.blockInfos.set(block.terminal.fallthrough, {
+        kind: 'end',
+        scope: block.terminal.scope,
+        pruned: block.terminal.kind === 'pruned-scope',
+      });
+    }
+  }
+  isScopeActive(scopeId) {
+    return (
+      __classPrivateFieldGet(
+        this,
+        _ScopeBlockTraversal_activeScopes,
+        'f'
+      ).indexOf(scopeId) !== -1
+    );
+  }
+  get currentScope() {
+    var _a;
+    return (_a = __classPrivateFieldGet(
+      this,
+      _ScopeBlockTraversal_activeScopes,
+      'f'
+    ).at(-1)) !== null && _a !== void 0
+      ? _a
+      : null;
+  }
+}
+_ScopeBlockTraversal_activeScopes = new WeakMap();
 function assertConsistentIdentifiers(fn) {
   const identifiers = new Map();
   const assignments = new Set();
@@ -150485,7 +150598,7 @@ const EnvironmentConfigSchema = z.object({
   enablePreserveExistingManualUseMemo: z.boolean().default(false),
   enableForest: z.boolean().default(false),
   enableUseTypeAnnotations: z.boolean().default(false),
-  enablePropagateDepsInHIR: z.boolean().default(true),
+  enablePropagateDepsInHIR: z.boolean().default(false),
   enableOptionalDependencies: z.boolean().default(true),
   validateHooksUsage: z.boolean().default(true),
   validateRefAccessDuringRender: z.boolean().default(true),
@@ -153014,8 +153127,10 @@ function mergeLocation(l, r) {
     };
   }
 }
-function isMutable({id: id}, place) {
-  const range = place.identifier.mutableRange;
+function isMutable(instr, place) {
+  return inRange(instr, place.identifier.mutableRange);
+}
+function inRange({id: id}, range) {
   return id >= range.start && id < range.end;
 }
 function mayAllocate(env, instruction) {
@@ -155630,7 +155745,7 @@ var _Context_nextScheduleId,
   _Context_catchHandlers,
   _Context_controlFlowStack;
 function buildReactiveFunction(fn) {
-  const cx = new Context$2(fn.body);
+  const cx = new Context$3(fn.body);
   const driver = new Driver(cx);
   const body = driver.traverseBlock(cx.block(fn.body.entry));
   return {
@@ -156678,7 +156793,7 @@ class Driver {
     };
   }
 }
-let Context$2 = class Context {
+let Context$3 = class Context {
   constructor(ir) {
     _Context_nextScheduleId.set(this, 0);
     this.emitted = new Set();
@@ -157058,7 +157173,7 @@ function expandFbtScopeRange(fbtRange, extendWith) {
     );
   }
 }
-var _Context_nextCacheIndex, _Context_declarations$1;
+var _Context_nextCacheIndex, _Context_declarations$2;
 const MEMO_CACHE_SENTINEL = 'react.memo_cache_sentinel';
 const EARLY_RETURN_SENTINEL = 'react.early_return_sentinel';
 function codegenFunction(
@@ -157066,7 +157181,7 @@ function codegenFunction(
   {uniqueIdentifiers: uniqueIdentifiers, fbtOperands: fbtOperands}
 ) {
   var _a, _b, _c;
-  const cx = new Context$1(
+  const cx = new Context$2(
     fn.env,
     (_a = fn.id) !== null && _a !== void 0 ? _a : '[[ anonymous ]]',
     uniqueIdentifiers,
@@ -157231,7 +157346,7 @@ function codegenFunction(
     pruneHoistedContexts(reactiveFunction);
     const identifiers = renameVariables(reactiveFunction);
     const codegen = codegenReactiveFunction(
-      new Context$1(
+      new Context$2(
         cx.env,
         (_c = reactiveFunction.id) !== null && _c !== void 0
           ? _c
@@ -157318,10 +157433,10 @@ function convertParameter(param) {
     return t__namespace.restElement(convertIdentifier(param.place.identifier));
   }
 }
-let Context$1 = class Context {
+let Context$2 = class Context {
   constructor(env, fnName, uniqueIdentifiers, fbtOperands, temporaries = null) {
     _Context_nextCacheIndex.set(this, 0);
-    _Context_declarations$1.set(this, new Set());
+    _Context_declarations$2.set(this, new Set());
     this.errors = new CompilerError();
     this.objectMethods = new Map();
     this.synthesizedNames = new Map();
@@ -157346,12 +157461,12 @@ let Context$1 = class Context {
     );
   }
   declare(identifier) {
-    __classPrivateFieldGet(this, _Context_declarations$1, 'f').add(
+    __classPrivateFieldGet(this, _Context_declarations$2, 'f').add(
       identifier.declarationId
     );
   }
   hasDeclared(identifier) {
-    return __classPrivateFieldGet(this, _Context_declarations$1, 'f').has(
+    return __classPrivateFieldGet(this, _Context_declarations$2, 'f').has(
       identifier.declarationId
     );
   }
@@ -157371,7 +157486,7 @@ let Context$1 = class Context {
   }
 };
 (_Context_nextCacheIndex = new WeakMap()),
-  (_Context_declarations$1 = new WeakMap());
+  (_Context_declarations$2 = new WeakMap());
 function codegenBlock(cx, block) {
   const temp = new Map(cx.temp);
   const result = codegenBlockNoReset(cx, block);
@@ -158648,7 +158763,7 @@ function codegenInstructionValue(cx, instrValue) {
               pruneUnusedLabels(reactiveFunction);
               pruneUnusedLValues(reactiveFunction);
               const fn = codegenReactiveFunction(
-                new Context$1(
+                new Context$2(
                   cx.env,
                   (_e = reactiveFunction.id) !== null && _e !== void 0
                     ? _e
@@ -158847,7 +158962,7 @@ function codegenInstructionValue(cx, instrValue) {
       pruneUnusedLValues(reactiveFunction);
       pruneHoistedContexts(reactiveFunction);
       const fn = codegenReactiveFunction(
-        new Context$1(
+        new Context$2(
           cx.env,
           (_g = reactiveFunction.id) !== null && _g !== void 0
             ? _g
@@ -160398,21 +160513,21 @@ class ReactiveScopeDependencyTree {
       _ReactiveScopeDependencyTree_getOrCreateRoot
     ).call(this, dep.identifier);
     for (const item of path) {
-      let currChild = getOrMakeProperty(currNode, item.property);
+      let currChild = getOrMakeProperty$1(currNode, item.property);
       const accessType = inConditional
-        ? PropertyAccessType.ConditionalAccess
+        ? PropertyAccessType$1.ConditionalAccess
         : item.optional
-          ? PropertyAccessType.OptionalAccess
-          : PropertyAccessType.UnconditionalAccess;
-      currChild.accessType = merge(currChild.accessType, accessType);
+          ? PropertyAccessType$1.OptionalAccess
+          : PropertyAccessType$1.UnconditionalAccess;
+      currChild.accessType = merge$1(currChild.accessType, accessType);
       currNode = currChild;
     }
     const depType = inConditional
-      ? PropertyAccessType.ConditionalDependency
+      ? PropertyAccessType$1.ConditionalDependency
       : isOptional(currNode.accessType)
-        ? PropertyAccessType.OptionalDependency
-        : PropertyAccessType.UnconditionalDependency;
-    currNode.accessType = merge(currNode.accessType, depType);
+        ? PropertyAccessType$1.OptionalDependency
+        : PropertyAccessType$1.UnconditionalDependency;
+    currNode.accessType = merge$1(currNode.accessType, depType);
   }
   deriveMinimalDependencies() {
     const results = new Set();
@@ -160421,12 +160536,12 @@ class ReactiveScopeDependencyTree {
       _ReactiveScopeDependencyTree_roots,
       'f'
     ).entries()) {
-      const deps = deriveMinimalDependenciesInSubtree(rootNode, null);
+      const deps = deriveMinimalDependenciesInSubtree$1(rootNode, null);
       CompilerError.invariant(
         deps.every(
           dep =>
-            dep.accessType === PropertyAccessType.UnconditionalDependency ||
-            dep.accessType == PropertyAccessType.OptionalDependency
+            dep.accessType === PropertyAccessType$1.UnconditionalDependency ||
+            dep.accessType == PropertyAccessType$1.OptionalDependency
         ),
         {
           reason:
@@ -160463,9 +160578,9 @@ class ReactiveScopeDependencyTree {
       ).call(this, id);
       addSubtree(currRoot, otherRoot, innerScopeInConditionalWithinParent);
       if (!isUnconditional(currRoot.accessType)) {
-        currRoot.accessType = isDependency(currRoot.accessType)
-          ? PropertyAccessType.UnconditionalDependency
-          : PropertyAccessType.UnconditionalAccess;
+        currRoot.accessType = isDependency$1(currRoot.accessType)
+          ? PropertyAccessType$1.UnconditionalDependency
+          : PropertyAccessType$1.UnconditionalAccess;
       }
     }
   }
@@ -160508,7 +160623,7 @@ class ReactiveScopeDependencyTree {
       _ReactiveScopeDependencyTree_roots,
       'f'
     ).entries()) {
-      const rootResults = printSubtree(rootNode, includeAccesses).map(
+      const rootResults = printSubtree$1(rootNode, includeAccesses).map(
         result => `${printIdentifier(rootId)}.${result}`
       );
       res.push(rootResults);
@@ -160546,7 +160661,7 @@ class ReactiveScopeDependencyTree {
       if (rootNode === undefined) {
         rootNode = {
           properties: new Map(),
-          accessType: PropertyAccessType.UnconditionalAccess,
+          accessType: PropertyAccessType$1.UnconditionalAccess,
         };
         __classPrivateFieldGet(
           this,
@@ -160570,7 +160685,7 @@ class ReactiveScopeDependencyTree {
         ).call(this, buf, childNode, depth + 1);
       }
     });
-var PropertyAccessType;
+var PropertyAccessType$1;
 (function (PropertyAccessType) {
   PropertyAccessType['ConditionalAccess'] = 'ConditionalAccess';
   PropertyAccessType['OptionalAccess'] = 'OptionalAccess';
@@ -160578,49 +160693,49 @@ var PropertyAccessType;
   PropertyAccessType['ConditionalDependency'] = 'ConditionalDependency';
   PropertyAccessType['OptionalDependency'] = 'OptionalDependency';
   PropertyAccessType['UnconditionalDependency'] = 'UnconditionalDependency';
-})(PropertyAccessType || (PropertyAccessType = {}));
-const MIN_ACCESS_TYPE = PropertyAccessType.ConditionalAccess;
+})(PropertyAccessType$1 || (PropertyAccessType$1 = {}));
+const MIN_ACCESS_TYPE$1 = PropertyAccessType$1.ConditionalAccess;
 function isUnconditional(access) {
   return (
-    access === PropertyAccessType.UnconditionalAccess ||
-    access === PropertyAccessType.UnconditionalDependency
+    access === PropertyAccessType$1.UnconditionalAccess ||
+    access === PropertyAccessType$1.UnconditionalDependency
   );
 }
-function isDependency(access) {
+function isDependency$1(access) {
   return (
-    access === PropertyAccessType.ConditionalDependency ||
-    access === PropertyAccessType.OptionalDependency ||
-    access === PropertyAccessType.UnconditionalDependency
+    access === PropertyAccessType$1.ConditionalDependency ||
+    access === PropertyAccessType$1.OptionalDependency ||
+    access === PropertyAccessType$1.UnconditionalDependency
   );
 }
 function isOptional(access) {
   return (
-    access === PropertyAccessType.OptionalAccess ||
-    access === PropertyAccessType.OptionalDependency
+    access === PropertyAccessType$1.OptionalAccess ||
+    access === PropertyAccessType$1.OptionalDependency
   );
 }
-function merge(access1, access2) {
+function merge$1(access1, access2) {
   const resultIsUnconditional =
     isUnconditional(access1) || isUnconditional(access2);
-  const resultIsDependency = isDependency(access1) || isDependency(access2);
+  const resultIsDependency = isDependency$1(access1) || isDependency$1(access2);
   const resultIsOptional = isOptional(access1) || isOptional(access2);
   if (resultIsUnconditional) {
     if (resultIsDependency) {
-      return PropertyAccessType.UnconditionalDependency;
+      return PropertyAccessType$1.UnconditionalDependency;
     } else {
-      return PropertyAccessType.UnconditionalAccess;
+      return PropertyAccessType$1.UnconditionalAccess;
     }
   } else if (resultIsOptional) {
     if (resultIsDependency) {
-      return PropertyAccessType.OptionalDependency;
+      return PropertyAccessType$1.OptionalDependency;
     } else {
-      return PropertyAccessType.OptionalAccess;
+      return PropertyAccessType$1.OptionalAccess;
     }
   } else {
     if (resultIsDependency) {
-      return PropertyAccessType.ConditionalDependency;
+      return PropertyAccessType$1.ConditionalDependency;
     } else {
-      return PropertyAccessType.ConditionalAccess;
+      return PropertyAccessType$1.ConditionalAccess;
     }
   }
 }
@@ -160640,28 +160755,28 @@ function prependPath(results, path) {
     relativePath: [path, ...result.relativePath],
   }));
 }
-function deriveMinimalDependenciesInSubtree(dep, property) {
+function deriveMinimalDependenciesInSubtree$1(dep, property) {
   const results = [];
   for (const [childName, childNode] of dep.properties) {
-    const childResult = deriveMinimalDependenciesInSubtree(
+    const childResult = deriveMinimalDependenciesInSubtree$1(
       childNode,
       childName
     );
     results.push(...childResult);
   }
   switch (dep.accessType) {
-    case PropertyAccessType.UnconditionalDependency: {
+    case PropertyAccessType$1.UnconditionalDependency: {
       return promoteResult(
-        PropertyAccessType.UnconditionalDependency,
+        PropertyAccessType$1.UnconditionalDependency,
         property !== null ? {property: property, optional: false} : null
       );
     }
-    case PropertyAccessType.UnconditionalAccess: {
+    case PropertyAccessType$1.UnconditionalAccess: {
       if (
         results.every(
           ({accessType: accessType}) =>
-            accessType === PropertyAccessType.UnconditionalDependency ||
-            accessType === PropertyAccessType.OptionalDependency
+            accessType === PropertyAccessType$1.UnconditionalDependency ||
+            accessType === PropertyAccessType$1.OptionalDependency
         )
       ) {
         return prependPath(
@@ -160670,23 +160785,23 @@ function deriveMinimalDependenciesInSubtree(dep, property) {
         );
       } else {
         return promoteResult(
-          PropertyAccessType.UnconditionalDependency,
+          PropertyAccessType$1.UnconditionalDependency,
           property !== null ? {property: property, optional: false} : null
         );
       }
     }
-    case PropertyAccessType.OptionalDependency: {
+    case PropertyAccessType$1.OptionalDependency: {
       return promoteResult(
-        PropertyAccessType.OptionalDependency,
+        PropertyAccessType$1.OptionalDependency,
         property !== null ? {property: property, optional: true} : null
       );
     }
-    case PropertyAccessType.OptionalAccess: {
+    case PropertyAccessType$1.OptionalAccess: {
       if (
         results.every(
           ({accessType: accessType}) =>
-            accessType === PropertyAccessType.UnconditionalDependency ||
-            accessType === PropertyAccessType.OptionalDependency
+            accessType === PropertyAccessType$1.UnconditionalDependency ||
+            accessType === PropertyAccessType$1.OptionalDependency
         )
       ) {
         return prependPath(
@@ -160695,26 +160810,26 @@ function deriveMinimalDependenciesInSubtree(dep, property) {
         );
       } else {
         return promoteResult(
-          PropertyAccessType.OptionalDependency,
+          PropertyAccessType$1.OptionalDependency,
           property !== null ? {property: property, optional: true} : null
         );
       }
     }
-    case PropertyAccessType.ConditionalAccess:
-    case PropertyAccessType.ConditionalDependency: {
+    case PropertyAccessType$1.ConditionalAccess:
+    case PropertyAccessType$1.ConditionalDependency: {
       if (
         results.every(
           ({accessType: accessType}) =>
-            accessType === PropertyAccessType.ConditionalDependency
+            accessType === PropertyAccessType$1.ConditionalDependency
         )
       ) {
         return promoteResult(
-          PropertyAccessType.ConditionalDependency,
+          PropertyAccessType$1.ConditionalDependency,
           property !== null ? {property: property, optional: true} : null
         );
       } else {
         return promoteResult(
-          PropertyAccessType.UnconditionalDependency,
+          PropertyAccessType$1.UnconditionalDependency,
           property !== null ? {property: property, optional: true} : null
         );
       }
@@ -160735,9 +160850,9 @@ function demoteSubtreeToConditional(subtree) {
     if (!isUnconditional(accessType)) {
       continue;
     }
-    node.accessType = isDependency(accessType)
-      ? PropertyAccessType.ConditionalDependency
-      : PropertyAccessType.ConditionalAccess;
+    node.accessType = isDependency$1(accessType)
+      ? PropertyAccessType$1.ConditionalDependency
+      : PropertyAccessType$1.ConditionalAccess;
     for (const childNode of properties.values()) {
       if (isUnconditional(accessType)) {
         stack.push(childNode);
@@ -160748,11 +160863,11 @@ function demoteSubtreeToConditional(subtree) {
 function addSubtree(currNode, otherNode, demoteOtherNode) {
   let otherType = otherNode.accessType;
   if (demoteOtherNode) {
-    otherType = isDependency(otherType)
-      ? PropertyAccessType.ConditionalDependency
-      : PropertyAccessType.ConditionalAccess;
+    otherType = isDependency$1(otherType)
+      ? PropertyAccessType$1.ConditionalDependency
+      : PropertyAccessType$1.ConditionalAccess;
   }
-  currNode.accessType = merge(currNode.accessType, otherType);
+  currNode.accessType = merge$1(currNode.accessType, otherType);
   for (const [propertyName, otherChild] of otherNode.properties) {
     const currChild = currNode.properties.get(propertyName);
     if (currChild) {
@@ -160787,29 +160902,29 @@ function addSubtreeIntersection(currProperties, otherProperties) {
         currNode.properties,
         otherNodes.map(node => node.properties)
       );
-      const isDep = otherNodes.some(tree => isDependency(tree.accessType));
+      const isDep = otherNodes.some(tree => isDependency$1(tree.accessType));
       const externalAccessType = isDep
-        ? PropertyAccessType.UnconditionalDependency
-        : PropertyAccessType.UnconditionalAccess;
-      currNode.accessType = merge(externalAccessType, currNode.accessType);
+        ? PropertyAccessType$1.UnconditionalDependency
+        : PropertyAccessType$1.UnconditionalAccess;
+      currNode.accessType = merge$1(externalAccessType, currNode.accessType);
     }
   }
 }
-function printSubtree(node, includeAccesses) {
+function printSubtree$1(node, includeAccesses) {
   const results = [];
   for (const [propertyName, propertyNode] of node.properties) {
-    if (includeAccesses || isDependency(propertyNode.accessType)) {
+    if (includeAccesses || isDependency$1(propertyNode.accessType)) {
       results.push(`${propertyName} (${propertyNode.accessType})`);
     }
-    const propertyResults = printSubtree(propertyNode, includeAccesses);
+    const propertyResults = printSubtree$1(propertyNode, includeAccesses);
     results.push(...propertyResults.map(result => `${propertyName}.${result}`));
   }
   return results;
 }
-function getOrMakeProperty(node, property) {
+function getOrMakeProperty$1(node, property) {
   let child = node.properties.get(property);
   if (child == null) {
-    child = {properties: new Map(), accessType: MIN_ACCESS_TYPE};
+    child = {properties: new Map(), accessType: MIN_ACCESS_TYPE$1};
     node.properties.set(property, child);
   }
   return child;
@@ -160828,26 +160943,26 @@ function mapNonNull(arr, fn) {
 }
 var _PoisonState_instances,
   _PoisonState_invalidate,
-  _Context_instances,
-  _Context_temporariesUsedOutsideScope,
-  _Context_declarations,
-  _Context_reassignments,
-  _Context_dependencies,
+  _Context_instances$1,
+  _Context_temporariesUsedOutsideScope$1,
+  _Context_declarations$1,
+  _Context_reassignments$1,
+  _Context_dependencies$1,
   _Context_properties,
-  _Context_temporaries,
+  _Context_temporaries$1,
   _Context_inConditionalWithinScope,
   _Context_depsInCurrentConditional,
-  _Context_scopes,
+  _Context_scopes$1,
   _Context_getProperty,
-  _Context_checkValidDependency,
-  _Context_isScopeActive;
+  _Context_checkValidDependency$1,
+  _Context_isScopeActive$1;
 function propagateScopeDependencies(fn) {
   const escapingTemporaries = {
     declarations: new Map(),
     usedOutsideDeclaringScope: new Set(),
   };
   visitReactiveFunction(fn, new FindPromotedTemporaries(), escapingTemporaries);
-  const context = new Context(escapingTemporaries.usedOutsideDeclaringScope);
+  const context = new Context$1(escapingTemporaries.usedOutsideDeclaringScope);
   for (const param of fn.params) {
     if (param.kind === 'Identifier') {
       context.declare(param.identifier, {
@@ -161015,25 +161130,25 @@ class PoisonState {
     }
     this.isPoisoned = false;
   });
-class Context {
+let Context$1 = class Context {
   constructor(temporariesUsedOutsideScope) {
-    _Context_instances.add(this);
-    _Context_temporariesUsedOutsideScope.set(this, void 0);
-    _Context_declarations.set(this, new Map());
-    _Context_reassignments.set(this, new Map());
-    _Context_dependencies.set(this, new ReactiveScopeDependencyTree());
+    _Context_instances$1.add(this);
+    _Context_temporariesUsedOutsideScope$1.set(this, void 0);
+    _Context_declarations$1.set(this, new Map());
+    _Context_reassignments$1.set(this, new Map());
+    _Context_dependencies$1.set(this, new ReactiveScopeDependencyTree());
     _Context_properties.set(this, new Map());
-    _Context_temporaries.set(this, new Map());
+    _Context_temporaries$1.set(this, new Map());
     _Context_inConditionalWithinScope.set(this, false);
     _Context_depsInCurrentConditional.set(
       this,
       new ReactiveScopeDependencyTree()
     );
-    _Context_scopes.set(this, empty());
+    _Context_scopes$1.set(this, empty());
     this.poisonState = new PoisonState(new Set(), new Set(), false);
     __classPrivateFieldSet(
       this,
-      _Context_temporariesUsedOutsideScope,
+      _Context_temporariesUsedOutsideScope$1,
       temporariesUsedOutsideScope,
       'f'
     );
@@ -161046,7 +161161,7 @@ class Context {
     );
     const previousDependencies = __classPrivateFieldGet(
       this,
-      _Context_dependencies,
+      _Context_dependencies$1,
       'f'
     );
     const prevDepsInConditional = this.isPoisoned
@@ -161064,14 +161179,14 @@ class Context {
     __classPrivateFieldSet(this, _Context_inConditionalWithinScope, false, 'f');
     __classPrivateFieldSet(
       this,
-      _Context_dependencies,
+      _Context_dependencies$1,
       scopedDependencies,
       'f'
     );
     __classPrivateFieldSet(
       this,
-      _Context_scopes,
-      __classPrivateFieldGet(this, _Context_scopes, 'f').push({
+      _Context_scopes$1,
+      __classPrivateFieldGet(this, _Context_scopes$1, 'f').push({
         value: scope,
         ownBlocks: empty(),
       }),
@@ -161081,17 +161196,17 @@ class Context {
     fn();
     __classPrivateFieldSet(
       this,
-      _Context_scopes,
-      __classPrivateFieldGet(this, _Context_scopes, 'f').pop(),
+      _Context_scopes$1,
+      __classPrivateFieldGet(this, _Context_scopes$1, 'f').pop(),
       'f'
     );
     this.poisonState.removeMaybePoisonedScope(
       scope.id,
-      __classPrivateFieldGet(this, _Context_scopes, 'f').value
+      __classPrivateFieldGet(this, _Context_scopes$1, 'f').value
     );
     __classPrivateFieldSet(
       this,
-      _Context_dependencies,
+      _Context_dependencies$1,
       previousDependencies,
       'f'
     );
@@ -161105,7 +161220,7 @@ class Context {
       scopedDependencies.deriveMinimalDependencies();
     __classPrivateFieldGet(
       this,
-      _Context_dependencies,
+      _Context_dependencies$1,
       'f'
     ).addDepsFromInnerScope(
       scopedDependencies,
@@ -161113,9 +161228,9 @@ class Context {
         this.isPoisoned,
       __classPrivateFieldGet(
         this,
-        _Context_instances,
+        _Context_instances$1,
         'm',
-        _Context_checkValidDependency
+        _Context_checkValidDependency$1
       ).bind(this)
     );
     if (prevDepsInConditional != null) {
@@ -161124,9 +161239,9 @@ class Context {
         true,
         __classPrivateFieldGet(
           this,
-          _Context_instances,
+          _Context_instances$1,
           'm',
-          _Context_checkValidDependency
+          _Context_checkValidDependency$1
         ).bind(this)
       );
       __classPrivateFieldSet(
@@ -161141,12 +161256,12 @@ class Context {
   isUsedOutsideDeclaringScope(place) {
     return __classPrivateFieldGet(
       this,
-      _Context_temporariesUsedOutsideScope,
+      _Context_temporariesUsedOutsideScope$1,
       'f'
     ).has(place.identifier.declarationId);
   }
   printDeps(includeAccesses = false) {
-    return __classPrivateFieldGet(this, _Context_dependencies, 'f').printDeps(
+    return __classPrivateFieldGet(this, _Context_dependencies$1, 'f').printDeps(
       includeAccesses
     );
   }
@@ -161191,7 +161306,7 @@ class Context {
   promoteDepsFromExhaustiveConditionals(depsInConditionals) {
     __classPrivateFieldGet(
       this,
-      _Context_dependencies,
+      _Context_dependencies$1,
       'f'
     ).promoteDepsFromExhaustiveConditionals(depsInConditionals);
     __classPrivateFieldGet(
@@ -161202,29 +161317,29 @@ class Context {
   }
   declare(identifier, decl) {
     if (
-      !__classPrivateFieldGet(this, _Context_declarations, 'f').has(
+      !__classPrivateFieldGet(this, _Context_declarations$1, 'f').has(
         identifier.declarationId
       )
     ) {
-      __classPrivateFieldGet(this, _Context_declarations, 'f').set(
+      __classPrivateFieldGet(this, _Context_declarations$1, 'f').set(
         identifier.declarationId,
         decl
       );
     }
-    __classPrivateFieldGet(this, _Context_reassignments, 'f').set(
+    __classPrivateFieldGet(this, _Context_reassignments$1, 'f').set(
       identifier,
       decl
     );
   }
   declareTemporary(lvalue, place) {
-    __classPrivateFieldGet(this, _Context_temporaries, 'f').set(
+    __classPrivateFieldGet(this, _Context_temporaries$1, 'f').set(
       lvalue.identifier,
       place
     );
   }
   resolveTemporary(place) {
     var _a;
-    return (_a = __classPrivateFieldGet(this, _Context_temporaries, 'f').get(
+    return (_a = __classPrivateFieldGet(this, _Context_temporaries$1, 'f').get(
       place.identifier
     )) !== null && _a !== void 0
       ? _a
@@ -161233,7 +161348,7 @@ class Context {
   declareProperty(lvalue, object, property, optional) {
     const nextDependency = __classPrivateFieldGet(
       this,
-      _Context_instances,
+      _Context_instances$1,
       'm',
       _Context_getProperty
     ).call(this, object, property, optional);
@@ -161243,7 +161358,7 @@ class Context {
     );
   }
   get currentScope() {
-    return __classPrivateFieldGet(this, _Context_scopes, 'f');
+    return __classPrivateFieldGet(this, _Context_scopes$1, 'f');
   }
   get isPoisoned() {
     return this.poisonState.isPoisoned;
@@ -161266,7 +161381,7 @@ class Context {
   visitProperty(object, property, optional) {
     const nextDependency = __classPrivateFieldGet(
       this,
-      _Context_instances,
+      _Context_instances$1,
       'm',
       _Context_getProperty
     ).call(this, object, property, optional);
@@ -161275,7 +161390,7 @@ class Context {
   visitDependency(maybeDependency) {
     const originalDeclaration = __classPrivateFieldGet(
       this,
-      _Context_declarations,
+      _Context_declarations$1,
       'f'
     ).get(maybeDependency.identifier.declarationId);
     if (
@@ -161286,9 +161401,9 @@ class Context {
         if (
           !__classPrivateFieldGet(
             this,
-            _Context_instances,
+            _Context_instances$1,
             'm',
-            _Context_isScopeActive
+            _Context_isScopeActive$1
           ).call(this, scope.value) &&
           !Iterable_some(
             scope.value.declarations.values(),
@@ -161307,9 +161422,9 @@ class Context {
     if (
       __classPrivateFieldGet(
         this,
-        _Context_instances,
+        _Context_instances$1,
         'm',
-        _Context_checkValidDependency
+        _Context_checkValidDependency$1
       ).call(this, maybeDependency)
     ) {
       const isPoisoned = this.isPoisoned;
@@ -161317,7 +161432,7 @@ class Context {
         maybeDependency,
         isPoisoned
       );
-      __classPrivateFieldGet(this, _Context_dependencies, 'f').add(
+      __classPrivateFieldGet(this, _Context_dependencies$1, 'f').add(
         maybeDependency,
         __classPrivateFieldGet(this, _Context_inConditionalWithinScope, 'f') ||
           isPoisoned
@@ -161339,9 +161454,9 @@ class Context {
       ) &&
       __classPrivateFieldGet(
         this,
-        _Context_instances,
+        _Context_instances$1,
         'm',
-        _Context_checkValidDependency
+        _Context_checkValidDependency$1
       ).call(this, {identifier: place.identifier, path: []})
     ) {
       currentScope.reassignments.add(place.identifier);
@@ -161350,7 +161465,7 @@ class Context {
   pushLabeledBlock(id) {
     const currentScope = __classPrivateFieldGet(
       this,
-      _Context_scopes,
+      _Context_scopes$1,
       'f'
     ).value;
     if (currentScope != null) {
@@ -161360,7 +161475,7 @@ class Context {
   popLabeledBlock(id) {
     const currentScope = __classPrivateFieldGet(
       this,
-      _Context_scopes,
+      _Context_scopes$1,
       'f'
     ).value;
     if (currentScope != null) {
@@ -161373,17 +161488,17 @@ class Context {
     }
     this.poisonState.removeMaybePoisonedBlock(id, currentScope);
   }
-}
-(_Context_temporariesUsedOutsideScope = new WeakMap()),
-  (_Context_declarations = new WeakMap()),
-  (_Context_reassignments = new WeakMap()),
-  (_Context_dependencies = new WeakMap()),
+};
+(_Context_temporariesUsedOutsideScope$1 = new WeakMap()),
+  (_Context_declarations$1 = new WeakMap()),
+  (_Context_reassignments$1 = new WeakMap()),
+  (_Context_dependencies$1 = new WeakMap()),
   (_Context_properties = new WeakMap()),
-  (_Context_temporaries = new WeakMap()),
+  (_Context_temporaries$1 = new WeakMap()),
   (_Context_inConditionalWithinScope = new WeakMap()),
   (_Context_depsInCurrentConditional = new WeakMap()),
-  (_Context_scopes = new WeakMap()),
-  (_Context_instances = new WeakSet()),
+  (_Context_scopes$1 = new WeakMap()),
+  (_Context_instances$1 = new WeakSet()),
   (_Context_getProperty = function _Context_getProperty(
     object,
     property,
@@ -161407,7 +161522,7 @@ class Context {
     objectDependency.path.push({property: property, optional: optional});
     return objectDependency;
   }),
-  (_Context_checkValidDependency = function _Context_checkValidDependency(
+  (_Context_checkValidDependency$1 = function _Context_checkValidDependency(
     maybeDependency
   ) {
     var _a, _b, _c, _d;
@@ -161427,11 +161542,11 @@ class Context {
     }
     const identifier = maybeDependency.identifier;
     const currentDeclaration =
-      (_b = __classPrivateFieldGet(this, _Context_reassignments, 'f').get(
+      (_b = __classPrivateFieldGet(this, _Context_reassignments$1, 'f').get(
         identifier
       )) !== null && _b !== void 0
         ? _b
-        : __classPrivateFieldGet(this, _Context_declarations, 'f').get(
+        : __classPrivateFieldGet(this, _Context_declarations$1, 'f').get(
             identifier.declarationId
           );
     const currentScope =
@@ -161448,11 +161563,11 @@ class Context {
           : _d.value) !== currentScope)
     );
   }),
-  (_Context_isScopeActive = function _Context_isScopeActive(scope) {
-    if (__classPrivateFieldGet(this, _Context_scopes, 'f') === null) {
+  (_Context_isScopeActive$1 = function _Context_isScopeActive(scope) {
+    if (__classPrivateFieldGet(this, _Context_scopes$1, 'f') === null) {
       return false;
     }
-    return __classPrivateFieldGet(this, _Context_scopes, 'f').find(
+    return __classPrivateFieldGet(this, _Context_scopes$1, 'f').find(
       state => state.value === scope
     );
   });
@@ -161975,6 +162090,248 @@ let Visitor$8 = class Visitor extends ReactiveFunctionTransform {
     return {kind: 'keep'};
   }
 };
+function inferOperandEffect(state, place) {
+  const value = state.kind(place);
+  CompilerError.invariant(value != null, {
+    reason: 'Expected operand to have a kind',
+    loc: null,
+  });
+  switch (place.effect) {
+    case exports.Effect.Store:
+    case exports.Effect.Mutate: {
+      if (isRefOrRefValue(place.identifier)) {
+        break;
+      } else if (value.kind === exports.ValueKind.Context) {
+        return {
+          kind: 'ContextMutation',
+          loc: place.loc,
+          effect: place.effect,
+          places: value.context.size === 0 ? new Set([place]) : value.context,
+        };
+      } else if (
+        value.kind !== exports.ValueKind.Mutable &&
+        value.kind !== exports.ValueKind.Primitive
+      ) {
+        let reason = getWriteErrorReason(value);
+        return {
+          kind:
+            value.reason.size === 1 && value.reason.has(ValueReason.Global)
+              ? 'GlobalMutation'
+              : 'ReactMutation',
+          error: {
+            reason: reason,
+            description:
+              place.identifier.name !== null &&
+              place.identifier.name.kind === 'named'
+                ? `Found mutation of \`${place.identifier.name.value}\``
+                : null,
+            loc: place.loc,
+            suggestions: null,
+            severity: exports.ErrorSeverity.InvalidReact,
+          },
+        };
+      }
+      break;
+    }
+  }
+  return null;
+}
+function inheritFunctionEffects(state, place) {
+  const effects = inferFunctionInstrEffects(state, place);
+  return effects
+    .flatMap(effect => {
+      if (effect.kind === 'GlobalMutation' || effect.kind === 'ReactMutation') {
+        return [effect];
+      } else {
+        const effects = [];
+        CompilerError.invariant(effect.kind === 'ContextMutation', {
+          reason: 'Expected ContextMutation',
+          loc: null,
+        });
+        for (const place of effect.places) {
+          if (state.isDefined(place)) {
+            const replayedEffect = inferOperandEffect(
+              state,
+              Object.assign(Object.assign({}, place), {
+                loc: effect.loc,
+                effect: effect.effect,
+              })
+            );
+            if (replayedEffect != null) {
+              if (replayedEffect.kind === 'ContextMutation') {
+                effects.push(effect);
+              } else {
+                effects.push(replayedEffect);
+              }
+            }
+          }
+        }
+        return effects;
+      }
+    })
+    .filter(effect => effect != null);
+}
+function inferFunctionInstrEffects(state, place) {
+  const effects = [];
+  const instrs = state.values(place);
+  CompilerError.invariant(instrs != null, {
+    reason: 'Expected operand to have instructions',
+    loc: null,
+  });
+  for (const instr of instrs) {
+    if (
+      (instr.kind === 'FunctionExpression' || instr.kind === 'ObjectMethod') &&
+      instr.loweredFunc.func.effects != null
+    ) {
+      effects.push(...instr.loweredFunc.func.effects);
+    }
+  }
+  return effects;
+}
+function operandEffects(state, place, filterRenderSafe) {
+  const functionEffects = [];
+  const effect = inferOperandEffect(state, place);
+  effect && functionEffects.push(effect);
+  functionEffects.push(...inheritFunctionEffects(state, place));
+  if (filterRenderSafe) {
+    return functionEffects.filter(effect => !isEffectSafeOutsideRender(effect));
+  } else {
+    return functionEffects;
+  }
+}
+function inferInstructionFunctionEffects(env, state, instr) {
+  var _a, _b;
+  var _c;
+  const functionEffects = [];
+  switch (instr.value.kind) {
+    case 'JsxExpression': {
+      if (instr.value.tag.kind === 'Identifier') {
+        functionEffects.push(...operandEffects(state, instr.value.tag, false));
+      }
+      (_a = instr.value.children) === null || _a === void 0
+        ? void 0
+        : _a.forEach(child =>
+            functionEffects.push(...operandEffects(state, child, false))
+          );
+      for (const attr of instr.value.props) {
+        if (attr.kind === 'JsxSpreadAttribute') {
+          functionEffects.push(...operandEffects(state, attr.argument, false));
+        } else {
+          functionEffects.push(...operandEffects(state, attr.place, true));
+        }
+      }
+      break;
+    }
+    case 'ObjectMethod':
+    case 'FunctionExpression': {
+      for (const operand of eachInstructionOperand(instr)) {
+        (_b = (_c = instr.value.loweredFunc.func).effects) !== null &&
+        _b !== void 0
+          ? _b
+          : (_c.effects = []);
+        instr.value.loweredFunc.func.effects.push(
+          ...inferFunctionInstrEffects(state, operand)
+        );
+      }
+      break;
+    }
+    case 'MethodCall':
+    case 'CallExpression': {
+      let callee;
+      if (instr.value.kind === 'MethodCall') {
+        callee = instr.value.property;
+        functionEffects.push(
+          ...operandEffects(state, instr.value.receiver, false)
+        );
+      } else {
+        callee = instr.value.callee;
+      }
+      functionEffects.push(...operandEffects(state, callee, false));
+      let isHook = getHookKind(env, callee.identifier) != null;
+      for (const arg of instr.value.args) {
+        const place = arg.kind === 'Identifier' ? arg : arg.place;
+        functionEffects.push(...operandEffects(state, place, isHook));
+      }
+      break;
+    }
+    case 'StartMemoize':
+    case 'FinishMemoize':
+    case 'LoadLocal':
+    case 'StoreLocal': {
+      break;
+    }
+    case 'StoreGlobal': {
+      functionEffects.push({
+        kind: 'GlobalMutation',
+        error: {
+          reason:
+            'Unexpected reassignment of a variable which was defined outside of the component. Components and hooks should be pure and side-effect free, but variable reassignment is a form of side-effect. If this variable is used in rendering, use useState instead. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)',
+          loc: instr.loc,
+          suggestions: null,
+          severity: exports.ErrorSeverity.InvalidReact,
+        },
+      });
+      break;
+    }
+    default: {
+      for (const operand of eachInstructionOperand(instr)) {
+        functionEffects.push(...operandEffects(state, operand, false));
+      }
+    }
+  }
+  return functionEffects;
+}
+function inferTerminalFunctionEffects(state, block) {
+  const functionEffects = [];
+  for (const operand of eachTerminalOperand(block.terminal)) {
+    functionEffects.push(...operandEffects(state, operand, true));
+  }
+  return functionEffects;
+}
+function raiseFunctionEffectErrors(functionEffects) {
+  functionEffects.forEach(eff => {
+    switch (eff.kind) {
+      case 'ReactMutation':
+      case 'GlobalMutation': {
+        CompilerError.throw(eff.error);
+      }
+      case 'ContextMutation': {
+        CompilerError.throw({
+          severity: exports.ErrorSeverity.Invariant,
+          reason: `Unexpected ContextMutation in top-level function effects`,
+          loc: eff.loc,
+        });
+      }
+      default:
+        assertExhaustive(
+          eff,
+          `Unexpected function effect kind \`${eff.kind}\``
+        );
+    }
+  });
+}
+function isEffectSafeOutsideRender(effect) {
+  return effect.kind === 'GlobalMutation';
+}
+function getWriteErrorReason(abstractValue) {
+  if (abstractValue.reason.has(ValueReason.Global)) {
+    return 'Writing to a variable defined outside a component or hook is not allowed. Consider using an effect';
+  } else if (abstractValue.reason.has(ValueReason.JsxCaptured)) {
+    return 'Updating a value used previously in JSX is not allowed. Consider moving the mutation before the JSX';
+  } else if (abstractValue.reason.has(ValueReason.Context)) {
+    return `Mutating a value returned from 'useContext()', which should not be mutated`;
+  } else if (abstractValue.reason.has(ValueReason.KnownReturnSignature)) {
+    return 'Mutating a value returned from a function whose return value should not be mutated';
+  } else if (abstractValue.reason.has(ValueReason.ReactiveFunctionArgument)) {
+    return 'Mutating component props or hook arguments is not allowed. Consider using a local variable instead';
+  } else if (abstractValue.reason.has(ValueReason.State)) {
+    return "Mutating a value returned from 'useState()', which should not be mutated. Use the setter function to update instead";
+  } else if (abstractValue.reason.has(ValueReason.ReducerState)) {
+    return "Mutating a value returned from 'useReducer()', which should not be mutated. Use the dispatch function to update instead";
+  } else {
+    return 'This mutates a variable that React considers immutable';
+  }
+}
 var _InferenceState_env, _InferenceState_values, _InferenceState_variables;
 const UndefinedValue = {
   kind: 'Primitive',
@@ -162074,35 +162431,16 @@ function inferReferenceEffects(fn, options = {isFunctionExpression: false}) {
       }
       statesByBlock.set(blockId, incomingState);
       const state = incomingState.clone();
-      inferBlock(fn.env, functionEffects, state, block);
+      inferBlock(fn.env, state, block, functionEffects);
       for (const nextBlockId of eachTerminalSuccessor(block.terminal)) {
         queue(nextBlockId, state);
       }
     }
   }
-  if (!options.isFunctionExpression) {
-    functionEffects.forEach(eff => {
-      switch (eff.kind) {
-        case 'ReactMutation':
-        case 'GlobalMutation': {
-          CompilerError.throw(eff.error);
-        }
-        case 'ContextMutation': {
-          CompilerError.throw({
-            severity: exports.ErrorSeverity.Invariant,
-            reason: `Unexpected ContextMutation in top-level function effects`,
-            loc: eff.loc,
-          });
-        }
-        default:
-          assertExhaustive(
-            eff,
-            `Unexpected function effect kind \`${eff.kind}\``
-          );
-      }
-    });
-  } else {
+  if (options.isFunctionExpression) {
     fn.effects = functionEffects;
+  } else {
+    raiseFunctionEffectErrors(functionEffects);
   }
 }
 class InferenceState {
@@ -162208,7 +162546,7 @@ class InferenceState {
       place.identifier.id
     );
   }
-  referenceAndRecordEffects(place, effectKind, reason, functionEffects) {
+  referenceAndRecordEffects(freezeActions, place, effectKind, reason) {
     const values = __classPrivateFieldGet(
       this,
       _InferenceState_variables,
@@ -162227,43 +162565,8 @@ class InferenceState {
           : exports.Effect.Read;
       return;
     }
-    for (const value of values) {
-      if (
-        (value.kind === 'FunctionExpression' ||
-          value.kind === 'ObjectMethod') &&
-        value.loweredFunc.func.effects != null
-      ) {
-        for (const effect of value.loweredFunc.func.effects) {
-          if (
-            effect.kind === 'GlobalMutation' ||
-            effect.kind === 'ReactMutation'
-          ) {
-            functionEffects.push(effect);
-          } else {
-            for (const place of effect.places) {
-              if (this.isDefined(place)) {
-                const replayedEffect = this.reference(
-                  Object.assign(Object.assign({}, place), {loc: effect.loc}),
-                  effect.effect,
-                  reason
-                );
-                if (replayedEffect != null) {
-                  if (replayedEffect.kind === 'ContextMutation') {
-                    functionEffects.push(effect);
-                  } else {
-                    functionEffects.push(replayedEffect);
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    const functionEffect = this.reference(place, effectKind, reason);
-    if (functionEffect !== null) {
-      functionEffects.push(functionEffect);
-    }
+    const action = this.reference(place, effectKind, reason);
+    action && freezeActions.push(action);
   }
   freezeValues(values, reason) {
     for (const value of values) {
@@ -162309,7 +162612,7 @@ class InferenceState {
     });
     let valueKind = this.kind(place);
     let effect = null;
-    let functionEffect = null;
+    let freeze = null;
     switch (effectKind) {
       case exports.Effect.Freeze: {
         if (
@@ -162324,7 +162627,7 @@ class InferenceState {
             reason: reasonSet,
             context: new Set(),
           };
-          this.freezeValues(values, reasonSet);
+          freeze = {values: values, reason: reasonSet};
         } else {
           effect = exports.Effect.Read;
         }
@@ -162342,80 +162645,10 @@ class InferenceState {
         break;
       }
       case exports.Effect.Mutate: {
-        if (isRefOrRefValue(place.identifier));
-        else if (valueKind.kind === exports.ValueKind.Context) {
-          functionEffect = {
-            kind: 'ContextMutation',
-            loc: place.loc,
-            effect: effectKind,
-            places:
-              valueKind.context.size === 0
-                ? new Set([place])
-                : valueKind.context,
-          };
-        } else if (
-          valueKind.kind !== exports.ValueKind.Mutable &&
-          valueKind.kind !== exports.ValueKind.Primitive
-        ) {
-          let reason = getWriteErrorReason(valueKind);
-          functionEffect = {
-            kind:
-              valueKind.reason.size === 1 &&
-              valueKind.reason.has(ValueReason.Global)
-                ? 'GlobalMutation'
-                : 'ReactMutation',
-            error: {
-              reason: reason,
-              description:
-                place.identifier.name !== null &&
-                place.identifier.name.kind === 'named'
-                  ? `Found mutation of \`${place.identifier.name.value}\``
-                  : null,
-              loc: place.loc,
-              suggestions: null,
-              severity: exports.ErrorSeverity.InvalidReact,
-            },
-          };
-        }
         effect = exports.Effect.Mutate;
         break;
       }
       case exports.Effect.Store: {
-        if (isRefOrRefValue(place.identifier));
-        else if (valueKind.kind === exports.ValueKind.Context) {
-          functionEffect = {
-            kind: 'ContextMutation',
-            loc: place.loc,
-            effect: effectKind,
-            places:
-              valueKind.context.size === 0
-                ? new Set([place])
-                : valueKind.context,
-          };
-        } else if (
-          valueKind.kind !== exports.ValueKind.Mutable &&
-          valueKind.kind !== exports.ValueKind.Primitive
-        ) {
-          let reason = getWriteErrorReason(valueKind);
-          functionEffect = {
-            kind:
-              valueKind.reason.size === 1 &&
-              valueKind.reason.has(ValueReason.Global)
-                ? 'GlobalMutation'
-                : 'ReactMutation',
-            error: {
-              reason: reason,
-              description:
-                place.identifier.name !== null &&
-                place.identifier.name.kind === 'named'
-                  ? `Found mutation of \`${place.identifier.name.value}\``
-                  : null,
-              loc: place.loc,
-              suggestions: null,
-              severity: exports.ErrorSeverity.InvalidReact,
-            },
-          };
-        }
         effect = isObjectType(place.identifier)
           ? exports.Effect.Store
           : exports.Effect.Mutate;
@@ -162461,7 +162694,7 @@ class InferenceState {
       suggestions: null,
     });
     place.effect = effect;
-    return functionEffect;
+    return freeze;
   }
   merge(other) {
     let nextValues = null;
@@ -162716,29 +162949,31 @@ function mergeAbstractValues(a, b) {
   }
   return {kind: kind, reason: reason, context: context};
 }
-function inferBlock(env, functionEffects, state, block) {
+function inferBlock(env, state, block, functionEffects) {
   var _a, _b, _c, _d;
-  var _e;
   for (const phi of block.phis) {
     state.inferPhi(phi);
   }
   for (const instr of block.instructions) {
     const instrValue = instr.value;
-    let effect = null;
-    let lvalueEffect = exports.Effect.ConditionallyMutate;
-    let valueKind;
+    const defaultLvalueEffect = exports.Effect.ConditionallyMutate;
+    let continuation;
+    const freezeActions = [];
     switch (instrValue.kind) {
       case 'BinaryExpression': {
-        valueKind = {
-          kind: exports.ValueKind.Primitive,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Primitive,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: {kind: exports.Effect.Read, reason: ValueReason.Other},
         };
-        effect = {kind: exports.Effect.Read, reason: ValueReason.Other};
         break;
       }
       case 'ArrayExpression': {
-        valueKind = hasContextRefOperand(state, instrValue)
+        const valueKind = hasContextRefOperand(state, instrValue)
           ? {
               kind: exports.ValueKind.Context,
               reason: new Set([ValueReason.Other]),
@@ -162749,37 +162984,42 @@ function inferBlock(env, functionEffects, state, block) {
               reason: new Set([ValueReason.Other]),
               context: new Set(),
             };
-        effect = {kind: exports.Effect.Capture, reason: ValueReason.Other};
-        lvalueEffect = exports.Effect.Store;
+        continuation = {
+          kind: 'initialize',
+          valueKind: valueKind,
+          effect: {kind: exports.Effect.Capture, reason: ValueReason.Other},
+          lvalueEffect: exports.Effect.Store,
+        };
         break;
       }
       case 'NewExpression': {
-        valueKind = {
+        const valueKind = {
           kind: exports.ValueKind.Mutable,
           reason: new Set([ValueReason.Other]),
           context: new Set(),
         };
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.callee,
           exports.Effect.Read,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         for (const operand of eachCallArgument(instrValue.args)) {
           state.referenceAndRecordEffects(
+            freezeActions,
             operand,
             exports.Effect.ConditionallyMutate,
-            ValueReason.Other,
-            functionEffects
+            ValueReason.Other
           );
         }
         state.initialize(instrValue, valueKind);
         state.define(instr.lvalue, instrValue);
-        instr.lvalue.effect = lvalueEffect;
-        continue;
+        instr.lvalue.effect = exports.Effect.ConditionallyMutate;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'ObjectExpression': {
-        valueKind = hasContextRefOperand(state, instrValue)
+        const valueKind = hasContextRefOperand(state, instrValue)
           ? {
               kind: exports.ValueKind.Context,
               reason: new Set([ValueReason.Other]),
@@ -162795,26 +163035,26 @@ function inferBlock(env, functionEffects, state, block) {
             case 'ObjectProperty': {
               if (property.key.kind === 'computed') {
                 state.referenceAndRecordEffects(
+                  freezeActions,
                   property.key.name,
                   exports.Effect.Freeze,
-                  ValueReason.Other,
-                  functionEffects
+                  ValueReason.Other
                 );
               }
               state.referenceAndRecordEffects(
+                freezeActions,
                 property.place,
                 exports.Effect.Capture,
-                ValueReason.Other,
-                functionEffects
+                ValueReason.Other
               );
               break;
             }
             case 'Spread': {
               state.referenceAndRecordEffects(
+                freezeActions,
                 property.place,
                 exports.Effect.Capture,
-                ValueReason.Other,
-                functionEffects
+                ValueReason.Other
               );
               break;
             }
@@ -162829,64 +163069,66 @@ function inferBlock(env, functionEffects, state, block) {
         state.initialize(instrValue, valueKind);
         state.define(instr.lvalue, instrValue);
         instr.lvalue.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'UnaryExpression': {
-        valueKind = {
-          kind: exports.ValueKind.Primitive,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Primitive,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: {kind: exports.Effect.Read, reason: ValueReason.Other},
         };
-        effect = {kind: exports.Effect.Read, reason: ValueReason.Other};
         break;
       }
       case 'UnsupportedNode': {
-        valueKind = {
-          kind: exports.ValueKind.Mutable,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Mutable,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: null,
         };
         break;
       }
       case 'JsxExpression': {
         if (instrValue.tag.kind === 'Identifier') {
           state.referenceAndRecordEffects(
+            freezeActions,
             instrValue.tag,
             exports.Effect.Freeze,
-            ValueReason.JsxCaptured,
-            functionEffects
+            ValueReason.JsxCaptured
           );
         }
         if (instrValue.children !== null) {
           for (const child of instrValue.children) {
             state.referenceAndRecordEffects(
+              freezeActions,
               child,
               exports.Effect.Freeze,
-              ValueReason.JsxCaptured,
-              functionEffects
+              ValueReason.JsxCaptured
             );
           }
         }
         for (const attr of instrValue.props) {
           if (attr.kind === 'JsxSpreadAttribute') {
             state.referenceAndRecordEffects(
+              freezeActions,
               attr.argument,
               exports.Effect.Freeze,
-              ValueReason.JsxCaptured,
-              functionEffects
+              ValueReason.JsxCaptured
             );
           } else {
-            const propEffects = [];
             state.referenceAndRecordEffects(
+              freezeActions,
               attr.place,
               exports.Effect.Freeze,
-              ValueReason.JsxCaptured,
-              propEffects
-            );
-            functionEffects.push(
-              ...propEffects.filter(
-                effect => !isEffectSafeOutsideRender(effect)
-              )
+              ValueReason.JsxCaptured
             );
           }
         }
@@ -162897,63 +163139,86 @@ function inferBlock(env, functionEffects, state, block) {
         });
         state.define(instr.lvalue, instrValue);
         instr.lvalue.effect = exports.Effect.ConditionallyMutate;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'JsxFragment': {
-        valueKind = {
-          kind: exports.ValueKind.Frozen,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Frozen,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: {kind: exports.Effect.Freeze, reason: ValueReason.Other},
         };
-        effect = {kind: exports.Effect.Freeze, reason: ValueReason.Other};
         break;
       }
       case 'TemplateLiteral': {
-        valueKind = {
-          kind: exports.ValueKind.Primitive,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Primitive,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: {kind: exports.Effect.Read, reason: ValueReason.Other},
         };
-        effect = {kind: exports.Effect.Read, reason: ValueReason.Other};
         break;
       }
       case 'RegExpLiteral': {
-        valueKind = {
-          kind: exports.ValueKind.Mutable,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
-        };
-        effect = {
-          kind: exports.Effect.ConditionallyMutate,
-          reason: ValueReason.Other,
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Mutable,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: {
+            kind: exports.Effect.ConditionallyMutate,
+            reason: ValueReason.Other,
+          },
         };
         break;
       }
       case 'MetaProperty': {
         if (instrValue.meta !== 'import' || instrValue.property !== 'meta') {
-          continue;
+          continuation = {kind: 'funeffects'};
+          break;
         }
-        valueKind = {
-          kind: exports.ValueKind.Global,
-          reason: new Set([ValueReason.Global]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Global,
+            reason: new Set([ValueReason.Global]),
+            context: new Set(),
+          },
+          effect: null,
         };
         break;
       }
       case 'LoadGlobal':
-        valueKind = {
-          kind: exports.ValueKind.Global,
-          reason: new Set([ValueReason.Global]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Global,
+            reason: new Set([ValueReason.Global]),
+            context: new Set(),
+          },
+          effect: null,
         };
         break;
       case 'Debugger':
       case 'JSXText':
       case 'Primitive': {
-        valueKind = {
-          kind: exports.ValueKind.Primitive,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Primitive,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: null,
         };
         break;
       }
@@ -162962,32 +163227,16 @@ function inferBlock(env, functionEffects, state, block) {
         let hasMutableOperand = false;
         for (const operand of eachInstructionOperand(instr)) {
           state.referenceAndRecordEffects(
+            freezeActions,
             operand,
             operand.effect === exports.Effect.Unknown
               ? exports.Effect.Read
               : operand.effect,
-            ValueReason.Other,
-            []
+            ValueReason.Other
           );
           if (isMutableEffect(operand.effect, operand.loc));
           hasMutableOperand ||
             (hasMutableOperand = isMutableEffect(operand.effect, operand.loc));
-          const values = state.values(operand);
-          for (const value of values) {
-            if (
-              (value.kind === 'ObjectMethod' ||
-                value.kind === 'FunctionExpression') &&
-              value.loweredFunc.func.effects !== null
-            ) {
-              (_a = (_e = instrValue.loweredFunc.func).effects) !== null &&
-              _a !== void 0
-                ? _a
-                : (_e.effects = []);
-              instrValue.loweredFunc.func.effects.push(
-                ...value.loweredFunc.func.effects
-              );
-            }
-          }
         }
         state.initialize(instrValue, {
           kind: hasMutableOperand
@@ -162998,7 +163247,8 @@ function inferBlock(env, functionEffects, state, block) {
         });
         state.define(instr.lvalue, instrValue);
         instr.lvalue.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'TaggedTemplateExpression': {
         const operands = [...eachInstructionValueOperand(instrValue)];
@@ -163013,19 +163263,19 @@ function inferBlock(env, functionEffects, state, block) {
           instrValue.tag.identifier.type
         );
         let calleeEffect =
-          (_b =
+          (_a =
             signature === null || signature === void 0
               ? void 0
-              : signature.calleeEffect) !== null && _b !== void 0
-            ? _b
+              : signature.calleeEffect) !== null && _a !== void 0
+            ? _a
             : exports.Effect.ConditionallyMutate;
         const returnValueKind =
           signature !== null
             ? {
                 kind: signature.returnValueKind,
                 reason: new Set([
-                  (_c = signature.returnValueReason) !== null && _c !== void 0
-                    ? _c
+                  (_b = signature.returnValueReason) !== null && _b !== void 0
+                    ? _b
                     : ValueReason.KnownReturnSignature,
                 ]),
                 context: new Set(),
@@ -163036,15 +163286,16 @@ function inferBlock(env, functionEffects, state, block) {
                 context: new Set(),
               };
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.tag,
           calleeEffect,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.initialize(instrValue, returnValueKind);
         state.define(instr.lvalue, instrValue);
         instr.lvalue.effect = exports.Effect.ConditionallyMutate;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'CallExpression': {
         const signature = getFunctionCallSignature(
@@ -163058,8 +163309,8 @@ function inferBlock(env, functionEffects, state, block) {
             ? {
                 kind: signature.returnValueKind,
                 reason: new Set([
-                  (_d = signature.returnValueReason) !== null && _d !== void 0
-                    ? _d
+                  (_c = signature.returnValueReason) !== null && _c !== void 0
+                    ? _c
                     : ValueReason.KnownReturnSignature,
                 ]),
                 context: new Set(),
@@ -163070,47 +163321,40 @@ function inferBlock(env, functionEffects, state, block) {
                 context: new Set(),
               };
         let hasCaptureArgument = false;
-        let isHook = getHookKind(env, instrValue.callee.identifier) != null;
         for (let i = 0; i < instrValue.args.length; i++) {
-          const argumentEffects = [];
           const arg = instrValue.args[i];
           const place = arg.kind === 'Identifier' ? arg : arg.place;
           if (effects !== null) {
             state.referenceAndRecordEffects(
+              freezeActions,
               place,
               effects[i],
-              ValueReason.Other,
-              argumentEffects
+              ValueReason.Other
             );
           } else {
             state.referenceAndRecordEffects(
+              freezeActions,
               place,
               exports.Effect.ConditionallyMutate,
-              ValueReason.Other,
-              argumentEffects
+              ValueReason.Other
             );
           }
-          functionEffects.push(
-            ...argumentEffects.filter(
-              argEffect => !isHook || !isEffectSafeOutsideRender(argEffect)
-            )
-          );
           hasCaptureArgument ||
             (hasCaptureArgument = place.effect === exports.Effect.Capture);
         }
         if (signature !== null) {
           state.referenceAndRecordEffects(
+            freezeActions,
             instrValue.callee,
             signature.calleeEffect,
-            ValueReason.Other,
-            functionEffects
+            ValueReason.Other
           );
         } else {
           state.referenceAndRecordEffects(
+            freezeActions,
             instrValue.callee,
             exports.Effect.ConditionallyMutate,
-            ValueReason.Other,
-            functionEffects
+            ValueReason.Other
           );
         }
         hasCaptureArgument ||
@@ -163121,7 +163365,8 @@ function inferBlock(env, functionEffects, state, block) {
         instr.lvalue.effect = hasCaptureArgument
           ? exports.Effect.Store
           : exports.Effect.ConditionallyMutate;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'MethodCall': {
         CompilerError.invariant(state.isDefined(instrValue.receiver), {
@@ -163132,10 +163377,10 @@ function inferBlock(env, functionEffects, state, block) {
           suggestions: null,
         });
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.property,
           exports.Effect.Read,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const signature = getFunctionCallSignature(
           env,
@@ -163161,17 +163406,17 @@ function inferBlock(env, functionEffects, state, block) {
           for (const arg of instrValue.args) {
             const place = arg.kind === 'Identifier' ? arg : arg.place;
             state.referenceAndRecordEffects(
+              freezeActions,
               place,
               exports.Effect.Read,
-              ValueReason.Other,
-              functionEffects
+              ValueReason.Other
             );
           }
           state.referenceAndRecordEffects(
+            freezeActions,
             instrValue.receiver,
             exports.Effect.Capture,
-            ValueReason.Other,
-            functionEffects
+            ValueReason.Other
           );
           state.initialize(instrValue, returnValueKind);
           state.define(instr.lvalue, instrValue);
@@ -163179,52 +163424,46 @@ function inferBlock(env, functionEffects, state, block) {
             instrValue.receiver.effect === exports.Effect.Capture
               ? exports.Effect.Store
               : exports.Effect.ConditionallyMutate;
-          continue;
+          continuation = {kind: 'funeffects'};
+          break;
         }
         const effects =
           signature !== null ? getFunctionEffects(instrValue, signature) : null;
         let hasCaptureArgument = false;
-        let isHook = getHookKind(env, instrValue.property.identifier) != null;
         for (let i = 0; i < instrValue.args.length; i++) {
-          const argumentEffects = [];
           const arg = instrValue.args[i];
           const place = arg.kind === 'Identifier' ? arg : arg.place;
           if (effects !== null) {
             state.referenceAndRecordEffects(
+              freezeActions,
               place,
               effects[i],
-              ValueReason.Other,
-              argumentEffects
+              ValueReason.Other
             );
           } else {
             state.referenceAndRecordEffects(
+              freezeActions,
               place,
               exports.Effect.ConditionallyMutate,
-              ValueReason.Other,
-              argumentEffects
+              ValueReason.Other
             );
           }
-          functionEffects.push(
-            ...argumentEffects.filter(
-              argEffect => !isHook || !isEffectSafeOutsideRender(argEffect)
-            )
-          );
           hasCaptureArgument ||
             (hasCaptureArgument = place.effect === exports.Effect.Capture);
         }
         if (signature !== null) {
           state.referenceAndRecordEffects(
+            freezeActions,
             instrValue.receiver,
             signature.calleeEffect,
-            ValueReason.Other,
-            functionEffects
+            ValueReason.Other
           );
         } else {
           state.referenceAndRecordEffects(
+            freezeActions,
             instrValue.receiver,
             exports.Effect.ConditionallyMutate,
-            ValueReason.Other,
-            functionEffects
+            ValueReason.Other
           );
         }
         hasCaptureArgument ||
@@ -163235,7 +163474,8 @@ function inferBlock(env, functionEffects, state, block) {
         instr.lvalue.effect = hasCaptureArgument
           ? exports.Effect.Store
           : exports.Effect.ConditionallyMutate;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'PropertyStore': {
         const effect =
@@ -163243,43 +163483,48 @@ function inferBlock(env, functionEffects, state, block) {
             ? exports.Effect.ConditionallyMutate
             : exports.Effect.Capture;
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           effect,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.object,
           exports.Effect.Store,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         state.alias(lvalue, instrValue.value);
         lvalue.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'PropertyDelete': {
-        valueKind = {
-          kind: exports.ValueKind.Primitive,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Primitive,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: {kind: exports.Effect.Mutate, reason: ValueReason.Other},
         };
-        effect = {kind: exports.Effect.Mutate, reason: ValueReason.Other};
         break;
       }
       case 'PropertyLoad': {
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.object,
           exports.Effect.Read,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         lvalue.effect = exports.Effect.ConditionallyMutate;
         state.initialize(instrValue, state.kind(instrValue.object));
         state.define(lvalue, instrValue);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'ComputedStore': {
         const effect =
@@ -163287,40 +163532,41 @@ function inferBlock(env, functionEffects, state, block) {
             ? exports.Effect.ConditionallyMutate
             : exports.Effect.Capture;
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           effect,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.property,
           exports.Effect.Capture,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.object,
           exports.Effect.Store,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         state.alias(lvalue, instrValue.value);
         lvalue.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'ComputedDelete': {
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.object,
           exports.Effect.Mutate,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.property,
           exports.Effect.Read,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.initialize(instrValue, {
           kind: exports.ValueKind.Primitive,
@@ -163329,69 +163575,73 @@ function inferBlock(env, functionEffects, state, block) {
         });
         state.define(instr.lvalue, instrValue);
         instr.lvalue.effect = exports.Effect.Mutate;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'ComputedLoad': {
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.object,
           exports.Effect.Read,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.property,
           exports.Effect.Read,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         lvalue.effect = exports.Effect.ConditionallyMutate;
         state.initialize(instrValue, state.kind(instrValue.object));
         state.define(lvalue, instrValue);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'Await': {
         state.initialize(instrValue, state.kind(instrValue.value));
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           exports.Effect.ConditionallyMutate,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         lvalue.effect = exports.Effect.ConditionallyMutate;
         state.alias(lvalue, instrValue.value);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'TypeCastExpression': {
         state.initialize(instrValue, state.kind(instrValue.value));
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           exports.Effect.Read,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         lvalue.effect = exports.Effect.ConditionallyMutate;
         state.alias(lvalue, instrValue.value);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'StartMemoize':
       case 'FinishMemoize': {
         for (const val of eachInstructionValueOperand(instrValue)) {
           if (env.config.enablePreserveExistingMemoizationGuarantees) {
             state.referenceAndRecordEffects(
+              freezeActions,
               val,
               exports.Effect.Freeze,
-              ValueReason.Other,
-              []
+              ValueReason.Other
             );
           } else {
             state.referenceAndRecordEffects(
+              freezeActions,
               val,
               exports.Effect.Read,
-              ValueReason.Other,
-              []
+              ValueReason.Other
             );
           }
         }
@@ -163403,7 +163653,8 @@ function inferBlock(env, functionEffects, state, block) {
           context: new Set(),
         });
         state.define(lvalue, instrValue);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'LoadLocal': {
         const lvalue = instr.lvalue;
@@ -163413,28 +163664,30 @@ function inferBlock(env, functionEffects, state, block) {
             ? exports.Effect.ConditionallyMutate
             : exports.Effect.Capture;
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.place,
           effect,
-          ValueReason.Other,
-          []
+          ValueReason.Other
         );
         lvalue.effect = exports.Effect.ConditionallyMutate;
         state.alias(lvalue, instrValue.place);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'LoadContext': {
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.place,
           exports.Effect.Capture,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         lvalue.effect = exports.Effect.ConditionallyMutate;
         const valueKind = state.kind(instrValue.place);
         state.initialize(instrValue, valueKind);
         state.define(lvalue, instrValue);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'DeclareLocal': {
         const value = UndefinedValue;
@@ -163453,7 +163706,8 @@ function inferBlock(env, functionEffects, state, block) {
               }
         );
         state.define(instrValue.lvalue.place, value);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'DeclareContext': {
         state.initialize(instrValue, {
@@ -163462,7 +163716,8 @@ function inferBlock(env, functionEffects, state, block) {
           context: new Set(),
         });
         state.define(instrValue.lvalue.place, instrValue);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'PostfixUpdate':
       case 'PrefixUpdate': {
@@ -163472,17 +163727,18 @@ function inferBlock(env, functionEffects, state, block) {
             ? exports.Effect.ConditionallyMutate
             : exports.Effect.Capture;
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           effect,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         state.alias(lvalue, instrValue.value);
         lvalue.effect = exports.Effect.Store;
         state.alias(instrValue.lvalue, instrValue.value);
         instrValue.lvalue.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'StoreLocal': {
         const effect =
@@ -163491,56 +163747,49 @@ function inferBlock(env, functionEffects, state, block) {
             ? exports.Effect.ConditionallyMutate
             : exports.Effect.Capture;
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           effect,
-          ValueReason.Other,
-          []
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         state.alias(lvalue, instrValue.value);
         lvalue.effect = exports.Effect.Store;
         state.alias(instrValue.lvalue.place, instrValue.value);
         instrValue.lvalue.place.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'StoreContext': {
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           exports.Effect.ConditionallyMutate,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.lvalue.place,
           exports.Effect.Mutate,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         state.alias(lvalue, instrValue.value);
         lvalue.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'StoreGlobal': {
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           exports.Effect.Capture,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         lvalue.effect = exports.Effect.Store;
-        functionEffects.push({
-          kind: 'GlobalMutation',
-          error: {
-            reason:
-              'Unexpected reassignment of a variable which was defined outside of the component. Components and hooks should be pure and side-effect free, but variable reassignment is a form of side-effect. If this variable is used in rendering, use useState instead. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)',
-            loc: instr.loc,
-            suggestions: null,
-            severity: exports.ErrorSeverity.InvalidReact,
-          },
-        });
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'Destructure': {
         let effect = exports.Effect.Capture;
@@ -163554,10 +163803,10 @@ function inferBlock(env, functionEffects, state, block) {
           }
         }
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           effect,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         state.alias(lvalue, instrValue.value);
@@ -163566,13 +163815,16 @@ function inferBlock(env, functionEffects, state, block) {
           state.alias(place, instrValue.value);
           place.effect = exports.Effect.Store;
         }
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'GetIterator': {
         const kind = state.kind(instrValue.collection).kind;
         const isMutable =
           kind === exports.ValueKind.Mutable ||
           kind === exports.ValueKind.Context;
+        let effect;
+        let valueKind;
         if (!isMutable || isArrayType(instrValue.collection.identifier)) {
           effect = {kind: exports.Effect.Read, reason: ValueReason.Other};
           valueKind = {
@@ -163584,34 +163836,43 @@ function inferBlock(env, functionEffects, state, block) {
           effect = {kind: exports.Effect.Capture, reason: ValueReason.Other};
           valueKind = state.kind(instrValue.collection);
         }
-        lvalueEffect = exports.Effect.Store;
+        continuation = {
+          kind: 'initialize',
+          effect: effect,
+          valueKind: valueKind,
+          lvalueEffect: exports.Effect.Store,
+        };
         break;
       }
       case 'IteratorNext': {
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.iterator,
           exports.Effect.ConditionallyMutate,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.collection,
           exports.Effect.Capture,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.initialize(instrValue, state.kind(instrValue.collection));
         state.define(instr.lvalue, instrValue);
         instr.lvalue.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'NextPropertyOf': {
-        effect = {kind: exports.Effect.Read, reason: ValueReason.Other};
-        lvalueEffect = exports.Effect.Store;
-        valueKind = {
-          kind: exports.ValueKind.Primitive,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          effect: {kind: exports.Effect.Read, reason: ValueReason.Other},
+          lvalueEffect: exports.Effect.Store,
+          valueKind: {
+            kind: exports.ValueKind.Primitive,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
         };
         break;
       }
@@ -163619,24 +163880,34 @@ function inferBlock(env, functionEffects, state, block) {
         assertExhaustive(instrValue, 'Unexpected instruction kind');
       }
     }
-    for (const operand of eachInstructionOperand(instr)) {
-      CompilerError.invariant(effect != null, {
-        reason: `effectKind must be set for instruction value \`${instrValue.kind}\``,
-        description: null,
-        loc: instrValue.loc,
-        suggestions: null,
-      });
-      state.referenceAndRecordEffects(
-        operand,
-        effect.kind,
-        effect.reason,
-        functionEffects
-      );
-    }
-    state.initialize(instrValue, valueKind);
-    state.define(instr.lvalue, instrValue);
-    instr.lvalue.effect = lvalueEffect;
+    if (continuation.kind === 'initialize') {
+      for (const operand of eachInstructionOperand(instr)) {
+        CompilerError.invariant(continuation.effect != null, {
+          reason: `effectKind must be set for instruction value \`${instrValue.kind}\``,
+          description: null,
+          loc: instrValue.loc,
+          suggestions: null,
+        });
+        state.referenceAndRecordEffects(
+          freezeActions,
+          operand,
+          continuation.effect.kind,
+          continuation.effect.reason
+        );
+      }
+      state.initialize(instrValue, continuation.valueKind);
+      state.define(instr.lvalue, instrValue);
+      instr.lvalue.effect =
+        (_d = continuation.lvalueEffect) !== null && _d !== void 0
+          ? _d
+          : defaultLvalueEffect;
+    }
+    functionEffects.push(...inferInstructionFunctionEffects(env, state, instr));
+    freezeActions.forEach(({values: values, reason: reason}) =>
+      state.freezeValues(values, reason)
+    );
   }
+  const terminalFreezeActions = [];
   for (const operand of eachTerminalOperand(block.terminal)) {
     let effect;
     if (block.terminal.kind === 'return' || block.terminal.kind === 'throw') {
@@ -163651,17 +163922,17 @@ function inferBlock(env, functionEffects, state, block) {
     } else {
       effect = exports.Effect.Read;
     }
-    const propEffects = [];
     state.referenceAndRecordEffects(
+      terminalFreezeActions,
       operand,
       effect,
-      ValueReason.Other,
-      propEffects
-    );
-    functionEffects.push(
-      ...propEffects.filter(effect => !isEffectSafeOutsideRender(effect))
+      ValueReason.Other
     );
   }
+  functionEffects.push(...inferTerminalFunctionEffects(state, block));
+  terminalFreezeActions.forEach(({values: values, reason: reason}) =>
+    state.freezeValues(values, reason)
+  );
 }
 function hasContextRefOperand(state, instrValue) {
   for (const place of eachInstructionValueOperand(instrValue)) {
@@ -163728,28 +163999,6 @@ function areArgumentsImmutableAndNonMutating(state, args) {
   }
   return true;
 }
-function isEffectSafeOutsideRender(effect) {
-  return effect.kind === 'GlobalMutation';
-}
-function getWriteErrorReason(abstractValue) {
-  if (abstractValue.reason.has(ValueReason.Global)) {
-    return 'Writing to a variable defined outside a component or hook is not allowed. Consider using an effect';
-  } else if (abstractValue.reason.has(ValueReason.JsxCaptured)) {
-    return 'Updating a value used previously in JSX is not allowed. Consider moving the mutation before the JSX';
-  } else if (abstractValue.reason.has(ValueReason.Context)) {
-    return `Mutating a value returned from 'useContext()', which should not be mutated`;
-  } else if (abstractValue.reason.has(ValueReason.KnownReturnSignature)) {
-    return 'Mutating a value returned from a function whose return value should not be mutated';
-  } else if (abstractValue.reason.has(ValueReason.ReactiveFunctionArgument)) {
-    return 'Mutating component props or hook arguments is not allowed. Consider using a local variable instead';
-  } else if (abstractValue.reason.has(ValueReason.State)) {
-    return "Mutating a value returned from 'useState()', which should not be mutated. Use the setter function to update instead";
-  } else if (abstractValue.reason.has(ValueReason.ReducerState)) {
-    return "Mutating a value returned from 'useReducer()', which should not be mutated. Use the dispatch function to update instead";
-  } else {
-    return 'This mutates a variable that React considers immutable';
-  }
-}
 function pruneNonEscapingScopes(fn) {
   const state = new State(fn.env);
   for (const param of fn.params) {
@@ -169445,6 +169694,917 @@ function validateNoJSXInTryStatement(fn) {
     throw errors;
   }
 }
+var _Tree_instances, _a, _Tree_getOrCreateRoot, _Tree_getOrCreateProperty;
+function collectHoistablePropertyLoads(fn, temporaries) {
+  const nodes = collectPropertyLoadsInBlocks(fn, temporaries);
+  propagateNonNull(fn, nodes);
+  const nodesKeyedByScopeId = new Map();
+  for (const [_, block] of fn.body.blocks) {
+    if (block.terminal.kind === 'scope') {
+      nodesKeyedByScopeId.set(
+        block.terminal.scope.id,
+        nodes.get(block.terminal.block)
+      );
+    }
+  }
+  return nodesKeyedByScopeId;
+}
+function getProperty(object, propertyName, temporaries) {
+  const resolvedDependency = temporaries.get(object.identifier.id);
+  let property;
+  if (resolvedDependency == null) {
+    property = {
+      identifier: object.identifier,
+      path: [{property: propertyName, optional: false}],
+    };
+  } else {
+    property = {
+      identifier: resolvedDependency.identifier,
+      path: [
+        ...resolvedDependency.path,
+        {property: propertyName, optional: false},
+      ],
+    };
+  }
+  return property;
+}
+class Tree {
+  constructor() {
+    _Tree_instances.add(this);
+    this.roots = new Map();
+  }
+  getPropertyLoadNode(n) {
+    CompilerError.invariant(n.path.length > 0, {
+      reason:
+        '[CollectHoistablePropertyLoads] Expected property node, found root node',
+      loc: GeneratedSource,
+    });
+    let currNode = __classPrivateFieldGet(
+      this,
+      _Tree_instances,
+      'm',
+      _Tree_getOrCreateRoot
+    ).call(this, n.identifier);
+    for (let i = 0; i < n.path.length - 1; i++) {
+      currNode = assertNonNull(currNode.properties.get(n.path[i].property));
+    }
+    return __classPrivateFieldGet(_a, _a, 'm', _Tree_getOrCreateProperty).call(
+      _a,
+      currNode,
+      n.path.at(-1).property
+    );
+  }
+}
+(_a = Tree),
+  (_Tree_instances = new WeakSet()),
+  (_Tree_getOrCreateRoot = function _Tree_getOrCreateRoot(identifier) {
+    let rootNode = this.roots.get(identifier);
+    if (rootNode === undefined) {
+      rootNode = {
+        root: identifier,
+        properties: new Map(),
+        fullPath: {identifier: identifier, path: []},
+        parent: null,
+      };
+      this.roots.set(identifier, rootNode);
+    }
+    return rootNode;
+  }),
+  (_Tree_getOrCreateProperty = function _Tree_getOrCreateProperty(
+    node,
+    property
+  ) {
+    let child = node.properties.get(property);
+    if (child == null) {
+      child = {
+        properties: new Map(),
+        parent: node,
+        fullPath: {
+          identifier: node.fullPath.identifier,
+          path: node.fullPath.path.concat([
+            {property: property, optional: false},
+          ]),
+        },
+      };
+      node.properties.set(property, child);
+    }
+    return child;
+  });
+function collectPropertyLoadsInBlocks(fn, temporaries) {
+  const knownImmutableIdentifiers = new Set();
+  if (fn.fnType === 'Component' || fn.fnType === 'Hook') {
+    for (const p of fn.params) {
+      if (p.kind === 'Identifier') {
+        knownImmutableIdentifiers.add(p.identifier);
+      }
+    }
+  }
+  const tree = new Tree();
+  const nodes = new Map();
+  for (const [_, block] of fn.body.blocks) {
+    const assumedNonNullObjects = new Set();
+    for (const instr of block.instructions) {
+      if (instr.value.kind === 'PropertyLoad') {
+        const property = getProperty(
+          instr.value.object,
+          instr.value.property,
+          temporaries
+        );
+        const propertyNode = tree.getPropertyLoadNode(property);
+        const object = instr.value.object.identifier;
+        const isMutableAtInstr =
+          object.mutableRange.end > object.mutableRange.start + 1 &&
+          object.scope != null &&
+          inRange(instr, object.scope.range);
+        if (
+          !isMutableAtInstr ||
+          knownImmutableIdentifiers.has(propertyNode.fullPath.identifier)
+        ) {
+          let curr = propertyNode.parent;
+          while (curr != null) {
+            assumedNonNullObjects.add(curr);
+            curr = curr.parent;
+          }
+        }
+      }
+    }
+    nodes.set(block.id, {
+      block: block,
+      assumedNonNullObjects: assumedNonNullObjects,
+    });
+  }
+  return nodes;
+}
+function propagateNonNull(fn, nodes) {
+  const blockSuccessors = new Map();
+  const terminalPreds = new Set();
+  for (const [blockId, block] of fn.body.blocks) {
+    for (const pred of block.preds) {
+      getOrInsertDefault(blockSuccessors, pred, new Set()).add(blockId);
+    }
+    if (block.terminal.kind === 'throw' || block.terminal.kind === 'return') {
+      terminalPreds.add(blockId);
+    }
+  }
+  function recursivelyPropagateNonNull(
+    nodeId,
+    direction,
+    traversalState,
+    nonNullObjectsByBlock
+  ) {
+    var _b;
+    if (traversalState.has(nodeId)) {
+      return false;
+    }
+    traversalState.set(nodeId, 'active');
+    const node = nodes.get(nodeId);
+    if (node == null) {
+      CompilerError.invariant(false, {
+        reason: `Bad node ${nodeId}, kind: ${direction}`,
+        loc: GeneratedSource,
+      });
+    }
+    const neighbors = Array.from(
+      direction === 'backward'
+        ? (_b = blockSuccessors.get(nodeId)) !== null && _b !== void 0
+          ? _b
+          : []
+        : node.block.preds
+    );
+    let changed = false;
+    for (const pred of neighbors) {
+      if (!traversalState.has(pred)) {
+        const neighborChanged = recursivelyPropagateNonNull(
+          pred,
+          direction,
+          traversalState,
+          nonNullObjectsByBlock
+        );
+        changed || (changed = neighborChanged);
+      }
+    }
+    const neighborAccesses = Set_intersect(
+      Array.from(neighbors)
+        .filter(n => traversalState.get(n) === 'done')
+        .map(n => assertNonNull(nonNullObjectsByBlock.get(n)))
+    );
+    const prevObjects = assertNonNull(nonNullObjectsByBlock.get(nodeId));
+    const newObjects = Set_union(prevObjects, neighborAccesses);
+    nonNullObjectsByBlock.set(nodeId, newObjects);
+    traversalState.set(nodeId, 'done');
+    changed || (changed = prevObjects.size !== newObjects.size);
+    return changed;
+  }
+  const fromEntry = new Map();
+  const fromExit = new Map();
+  for (const [blockId, blockInfo] of nodes) {
+    fromEntry.set(blockId, blockInfo.assumedNonNullObjects);
+    fromExit.set(blockId, blockInfo.assumedNonNullObjects);
+  }
+  const traversalState = new Map();
+  const reversedBlocks = [...fn.body.blocks];
+  reversedBlocks.reverse();
+  let i = 0;
+  let changed;
+  do {
+    i++;
+    changed = false;
+    for (const [blockId] of fn.body.blocks) {
+      const forwardChanged = recursivelyPropagateNonNull(
+        blockId,
+        'forward',
+        traversalState,
+        fromEntry
+      );
+      changed || (changed = forwardChanged);
+    }
+    traversalState.clear();
+    for (const [blockId] of reversedBlocks) {
+      const backwardChanged = recursivelyPropagateNonNull(
+        blockId,
+        'backward',
+        traversalState,
+        fromExit
+      );
+      changed || (changed = backwardChanged);
+    }
+    traversalState.clear();
+  } while (changed);
+  CompilerError.invariant(i <= 2, {
+    reason: 'require fixed-point iteration',
+    description: `#iterations = ${i}`,
+    loc: GeneratedSource,
+  });
+  CompilerError.invariant(
+    fromEntry.size === fromExit.size && fromEntry.size === nodes.size,
+    {
+      reason:
+        'bad sizes after calculating fromEntry + fromExit ' +
+        `${fromEntry.size} ${fromExit.size} ${nodes.size}`,
+      loc: GeneratedSource,
+    }
+  );
+  for (const [id, node] of nodes) {
+    node.assumedNonNullObjects = Set_union(
+      assertNonNull(fromEntry.get(id)),
+      assertNonNull(fromExit.get(id))
+    );
+  }
+}
+function assertNonNull(value, source) {
+  CompilerError.invariant(value != null, {
+    reason: 'Unexpected null',
+    description: source != null ? `(from ${source})` : null,
+    loc: GeneratedSource,
+  });
+  return value;
+}
+var _ReactiveScopeDependencyTreeHIR_instances,
+  _ReactiveScopeDependencyTreeHIR_roots,
+  _ReactiveScopeDependencyTreeHIR_getOrCreateRoot;
+class ReactiveScopeDependencyTreeHIR {
+  constructor() {
+    _ReactiveScopeDependencyTreeHIR_instances.add(this);
+    _ReactiveScopeDependencyTreeHIR_roots.set(this, new Map());
+  }
+  addDependency(dep) {
+    const {path: path} = dep;
+    let currNode = __classPrivateFieldGet(
+      this,
+      _ReactiveScopeDependencyTreeHIR_instances,
+      'm',
+      _ReactiveScopeDependencyTreeHIR_getOrCreateRoot
+    ).call(this, dep.identifier, false);
+    const accessType = PropertyAccessType.Access;
+    currNode.accessType = merge(currNode.accessType, accessType);
+    for (const property of path) {
+      let currChild = getOrMakeProperty(currNode, property.property);
+      currChild.accessType = merge(currChild.accessType, accessType);
+      currNode = currChild;
+    }
+    currNode.accessType = merge(
+      currNode.accessType,
+      PropertyAccessType.Dependency
+    );
+  }
+  markNodesNonNull(dep) {
+    const accessType = PropertyAccessType.NonNullAccess;
+    let currNode = __classPrivateFieldGet(
+      this,
+      _ReactiveScopeDependencyTreeHIR_roots,
+      'f'
+    ).get(dep.identifier);
+    let cursor = 0;
+    while (currNode != null && cursor < dep.path.length) {
+      currNode.accessType = merge(currNode.accessType, accessType);
+      currNode = currNode.properties.get(dep.path[cursor++].property);
+    }
+    if (currNode != null) {
+      currNode.accessType = merge(currNode.accessType, accessType);
+    }
+  }
+  deriveMinimalDependencies() {
+    const results = new Set();
+    for (const [rootId, rootNode] of __classPrivateFieldGet(
+      this,
+      _ReactiveScopeDependencyTreeHIR_roots,
+      'f'
+    ).entries()) {
+      {
+        assertWellFormedTree(rootNode);
+      }
+      const deps = deriveMinimalDependenciesInSubtree(rootNode, []);
+      for (const dep of deps) {
+        results.add({
+          identifier: rootId,
+          path: dep.path.map(s => ({property: s, optional: false})),
+        });
+      }
+    }
+    return results;
+  }
+  printDeps(includeAccesses) {
+    let res = [];
+    for (const [rootId, rootNode] of __classPrivateFieldGet(
+      this,
+      _ReactiveScopeDependencyTreeHIR_roots,
+      'f'
+    ).entries()) {
+      const rootResults = printSubtree(rootNode, includeAccesses).map(
+        result => `${printIdentifier(rootId)}.${result}`
+      );
+      res.push(rootResults);
+    }
+    return res.flat().join('\n');
+  }
+}
+(_ReactiveScopeDependencyTreeHIR_roots = new WeakMap()),
+  (_ReactiveScopeDependencyTreeHIR_instances = new WeakSet()),
+  (_ReactiveScopeDependencyTreeHIR_getOrCreateRoot =
+    function _ReactiveScopeDependencyTreeHIR_getOrCreateRoot(
+      identifier,
+      isNonNull
+    ) {
+      let rootNode = __classPrivateFieldGet(
+        this,
+        _ReactiveScopeDependencyTreeHIR_roots,
+        'f'
+      ).get(identifier);
+      if (rootNode === undefined) {
+        rootNode = {
+          properties: new Map(),
+          accessType: isNonNull
+            ? PropertyAccessType.NonNullAccess
+            : PropertyAccessType.Access,
+        };
+        __classPrivateFieldGet(
+          this,
+          _ReactiveScopeDependencyTreeHIR_roots,
+          'f'
+        ).set(identifier, rootNode);
+      }
+      return rootNode;
+    });
+var PropertyAccessType;
+(function (PropertyAccessType) {
+  PropertyAccessType['Access'] = 'Access';
+  PropertyAccessType['NonNullAccess'] = 'NonNullAccess';
+  PropertyAccessType['Dependency'] = 'Dependency';
+  PropertyAccessType['NonNullDependency'] = 'NonNullDependency';
+})(PropertyAccessType || (PropertyAccessType = {}));
+const MIN_ACCESS_TYPE = PropertyAccessType.Access;
+function isNonNull(access) {
+  return (
+    access === PropertyAccessType.NonNullAccess ||
+    access === PropertyAccessType.NonNullDependency
+  );
+}
+function isDependency(access) {
+  return (
+    access === PropertyAccessType.Dependency ||
+    access === PropertyAccessType.NonNullDependency
+  );
+}
+function merge(access1, access2) {
+  const resultisNonNull = isNonNull(access1) || isNonNull(access2);
+  const resultIsDependency = isDependency(access1) || isDependency(access2);
+  if (resultisNonNull) {
+    if (resultIsDependency) {
+      return PropertyAccessType.NonNullDependency;
+    } else {
+      return PropertyAccessType.NonNullAccess;
+    }
+  } else {
+    if (resultIsDependency) {
+      return PropertyAccessType.Dependency;
+    } else {
+      return PropertyAccessType.Access;
+    }
+  }
+}
+function assertWellFormedTree(node) {
+  let nonNullInChildren = false;
+  for (const childNode of node.properties.values()) {
+    assertWellFormedTree(childNode);
+    nonNullInChildren || (nonNullInChildren = isNonNull(childNode.accessType));
+  }
+  if (nonNullInChildren) {
+    CompilerError.invariant(isNonNull(node.accessType), {
+      reason:
+        '[DeriveMinimialDependencies] Not well formed tree, unexpected non-null node',
+      description: node.accessType,
+      loc: GeneratedSource,
+    });
+  }
+}
+function deriveMinimalDependenciesInSubtree(node, path) {
+  if (isDependency(node.accessType)) {
+    return [{path: path}];
+  } else {
+    if (isNonNull(node.accessType)) {
+      const result = [];
+      for (const [childName, childNode] of node.properties) {
+        result.push(
+          ...deriveMinimalDependenciesInSubtree(childNode, [...path, childName])
+        );
+      }
+      return result;
+    } else {
+      return [{path: path}];
+    }
+  }
+}
+function printSubtree(node, includeAccesses) {
+  const results = [];
+  for (const [propertyName, propertyNode] of node.properties) {
+    if (includeAccesses || isDependency(propertyNode.accessType)) {
+      results.push(`${propertyName} (${propertyNode.accessType})`);
+    }
+    const propertyResults = printSubtree(propertyNode, includeAccesses);
+    results.push(...propertyResults.map(result => `${propertyName}.${result}`));
+  }
+  return results;
+}
+function getOrMakeProperty(node, property) {
+  let child = node.properties.get(property);
+  if (child == null) {
+    child = {properties: new Map(), accessType: MIN_ACCESS_TYPE};
+    node.properties.set(property, child);
+  }
+  return child;
+}
+var _Context_instances,
+  _Context_declarations,
+  _Context_reassignments,
+  _Context_scopes,
+  _Context_dependencies,
+  _Context_temporaries,
+  _Context_temporariesUsedOutsideScope,
+  _Context_checkValidDependency,
+  _Context_isScopeActive;
+function propagateScopeDependenciesHIR(fn) {
+  const usedOutsideDeclaringScope =
+    findTemporariesUsedOutsideDeclaringScope(fn);
+  const temporaries = collectTemporariesSidemap(fn, usedOutsideDeclaringScope);
+  const hoistablePropertyLoads = collectHoistablePropertyLoads(fn, temporaries);
+  const scopeDeps = collectDependencies(
+    fn,
+    usedOutsideDeclaringScope,
+    temporaries
+  );
+  for (const [scope, deps] of scopeDeps) {
+    const tree = new ReactiveScopeDependencyTreeHIR();
+    for (const dep of deps) {
+      tree.addDependency(Object.assign({}, dep));
+    }
+    recordHoistablePropertyReads(hoistablePropertyLoads, scope.id, tree);
+    const candidates = tree.deriveMinimalDependencies();
+    for (const candidateDep of candidates) {
+      if (
+        !Iterable_some(
+          scope.dependencies,
+          existingDep =>
+            existingDep.identifier.declarationId ===
+              candidateDep.identifier.declarationId &&
+            areEqualPaths(existingDep.path, candidateDep.path)
+        )
+      )
+        scope.dependencies.add(candidateDep);
+    }
+  }
+}
+function findTemporariesUsedOutsideDeclaringScope(fn) {
+  const declarations = new Map();
+  const prunedScopes = new Set();
+  const scopeTraversal = new ScopeBlockTraversal();
+  const usedOutsideDeclaringScope = new Set();
+  function handlePlace(place) {
+    const declaringScope = declarations.get(place.identifier.declarationId);
+    if (
+      declaringScope != null &&
+      !scopeTraversal.isScopeActive(declaringScope) &&
+      !prunedScopes.has(declaringScope)
+    ) {
+      usedOutsideDeclaringScope.add(place.identifier.declarationId);
+    }
+  }
+  function handleInstruction(instr) {
+    const scope = scopeTraversal.currentScope;
+    if (scope == null || prunedScopes.has(scope)) {
+      return;
+    }
+    switch (instr.value.kind) {
+      case 'LoadLocal':
+      case 'LoadContext':
+      case 'PropertyLoad': {
+        declarations.set(instr.lvalue.identifier.declarationId, scope);
+        break;
+      }
+    }
+  }
+  for (const [blockId, block] of fn.body.blocks) {
+    scopeTraversal.recordScopes(block);
+    const scopeStartInfo = scopeTraversal.blockInfos.get(blockId);
+    if (
+      (scopeStartInfo === null || scopeStartInfo === void 0
+        ? void 0
+        : scopeStartInfo.kind) === 'begin' &&
+      scopeStartInfo.pruned
+    ) {
+      prunedScopes.add(scopeStartInfo.scope.id);
+    }
+    for (const instr of block.instructions) {
+      for (const place of eachInstructionOperand(instr)) {
+        handlePlace(place);
+      }
+      handleInstruction(instr);
+    }
+    for (const place of eachTerminalOperand(block.terminal)) {
+      handlePlace(place);
+    }
+  }
+  return usedOutsideDeclaringScope;
+}
+function collectTemporariesSidemap(fn, usedOutsideDeclaringScope) {
+  const temporaries = new Map();
+  for (const [_, block] of fn.body.blocks) {
+    for (const instr of block.instructions) {
+      const {value: value, lvalue: lvalue} = instr;
+      const usedOutside = usedOutsideDeclaringScope.has(
+        lvalue.identifier.declarationId
+      );
+      if (value.kind === 'PropertyLoad' && !usedOutside) {
+        const property = getProperty(value.object, value.property, temporaries);
+        temporaries.set(lvalue.identifier.id, property);
+      } else if (
+        value.kind === 'LoadLocal' &&
+        lvalue.identifier.name == null &&
+        value.place.identifier.name !== null &&
+        !usedOutside
+      ) {
+        temporaries.set(lvalue.identifier.id, {
+          identifier: value.place.identifier,
+          path: [],
+        });
+      }
+    }
+  }
+  return temporaries;
+}
+class Context {
+  constructor(temporariesUsedOutsideScope, temporaries) {
+    _Context_instances.add(this);
+    _Context_declarations.set(this, new Map());
+    _Context_reassignments.set(this, new Map());
+    _Context_scopes.set(this, empty());
+    _Context_dependencies.set(this, empty());
+    this.deps = new Map();
+    _Context_temporaries.set(this, void 0);
+    _Context_temporariesUsedOutsideScope.set(this, void 0);
+    __classPrivateFieldSet(
+      this,
+      _Context_temporariesUsedOutsideScope,
+      temporariesUsedOutsideScope,
+      'f'
+    );
+    __classPrivateFieldSet(this, _Context_temporaries, temporaries, 'f');
+  }
+  enterScope(scope) {
+    __classPrivateFieldSet(
+      this,
+      _Context_dependencies,
+      __classPrivateFieldGet(this, _Context_dependencies, 'f').push([]),
+      'f'
+    );
+    __classPrivateFieldSet(
+      this,
+      _Context_scopes,
+      __classPrivateFieldGet(this, _Context_scopes, 'f').push(scope),
+      'f'
+    );
+  }
+  exitScope(scope, pruned) {
+    var _a;
+    const scopedDependencies = __classPrivateFieldGet(
+      this,
+      _Context_dependencies,
+      'f'
+    ).value;
+    CompilerError.invariant(scopedDependencies != null, {
+      reason: '[PropagateScopeDeps]: Unexpected scope mismatch',
+      loc: scope.loc,
+    });
+    __classPrivateFieldSet(
+      this,
+      _Context_scopes,
+      __classPrivateFieldGet(this, _Context_scopes, 'f').pop(),
+      'f'
+    );
+    __classPrivateFieldSet(
+      this,
+      _Context_dependencies,
+      __classPrivateFieldGet(this, _Context_dependencies, 'f').pop(),
+      'f'
+    );
+    for (const dep of scopedDependencies) {
+      if (
+        __classPrivateFieldGet(
+          this,
+          _Context_instances,
+          'm',
+          _Context_checkValidDependency
+        ).call(this, dep)
+      ) {
+        (_a = __classPrivateFieldGet(
+          this,
+          _Context_dependencies,
+          'f'
+        ).value) === null || _a === void 0
+          ? void 0
+          : _a.push(dep);
+      }
+    }
+    if (!pruned) {
+      this.deps.set(scope, scopedDependencies);
+    }
+  }
+  isUsedOutsideDeclaringScope(place) {
+    return __classPrivateFieldGet(
+      this,
+      _Context_temporariesUsedOutsideScope,
+      'f'
+    ).has(place.identifier.declarationId);
+  }
+  declare(identifier, decl) {
+    if (
+      !__classPrivateFieldGet(this, _Context_declarations, 'f').has(
+        identifier.declarationId
+      )
+    ) {
+      __classPrivateFieldGet(this, _Context_declarations, 'f').set(
+        identifier.declarationId,
+        decl
+      );
+    }
+    __classPrivateFieldGet(this, _Context_reassignments, 'f').set(
+      identifier,
+      decl
+    );
+  }
+  get currentScope() {
+    return __classPrivateFieldGet(this, _Context_scopes, 'f');
+  }
+  visitOperand(place) {
+    var _a;
+    this.visitDependency(
+      (_a = __classPrivateFieldGet(this, _Context_temporaries, 'f').get(
+        place.identifier.id
+      )) !== null && _a !== void 0
+        ? _a
+        : {identifier: place.identifier, path: []}
+    );
+  }
+  visitProperty(object, property) {
+    const nextDependency = getProperty(
+      object,
+      property,
+      __classPrivateFieldGet(this, _Context_temporaries, 'f')
+    );
+    this.visitDependency(nextDependency);
+  }
+  visitDependency(maybeDependency) {
+    const originalDeclaration = __classPrivateFieldGet(
+      this,
+      _Context_declarations,
+      'f'
+    ).get(maybeDependency.identifier.declarationId);
+    if (
+      originalDeclaration !== undefined &&
+      originalDeclaration.scope.value !== null
+    ) {
+      originalDeclaration.scope.each(scope => {
+        if (
+          !__classPrivateFieldGet(
+            this,
+            _Context_instances,
+            'm',
+            _Context_isScopeActive
+          ).call(this, scope) &&
+          !Iterable_some(
+            scope.declarations.values(),
+            decl =>
+              decl.identifier.declarationId ===
+              maybeDependency.identifier.declarationId
+          )
+        ) {
+          scope.declarations.set(maybeDependency.identifier.id, {
+            identifier: maybeDependency.identifier,
+            scope: originalDeclaration.scope.value,
+          });
+        }
+      });
+    }
+    if (
+      __classPrivateFieldGet(
+        this,
+        _Context_instances,
+        'm',
+        _Context_checkValidDependency
+      ).call(this, maybeDependency)
+    ) {
+      __classPrivateFieldGet(this, _Context_dependencies, 'f').value.push(
+        maybeDependency
+      );
+    }
+  }
+  visitReassignment(place) {
+    const currentScope = this.currentScope.value;
+    if (
+      currentScope != null &&
+      !Iterable_some(
+        currentScope.reassignments,
+        identifier =>
+          identifier.declarationId === place.identifier.declarationId
+      ) &&
+      __classPrivateFieldGet(
+        this,
+        _Context_instances,
+        'm',
+        _Context_checkValidDependency
+      ).call(this, {identifier: place.identifier, path: []})
+    ) {
+      currentScope.reassignments.add(place.identifier);
+    }
+  }
+}
+(_Context_declarations = new WeakMap()),
+  (_Context_reassignments = new WeakMap()),
+  (_Context_scopes = new WeakMap()),
+  (_Context_dependencies = new WeakMap()),
+  (_Context_temporaries = new WeakMap()),
+  (_Context_temporariesUsedOutsideScope = new WeakMap()),
+  (_Context_instances = new WeakSet()),
+  (_Context_checkValidDependency = function _Context_checkValidDependency(
+    maybeDependency
+  ) {
+    var _a, _b;
+    if (
+      isUseRefType(maybeDependency.identifier) &&
+      ((_a = maybeDependency.path.at(0)) === null || _a === void 0
+        ? void 0
+        : _a.property) === 'current'
+    ) {
+      return false;
+    }
+    if (isRefValueType(maybeDependency.identifier)) {
+      return false;
+    }
+    if (isObjectMethodType(maybeDependency.identifier)) {
+      return false;
+    }
+    const identifier = maybeDependency.identifier;
+    const currentDeclaration =
+      (_b = __classPrivateFieldGet(this, _Context_reassignments, 'f').get(
+        identifier
+      )) !== null && _b !== void 0
+        ? _b
+        : __classPrivateFieldGet(this, _Context_declarations, 'f').get(
+            identifier.declarationId
+          );
+    const currentScope = this.currentScope.value;
+    return (
+      currentScope != null &&
+      currentDeclaration !== undefined &&
+      currentDeclaration.id < currentScope.range.start
+    );
+  }),
+  (_Context_isScopeActive = function _Context_isScopeActive(scope) {
+    if (__classPrivateFieldGet(this, _Context_scopes, 'f') === null) {
+      return false;
+    }
+    return __classPrivateFieldGet(this, _Context_scopes, 'f').find(
+      state => state === scope
+    );
+  });
+function handleInstruction(instr, context) {
+  const {id: id, value: value, lvalue: lvalue} = instr;
+  if (value.kind === 'LoadLocal') {
+    if (
+      value.place.identifier.name === null ||
+      lvalue.identifier.name !== null ||
+      context.isUsedOutsideDeclaringScope(lvalue)
+    ) {
+      context.visitOperand(value.place);
+    }
+  } else if (value.kind === 'PropertyLoad') {
+    if (context.isUsedOutsideDeclaringScope(lvalue)) {
+      context.visitProperty(value.object, value.property);
+    }
+  } else if (value.kind === 'StoreLocal') {
+    context.visitOperand(value.value);
+    if (value.lvalue.kind === InstructionKind.Reassign) {
+      context.visitReassignment(value.lvalue.place);
+    }
+    context.declare(value.lvalue.place.identifier, {
+      id: id,
+      scope: context.currentScope,
+    });
+  } else if (value.kind === 'DeclareLocal' || value.kind === 'DeclareContext') {
+    context.declare(value.lvalue.place.identifier, {
+      id: id,
+      scope: context.currentScope,
+    });
+  } else if (value.kind === 'Destructure') {
+    context.visitOperand(value.value);
+    for (const place of eachPatternOperand(value.lvalue.pattern)) {
+      if (value.lvalue.kind === InstructionKind.Reassign) {
+        context.visitReassignment(place);
+      }
+      context.declare(place.identifier, {id: id, scope: context.currentScope});
+    }
+  } else {
+    for (const operand of eachInstructionValueOperand(value)) {
+      context.visitOperand(operand);
+    }
+  }
+  context.declare(lvalue.identifier, {id: id, scope: context.currentScope});
+}
+function collectDependencies(fn, usedOutsideDeclaringScope, temporaries) {
+  const context = new Context(usedOutsideDeclaringScope, temporaries);
+  for (const param of fn.params) {
+    if (param.kind === 'Identifier') {
+      context.declare(param.identifier, {
+        id: makeInstructionId(0),
+        scope: empty(),
+      });
+    } else {
+      context.declare(param.place.identifier, {
+        id: makeInstructionId(0),
+        scope: empty(),
+      });
+    }
+  }
+  const scopeTraversal = new ScopeBlockTraversal();
+  for (const [blockId, block] of fn.body.blocks) {
+    scopeTraversal.recordScopes(block);
+    const scopeBlockInfo = scopeTraversal.blockInfos.get(blockId);
+    if (
+      (scopeBlockInfo === null || scopeBlockInfo === void 0
+        ? void 0
+        : scopeBlockInfo.kind) === 'begin'
+    ) {
+      context.enterScope(scopeBlockInfo.scope);
+    } else if (
+      (scopeBlockInfo === null || scopeBlockInfo === void 0
+        ? void 0
+        : scopeBlockInfo.kind) === 'end'
+    ) {
+      context.exitScope(
+        scopeBlockInfo.scope,
+        scopeBlockInfo === null || scopeBlockInfo === void 0
+          ? void 0
+          : scopeBlockInfo.pruned
+      );
+    }
+    for (const instr of block.instructions) {
+      handleInstruction(instr, context);
+    }
+    for (const place of eachTerminalOperand(block.terminal)) {
+      context.visitOperand(place);
+    }
+  }
+  return context.deps;
+}
+function recordHoistablePropertyReads(nodes, scopeId, tree) {
+  const node = nodes.get(scopeId);
+  CompilerError.invariant(node != null, {
+    reason: '[PropagateScopeDependencies] Scope not found in tracked blocks',
+    loc: GeneratedSource,
+  });
+  for (const item of node.assumedNonNullObjects) {
+    tree.markNodesNonNull(Object.assign({}, item.fullPath));
+  }
+}
 function* run(
   func,
   config,
@@ -169596,6 +170756,10 @@ function* runWithEnvironment(func, env) {
   yield log({kind: 'hir', name: 'FlattenScopesWithHooksOrUseHIR', value: hir});
   assertTerminalSuccessorsExist(hir);
   assertTerminalPredsExist(hir);
+  if (env.config.enablePropagateDepsInHIR) {
+    propagateScopeDependenciesHIR(hir);
+    yield log({kind: 'hir', name: 'PropagateScopeDependenciesHIR', value: hir});
+  }
   const reactiveFunction = buildReactiveFunction(hir);
   yield log({
     kind: 'reactive',
@@ -169610,12 +170774,14 @@ function* runWithEnvironment(func, env) {
     value: reactiveFunction,
   });
   assertScopeInstructionsWithinScopes(reactiveFunction);
-  propagateScopeDependencies(reactiveFunction);
-  yield log({
-    kind: 'reactive',
-    name: 'PropagateScopeDependencies',
-    value: reactiveFunction,
-  });
+  if (!env.config.enablePropagateDepsInHIR) {
+    propagateScopeDependencies(reactiveFunction);
+    yield log({
+      kind: 'reactive',
+      name: 'PropagateScopeDependencies',
+      value: reactiveFunction,
+    });
+  }
   pruneNonEscapingScopes(reactiveFunction);
   yield log({
     kind: 'reactive',