babel-plugin-react-compiler 0.0.0-experimental-de2cfda-20240912 → 0.0.0-experimental-ca8e0be-20240916

package/dist/index.js

@@ -139601,6 +139601,8 @@ var InstructionKind;
   InstructionKind['Catch'] = 'Catch';
   InstructionKind['HoistedConst'] = 'HoistedConst';
   InstructionKind['HoistedLet'] = 'HoistedLet';
+  InstructionKind['HoistedFunction'] = 'HoistedFunction';
+  InstructionKind['Function'] = 'Function';
 })(InstructionKind || (InstructionKind = {}));
 function makeTemporaryIdentifier(id, loc) {
   return {
@@ -144017,7 +144019,14 @@ function lowerStatement(builder, stmtPath, label = null) {
           if (builder.environment.isHoistedIdentifier(binding.identifier)) {
             continue;
           }
-          if (!binding.path.isVariableDeclarator()) {
+          let kind;
+          if (binding.kind === 'const' || binding.kind === 'var') {
+            kind = InstructionKind.HoistedConst;
+          } else if (binding.kind === 'let') {
+            kind = InstructionKind.HoistedLet;
+          } else if (binding.path.isFunctionDeclaration()) {
+            kind = InstructionKind.HoistedFunction;
+          } else if (!binding.path.isVariableDeclarator()) {
             builder.errors.push({
               severity: exports.ErrorSeverity.Todo,
               reason: 'Unsupported declaration type for hoisting',
@@ -144029,11 +144038,7 @@ function lowerStatement(builder, stmtPath, label = null) {
                   : GeneratedSource,
             });
             continue;
-          } else if (
-            binding.kind !== 'const' &&
-            binding.kind !== 'var' &&
-            binding.kind !== 'let'
-          ) {
+          } else {
             builder.errors.push({
               severity: exports.ErrorSeverity.Todo,
               reason: 'Handle non-const declarations for hoisting',
@@ -144065,12 +144070,6 @@ function lowerStatement(builder, stmtPath, label = null) {
                 ? _j
                 : GeneratedSource,
           };
-          const kind =
-            binding.kind === 'const' || binding.kind === 'var'
-              ? InstructionKind.HoistedConst
-              : binding.kind === 'let'
-                ? InstructionKind.HoistedLet
-                : assertExhaustive(binding.kind, 'Unexpected binding kind');
           lowerValueToTemporary(builder, {
             kind: 'DeclareContext',
             lvalue: {kind: kind, place: place},
@@ -144615,7 +144614,7 @@ function lowerStatement(builder, stmtPath, label = null) {
         (_10 = stmt.node.loc) !== null && _10 !== void 0
           ? _10
           : GeneratedSource,
-        InstructionKind.Let,
+        InstructionKind.Function,
         id,
         fn,
         'Assignment'
@@ -150159,6 +150158,17 @@ const REACT_APIS = [
       returnValueKind: exports.ValueKind.Mutable,
     }),
   ],
+  [
+    'useImperativeHandle',
+    addHook(DEFAULT_SHAPES, {
+      positionalParams: [],
+      restParam: exports.Effect.Freeze,
+      returnType: {kind: 'Primitive'},
+      calleeEffect: exports.Effect.Read,
+      hookKind: 'useImperativeHandle',
+      returnValueKind: exports.ValueKind.Frozen,
+    }),
+  ],
   [
     'useMemo',
     addHook(DEFAULT_SHAPES, {
@@ -157991,22 +158001,12 @@ function codegenTerminal(cx, terminal) {
             suggestions: null,
           });
         case InstructionKind.Catch:
-          CompilerError.invariant(false, {
-            reason: 'Unexpected catch variable as for..in collection',
-            description: null,
-            loc: iterableItem.loc,
-            suggestions: null,
-          });
         case InstructionKind.HoistedConst:
-          CompilerError.invariant(false, {
-            reason: 'Unexpected HoistedConst variable in for..in collection',
-            description: null,
-            loc: iterableItem.loc,
-            suggestions: null,
-          });
         case InstructionKind.HoistedLet:
+        case InstructionKind.HoistedFunction:
+        case InstructionKind.Function:
           CompilerError.invariant(false, {
-            reason: 'Unexpected HoistedLet variable in for..in collection',
+            reason: `Unexpected ${iterableItem.value.lvalue.kind} variable in for..in collection`,
             description: null,
             loc: iterableItem.loc,
             suggestions: null,
@@ -158080,30 +158080,13 @@ function codegenTerminal(cx, terminal) {
           varDeclKind = 'let';
           break;
         case InstructionKind.Reassign:
-          CompilerError.invariant(false, {
-            reason:
-              'Destructure should never be Reassign as it would be an Object/ArrayPattern',
-            description: null,
-            loc: iterableItem.loc,
-            suggestions: null,
-          });
         case InstructionKind.Catch:
-          CompilerError.invariant(false, {
-            reason: 'Unexpected catch variable as for..of collection',
-            description: null,
-            loc: iterableItem.loc,
-            suggestions: null,
-          });
         case InstructionKind.HoistedConst:
-          CompilerError.invariant(false, {
-            reason: 'Unexpected HoistedConst variable in for..of collection',
-            description: null,
-            loc: iterableItem.loc,
-            suggestions: null,
-          });
         case InstructionKind.HoistedLet:
+        case InstructionKind.HoistedFunction:
+        case InstructionKind.Function:
           CompilerError.invariant(false, {
-            reason: 'Unexpected HoistedLet variable in for..of collection',
+            reason: `Unexpected ${iterableItem.value.lvalue.kind} variable in for..of collection`,
             description: null,
             loc: iterableItem.loc,
             suggestions: null,
@@ -158262,6 +158245,39 @@ function codegenInstructionNullable(cx, instr) {
           t__namespace.variableDeclarator(codegenLValue(cx, lvalue), value),
         ]);
       }
+      case InstructionKind.Function: {
+        CompilerError.invariant(instr.lvalue === null, {
+          reason: `Function declaration cannot be referenced as an expression`,
+          description: null,
+          loc: instr.value.loc,
+          suggestions: null,
+        });
+        const genLvalue = codegenLValue(cx, lvalue);
+        CompilerError.invariant(genLvalue.type === 'Identifier', {
+          reason: 'Expected an identifier as a function declaration lvalue',
+          description: null,
+          loc: instr.value.loc,
+          suggestions: null,
+        });
+        CompilerError.invariant(
+          (value === null || value === void 0 ? void 0 : value.type) ===
+            'FunctionExpression',
+          {
+            reason: 'Expected a function as a function declaration value',
+            description: null,
+            loc: instr.value.loc,
+            suggestions: null,
+          }
+        );
+        return createFunctionDeclaration(
+          instr.loc,
+          genLvalue,
+          value.params,
+          value.body,
+          value.generator,
+          value.async
+        );
+      }
       case InstructionKind.Let: {
         CompilerError.invariant(instr.lvalue === null, {
           reason: `Const declaration cannot be referenced as an expression`,
@@ -158303,19 +158319,11 @@ function codegenInstructionNullable(cx, instr) {
       case InstructionKind.Catch: {
         return t__namespace.emptyStatement();
       }
-      case InstructionKind.HoistedLet: {
-        CompilerError.invariant(false, {
-          reason:
-            'Expected HoistedLet to have been pruned in PruneHoistedContexts',
-          description: null,
-          loc: instr.loc,
-          suggestions: null,
-        });
-      }
-      case InstructionKind.HoistedConst: {
+      case InstructionKind.HoistedLet:
+      case InstructionKind.HoistedConst:
+      case InstructionKind.HoistedFunction: {
         CompilerError.invariant(false, {
-          reason:
-            'Expected HoistedConsts to have been pruned in PruneHoistedContexts',
+          reason: `Expected ${kind} to have been pruned in PruneHoistedContexts`,
           description: null,
           loc: instr.loc,
           suggestions: null,
@@ -158463,6 +158471,7 @@ function withLoc(fn) {
 const createBinaryExpression = withLoc(t__namespace.binaryExpression);
 const createExpressionStatement = withLoc(t__namespace.expressionStatement);
 const createVariableDeclaration = withLoc(t__namespace.variableDeclaration);
+const createFunctionDeclaration = withLoc(t__namespace.functionDeclaration);
 const createTaggedTemplateExpression = withLoc(
   t__namespace.taggedTemplateExpression
 );
@@ -162063,6 +162072,16 @@ let Visitor$8 = class Visitor extends ReactiveFunctionTransform {
       );
       return {kind: 'remove'};
     }
+    if (
+      instruction.value.kind === 'DeclareContext' &&
+      instruction.value.lvalue.kind === 'HoistedFunction'
+    ) {
+      state.set(
+        instruction.value.lvalue.place.identifier.declarationId,
+        InstructionKind.Function
+      );
+      return {kind: 'remove'};
+    }
     if (
       instruction.value.kind === 'StoreContext' &&
       state.has(instruction.value.lvalue.place.identifier.declarationId)
@@ -162090,6 +162109,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',
@@ -162189,35 +162450,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 {
@@ -162323,7 +162565,7 @@ class InferenceState {
       place.identifier.id
     );
   }
-  referenceAndRecordEffects(place, effectKind, reason, functionEffects) {
+  referenceAndRecordEffects(freezeActions, place, effectKind, reason) {
     const values = __classPrivateFieldGet(
       this,
       _InferenceState_variables,
@@ -162342,43 +162584,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) {
@@ -162424,7 +162631,7 @@ class InferenceState {
     });
     let valueKind = this.kind(place);
     let effect = null;
-    let functionEffect = null;
+    let freeze = null;
     switch (effectKind) {
       case exports.Effect.Freeze: {
         if (
@@ -162439,7 +162646,7 @@ class InferenceState {
             reason: reasonSet,
             context: new Set(),
           };
-          this.freezeValues(values, reasonSet);
+          freeze = {values: values, reason: reasonSet};
         } else {
           effect = exports.Effect.Read;
         }
@@ -162457,80 +162664,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;
@@ -162576,7 +162713,7 @@ class InferenceState {
       suggestions: null,
     });
     place.effect = effect;
-    return functionEffect;
+    return freeze;
   }
   merge(other) {
     let nextValues = null;
@@ -162831,29 +162968,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]),
@@ -162864,37 +163003,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]),
@@ -162910,26 +163054,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;
             }
@@ -162944,64 +163088,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
             );
           }
         }
@@ -163012,63 +163158,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;
       }
@@ -163077,32 +163246,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
@@ -163113,7 +163266,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)];
@@ -163128,19 +163282,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(),
@@ -163151,15 +163305,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(
@@ -163173,8 +163328,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(),
@@ -163185,47 +163340,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 ||
@@ -163236,7 +163384,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), {
@@ -163247,10 +163396,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,
@@ -163276,17 +163425,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);
@@ -163294,52 +163443,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 ||
@@ -163350,7 +163493,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 =
@@ -163358,43 +163502,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 =
@@ -163402,40 +163551,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,
@@ -163444,69 +163594,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
             );
           }
         }
@@ -163518,7 +163672,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;
@@ -163528,28 +163683,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;
@@ -163568,7 +163725,8 @@ function inferBlock(env, functionEffects, state, block) {
               }
         );
         state.define(instrValue.lvalue.place, value);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'DeclareContext': {
         state.initialize(instrValue, {
@@ -163577,7 +163735,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': {
@@ -163587,17 +163746,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 =
@@ -163606,56 +163766,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;
@@ -163669,10 +163822,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);
@@ -163681,13 +163834,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 = {
@@ -163699,34 +163855,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;
       }
@@ -163734,24 +163899,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') {
@@ -163766,17 +163941,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)) {
@@ -163843,28 +164018,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) {
@@ -167038,7 +167191,7 @@ function equation(left, right) {
   return {left: left, right: right};
 }
 function* generate(func) {
-  if (func.env.fnType === 'Component') {
+  if (func.fnType === 'Component') {
     const [props, ref] = func.params;
     if (props && props.kind === 'Identifier') {
       yield equation(props.identifier.type, {
@@ -168070,16 +168223,131 @@ function validateNoCapitalizedCalls(fn) {
     }
   }
 }
+var _Env_changed;
+class Env extends Map {
+  constructor() {
+    super(...arguments);
+    _Env_changed.set(this, false);
+  }
+  resetChanged() {
+    __classPrivateFieldSet(this, _Env_changed, false, 'f');
+  }
+  hasChanged() {
+    return __classPrivateFieldGet(this, _Env_changed, 'f');
+  }
+  set(key, value) {
+    const cur = this.get(key);
+    const widenedValue = joinRefAccessTypes(
+      value,
+      cur !== null && cur !== void 0 ? cur : {kind: 'None'}
+    );
+    if (
+      !(cur == null && widenedValue.kind === 'None') &&
+      (cur == null || !tyEqual(cur, widenedValue))
+    ) {
+      __classPrivateFieldSet(this, _Env_changed, true, 'f');
+    }
+    return super.set(key, widenedValue);
+  }
+}
+_Env_changed = new WeakMap();
 function validateNoRefAccessInRender(fn) {
-  const state = {
-    refs: new Set(),
-    refValues: new Map(),
-    refAccessingFunctions: new Set(),
-  };
-  validateNoRefAccessInRenderImpl(fn, state).unwrap();
+  const env = new Env();
+  validateNoRefAccessInRenderImpl(fn, env).unwrap();
+}
+function refTypeOfType(identifier) {
+  if (isRefValueType(identifier)) {
+    return {kind: 'RefValue'};
+  } else if (isUseRefType(identifier)) {
+    return {kind: 'Ref'};
+  } else {
+    return {kind: 'None'};
+  }
 }
-function validateNoRefAccessInRenderImpl(fn, state) {
-  var _a, _b;
+function tyEqual(a, b) {
+  if (a.kind !== b.kind) {
+    return false;
+  }
+  switch (a.kind) {
+    case 'None':
+      return true;
+    case 'Ref':
+      return true;
+    case 'RefValue':
+      CompilerError.invariant(b.kind === 'RefValue', {
+        reason: 'Expected ref value',
+        loc: null,
+      });
+      return a.loc == b.loc;
+    case 'Structure': {
+      CompilerError.invariant(b.kind === 'Structure', {
+        reason: 'Expected structure',
+        loc: null,
+      });
+      const fnTypesEqual =
+        (a.fn === null && b.fn === null) ||
+        (a.fn !== null &&
+          b.fn !== null &&
+          a.fn.readRefEffect === b.fn.readRefEffect &&
+          tyEqual(a.fn.returnType, b.fn.returnType));
+      return (
+        fnTypesEqual &&
+        (a.value === b.value ||
+          (a.value !== null && b.value !== null && tyEqual(a.value, b.value)))
+      );
+    }
+  }
+}
+function joinRefAccessTypes(...types) {
+  function joinRefAccessRefTypes(a, b) {
+    if (a.kind === 'RefValue') {
+      return a;
+    } else if (b.kind === 'RefValue') {
+      return b;
+    } else if (a.kind === 'Ref' || b.kind === 'Ref') {
+      return {kind: 'Ref'};
+    } else {
+      CompilerError.invariant(
+        a.kind === 'Structure' && b.kind === 'Structure',
+        {reason: 'Expected structure', loc: null}
+      );
+      const fn =
+        a.fn === null
+          ? b.fn
+          : b.fn === null
+            ? a.fn
+            : {
+                readRefEffect: a.fn.readRefEffect || b.fn.readRefEffect,
+                returnType: joinRefAccessTypes(
+                  a.fn.returnType,
+                  b.fn.returnType
+                ),
+              };
+      const value =
+        a.value === null
+          ? b.value
+          : b.value === null
+            ? a.value
+            : joinRefAccessRefTypes(a.value, b.value);
+      return {kind: 'Structure', fn: fn, value: value};
+    }
+  }
+  return types.reduce(
+    (a, b) => {
+      if (a.kind === 'None') {
+        return b;
+      } else if (b.kind === 'None') {
+        return a;
+      } else {
+        return joinRefAccessRefTypes(a, b);
+      }
+    },
+    {kind: 'None'}
+  );
+}
+function validateNoRefAccessInRenderImpl(fn, env) {
+  var _a, _b, _c, _d, _e, _f;
+  let returnValues = [];
   let place;
   for (const param of fn.params) {
     if (param.kind === 'Identifier') {
@@ -168087,291 +168355,293 @@ function validateNoRefAccessInRenderImpl(fn, state) {
     } else {
       place = param.place;
     }
-    if (isRefValueType(place.identifier)) {
-      state.refValues.set(place.identifier.id, null);
-    }
-    if (isUseRefType(place.identifier)) {
-      state.refs.add(place.identifier.id);
-    }
+    const type = refTypeOfType(place.identifier);
+    env.set(place.identifier.id, type);
   }
-  const errors = new CompilerError();
-  for (const [, block] of fn.body.blocks) {
-    for (const phi of block.phis) {
-      phi.operands.forEach(operand => {
-        var _a;
-        if (state.refs.has(operand.id) || isUseRefType(phi.id)) {
-          state.refs.add(phi.id.id);
-        }
-        const refValue = state.refValues.get(operand.id);
-        if (refValue !== undefined || isRefValueType(operand)) {
-          state.refValues.set(
-            phi.id.id,
-            (_a =
-              refValue !== null && refValue !== void 0
-                ? refValue
-                : state.refValues.get(phi.id.id)) !== null && _a !== void 0
-              ? _a
-              : null
-          );
-        }
-        if (state.refAccessingFunctions.has(operand.id)) {
-          state.refAccessingFunctions.add(phi.id.id);
-        }
-      });
-    }
-    for (const instr of block.instructions) {
-      for (const operand of eachInstructionValueOperand(instr.value)) {
-        if (isRefValueType(operand.identifier)) {
-          CompilerError.invariant(state.refValues.has(operand.identifier.id), {
-            reason: 'Expected ref value to be in state',
-            loc: operand.loc,
-          });
-        }
-        if (isUseRefType(operand.identifier)) {
-          CompilerError.invariant(state.refs.has(operand.identifier.id), {
-            reason: 'Expected ref to be in state',
-            loc: operand.loc,
-          });
-        }
+  for (let i = 0; (i == 0 || env.hasChanged()) && i < 10; i++) {
+    env.resetChanged();
+    returnValues = [];
+    const errors = new CompilerError();
+    for (const [, block] of fn.body.blocks) {
+      for (const phi of block.phis) {
+        env.set(
+          phi.id.id,
+          joinRefAccessTypes(
+            ...Array(...phi.operands.values()).map(operand => {
+              var _a;
+              return (_a = env.get(operand.id)) !== null && _a !== void 0
+                ? _a
+                : {kind: 'None'};
+            })
+          )
+        );
       }
-      switch (instr.value.kind) {
-        case 'JsxExpression':
-        case 'JsxFragment': {
-          for (const operand of eachInstructionValueOperand(instr.value)) {
-            validateNoDirectRefValueAccess(errors, operand, state);
-          }
-          break;
-        }
-        case 'ComputedLoad':
-        case 'PropertyLoad': {
-          if (typeof instr.value.property !== 'string') {
-            validateNoRefValueAccess(errors, state, instr.value.property);
-          }
-          if (
-            state.refAccessingFunctions.has(instr.value.object.identifier.id)
-          ) {
-            state.refAccessingFunctions.add(instr.lvalue.identifier.id);
-          }
-          if (state.refs.has(instr.value.object.identifier.id)) {
-            state.refs.add(instr.lvalue.identifier.id);
-            state.refValues.set(instr.lvalue.identifier.id, instr.loc);
-          }
-          break;
-        }
-        case 'LoadContext':
-        case 'LoadLocal': {
-          if (
-            state.refAccessingFunctions.has(instr.value.place.identifier.id)
-          ) {
-            state.refAccessingFunctions.add(instr.lvalue.identifier.id);
-          }
-          const refValue = state.refValues.get(instr.value.place.identifier.id);
-          if (refValue !== undefined) {
-            state.refValues.set(instr.lvalue.identifier.id, refValue);
+      for (const instr of block.instructions) {
+        switch (instr.value.kind) {
+          case 'JsxExpression':
+          case 'JsxFragment': {
+            for (const operand of eachInstructionValueOperand(instr.value)) {
+              validateNoDirectRefValueAccess(errors, operand, env);
+            }
+            break;
           }
-          if (state.refs.has(instr.value.place.identifier.id)) {
-            state.refs.add(instr.lvalue.identifier.id);
+          case 'ComputedLoad':
+          case 'PropertyLoad': {
+            if (typeof instr.value.property !== 'string') {
+              validateNoDirectRefValueAccess(errors, instr.value.property, env);
+            }
+            const objType = env.get(instr.value.object.identifier.id);
+            let lookupType = null;
+            if (
+              (objType === null || objType === void 0
+                ? void 0
+                : objType.kind) === 'Structure'
+            ) {
+              lookupType = objType.value;
+            } else if (
+              (objType === null || objType === void 0
+                ? void 0
+                : objType.kind) === 'Ref'
+            ) {
+              lookupType = {kind: 'RefValue', loc: instr.loc};
+            }
+            env.set(
+              instr.lvalue.identifier.id,
+              lookupType !== null && lookupType !== void 0
+                ? lookupType
+                : refTypeOfType(instr.lvalue.identifier)
+            );
+            break;
           }
-          break;
-        }
-        case 'StoreContext':
-        case 'StoreLocal': {
-          if (
-            state.refAccessingFunctions.has(instr.value.value.identifier.id)
-          ) {
-            state.refAccessingFunctions.add(
-              instr.value.lvalue.place.identifier.id
+          case 'LoadContext':
+          case 'LoadLocal': {
+            env.set(
+              instr.lvalue.identifier.id,
+              (_a = env.get(instr.value.place.identifier.id)) !== null &&
+                _a !== void 0
+                ? _a
+                : refTypeOfType(instr.lvalue.identifier)
             );
-            state.refAccessingFunctions.add(instr.lvalue.identifier.id);
+            break;
           }
-          const refValue = state.refValues.get(instr.value.value.identifier.id);
-          if (
-            refValue !== undefined ||
-            isRefValueType(instr.value.lvalue.place.identifier)
-          ) {
-            state.refValues.set(
+          case 'StoreContext':
+          case 'StoreLocal': {
+            env.set(
               instr.value.lvalue.place.identifier.id,
-              refValue !== null && refValue !== void 0 ? refValue : null
+              (_b = env.get(instr.value.value.identifier.id)) !== null &&
+                _b !== void 0
+                ? _b
+                : refTypeOfType(instr.value.lvalue.place.identifier)
             );
-            state.refValues.set(
+            env.set(
               instr.lvalue.identifier.id,
-              refValue !== null && refValue !== void 0 ? refValue : null
+              (_c = env.get(instr.value.value.identifier.id)) !== null &&
+                _c !== void 0
+                ? _c
+                : refTypeOfType(instr.lvalue.identifier)
             );
+            break;
           }
-          if (state.refs.has(instr.value.value.identifier.id)) {
-            state.refs.add(instr.value.lvalue.place.identifier.id);
-            state.refs.add(instr.lvalue.identifier.id);
-          }
-          break;
-        }
-        case 'Destructure': {
-          const destructuredFunction = state.refAccessingFunctions.has(
-            instr.value.value.identifier.id
-          );
-          const destructuredRef = state.refs.has(
-            instr.value.value.identifier.id
-          );
-          for (const lval of eachPatternOperand(instr.value.lvalue.pattern)) {
-            if (isUseRefType(lval.identifier)) {
-              state.refs.add(lval.identifier.id);
-            }
-            if (destructuredRef || isRefValueType(lval.identifier)) {
-              state.refs.add(lval.identifier.id);
-              state.refValues.set(lval.identifier.id, null);
+          case 'Destructure': {
+            const objType = env.get(instr.value.value.identifier.id);
+            let lookupType = null;
+            if (
+              (objType === null || objType === void 0
+                ? void 0
+                : objType.kind) === 'Structure'
+            ) {
+              lookupType = objType.value;
             }
-            if (destructuredFunction) {
-              state.refAccessingFunctions.add(lval.identifier.id);
+            env.set(
+              instr.lvalue.identifier.id,
+              lookupType !== null && lookupType !== void 0
+                ? lookupType
+                : refTypeOfType(instr.lvalue.identifier)
+            );
+            for (const lval of eachPatternOperand(instr.value.lvalue.pattern)) {
+              env.set(
+                lval.identifier.id,
+                lookupType !== null && lookupType !== void 0
+                  ? lookupType
+                  : refTypeOfType(lval.identifier)
+              );
             }
+            break;
           }
-          break;
-        }
-        case 'ObjectMethod':
-        case 'FunctionExpression': {
-          if (
-            [...eachInstructionValueOperand(instr.value)].some(
-              operand =>
-                state.refValues.has(operand.identifier.id) ||
-                state.refAccessingFunctions.has(operand.identifier.id)
-            ) ||
-            ([...eachInstructionValueOperand(instr.value)].some(operand =>
-              state.refs.has(operand.identifier.id)
-            ) &&
-              validateNoRefAccessInRenderImpl(
-                instr.value.loweredFunc.func,
-                state
-              ).isErr())
-          ) {
-            state.refAccessingFunctions.add(instr.lvalue.identifier.id);
+          case 'ObjectMethod':
+          case 'FunctionExpression': {
+            let returnType = {kind: 'None'};
+            let readRefEffect = false;
+            const result = validateNoRefAccessInRenderImpl(
+              instr.value.loweredFunc.func,
+              env
+            );
+            if (result.isOk()) {
+              returnType = result.unwrap();
+            } else if (result.isErr()) {
+              readRefEffect = true;
+            }
+            env.set(instr.lvalue.identifier.id, {
+              kind: 'Structure',
+              fn: {readRefEffect: readRefEffect, returnType: returnType},
+              value: null,
+            });
+            break;
           }
-          break;
-        }
-        case 'MethodCall': {
-          if (!isEffectHook(instr.value.property.identifier)) {
+          case 'MethodCall':
+          case 'CallExpression': {
+            const callee =
+              instr.value.kind === 'CallExpression'
+                ? instr.value.callee
+                : instr.value.property;
+            const hookKind = getHookKindForType(fn.env, callee.identifier.type);
+            let returnType = {kind: 'None'};
+            const fnType = env.get(callee.identifier.id);
+            if (
+              (fnType === null || fnType === void 0 ? void 0 : fnType.kind) ===
+                'Structure' &&
+              fnType.fn !== null
+            ) {
+              returnType = fnType.fn.returnType;
+              if (fnType.fn.readRefEffect) {
+                errors.push({
+                  severity: exports.ErrorSeverity.InvalidReact,
+                  reason:
+                    'This function accesses a ref value (the `current` property), which may not be accessed during render. (https://react.dev/reference/react/useRef)',
+                  loc: callee.loc,
+                  description:
+                    callee.identifier.name !== null &&
+                    callee.identifier.name.kind === 'named'
+                      ? `Function \`${callee.identifier.name.value}\` accesses a ref`
+                      : null,
+                  suggestions: null,
+                });
+              }
+            }
             for (const operand of eachInstructionValueOperand(instr.value)) {
-              validateNoRefAccess(errors, state, operand, operand.loc);
+              if (hookKind != null) {
+                validateNoDirectRefValueAccess(errors, operand, env);
+              } else {
+                validateNoRefAccess(errors, env, operand, operand.loc);
+              }
             }
+            env.set(instr.lvalue.identifier.id, returnType);
+            break;
           }
-          break;
-        }
-        case 'CallExpression': {
-          const callee = instr.value.callee;
-          const isUseEffect = isEffectHook(callee.identifier);
-          if (!isUseEffect) {
-            if (state.refAccessingFunctions.has(callee.identifier.id)) {
-              errors.push({
-                severity: exports.ErrorSeverity.InvalidReact,
-                reason:
-                  'This function accesses a ref value (the `current` property), which may not be accessed during render. (https://react.dev/reference/react/useRef)',
-                loc: callee.loc,
-                description:
-                  callee.identifier.name !== null &&
-                  callee.identifier.name.kind === 'named'
-                    ? `Function \`${callee.identifier.name.value}\` accesses a ref`
-                    : null,
-                suggestions: null,
-              });
-            }
+          case 'ObjectExpression':
+          case 'ArrayExpression': {
+            const types = [];
             for (const operand of eachInstructionValueOperand(instr.value)) {
-              validateNoRefAccess(
-                errors,
-                state,
-                operand,
-                (_a = state.refValues.get(operand.identifier.id)) !== null &&
-                  _a !== void 0
-                  ? _a
-                  : operand.loc
+              validateNoDirectRefValueAccess(errors, operand, env);
+              types.push(
+                (_d = env.get(operand.identifier.id)) !== null && _d !== void 0
+                  ? _d
+                  : {kind: 'None'}
               );
             }
-          }
-          break;
-        }
-        case 'ObjectExpression':
-        case 'ArrayExpression': {
-          for (const operand of eachInstructionValueOperand(instr.value)) {
-            validateNoDirectRefValueAccess(errors, operand, state);
-            if (state.refAccessingFunctions.has(operand.identifier.id)) {
-              state.refAccessingFunctions.add(instr.lvalue.identifier.id);
+            const value = joinRefAccessTypes(...types);
+            if (value.kind === 'None') {
+              env.set(instr.lvalue.identifier.id, {kind: 'None'});
+            } else {
+              env.set(instr.lvalue.identifier.id, {
+                kind: 'Structure',
+                value: value,
+                fn: null,
+              });
             }
-            if (state.refs.has(operand.identifier.id)) {
-              state.refs.add(instr.lvalue.identifier.id);
+            break;
+          }
+          case 'PropertyDelete':
+          case 'PropertyStore':
+          case 'ComputedDelete':
+          case 'ComputedStore': {
+            validateNoRefAccess(errors, env, instr.value.object, instr.loc);
+            for (const operand of eachInstructionValueOperand(instr.value)) {
+              if (operand === instr.value.object) {
+                continue;
+              }
+              validateNoRefValueAccess(errors, env, operand);
             }
-            const refValue = state.refValues.get(operand.identifier.id);
-            if (refValue !== undefined) {
-              state.refValues.set(instr.lvalue.identifier.id, refValue);
+            break;
+          }
+          case 'StartMemoize':
+          case 'FinishMemoize':
+            break;
+          default: {
+            for (const operand of eachInstructionValueOperand(instr.value)) {
+              validateNoRefValueAccess(errors, env, operand);
             }
+            break;
           }
-          break;
         }
-        case 'PropertyDelete':
-        case 'PropertyStore':
-        case 'ComputedDelete':
-        case 'ComputedStore': {
-          validateNoRefAccess(
-            errors,
-            state,
-            instr.value.object,
-            (_b = state.refValues.get(instr.value.object.identifier.id)) !==
-              null && _b !== void 0
-              ? _b
-              : instr.loc
+        if (isUseRefType(instr.lvalue.identifier)) {
+          env.set(
+            instr.lvalue.identifier.id,
+            joinRefAccessTypes(
+              (_e = env.get(instr.lvalue.identifier.id)) !== null &&
+                _e !== void 0
+                ? _e
+                : {kind: 'None'},
+              {kind: 'Ref'}
+            )
           );
-          for (const operand of eachInstructionValueOperand(instr.value)) {
-            if (operand === instr.value.object) {
-              continue;
-            }
-            validateNoRefValueAccess(errors, state, operand);
-          }
-          break;
         }
-        case 'StartMemoize':
-        case 'FinishMemoize':
-          break;
-        default: {
-          for (const operand of eachInstructionValueOperand(instr.value)) {
-            validateNoRefValueAccess(errors, state, operand);
-          }
-          break;
+        if (isRefValueType(instr.lvalue.identifier)) {
+          env.set(
+            instr.lvalue.identifier.id,
+            joinRefAccessTypes(
+              (_f = env.get(instr.lvalue.identifier.id)) !== null &&
+                _f !== void 0
+                ? _f
+                : {kind: 'None'},
+              {kind: 'RefValue', loc: instr.loc}
+            )
+          );
         }
       }
-      if (isUseRefType(instr.lvalue.identifier)) {
-        state.refs.add(instr.lvalue.identifier.id);
-      }
-      if (
-        isRefValueType(instr.lvalue.identifier) &&
-        !state.refValues.has(instr.lvalue.identifier.id)
-      ) {
-        state.refValues.set(instr.lvalue.identifier.id, instr.loc);
+      for (const operand of eachTerminalOperand(block.terminal)) {
+        if (block.terminal.kind !== 'return') {
+          validateNoRefValueAccess(errors, env, operand);
+        } else {
+          validateNoDirectRefValueAccess(errors, operand, env);
+          returnValues.push(env.get(operand.identifier.id));
+        }
       }
     }
-    for (const operand of eachTerminalOperand(block.terminal)) {
-      if (block.terminal.kind !== 'return') {
-        validateNoRefValueAccess(errors, state, operand);
-      } else {
-        validateNoDirectRefValueAccess(errors, operand, state);
-      }
+    if (errors.hasErrors()) {
+      return Err(errors);
     }
   }
-  if (errors.hasErrors()) {
-    return Err(errors);
-  } else {
-    return Ok(undefined);
+  CompilerError.invariant(!env.hasChanged(), {
+    reason: 'Ref type environment did not converge',
+    loc: null,
+  });
+  return Ok(
+    joinRefAccessTypes(...returnValues.filter(env => env !== undefined))
+  );
+}
+function destructure(type) {
+  if (
+    (type === null || type === void 0 ? void 0 : type.kind) === 'Structure' &&
+    type.value !== null
+  ) {
+    return destructure(type.value);
   }
+  return type;
 }
-function validateNoRefValueAccess(errors, state, operand) {
+function validateNoRefValueAccess(errors, env, operand) {
   var _a;
+  const type = destructure(env.get(operand.identifier.id));
   if (
-    state.refValues.has(operand.identifier.id) ||
-    state.refAccessingFunctions.has(operand.identifier.id)
+    (type === null || type === void 0 ? void 0 : type.kind) === 'RefValue' ||
+    ((type === null || type === void 0 ? void 0 : type.kind) === 'Structure' &&
+      ((_a = type.fn) === null || _a === void 0 ? void 0 : _a.readRefEffect))
   ) {
     errors.push({
       severity: exports.ErrorSeverity.InvalidReact,
       reason:
         'Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)',
-      loc:
-        (_a = state.refValues.get(operand.identifier.id)) !== null &&
-        _a !== void 0
-          ? _a
-          : operand.loc,
+      loc: (type.kind === 'RefValue' && type.loc) || operand.loc,
       description:
         operand.identifier.name !== null &&
         operand.identifier.name.kind === 'named'
@@ -168381,17 +168651,20 @@ function validateNoRefValueAccess(errors, state, operand) {
     });
   }
 }
-function validateNoRefAccess(errors, state, operand, loc) {
+function validateNoRefAccess(errors, env, operand, loc) {
+  var _a;
+  const type = destructure(env.get(operand.identifier.id));
   if (
-    state.refs.has(operand.identifier.id) ||
-    state.refValues.has(operand.identifier.id) ||
-    state.refAccessingFunctions.has(operand.identifier.id)
+    (type === null || type === void 0 ? void 0 : type.kind) === 'Ref' ||
+    (type === null || type === void 0 ? void 0 : type.kind) === 'RefValue' ||
+    ((type === null || type === void 0 ? void 0 : type.kind) === 'Structure' &&
+      ((_a = type.fn) === null || _a === void 0 ? void 0 : _a.readRefEffect))
   ) {
     errors.push({
       severity: exports.ErrorSeverity.InvalidReact,
       reason:
         'Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)',
-      loc: loc,
+      loc: (type.kind === 'RefValue' && type.loc) || loc,
       description:
         operand.identifier.name !== null &&
         operand.identifier.name.kind === 'named'
@@ -168401,18 +168674,15 @@ function validateNoRefAccess(errors, state, operand, loc) {
     });
   }
 }
-function validateNoDirectRefValueAccess(errors, operand, state) {
+function validateNoDirectRefValueAccess(errors, operand, env) {
   var _a;
-  if (state.refValues.has(operand.identifier.id)) {
+  const type = destructure(env.get(operand.identifier.id));
+  if ((type === null || type === void 0 ? void 0 : type.kind) === 'RefValue') {
     errors.push({
       severity: exports.ErrorSeverity.InvalidReact,
       reason:
         'Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)',
-      loc:
-        (_a = state.refValues.get(operand.identifier.id)) !== null &&
-        _a !== void 0
-          ? _a
-          : operand.loc,
+      loc: (_a = type.loc) !== null && _a !== void 0 ? _a : operand.loc,
       description:
         operand.identifier.name !== null &&
         operand.identifier.name.kind === 'named'