babel-plugin-react-compiler 0.0.0-experimental-f1f288c-20240725 → 0.0.0-experimental-0725353-20240806

package/dist/index.js

@@ -135625,6 +135625,14 @@ function getOrInsertDefault(m, key, defaultValue) {
     return defaultValue;
   }
 }
+function Iterable_some(iter, pred) {
+  for (const item of iter) {
+    if (pred(item)) {
+      return true;
+    }
+  }
+  return false;
+}
 function hasNode(input) {
   return input.node != null;
 }
@@ -135902,6 +135910,17 @@ var InstructionKind;
   InstructionKind['Catch'] = 'Catch';
   InstructionKind['HoistedConst'] = 'HoistedConst';
 })(InstructionKind || (InstructionKind = {}));
+function makeTemporaryIdentifier(id, loc) {
+  return {
+    id: id,
+    name: null,
+    declarationId: makeDeclarationId(id),
+    mutableRange: {start: makeInstructionId(0), end: makeInstructionId(0)},
+    scope: null,
+    type: makeType(),
+    loc: loc,
+  };
+}
 function makeIdentifierName(name) {
   CompilerError.invariant(t__namespace.isValidIdentifier(name), {
     reason: `Expected a valid identifier name`,
@@ -135918,7 +135937,7 @@ function promoteTemporary(identifier) {
     description: `Identifier already has a name, \`${identifier.name}\``,
     suggestions: null,
   });
-  identifier.name = {kind: 'promoted', value: `#t${identifier.id}`};
+  identifier.name = {kind: 'promoted', value: `#t${identifier.declarationId}`};
 }
 function isPromotedTemporary(name) {
   return name.startsWith('#t');
@@ -135930,7 +135949,7 @@ function promoteTemporaryJsxTag(identifier) {
     description: `Identifier already has a name, \`${identifier.name}\``,
     suggestions: null,
   });
-  identifier.name = {kind: 'promoted', value: `#T${identifier.id}`};
+  identifier.name = {kind: 'promoted', value: `#T${identifier.declarationId}`};
 }
 function isPromotedJsxTemporary(name) {
   return name.startsWith('#T');
@@ -136017,6 +136036,15 @@ function makeIdentifierId(id) {
   });
   return id;
 }
+function makeDeclarationId(id) {
+  CompilerError.invariant(id >= 0 && Number.isInteger(id), {
+    reason: 'Expected declaration id to be a non-negative integer',
+    description: null,
+    loc: null,
+    suggestions: null,
+  });
+  return id;
+}
 function makeInstructionId(id) {
   CompilerError.invariant(id >= 0 && Number.isInteger(id), {
     reason: 'Expected instruction id to be a non-negative integer',
@@ -138666,6 +138694,7 @@ class HIRBuilder {
     _HIRBuilder_env.set(this, void 0);
     _HIRBuilder_exceptionHandlerStack.set(this, []);
     this.errors = new CompilerError();
+    this.fbtDepth = 0;
     __classPrivateFieldSet(this, _HIRBuilder_env, env, 'f');
     __classPrivateFieldSet(
       this,
@@ -138736,14 +138765,7 @@ class HIRBuilder {
   }
   makeTemporary(loc) {
     const id = this.nextIdentifierId;
-    return {
-      id: id,
-      name: null,
-      mutableRange: {start: makeInstructionId(0), end: makeInstructionId(0)},
-      scope: null,
-      type: makeType(),
-      loc: loc,
-    };
+    return makeTemporaryIdentifier(id, loc);
   }
   resolveIdentifier(path) {
     const originalName = path.node.name;
@@ -138823,7 +138845,13 @@ class HIRBuilder {
     }
   }
   resolveBinding(node) {
-    var _a;
+    var _a, _b;
+    if (node.name === 'fbt') {
+      CompilerError.throwTodo({
+        reason: 'Support local variables named "fbt"',
+        loc: (_a = node.loc) !== null && _a !== void 0 ? _a : null,
+      });
+    }
     const originalName = node.name;
     let name = originalName;
     let index = 0;
@@ -138837,6 +138865,7 @@ class HIRBuilder {
         const id = this.nextIdentifierId;
         const identifier = {
           id: id,
+          declarationId: makeDeclarationId(id),
           name: makeIdentifierName(name),
           mutableRange: {
             start: makeInstructionId(0),
@@ -138844,7 +138873,7 @@ class HIRBuilder {
           },
           scope: null,
           type: makeType(),
-          loc: (_a = node.loc) !== null && _a !== void 0 ? _a : GeneratedSource,
+          loc: (_b = node.loc) !== null && _b !== void 0 ? _b : GeneratedSource,
         };
         __classPrivateFieldGet(this, _HIRBuilder_bindings, 'f').set(name, {
           node: node,
@@ -139280,19 +139309,19 @@ function removeUnnecessaryTryCatch(fn) {
 function createTemporaryPlace(env, loc) {
   return {
     kind: 'Identifier',
-    identifier: {
-      id: env.nextIdentifierId,
-      mutableRange: {start: makeInstructionId(0), end: makeInstructionId(0)},
-      name: null,
-      scope: null,
-      type: makeType(),
-      loc: loc,
-    },
+    identifier: makeTemporaryIdentifier(env.nextIdentifierId, loc),
     reactive: false,
     effect: exports.Effect.Unknown,
     loc: GeneratedSource,
   };
 }
+function clonePlaceToTemporary(env, place) {
+  const temp = createTemporaryPlace(env, place.loc);
+  temp.effect = place.effect;
+  temp.identifier.type = place.identifier.type;
+  temp.reactive = place.reactive;
+  return temp;
+}
 const PRIMITIVE_TYPE = {kind: 'Primitive'};
 let nextAnonId = 0;
 function createAnonId() {
@@ -139347,6 +139376,7 @@ const BuiltInUseInsertionEffectHookId = 'BuiltInUseInsertionEffectHook';
 const BuiltInUseOperatorId = 'BuiltInUseOperator';
 const BuiltInUseReducerId = 'BuiltInUseReducer';
 const BuiltInDispatchId = 'BuiltInDispatch';
+const BuiltInUseContextHookId = 'BuiltInUseContextHook';
 const BUILTIN_SHAPES = new Map();
 addObject(BUILTIN_SHAPES, BuiltInPropsId, [
   ['ref', {kind: 'Object', shapeId: BuiltInUseRefId}],
@@ -141660,7 +141690,6 @@ function lowerExpression(builder, exprPath) {
       switch (leftNode.type) {
         case 'Identifier': {
           const leftExpr = left;
-          const identifier = lowerIdentifier(builder, leftExpr);
           const leftPlace = lowerExpressionToTemporary(builder, leftExpr);
           const right = lowerExpressionToTemporary(builder, expr.get('right'));
           const binaryPlace = lowerValueToTemporary(builder, {
@@ -141670,30 +141699,42 @@ function lowerExpression(builder, exprPath) {
             right: right,
             loc: exprLoc,
           });
-          const kind = getStoreKind(builder, leftExpr);
-          if (kind === 'StoreLocal') {
-            lowerValueToTemporary(builder, {
-              kind: 'StoreLocal',
-              lvalue: {
-                place: Object.assign({}, identifier),
-                kind: InstructionKind.Reassign,
-              },
-              value: Object.assign({}, binaryPlace),
-              type: null,
-              loc: exprLoc,
-            });
-            return {kind: 'LoadLocal', place: identifier, loc: exprLoc};
+          const binding = builder.resolveIdentifier(leftExpr);
+          if (binding.kind === 'Identifier') {
+            const identifier = lowerIdentifier(builder, leftExpr);
+            const kind = getStoreKind(builder, leftExpr);
+            if (kind === 'StoreLocal') {
+              lowerValueToTemporary(builder, {
+                kind: 'StoreLocal',
+                lvalue: {
+                  place: Object.assign({}, identifier),
+                  kind: InstructionKind.Reassign,
+                },
+                value: Object.assign({}, binaryPlace),
+                type: null,
+                loc: exprLoc,
+              });
+              return {kind: 'LoadLocal', place: identifier, loc: exprLoc};
+            } else {
+              lowerValueToTemporary(builder, {
+                kind: 'StoreContext',
+                lvalue: {
+                  place: Object.assign({}, identifier),
+                  kind: InstructionKind.Reassign,
+                },
+                value: Object.assign({}, binaryPlace),
+                loc: exprLoc,
+              });
+              return {kind: 'LoadContext', place: identifier, loc: exprLoc};
+            }
           } else {
-            lowerValueToTemporary(builder, {
-              kind: 'StoreContext',
-              lvalue: {
-                place: Object.assign({}, identifier),
-                kind: InstructionKind.Reassign,
-              },
+            const temporary = lowerValueToTemporary(builder, {
+              kind: 'StoreGlobal',
+              name: leftExpr.node.name,
               value: Object.assign({}, binaryPlace),
               loc: exprLoc,
             });
-            return {kind: 'LoadContext', place: identifier, loc: exprLoc};
+            return {kind: 'LoadLocal', place: temporary, loc: temporary.loc};
           }
         }
         case 'MemberExpression': {
@@ -141856,18 +141897,17 @@ function lowerExpression(builder, exprPath) {
         }
         props.push({kind: 'JsxAttribute', name: propName, place: value});
       }
-      if (
-        tag.kind === 'BuiltinTag' &&
-        (tag.name === 'fbt' || tag.name === 'fbs')
-      ) {
+      const isFbt =
+        tag.kind === 'BuiltinTag' && (tag.name === 'fbt' || tag.name === 'fbs');
+      if (isFbt) {
         const tagName = tag.name;
         const openingIdentifier = opening.get('name');
         const tagIdentifier = openingIdentifier.isJSXIdentifier()
           ? builder.resolveIdentifier(openingIdentifier)
           : null;
-        if (tagIdentifier != null && tagIdentifier.kind === 'Identifier') {
-          CompilerError.throwTodo({
-            reason: `Support <${tagName}> tags where '${tagName}' is a local variable instead of a global`,
+        if (tagIdentifier != null) {
+          CompilerError.invariant(tagIdentifier.kind !== 'Identifier', {
+            reason: `<${tagName}> tags should be module-level imports`,
             loc:
               (_3 = openingIdentifier.node.loc) !== null && _3 !== void 0
                 ? _3
@@ -141876,63 +141916,64 @@ function lowerExpression(builder, exprPath) {
             suggestions: null,
           });
         }
-        const fbtEnumLocations = [];
+        const fbtLocations = {
+          enum: new Array(),
+          plural: new Array(),
+          pronoun: new Array(),
+        };
         expr.traverse({
+          JSXClosingElement(path) {
+            path.skip();
+          },
           JSXNamespacedName(path) {
-            var _a;
-            if (
-              path.node.namespace.name === tagName &&
-              path.node.name.name === 'enum'
-            ) {
-              fbtEnumLocations.push(
-                (_a = path.node.loc) !== null && _a !== void 0
-                  ? _a
-                  : GeneratedSource
-              );
+            var _a, _b, _c;
+            if (path.node.namespace.name === tagName) {
+              switch (path.node.name.name) {
+                case 'enum':
+                  fbtLocations.enum.push(
+                    (_a = path.node.loc) !== null && _a !== void 0
+                      ? _a
+                      : GeneratedSource
+                  );
+                  break;
+                case 'plural':
+                  fbtLocations.plural.push(
+                    (_b = path.node.loc) !== null && _b !== void 0
+                      ? _b
+                      : GeneratedSource
+                  );
+                  break;
+                case 'pronoun':
+                  fbtLocations.pronoun.push(
+                    (_c = path.node.loc) !== null && _c !== void 0
+                      ? _c
+                      : GeneratedSource
+                  );
+                  break;
+              }
             }
           },
         });
-        if (fbtEnumLocations.length > 1) {
-          CompilerError.throwTodo({
-            reason: `Support <${tagName}> tags with multiple <${tagName}:enum> values`,
-            loc:
-              (_4 = fbtEnumLocations.at(-1)) !== null && _4 !== void 0
-                ? _4
-                : GeneratedSource,
-            description: null,
-            suggestions: null,
-          });
+        for (const [name, locations] of Object.entries(fbtLocations)) {
+          if (locations.length > 1) {
+            CompilerError.throwTodo({
+              reason: `Support <${tagName}> tags with multiple <${tagName}:${name}> values`,
+              loc:
+                (_4 = locations.at(-1)) !== null && _4 !== void 0
+                  ? _4
+                  : GeneratedSource,
+              description: null,
+              suggestions: null,
+            });
+          }
         }
       }
-      let children;
-      if (
-        tag.kind === 'BuiltinTag' &&
-        (tag.name === 'fbt' || tag.name === 'fbs')
-      ) {
-        children = expr
-          .get('children')
-          .map(child => {
-            var _a;
-            if (child.isJSXText()) {
-              const text = child.node.value.replace(/[^\S\u00A0]+/g, ' ');
-              return lowerValueToTemporary(builder, {
-                kind: 'JSXText',
-                value: text,
-                loc:
-                  (_a = child.node.loc) !== null && _a !== void 0
-                    ? _a
-                    : GeneratedSource,
-              });
-            }
-            return lowerJsxElement(builder, child);
-          })
-          .filter(notNull);
-      } else {
-        children = expr
-          .get('children')
-          .map(child => lowerJsxElement(builder, child))
-          .filter(notNull);
-      }
+      isFbt && builder.fbtDepth++;
+      const children = expr
+        .get('children')
+        .map(child => lowerJsxElement(builder, child))
+        .filter(notNull);
+      isFbt && builder.fbtDepth--;
       return {
         kind: 'JsxExpression',
         tag: tag,
@@ -142788,7 +142829,12 @@ function lowerJsxElement(builder, exprPath) {
       return lowerExpressionToTemporary(builder, expression);
     }
   } else if (exprPath.isJSXText()) {
-    const text = trimJsxText(exprPath.node.value);
+    let text;
+    if (builder.fbtDepth > 0) {
+      text = exprPath.node.value;
+    } else {
+      text = trimJsxText(exprPath.node.value);
+    }
     if (text === null) {
       return null;
     }
@@ -142872,7 +142918,7 @@ function lowerFunctionToValue(builder, expr) {
   return {
     kind: 'FunctionExpression',
     name: name,
-    expr: expr.node,
+    type: expr.node.type,
     loc: exprLoc,
     loweredFunc: loweredFunc,
   };
@@ -149706,15 +149752,19 @@ const TYPED_GLOBALS = [
 const REACT_APIS = [
   [
     'useContext',
-    addHook(DEFAULT_SHAPES, {
-      positionalParams: [],
-      restParam: exports.Effect.Read,
-      returnType: {kind: 'Poly'},
-      calleeEffect: exports.Effect.Read,
-      hookKind: 'useContext',
-      returnValueKind: exports.ValueKind.Frozen,
-      returnValueReason: ValueReason.Context,
-    }),
+    addHook(
+      DEFAULT_SHAPES,
+      {
+        positionalParams: [],
+        restParam: exports.Effect.Read,
+        returnType: {kind: 'Poly'},
+        calleeEffect: exports.Effect.Read,
+        hookKind: 'useContext',
+        returnValueKind: exports.ValueKind.Frozen,
+        returnValueReason: ValueReason.Context,
+      },
+      BuiltInUseContextHookId
+    ),
   ],
   [
     'useState',
@@ -150031,6 +150081,7 @@ const EnvironmentConfigSchema = z.object({
   enableCustomTypeDefinitionForReanimated: z.boolean().default(false),
   hookPattern: z.string().nullable().default(null),
   enableTreatRefLikeIdentifiersAsRefs: z.boolean().nullable().default(false),
+  enableLowerContextAccess: z.boolean().nullable().default(false),
 });
 function parseConfigPragma(pragma) {
   const maybeConfig = {};
@@ -150055,6 +150106,10 @@ function parseConfigPragma(pragma) {
       };
       continue;
     }
+    if (key === 'customMacros' && val) {
+      maybeConfig[key] = [val];
+      continue;
+    }
     if (typeof defaultConfig[key] !== 'boolean') {
       continue;
     }
@@ -153260,6 +153315,12 @@ function mayAllocate(env, instruction) {
 function findDisjointMutableValues(fn) {
   var _a, _b;
   const scopeIdentifiers = new DisjointSet();
+  const declarations = new Map();
+  function declareIdentifier(lvalue) {
+    if (!declarations.has(lvalue.identifier.declarationId)) {
+      declarations.set(lvalue.identifier.declarationId, lvalue.identifier);
+    }
+  }
   for (const [_, block] of fn.body.blocks) {
     for (const phi of block.phis) {
       if (
@@ -153272,9 +153333,15 @@ function findDisjointMutableValues(fn) {
             ? _b
             : block.terminal.id)
       ) {
-        for (const [, phiId] of phi.operands) {
-          scopeIdentifiers.union([phi.id, phiId]);
+        const operands = [phi.id];
+        const declaration = declarations.get(phi.id.declarationId);
+        if (declaration !== undefined) {
+          operands.push(declaration);
         }
+        for (const [_, phiId] of phi.operands) {
+          operands.push(phiId);
+        }
+        scopeIdentifiers.union(operands);
       } else if (fn.env.config.enableForest) {
         for (const [, phiId] of phi.operands) {
           scopeIdentifiers.union([phi.id, phiId]);
@@ -153288,9 +153355,15 @@ function findDisjointMutableValues(fn) {
         operands.push(instr.lvalue.identifier);
       }
       if (
+        instr.value.kind === 'DeclareLocal' ||
+        instr.value.kind === 'DeclareContext'
+      ) {
+        declareIdentifier(instr.value.lvalue.place);
+      } else if (
         instr.value.kind === 'StoreLocal' ||
         instr.value.kind === 'StoreContext'
       ) {
+        declareIdentifier(instr.value.lvalue.place);
         if (
           instr.value.lvalue.place.identifier.mutableRange.end >
           instr.value.lvalue.place.identifier.mutableRange.start + 1
@@ -153305,6 +153378,7 @@ function findDisjointMutableValues(fn) {
         }
       } else if (instr.value.kind === 'Destructure') {
         for (const place of eachPatternOperand(instr.value.lvalue.pattern)) {
+          declareIdentifier(place);
           if (
             place.identifier.mutableRange.end >
             place.identifier.mutableRange.start + 1
@@ -153925,10 +153999,10 @@ function eliminateRedundantPhi(fn, sharedRewrites) {
       }
       for (const instr of block.instructions) {
         for (const place of eachInstructionLValue(instr)) {
-          rewritePlace$1(place, rewrites);
+          rewritePlace(place, rewrites);
         }
         for (const place of eachInstructionOperand(instr)) {
-          rewritePlace$1(place, rewrites);
+          rewritePlace(place, rewrites);
         }
         if (
           instr.value.kind === 'FunctionExpression' ||
@@ -153936,19 +154010,19 @@ function eliminateRedundantPhi(fn, sharedRewrites) {
         ) {
           const {context: context} = instr.value.loweredFunc.func;
           for (const place of context) {
-            rewritePlace$1(place, rewrites);
+            rewritePlace(place, rewrites);
           }
           eliminateRedundantPhi(instr.value.loweredFunc.func, rewrites);
         }
       }
       const {terminal: terminal} = block;
       for (const place of eachTerminalOperand(terminal)) {
-        rewritePlace$1(place, rewrites);
+        rewritePlace(place, rewrites);
       }
     }
   } while (rewrites.size > size && hasBackEdge);
 }
-function rewritePlace$1(place, rewrites) {
+function rewritePlace(place, rewrites) {
   const rewrite = rewrites.get(place.identifier);
   if (rewrite != null) {
     place.identifier = rewrite;
@@ -154002,6 +154076,7 @@ class SSABuilder {
   makeId(oldId) {
     return {
       id: this.nextSsaId,
+      declarationId: oldId.declarationId,
       name: oldId.name,
       mutableRange: {start: makeInstructionId(0), end: makeInstructionId(0)},
       scope: null,
@@ -154205,333 +154280,143 @@ function enterSSAImpl(func, builder, rootEntry) {
     }
   }
 }
-function leaveSSA(fn) {
-  var _a, _b, _c;
+function rewriteInstructionKindsBasedOnReassignment(fn) {
   const declarations = new Map();
   for (const param of fn.params) {
     let place = param.kind === 'Identifier' ? param : param.place;
     if (place.identifier.name !== null) {
-      declarations.set(place.identifier.name.value, {
-        lvalue: {kind: InstructionKind.Let, place: place},
+      declarations.set(place.identifier.declarationId, {
+        kind: InstructionKind.Let,
         place: place,
       });
     }
   }
-  const rewrites = new Map();
-  const seen = new Set();
-  const backEdgePhis = new Set();
-  for (const [, block] of fn.body.blocks) {
-    for (const phi of block.phis) {
-      for (const [pred] of phi.operands) {
-        if (!seen.has(pred)) {
-          backEdgePhis.add(phi);
-          break;
-        }
-      }
+  for (const place of fn.context) {
+    if (place.identifier.name !== null) {
+      declarations.set(place.identifier.declarationId, {
+        kind: InstructionKind.Let,
+        place: place,
+      });
     }
-    seen.add(block.id);
   }
   for (const [, block] of fn.body.blocks) {
     for (const instr of block.instructions) {
-      const {lvalue: lvalue, value: value} = instr;
-      if (value.kind === 'DeclareLocal') {
-        const name = value.lvalue.place.identifier.name;
-        if (name !== null) {
-          CompilerError.invariant(!declarations.has(name.value), {
-            reason: `Unexpected duplicate declaration`,
-            description: `Found duplicate declaration for \`${name.value}\``,
-            loc: value.lvalue.place.loc,
-            suggestions: null,
-          });
-          declarations.set(name.value, {
-            lvalue: value.lvalue,
-            place: value.lvalue.place,
-          });
-        }
-      } else if (
-        value.kind === 'PrefixUpdate' ||
-        value.kind === 'PostfixUpdate'
-      ) {
-        CompilerError.invariant(value.lvalue.identifier.name !== null, {
-          reason: `Expected update expression to be applied to a named variable`,
-          description: null,
-          loc: value.lvalue.loc,
-          suggestions: null,
-        });
-        const originalLVal = declarations.get(
-          value.lvalue.identifier.name.value
-        );
-        CompilerError.invariant(originalLVal !== undefined, {
-          reason: `Expected update expression to be applied to a previously defined variable`,
-          description: null,
-          loc: value.lvalue.loc,
-          suggestions: null,
-        });
-        originalLVal.lvalue.kind = InstructionKind.Let;
-      } else if (value.kind === 'StoreLocal') {
-        if (value.lvalue.place.identifier.name != null) {
-          const originalLVal = declarations.get(
-            value.lvalue.place.identifier.name.value
+      const {value: value} = instr;
+      switch (value.kind) {
+        case 'DeclareLocal': {
+          const lvalue = value.lvalue;
+          CompilerError.invariant(
+            !declarations.has(lvalue.place.identifier.declarationId),
+            {
+              reason: `Expected variable not to be defined prior to declaration`,
+              description: `${printPlace(lvalue.place)} was already defined`,
+              loc: lvalue.place.loc,
+            }
           );
-          if (
-            originalLVal === undefined ||
-            originalLVal.lvalue === value.lvalue
-          ) {
-            CompilerError.invariant(
-              originalLVal !== undefined ||
-                block.kind === 'block' ||
-                block.kind === 'catch',
-              {
-                reason: `TODO: Handle reassignment in a value block where the original declaration was removed by dead code elimination (DCE)`,
-                description: null,
-                loc: value.lvalue.place.loc,
-                suggestions: null,
-              }
-            );
-            declarations.set(value.lvalue.place.identifier.name.value, {
-              lvalue: value.lvalue,
-              place: value.lvalue.place,
-            });
-            value.lvalue.kind = InstructionKind.Const;
-          } else {
-            originalLVal.lvalue.kind = InstructionKind.Let;
-            value.lvalue.kind = InstructionKind.Reassign;
-          }
-        } else if (rewrites.has(value.lvalue.place.identifier)) {
-          value.lvalue.kind = InstructionKind.Const;
+          declarations.set(lvalue.place.identifier.declarationId, lvalue);
+          break;
         }
-      } else if (value.kind === 'Destructure') {
-        let kind = null;
-        for (const place of eachPatternOperand(value.lvalue.pattern)) {
-          if (place.identifier.name == null) {
-            CompilerError.invariant(
-              kind === null || kind === InstructionKind.Const,
-              {
-                reason: `Expected consistent kind for destructuring`,
-                description: `other places were \`${kind}\` but '${printPlace(place)}' is const`,
-                loc: place.loc,
-                suggestions: null,
-              }
+        case 'StoreLocal': {
+          const lvalue = value.lvalue;
+          if (lvalue.place.identifier.name !== null) {
+            const declaration = declarations.get(
+              lvalue.place.identifier.declarationId
             );
-            kind = InstructionKind.Const;
-          } else {
-            const originalLVal = declarations.get(place.identifier.name.value);
-            if (
-              originalLVal === undefined ||
-              originalLVal.lvalue === value.lvalue
-            ) {
+            if (declaration === undefined) {
               CompilerError.invariant(
-                originalLVal !== undefined || block.kind !== 'value',
+                !declarations.has(lvalue.place.identifier.declarationId),
                 {
-                  reason: `TODO: Handle reassignment in a value block where the original declaration was removed by dead code elimination (DCE)`,
-                  description: null,
-                  loc: place.loc,
-                  suggestions: null,
+                  reason: `Expected variable not to be defined prior to declaration`,
+                  description: `${printPlace(lvalue.place)} was already defined`,
+                  loc: lvalue.place.loc,
                 }
               );
-              declarations.set(place.identifier.name.value, {
-                lvalue: value.lvalue,
-                place: place,
-              });
+              declarations.set(lvalue.place.identifier.declarationId, lvalue);
+              lvalue.kind = InstructionKind.Const;
+            } else {
+              declaration.kind = InstructionKind.Let;
+              lvalue.kind = InstructionKind.Reassign;
+            }
+          }
+          break;
+        }
+        case 'Destructure': {
+          const lvalue = value.lvalue;
+          let kind = null;
+          for (const place of eachPatternOperand(lvalue.pattern)) {
+            if (place.identifier.name === null) {
               CompilerError.invariant(
                 kind === null || kind === InstructionKind.Const,
                 {
                   reason: `Expected consistent kind for destructuring`,
-                  description: `Other places were \`${kind}\` but '${printPlace(place)}' is const`,
+                  description: `other places were \`${kind}\` but '${printPlace(place)}' is const`,
                   loc: place.loc,
                   suggestions: null,
                 }
               );
               kind = InstructionKind.Const;
             } else {
-              CompilerError.invariant(
-                kind === null || kind === InstructionKind.Reassign,
-                {
-                  reason: `Expected consistent kind for destructuring`,
-                  description: `Other places were \`${kind}\` but '${printPlace(place)}' is reassigned`,
+              const declaration = declarations.get(
+                place.identifier.declarationId
+              );
+              if (declaration === undefined) {
+                CompilerError.invariant(block.kind !== 'value', {
+                  reason: `TODO: Handle reassignment in a value block where the original declaration was removed by dead code elimination (DCE)`,
+                  description: null,
                   loc: place.loc,
                   suggestions: null,
-                }
-              );
-              kind = InstructionKind.Reassign;
-              originalLVal.lvalue.kind = InstructionKind.Let;
-            }
-          }
-        }
-        CompilerError.invariant(kind !== null, {
-          reason: 'Expected at least one operand',
-          description: null,
-          loc: null,
-          suggestions: null,
-        });
-        value.lvalue.kind = kind;
-      }
-      rewritePlace(lvalue, rewrites, declarations);
-      for (const operand of eachInstructionLValue(instr)) {
-        rewritePlace(operand, rewrites, declarations);
-      }
-      for (const operand of eachInstructionValueOperand(instr.value)) {
-        rewritePlace(operand, rewrites, declarations);
-      }
-    }
-    const terminal = block.terminal;
-    for (const operand of eachTerminalOperand(terminal)) {
-      rewritePlace(operand, rewrites, declarations);
-    }
-    const reassignmentPhis = [];
-    const rewritePhis = [];
-    function pushPhis(phiBlock) {
-      for (const phi of phiBlock.phis) {
-        if (phi.id.name === null) {
-          rewritePhis.push({phi: phi, block: phiBlock});
-        } else {
-          reassignmentPhis.push({phi: phi, block: phiBlock});
-        }
-      }
-    }
-    const fallthroughId = terminalFallthrough(terminal);
-    if (fallthroughId !== null) {
-      const fallthrough = fn.body.blocks.get(fallthroughId);
-      pushPhis(fallthrough);
-    }
-    if (terminal.kind === 'while' || terminal.kind === 'for') {
-      const test = fn.body.blocks.get(terminal.test);
-      pushPhis(test);
-      const loop = fn.body.blocks.get(terminal.loop);
-      pushPhis(loop);
-    }
-    if (
-      terminal.kind === 'for' ||
-      terminal.kind === 'for-of' ||
-      terminal.kind === 'for-in'
-    ) {
-      let init = fn.body.blocks.get(terminal.init);
-      pushPhis(init);
-      let initContinuation =
-        terminal.kind === 'for' ? terminal.test : terminal.loop;
-      const queue = [init.id];
-      while (queue.length !== 0) {
-        const blockId = queue.shift();
-        if (blockId === initContinuation) {
-          break;
-        }
-        const block = fn.body.blocks.get(blockId);
-        for (const instr of block.instructions) {
-          if (
-            instr.value.kind === 'StoreLocal' &&
-            instr.value.lvalue.kind !== InstructionKind.Reassign
-          ) {
-            const value = instr.value;
-            if (value.lvalue.place.identifier.name !== null) {
-              const originalLVal = declarations.get(
-                value.lvalue.place.identifier.name.value
-              );
-              if (originalLVal === undefined) {
-                declarations.set(value.lvalue.place.identifier.name.value, {
-                  lvalue: value.lvalue,
-                  place: value.lvalue.place,
                 });
-                value.lvalue.kind = InstructionKind.Const;
+                declarations.set(place.identifier.declarationId, lvalue);
+                CompilerError.invariant(
+                  kind === null || kind === InstructionKind.Const,
+                  {
+                    reason: `Expected consistent kind for destructuring`,
+                    description: `Other places were \`${kind}\` but '${printPlace(place)}' is const`,
+                    loc: place.loc,
+                    suggestions: null,
+                  }
+                );
+                kind = InstructionKind.Const;
+              } else {
+                CompilerError.invariant(
+                  kind === null || kind === InstructionKind.Reassign,
+                  {
+                    reason: `Expected consistent kind for destructuring`,
+                    description: `Other places were \`${kind}\` but '${printPlace(place)}' is reassigned`,
+                    loc: place.loc,
+                    suggestions: null,
+                  }
+                );
+                kind = InstructionKind.Reassign;
+                declaration.kind = InstructionKind.Let;
               }
             }
           }
+          CompilerError.invariant(kind !== null, {
+            reason: 'Expected at least one operand',
+            description: null,
+            loc: null,
+            suggestions: null,
+          });
+          lvalue.kind = kind;
+          break;
         }
-        switch (block.terminal.kind) {
-          case 'maybe-throw': {
-            queue.push(block.terminal.continuation);
-            break;
-          }
-          case 'goto': {
-            queue.push(block.terminal.block);
-            break;
-          }
-          case 'branch':
-          case 'logical':
-          case 'optional':
-          case 'ternary':
-          case 'label': {
-            for (const successor of eachTerminalSuccessor(block.terminal)) {
-              queue.push(successor);
-            }
-            break;
-          }
-        }
-      }
-      if (terminal.kind === 'for' && terminal.update !== null) {
-        const update = fn.body.blocks.get(terminal.update);
-        pushPhis(update);
-      }
-    }
-    for (const {phi: phi, block: phiBlock} of reassignmentPhis) {
-      for (const [, operand] of phi.operands) {
-        if (operand.mutableRange.start < terminal.id);
-      }
-      const isPhiMutatedAfterCreation =
-        phi.id.mutableRange.end >
-        ((_b =
-          (_a = phiBlock.instructions.at(0)) === null || _a === void 0
-            ? void 0
-            : _a.id) !== null && _b !== void 0
-          ? _b
-          : phiBlock.terminal.id);
-      CompilerError.invariant(phi.id.name != null, {
-        reason: 'Expected reassignment phis to have a name',
-        description: null,
-        loc: null,
-        suggestions: null,
-      });
-      const declaration = declarations.get(phi.id.name.value);
-      CompilerError.invariant(declaration != null, {
-        loc: null,
-        reason: 'Expected a declaration for all variables',
-        description: `${printIdentifier(phi.id)} in block bb${phiBlock.id}`,
-        suggestions: null,
-      });
-      if (isPhiMutatedAfterCreation) {
-        declaration.place.identifier.mutableRange.end = phi.id.mutableRange.end;
-      }
-      rewrites.set(phi.id, declaration.place.identifier);
-    }
-    for (const {phi: phi} of rewritePhis) {
-      let canonicalId = rewrites.get(phi.id);
-      if (canonicalId === undefined) {
-        canonicalId = phi.id;
-        for (const [, operand] of phi.operands) {
-          let canonicalOperand =
-            (_c = rewrites.get(operand)) !== null && _c !== void 0
-              ? _c
-              : operand;
-          if (canonicalOperand.id < canonicalId.id) {
-            canonicalId = canonicalOperand;
-          }
-        }
-        rewrites.set(phi.id, canonicalId);
-        if (canonicalId.name !== null) {
-          const declaration = declarations.get(canonicalId.name.value);
-          if (declaration !== undefined) {
-            declaration.lvalue.kind = InstructionKind.Let;
-          }
+        case 'PostfixUpdate':
+        case 'PrefixUpdate': {
+          const lvalue = value.lvalue;
+          const declaration = declarations.get(lvalue.identifier.declarationId);
+          CompilerError.invariant(declaration !== undefined, {
+            reason: `Expected variable to have been defined`,
+            description: `No declaration for ${printPlace(lvalue)}`,
+            loc: lvalue.loc,
+          });
+          declaration.kind = InstructionKind.Let;
+          break;
         }
       }
-      for (const [, operand] of phi.operands) {
-        rewrites.set(operand, canonicalId);
-      }
     }
   }
 }
-function rewritePlace(place, rewrites, declarations) {
-  const prevIdentifier = place.identifier;
-  const nextIdentifier = rewrites.get(prevIdentifier);
-  if (nextIdentifier !== undefined) {
-    if (nextIdentifier === prevIdentifier) return;
-    place.identifier = nextIdentifier;
-  } else if (prevIdentifier.name != null) {
-    const declaration = declarations.get(prevIdentifier.name.value);
-    if (declaration === undefined) return;
-    const originalIdentifier = declaration.place.identifier;
-    prevIdentifier.id = originalIdentifier.id;
-  }
-}
 function constantPropagation(fn) {
   const constants = new Map();
   constantPropagationImpl(fn, constants);
@@ -156825,12 +156710,7 @@ function visit$1(fn, fbtMacroTags, fbtValues) {
         }
         for (const operand of eachReactiveValueOperand(value)) {
           operand.identifier.scope = fbtScope;
-          fbtScope.range.start = makeInstructionId(
-            Math.min(
-              fbtScope.range.start,
-              operand.identifier.mutableRange.start
-            )
-          );
+          expandFbtScopeRange(fbtScope.range, operand.identifier.mutableRange);
           fbtValues.add(operand.identifier.id);
         }
       } else if (
@@ -156843,12 +156723,7 @@ function visit$1(fn, fbtMacroTags, fbtValues) {
         }
         for (const operand of eachReactiveValueOperand(value)) {
           operand.identifier.scope = fbtScope;
-          fbtScope.range.start = makeInstructionId(
-            Math.min(
-              fbtScope.range.start,
-              operand.identifier.mutableRange.start
-            )
-          );
+          expandFbtScopeRange(fbtScope.range, operand.identifier.mutableRange);
           fbtValues.add(operand.identifier.id);
         }
       } else if (fbtValues.has(lvalue.identifier.id)) {
@@ -156864,12 +156739,7 @@ function visit$1(fn, fbtMacroTags, fbtValues) {
             continue;
           }
           operand.identifier.scope = fbtScope;
-          fbtScope.range.start = makeInstructionId(
-            Math.min(
-              fbtScope.range.start,
-              operand.identifier.mutableRange.start
-            )
-          );
+          expandFbtScopeRange(fbtScope.range, operand.identifier.mutableRange);
         }
       }
     }
@@ -156895,6 +156765,13 @@ function isFbtJsxChild(fbtValues, lvalue, value) {
     fbtValues.has(lvalue.identifier.id)
   );
 }
+function expandFbtScopeRange(fbtRange, extendWith) {
+  if (extendWith.start !== 0) {
+    fbtRange.start = makeInstructionId(
+      Math.min(fbtRange.start, extendWith.start)
+    );
+  }
+}
 var _Context_nextCacheIndex, _Context_declarations$1;
 const MEMO_CACHE_SENTINEL = 'react.memo_cache_sentinel';
 const EARLY_RETURN_SENTINEL = 'react.early_return_sentinel';
@@ -157064,7 +156941,7 @@ function codegenFunction(
   } of cx.env.getOutlinedFunctions()) {
     const reactiveFunction = buildReactiveFunction(outlinedFunction);
     pruneUnusedLabels(reactiveFunction);
-    pruneTemporaryLValues(reactiveFunction);
+    pruneUnusedLValues(reactiveFunction);
     pruneHoistedContexts(reactiveFunction);
     const identifiers = renameVariables(reactiveFunction);
     const codegen = codegenReactiveFunction(
@@ -157089,9 +156966,9 @@ function codegenFunction(
 function codegenReactiveFunction(cx, fn) {
   for (const param of fn.params) {
     if (param.kind === 'Identifier') {
-      cx.temp.set(param.identifier.id, null);
+      cx.temp.set(param.identifier.declarationId, null);
     } else {
-      cx.temp.set(param.place.identifier.id, null);
+      cx.temp.set(param.place.identifier.declarationId, null);
     }
   }
   const params = fn.params.map(param => convertParameter(param));
@@ -157183,12 +157060,12 @@ let Context$2 = class Context {
   }
   declare(identifier) {
     __classPrivateFieldGet(this, _Context_declarations$1, 'f').add(
-      identifier.id
+      identifier.declarationId
     );
   }
   hasDeclared(identifier) {
     return __classPrivateFieldGet(this, _Context_declarations$1, 'f').has(
-      identifier.id
+      identifier.declarationId
     );
   }
   synthesizeName(name) {
@@ -157884,7 +157761,7 @@ function codegenTerminal(cx, terminal) {
       let catchParam = null;
       if (terminal.handlerBinding !== null) {
         catchParam = convertIdentifier(terminal.handlerBinding.identifier);
-        cx.temp.set(terminal.handlerBinding.identifier.id, null);
+        cx.temp.set(terminal.handlerBinding.identifier.declarationId, null);
       }
       return t__namespace.tryStatement(
         codegenBlock(cx, terminal.block),
@@ -157938,7 +157815,7 @@ function codegenInstructionNullable(cx, instr) {
           kind !== InstructionKind.Reassign &&
           place.identifier.name === null
         ) {
-          cx.temp.set(place.identifier.id, null);
+          cx.temp.set(place.identifier.declarationId, null);
         }
         const isDeclared = cx.hasDeclared(place.identifier);
         hasReasign || (hasReasign = isDeclared);
@@ -157994,7 +157871,7 @@ function codegenInstructionNullable(cx, instr) {
         );
         if (instr.lvalue !== null) {
           if (instr.value.kind !== 'StoreContext') {
-            cx.temp.set(instr.lvalue.identifier.id, expr);
+            cx.temp.set(instr.lvalue.identifier.declarationId, expr);
             return null;
           } else {
             const statement = codegenInstruction(cx, instr, expr);
@@ -158219,7 +158096,7 @@ function codegenInstruction(cx, instr, value) {
     return t__namespace.expressionStatement(convertValueToExpression(value));
   }
   if (instr.lvalue.identifier.name === null) {
-    cx.temp.set(instr.lvalue.identifier.id, value);
+    cx.temp.set(instr.lvalue.identifier.declarationId, value);
     return t__namespace.emptyStatement();
   } else {
     const expressionValue = convertValueToExpression(value);
@@ -158449,7 +158326,7 @@ function codegenInstructionValue(cx, instrValue) {
               const loweredFunc = method.loweredFunc;
               const reactiveFunction = buildReactiveFunction(loweredFunc.func);
               pruneUnusedLabels(reactiveFunction);
-              pruneTemporaryLValues(reactiveFunction);
+              pruneUnusedLValues(reactiveFunction);
               const fn = codegenReactiveFunction(
                 new Context$2(
                   cx.env,
@@ -158647,7 +158524,7 @@ function codegenInstructionValue(cx, instrValue) {
       const loweredFunc = instrValue.loweredFunc.func;
       const reactiveFunction = buildReactiveFunction(loweredFunc);
       pruneUnusedLabels(reactiveFunction);
-      pruneTemporaryLValues(reactiveFunction);
+      pruneUnusedLValues(reactiveFunction);
       pruneHoistedContexts(reactiveFunction);
       const fn = codegenReactiveFunction(
         new Context$2(
@@ -158661,7 +158538,7 @@ function codegenInstructionValue(cx, instrValue) {
         ),
         reactiveFunction
       ).unwrap();
-      if (instrValue.expr.type === 'ArrowFunctionExpression') {
+      if (instrValue.type === 'ArrowFunctionExpression') {
         let body = fn.body;
         if (body.body.length === 1 && loweredFunc.directives.length == 0) {
           const stmt = body.body[0];
@@ -159093,7 +158970,7 @@ function codegenPlaceToExpression(cx, place) {
   return convertValueToExpression(value);
 }
 function codegenPlace(cx, place) {
-  let tmp = cx.temp.get(place.identifier.id);
+  let tmp = cx.temp.get(place.identifier.declarationId);
   if (tmp != null) {
     return tmp;
   }
@@ -159132,7 +159009,7 @@ let State$1 = class State {
 let Visitor$b = class Visitor extends ReactiveFunctionTransform {
   visitScope(scope, state) {
     for (const [, declaration] of scope.scope.declarations) {
-      state.declared.add(declaration.identifier.id);
+      state.declared.add(declaration.identifier.declarationId);
     }
     this.traverseScope(scope, state);
   }
@@ -159161,7 +159038,7 @@ function transformDestructuring(state, instr, destructure) {
   let reassigned = new Set();
   let hasDeclaration = false;
   for (const place of eachPatternOperand(destructure.lvalue.pattern)) {
-    const isDeclared = state.declared.has(place.identifier.id);
+    const isDeclared = state.declared.has(place.identifier.declarationId);
     if (isDeclared) {
       reassigned.add(place.identifier.id);
     }
@@ -159176,13 +159053,7 @@ function transformDestructuring(state, instr, destructure) {
     if (!reassigned.has(place.identifier.id)) {
       return place;
     }
-    const tempId = state.env.nextIdentifierId;
-    const temporary = Object.assign(Object.assign({}, place), {
-      identifier: Object.assign(Object.assign({}, place.identifier), {
-        id: tempId,
-        name: null,
-      }),
-    });
+    const temporary = clonePlaceToTemporary(state.env, place);
     promoteTemporary(temporary.identifier);
     renamed.set(place, temporary);
     return temporary;
@@ -159445,12 +159316,12 @@ class FindLastUsageVisitor extends ReactiveFunctionVisitor {
     this.lastUsage = new Map();
   }
   visitPlace(id, place, _state) {
-    const previousUsage = this.lastUsage.get(place.identifier.id);
+    const previousUsage = this.lastUsage.get(place.identifier.declarationId);
     const lastUsage =
       previousUsage !== undefined
         ? makeInstructionId(Math.max(previousUsage, id))
         : id;
-    this.lastUsage.set(place.identifier.id, lastUsage);
+    this.lastUsage.set(place.identifier.declarationId, lastUsage);
   }
 }
 let Transform$4 = class Transform extends ReactiveFunctionTransform {
@@ -159519,7 +159390,9 @@ let Transform$4 = class Transform extends ReactiveFunctionTransform {
             case 'TemplateLiteral':
             case 'UnaryExpression': {
               if (current !== null && instr.instruction.lvalue !== null) {
-                current.lvalues.add(instr.instruction.lvalue.identifier.id);
+                current.lvalues.add(
+                  instr.instruction.lvalue.identifier.declarationId
+                );
               }
               break;
             }
@@ -159531,7 +159404,7 @@ let Transform$4 = class Transform extends ReactiveFunctionTransform {
                   for (const lvalue of eachInstructionLValue(
                     instr.instruction
                   )) {
-                    current.lvalues.add(lvalue.identifier.id);
+                    current.lvalues.add(lvalue.identifier.declarationId);
                   }
                 } else {
                   log$1(
@@ -159656,10 +159529,10 @@ let Transform$4 = class Transform extends ReactiveFunctionTransform {
   }
 };
 function updateScopeDeclarations(scope, lastUsage) {
-  for (const [key] of scope.declarations) {
-    const lastUsedAt = lastUsage.get(key);
+  for (const [id, decl] of scope.declarations) {
+    const lastUsedAt = lastUsage.get(decl.identifier.declarationId);
     if (lastUsedAt < scope.range.end) {
-      scope.declarations.delete(key);
+      scope.declarations.delete(id);
     }
   }
 }
@@ -159698,8 +159571,12 @@ function canMergeScopes(current, next) {
     (next.scope.dependencies.size !== 0 &&
       [...next.scope.dependencies].every(
         dep =>
-          current.scope.declarations.has(dep.identifier.id) &&
-          isAlwaysInvalidatingType(dep.identifier.type)
+          isAlwaysInvalidatingType(dep.identifier.type) &&
+          Iterable_some(
+            current.scope.declarations.values(),
+            decl =>
+              decl.identifier.declarationId === dep.identifier.declarationId
+          )
       ))
   ) {
     return true;
@@ -159729,7 +159606,7 @@ function areEqualDependencies(a, b) {
     let found = false;
     for (const bValue of b) {
       if (
-        aValue.identifier === bValue.identifier &&
+        aValue.identifier.declarationId === bValue.identifier.declarationId &&
         areEqualPaths(aValue.path, bValue.path)
       ) {
         found = true;
@@ -159755,7 +159632,6 @@ function scopeIsEligibleForMerging(scopeBlock) {
 }
 let Visitor$9 = class Visitor extends ReactiveFunctionVisitor {
   visitScope(scopeBlock, state) {
-    this.traverseScope(scopeBlock, state);
     for (const dep of scopeBlock.scope.dependencies) {
       const {identifier: identifier} = dep;
       if (identifier.name == null) {
@@ -159767,21 +159643,22 @@ let Visitor$9 = class Visitor extends ReactiveFunctionVisitor {
         promoteIdentifier(declaration.identifier, state);
       }
     }
+    this.traverseScope(scopeBlock, state);
   }
   visitPrunedScope(scopeBlock, state) {
     var _a;
-    this.traversePrunedScope(scopeBlock, state);
     for (const [, declaration] of scopeBlock.scope.declarations) {
       if (
         declaration.identifier.name == null &&
-        ((_a = state.pruned.get(declaration.identifier.id)) === null ||
-        _a === void 0
+        ((_a = state.pruned.get(declaration.identifier.declarationId)) ===
+          null || _a === void 0
           ? void 0
           : _a.usedOutsideScope) === true
       ) {
         promoteIdentifier(declaration.identifier, state);
       }
     }
+    this.traversePrunedScope(scopeBlock, state);
   }
   visitParam(place, state) {
     if (place.identifier.name === null) {
@@ -159804,6 +159681,56 @@ let Visitor$9 = class Visitor extends ReactiveFunctionVisitor {
     visitReactiveFunction(fn, this, state);
   }
 };
+class Visitor2 extends ReactiveFunctionVisitor {
+  visitPlace(_id, place, state) {
+    if (
+      place.identifier.name === null &&
+      state.promoted.has(place.identifier.declarationId)
+    ) {
+      promoteIdentifier(place.identifier, state);
+    }
+  }
+  visitLValue(_id, _lvalue, _state) {
+    this.visitPlace(_id, _lvalue, _state);
+  }
+  traverseScopeIdentifiers(scope, state) {
+    for (const [, decl] of scope.declarations) {
+      if (
+        decl.identifier.name === null &&
+        state.promoted.has(decl.identifier.declarationId)
+      ) {
+        promoteIdentifier(decl.identifier, state);
+      }
+    }
+    for (const dep of scope.dependencies) {
+      if (
+        dep.identifier.name === null &&
+        state.promoted.has(dep.identifier.declarationId)
+      ) {
+        promoteIdentifier(dep.identifier, state);
+      }
+    }
+    for (const reassignment of scope.reassignments) {
+      if (
+        reassignment.name === null &&
+        state.promoted.has(reassignment.declarationId)
+      ) {
+        promoteIdentifier(reassignment, state);
+      }
+    }
+  }
+  visitScope(scope, state) {
+    this.traverseScope(scope, state);
+    this.traverseScopeIdentifiers(scope.scope, state);
+  }
+  visitPrunedScope(scopeBlock, state) {
+    this.traversePrunedScope(scopeBlock, state);
+    this.traverseScopeIdentifiers(scopeBlock.scope, state);
+  }
+  visitReactiveFunctionValue(_id, _dependencies, fn, state) {
+    visitReactiveFunction(fn, this, state);
+  }
+}
 class CollectPromotableTemporaries extends ReactiveFunctionVisitor {
   constructor() {
     super(...arguments);
@@ -159812,9 +159739,9 @@ class CollectPromotableTemporaries extends ReactiveFunctionVisitor {
   visitPlace(_id, place, state) {
     if (
       this.activeScopes.length !== 0 &&
-      state.pruned.has(place.identifier.id)
+      state.pruned.has(place.identifier.declarationId)
     ) {
-      const prunedPlace = state.pruned.get(place.identifier.id);
+      const prunedPlace = state.pruned.get(place.identifier.declarationId);
       if (prunedPlace.activeScopes.indexOf(this.activeScopes.at(-1)) === -1) {
         prunedPlace.usedOutsideScope = true;
       }
@@ -159823,16 +159750,17 @@ class CollectPromotableTemporaries extends ReactiveFunctionVisitor {
   visitValue(id, value, state) {
     this.traverseValue(id, value, state);
     if (value.kind === 'JsxExpression' && value.tag.kind === 'Identifier') {
-      state.tags.add(value.tag.identifier.id);
+      state.tags.add(value.tag.identifier.declarationId);
     }
   }
   visitPrunedScope(scopeBlock, state) {
-    for (const [id] of scopeBlock.scope.declarations) {
-      state.pruned.set(id, {
+    for (const [_id, decl] of scopeBlock.scope.declarations) {
+      state.pruned.set(decl.identifier.declarationId, {
         activeScopes: [...this.activeScopes],
         usedOutsideScope: false,
       });
     }
+    this.visitBlock(scopeBlock.instructions, state);
   }
   visitScope(scopeBlock, state) {
     this.activeScopes.push(scopeBlock.scope.id);
@@ -159841,7 +159769,7 @@ class CollectPromotableTemporaries extends ReactiveFunctionVisitor {
   }
 }
 function promoteUsedTemporaries(fn) {
-  const state = {tags: new Set(), pruned: new Map()};
+  const state = {tags: new Set(), promoted: new Set(), pruned: new Map()};
   visitReactiveFunction(fn, new CollectPromotableTemporaries(), state);
   for (const operand of fn.params) {
     const place = operand.kind === 'Identifier' ? operand : operand.place;
@@ -159850,6 +159778,7 @@ function promoteUsedTemporaries(fn) {
     }
   }
   visitReactiveFunction(fn, new Visitor$9(), state);
+  visitReactiveFunction(fn, new Visitor2(), state);
 }
 function promoteIdentifier(identifier, state) {
   CompilerError.invariant(identifier.name === null, {
@@ -159859,11 +159788,12 @@ function promoteIdentifier(identifier, state) {
     loc: GeneratedSource,
     suggestions: null,
   });
-  if (state.tags.has(identifier.id)) {
+  if (state.tags.has(identifier.declarationId)) {
     promoteTemporaryJsxTag(identifier);
   } else {
     promoteTemporary(identifier);
   }
+  state.promoted.add(identifier.declarationId);
 }
 function propagateEarlyReturns(fn) {
   visitReactiveFunction(fn, new Transform$3(fn.env), {
@@ -160542,18 +160472,23 @@ class FindPromotedTemporaries extends ReactiveFunctionVisitor {
       case 'LoadLocal':
       case 'LoadContext':
       case 'PropertyLoad': {
-        state.declarations.set(instruction.lvalue.identifier.id, scope);
+        state.declarations.set(
+          instruction.lvalue.identifier.declarationId,
+          scope
+        );
         break;
       }
     }
   }
   visitPlace(_id, place, state) {
-    const declaringScope = state.declarations.get(place.identifier.id);
+    const declaringScope = state.declarations.get(
+      place.identifier.declarationId
+    );
     if (declaringScope === undefined) {
       return;
     }
     if (this.scopes.indexOf(declaringScope) === -1) {
-      state.usedOutsideDeclaringScope.add(place.identifier.id);
+      state.usedOutsideDeclaringScope.add(place.identifier.declarationId);
     }
   }
 }
@@ -160797,7 +160732,7 @@ class Context {
       this,
       _Context_temporariesUsedOutsideScope,
       'f'
-    ).has(place.identifier.id);
+    ).has(place.identifier.declarationId);
   }
   printDeps(includeAccesses = false) {
     return __classPrivateFieldGet(this, _Context_dependencies, 'f').printDeps(
@@ -160857,11 +160792,11 @@ class Context {
   declare(identifier, decl) {
     if (
       !__classPrivateFieldGet(this, _Context_declarations, 'f').has(
-        identifier.id
+        identifier.declarationId
       )
     ) {
       __classPrivateFieldGet(this, _Context_declarations, 'f').set(
-        identifier.id,
+        identifier.declarationId,
         decl
       );
     }
@@ -160935,7 +160870,7 @@ class Context {
       this,
       _Context_declarations,
       'f'
-    ).get(maybeDependency.identifier.id);
+    ).get(maybeDependency.identifier.declarationId);
     if (
       originalDeclaration !== undefined &&
       originalDeclaration.scope.value !== null
@@ -160947,7 +160882,13 @@ class Context {
             _Context_instances,
             'm',
             _Context_isScopeActive
-          ).call(this, scope.value)
+          ).call(this, scope.value) &&
+          !Iterable_some(
+            scope.value.declarations.values(),
+            decl =>
+              decl.identifier.declarationId ===
+              maybeDependency.identifier.declarationId
+          )
         ) {
           scope.value.declarations.set(maybeDependency.identifier.id, {
             identifier: maybeDependency.identifier,
@@ -160984,8 +160925,10 @@ class Context {
         : _a.value;
     if (
       currentScope != null &&
-      !Array.from(currentScope.reassignments).some(
-        identifier => identifier.id === place.identifier.id
+      !Iterable_some(
+        currentScope.reassignments,
+        identifier =>
+          identifier.declarationId === place.identifier.declarationId
       ) &&
       __classPrivateFieldGet(
         this,
@@ -161091,7 +161034,7 @@ class Context {
       )) !== null && _a !== void 0
         ? _a
         : __classPrivateFieldGet(this, _Context_declarations, 'f').get(
-            identifier.id
+            identifier.declarationId
           );
     const currentScope =
       (_b = this.currentScope.value) === null || _b === void 0
@@ -161126,7 +161069,19 @@ class PropagationVisitor extends ReactiveFunctionVisitor {
     const scopeDependencies = context.enter(scope.scope, () => {
       this.visitBlock(scope.instructions, context);
     });
-    scope.scope.dependencies = scopeDependencies;
+    for (const candidateDep of scopeDependencies) {
+      if (
+        !Iterable_some(
+          scope.scope.dependencies,
+          existingDep =>
+            existingDep.identifier.declarationId ===
+              candidateDep.identifier.declarationId &&
+            areEqualPaths(existingDep.path, candidateDep.path)
+        )
+      ) {
+        scope.scope.dependencies.add(candidateDep);
+      }
+    }
   }
   visitPrunedScope(scopeBlock, context) {
     context.enter(scopeBlock.scope, () => {
@@ -161438,12 +161393,12 @@ let Visitor$8 = class Visitor extends ReactiveFunctionTransform {
       instruction.value.kind === 'DeclareContext' &&
       instruction.value.lvalue.kind === 'HoistedConst'
     ) {
-      state.add(instruction.value.lvalue.place.identifier);
+      state.add(instruction.value.lvalue.place.identifier.declarationId);
       return {kind: 'remove'};
     }
     if (
       instruction.value.kind === 'StoreContext' &&
-      state.has(instruction.value.lvalue.place.identifier)
+      state.has(instruction.value.lvalue.place.identifier.declarationId)
     ) {
       return {
         kind: 'replace',
@@ -161465,69 +161420,6 @@ let Visitor$8 = class Visitor extends ReactiveFunctionTransform {
     return {kind: 'keep'};
   }
 };
-function validateMemoizedEffectDependencies(fn) {
-  const errors = new CompilerError();
-  visitReactiveFunction(fn, new Visitor$7(), errors);
-  if (errors.hasErrors()) {
-    throw errors;
-  }
-}
-let Visitor$7 = class Visitor extends ReactiveFunctionVisitor {
-  constructor() {
-    super(...arguments);
-    this.scopes = new Set();
-  }
-  visitScope(scopeBlock, state) {
-    this.traverseScope(scopeBlock, state);
-    let areDependenciesMemoized = true;
-    for (const dep of scopeBlock.scope.dependencies) {
-      if (isUnmemoized$1(dep.identifier, this.scopes)) {
-        areDependenciesMemoized = false;
-        break;
-      }
-    }
-    if (areDependenciesMemoized) {
-      this.scopes.add(scopeBlock.scope.id);
-      for (const id of scopeBlock.scope.merged) {
-        this.scopes.add(id);
-      }
-    }
-  }
-  visitInstruction(instruction, state) {
-    this.traverseInstruction(instruction, state);
-    if (
-      instruction.value.kind === 'CallExpression' &&
-      isEffectHook(instruction.value.callee.identifier) &&
-      instruction.value.args.length >= 2
-    ) {
-      const deps = instruction.value.args[1];
-      if (
-        deps.kind === 'Identifier' &&
-        (isMutable(instruction, deps) ||
-          isUnmemoized$1(deps.identifier, this.scopes))
-      ) {
-        state.push({
-          reason:
-            'React Compiler has skipped optimizing this component because the effect dependencies could not be memoized. Unmemoized effect dependencies can trigger an infinite loop or other unexpected behavior',
-          description: null,
-          severity: exports.ErrorSeverity.CannotPreserveMemoization,
-          loc: typeof instruction.loc !== 'symbol' ? instruction.loc : null,
-          suggestions: null,
-        });
-      }
-    }
-  }
-};
-function isUnmemoized$1(operand, scopes) {
-  return operand.scope != null && !scopes.has(operand.scope.id);
-}
-function isEffectHook(identifier) {
-  return (
-    isUseEffectHookType(identifier) ||
-    isUseLayoutEffectHookType(identifier) ||
-    isUseInsertionEffectHookType(identifier)
-  );
-}
 var _InferenceState_env, _InferenceState_values, _InferenceState_variables;
 const UndefinedValue = {
   kind: 'Primitive',
@@ -162434,7 +162326,7 @@ function inferBlock(env, functionEffects, state, block) {
             );
             functionEffects.push(
               ...propEffects.filter(
-                propEffect => propEffect.kind !== 'GlobalMutation'
+                effect => !isEffectSafeOutsideRender(effect)
               )
             );
           }
@@ -162584,7 +162476,7 @@ function inferBlock(env, functionEffects, state, block) {
                 context: new Set(),
               };
         let hasCaptureArgument = false;
-        let isUseEffect = isEffectHook(instrValue.callee.identifier);
+        let isHook = getHookKind(env, instrValue.callee.identifier) != null;
         for (let i = 0; i < instrValue.args.length; i++) {
           const argumentEffects = [];
           const arg = instrValue.args[i];
@@ -162606,8 +162498,7 @@ function inferBlock(env, functionEffects, state, block) {
           }
           functionEffects.push(
             ...argumentEffects.filter(
-              argEffect =>
-                !isUseEffect || i !== 0 || argEffect.kind !== 'GlobalMutation'
+              argEffect => !isHook || !isEffectSafeOutsideRender(argEffect)
             )
           );
           hasCaptureArgument ||
@@ -162699,7 +162590,7 @@ function inferBlock(env, functionEffects, state, block) {
         const effects =
           signature !== null ? getFunctionEffects(instrValue, signature) : null;
         let hasCaptureArgument = false;
-        let isUseEffect = isEffectHook(instrValue.property.identifier);
+        let isHook = getHookKind(env, instrValue.property.identifier) != null;
         for (let i = 0; i < instrValue.args.length; i++) {
           const argumentEffects = [];
           const arg = instrValue.args[i];
@@ -162721,8 +162612,7 @@ function inferBlock(env, functionEffects, state, block) {
           }
           functionEffects.push(
             ...argumentEffects.filter(
-              argEffect =>
-                !isUseEffect || i !== 0 || argEffect.kind !== 'GlobalMutation'
+              argEffect => !isHook || !isEffectSafeOutsideRender(argEffect)
             )
           );
           hasCaptureArgument ||
@@ -163167,11 +163057,15 @@ function inferBlock(env, functionEffects, state, block) {
     } else {
       effect = exports.Effect.Read;
     }
+    const propEffects = [];
     state.referenceAndRecordEffects(
       operand,
       effect,
       ValueReason.Other,
-      functionEffects
+      propEffects
+    );
+    functionEffects.push(
+      ...propEffects.filter(effect => !isEffectSafeOutsideRender(effect))
     );
   }
 }
@@ -163240,6 +163134,9 @@ 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';
@@ -163263,9 +163160,9 @@ function pruneNonEscapingScopes(fn) {
   const state = new State(fn.env);
   for (const param of fn.params) {
     if (param.kind === 'Identifier') {
-      state.declare(param.identifier.id);
+      state.declare(param.identifier.declarationId);
     } else {
-      state.declare(param.place.identifier.id);
+      state.declare(param.place.identifier.declarationId);
     }
   }
   visitReactiveFunction(fn, new CollectDependenciesVisitor(fn.env), state);
@@ -163322,7 +163219,9 @@ class State {
       let node = this.scopes.get(scope.id);
       if (node === undefined) {
         node = {
-          dependencies: [...scope.dependencies].map(dep => dep.identifier.id),
+          dependencies: [...scope.dependencies].map(
+            dep => dep.identifier.declarationId
+          ),
           seen: false,
         };
         this.scopes.set(scope.id, node);
@@ -163766,18 +163665,18 @@ class CollectDependenciesVisitor extends ReactiveFunctionVisitor {
     );
     for (const operand of aliasing.rvalues) {
       const operandId =
-        (_a = state.definitions.get(operand.identifier.id)) !== null &&
-        _a !== void 0
+        (_a = state.definitions.get(operand.identifier.declarationId)) !==
+          null && _a !== void 0
           ? _a
-          : operand.identifier.id;
+          : operand.identifier.declarationId;
       state.visitOperand(instruction.id, operand, operandId);
     }
     for (const {place: lvalue, level: level} of aliasing.lvalues) {
       const lvalueId =
-        (_b = state.definitions.get(lvalue.identifier.id)) !== null &&
-        _b !== void 0
+        (_b = state.definitions.get(lvalue.identifier.declarationId)) !==
+          null && _b !== void 0
           ? _b
-          : lvalue.identifier.id;
+          : lvalue.identifier.declarationId;
       let node = state.identifiers.get(lvalueId);
       if (node === undefined) {
         node = {
@@ -163792,10 +163691,10 @@ class CollectDependenciesVisitor extends ReactiveFunctionVisitor {
       node.level = joinAliases(node.level, level);
       for (const operand of aliasing.rvalues) {
         const operandId =
-          (_c = state.definitions.get(operand.identifier.id)) !== null &&
-          _c !== void 0
+          (_c = state.definitions.get(operand.identifier.declarationId)) !==
+            null && _c !== void 0
             ? _c
-            : operand.identifier.id;
+            : operand.identifier.declarationId;
         if (operandId === lvalueId) {
           continue;
         }
@@ -163805,8 +163704,8 @@ class CollectDependenciesVisitor extends ReactiveFunctionVisitor {
     }
     if (instruction.value.kind === 'LoadLocal' && instruction.lvalue !== null) {
       state.definitions.set(
-        instruction.lvalue.identifier.id,
-        instruction.value.place.identifier.id
+        instruction.lvalue.identifier.declarationId,
+        instruction.value.place.identifier.declarationId
       );
     } else if (
       instruction.value.kind === 'CallExpression' ||
@@ -163826,7 +163725,7 @@ class CollectDependenciesVisitor extends ReactiveFunctionVisitor {
         }
         for (const operand of instruction.value.args) {
           const place = operand.kind === 'Spread' ? operand.place : operand;
-          state.escapingValues.add(place.identifier.id);
+          state.escapingValues.add(place.identifier.declarationId);
         }
       }
     }
@@ -163834,7 +163733,7 @@ class CollectDependenciesVisitor extends ReactiveFunctionVisitor {
   visitTerminal(stmt, state) {
     this.traverseTerminal(stmt, state);
     if (stmt.terminal.kind === 'return') {
-      state.escapingValues.add(stmt.terminal.value.identifier.id);
+      state.escapingValues.add(stmt.terminal.value.identifier.declarationId);
     }
   }
 }
@@ -163853,11 +163752,11 @@ class PruneScopesTransform extends ReactiveFunctionTransform {
       return {kind: 'keep'};
     }
     const hasMemoizedOutput =
-      Array.from(scopeBlock.scope.declarations.keys()).some(id =>
-        state.has(id)
+      Array.from(scopeBlock.scope.declarations.values()).some(decl =>
+        state.has(decl.identifier.declarationId)
       ) ||
       Array.from(scopeBlock.scope.reassignments).some(identifier =>
-        state.has(identifier.id)
+        state.has(identifier.declarationId)
       );
     if (hasMemoizedOutput) {
       return {kind: 'keep'};
@@ -163880,7 +163779,7 @@ class PruneScopesTransform extends ReactiveFunctionTransform {
     return {kind: 'keep'};
   }
 }
-let Visitor$6 = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$7 = class Visitor extends ReactiveFunctionVisitor {
   visitLValue(id, lvalue, state) {
     this.visitPlace(id, lvalue, state);
   }
@@ -163899,16 +163798,16 @@ let Visitor$6 = class Visitor extends ReactiveFunctionVisitor {
   }
 };
 function collectReactiveIdentifiers(fn) {
-  const visitor = new Visitor$6();
+  const visitor = new Visitor$7();
   const state = new Set();
   visitReactiveFunction(fn, visitor, state);
   return state;
 }
 function pruneNonReactiveDependencies(fn) {
   const reactiveIdentifiers = collectReactiveIdentifiers(fn);
-  visitReactiveFunction(fn, new Visitor$5(), reactiveIdentifiers);
+  visitReactiveFunction(fn, new Visitor$6(), reactiveIdentifiers);
 }
-let Visitor$5 = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$6 = class Visitor extends ReactiveFunctionVisitor {
   visitInstruction(instruction, state) {
     this.traverseInstruction(instruction, state);
     const {lvalue: lvalue, value: value} = instruction;
@@ -163982,16 +163881,16 @@ let Visitor$5 = class Visitor extends ReactiveFunctionVisitor {
     }
   }
 };
-function pruneTemporaryLValues(fn) {
+function pruneUnusedLValues(fn) {
   const lvalues = new Map();
-  visitReactiveFunction(fn, new Visitor$4(), lvalues);
+  visitReactiveFunction(fn, new Visitor$5(), lvalues);
   for (const [, instr] of lvalues) {
     instr.lvalue = null;
   }
 }
-let Visitor$4 = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$5 = class Visitor extends ReactiveFunctionVisitor {
   visitPlace(id, place, state) {
-    state.delete(place.identifier);
+    state.delete(place.identifier.declarationId);
   }
   visitInstruction(instruction, state) {
     this.traverseInstruction(instruction, state);
@@ -163999,7 +163898,7 @@ let Visitor$4 = class Visitor extends ReactiveFunctionVisitor {
       instruction.lvalue !== null &&
       instruction.lvalue.identifier.name === null
     ) {
-      state.set(instruction.lvalue.identifier, instruction);
+      state.set(instruction.lvalue.identifier.declarationId, instruction);
     }
   }
 };
@@ -164080,10 +163979,10 @@ function hasOwnDeclaration(block) {
 }
 function collectReferencedGlobals(fn) {
   const identifiers = new Set();
-  visitReactiveFunction(fn, new Visitor$3(), identifiers);
+  visitReactiveFunction(fn, new Visitor$4(), identifiers);
   return identifiers;
 }
-let Visitor$3 = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$4 = class Visitor extends ReactiveFunctionVisitor {
   visitValue(id, value, state) {
     this.traverseValue(id, value, state);
     if (value.kind === 'FunctionExpression' || value.kind === 'ObjectMethod') {
@@ -164104,7 +164003,7 @@ var _Scopes_instances,
 function renameVariables(fn) {
   const globals = collectReferencedGlobals(fn);
   const scopes = new Scopes(globals);
-  renameVariablesImpl(fn, new Visitor$2(), scopes);
+  renameVariablesImpl(fn, new Visitor$3(), scopes);
   return new Set([...scopes.names, ...globals]);
 }
 function renameVariablesImpl(fn, visitor, scopes) {
@@ -164119,7 +164018,7 @@ function renameVariablesImpl(fn, visitor, scopes) {
     visitReactiveFunction(fn, visitor, scopes);
   });
 }
-let Visitor$2 = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$3 = class Visitor extends ReactiveFunctionVisitor {
   visitParam(place, state) {
     state.visit(place.identifier);
   }
@@ -164168,7 +164067,7 @@ class Scopes {
       return;
     }
     const mappedName = __classPrivateFieldGet(this, _Scopes_seen, 'f').get(
-      identifier.id
+      identifier.declarationId
     );
     if (mappedName !== undefined) {
       identifier.name = mappedName;
@@ -164199,12 +164098,12 @@ class Scopes {
     const identifierName = makeIdentifierName(name);
     identifier.name = identifierName;
     __classPrivateFieldGet(this, _Scopes_seen, 'f').set(
-      identifier.id,
+      identifier.declarationId,
       identifierName
     );
     __classPrivateFieldGet(this, _Scopes_stack, 'f')
       .at(-1)
-      .set(identifierName.value, identifier.id);
+      .set(identifierName.value, identifier.declarationId);
     this.names.add(identifierName.value);
   }
   enter(fn) {
@@ -164682,7 +164581,7 @@ function lower(func) {
   inferReferenceEffects(func, {isFunctionExpression: true});
   deadCodeElimination(func);
   inferMutableRanges(func);
-  leaveSSA(func);
+  rewriteInstructionKindsBasedOnReassignment(func);
   inferReactiveScopeVariables(func);
   inferMutableContextVariables(func);
 }
@@ -164926,6 +164825,7 @@ function extractManualMemoizationArgs(instr, kind, sidemap) {
 function dropManualMemoization(func) {
   const isValidationEnabled =
     func.env.config.validatePreserveExistingMemoizationGuarantees ||
+    func.env.config.validateNoSetStateInRender ||
     func.env.config.enablePreserveExistingMemoizationGuarantees;
   const sidemap = {
     functions: new Map(),
@@ -165360,20 +165260,7 @@ function rewriteBlock(env, block, returnTarget, returnValue) {
   block.instructions.push({
     id: makeInstructionId(0),
     loc: terminal.loc,
-    lvalue: {
-      effect: exports.Effect.Unknown,
-      identifier: {
-        id: env.nextIdentifierId,
-        mutableRange: {start: makeInstructionId(0), end: makeInstructionId(0)},
-        name: null,
-        scope: null,
-        type: makeType(),
-        loc: terminal.loc,
-      },
-      kind: 'Identifier',
-      reactive: false,
-      loc: terminal.loc,
-    },
+    lvalue: createTemporaryPlace(env, terminal.loc),
     value: {
       kind: 'StoreLocal',
       lvalue: {
@@ -165397,20 +165284,7 @@ function declareTemporary(env, block, result) {
   block.instructions.push({
     id: makeInstructionId(0),
     loc: GeneratedSource,
-    lvalue: {
-      effect: exports.Effect.Unknown,
-      identifier: {
-        id: env.nextIdentifierId,
-        mutableRange: {start: makeInstructionId(0), end: makeInstructionId(0)},
-        name: null,
-        scope: null,
-        type: makeType(),
-        loc: result.loc,
-      },
-      kind: 'Identifier',
-      reactive: false,
-      loc: GeneratedSource,
-    },
+    lvalue: createTemporaryPlace(env, result.loc),
     value: {
       kind: 'DeclareLocal',
       lvalue: {place: result, kind: InstructionKind.Let},
@@ -166073,7 +165947,7 @@ class Transform extends ReactiveFunctionTransform {
     return {kind: 'keep'};
   }
 }
-let Visitor$1 = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$2 = class Visitor extends ReactiveFunctionVisitor {
   constructor(env, aliases, paths) {
     super();
     this.map = new Map();
@@ -166215,7 +166089,7 @@ let Visitor$1 = class Visitor extends ReactiveFunctionVisitor {
 };
 function pruneInitializationDependencies(fn) {
   const [aliases, paths] = getAliases(fn);
-  visitReactiveFunction(fn, new Visitor$1(fn.env, aliases, paths), 'Update');
+  visitReactiveFunction(fn, new Visitor$2(fn.env, aliases, paths), 'Update');
 }
 function update(map, key, path, value) {
   var _a;
@@ -167120,6 +166994,69 @@ function visitFunctionExpression(errors, fn) {
     }
   }
 }
+function validateMemoizedEffectDependencies(fn) {
+  const errors = new CompilerError();
+  visitReactiveFunction(fn, new Visitor$1(), errors);
+  if (errors.hasErrors()) {
+    throw errors;
+  }
+}
+let Visitor$1 = class Visitor extends ReactiveFunctionVisitor {
+  constructor() {
+    super(...arguments);
+    this.scopes = new Set();
+  }
+  visitScope(scopeBlock, state) {
+    this.traverseScope(scopeBlock, state);
+    let areDependenciesMemoized = true;
+    for (const dep of scopeBlock.scope.dependencies) {
+      if (isUnmemoized$1(dep.identifier, this.scopes)) {
+        areDependenciesMemoized = false;
+        break;
+      }
+    }
+    if (areDependenciesMemoized) {
+      this.scopes.add(scopeBlock.scope.id);
+      for (const id of scopeBlock.scope.merged) {
+        this.scopes.add(id);
+      }
+    }
+  }
+  visitInstruction(instruction, state) {
+    this.traverseInstruction(instruction, state);
+    if (
+      instruction.value.kind === 'CallExpression' &&
+      isEffectHook(instruction.value.callee.identifier) &&
+      instruction.value.args.length >= 2
+    ) {
+      const deps = instruction.value.args[1];
+      if (
+        deps.kind === 'Identifier' &&
+        (isMutable(instruction, deps) ||
+          isUnmemoized$1(deps.identifier, this.scopes))
+      ) {
+        state.push({
+          reason:
+            'React Compiler has skipped optimizing this component because the effect dependencies could not be memoized. Unmemoized effect dependencies can trigger an infinite loop or other unexpected behavior',
+          description: null,
+          severity: exports.ErrorSeverity.CannotPreserveMemoization,
+          loc: typeof instruction.loc !== 'symbol' ? instruction.loc : null,
+          suggestions: null,
+        });
+      }
+    }
+  }
+};
+function isUnmemoized$1(operand, scopes) {
+  return operand.scope != null && !scopes.has(operand.scope.id);
+}
+function isEffectHook(identifier) {
+  return (
+    isUseEffectHookType(identifier) ||
+    isUseLayoutEffectHookType(identifier) ||
+    isUseInsertionEffectHookType(identifier)
+  );
+}
 function validateNoCapitalizedCalls(fn) {
   var _a;
   const envConfig = fn.env.config;
@@ -167375,59 +167312,94 @@ function validateNoSetStateInRender(fn) {
 }
 function validateNoSetStateInRenderImpl(fn, unconditionalSetStateFunctions) {
   const unconditionalBlocks = computeUnconditionalBlocks(fn);
+  let activeManualMemoId = null;
   const errors = new CompilerError();
   for (const [, block] of fn.body.blocks) {
-    if (unconditionalBlocks.has(block.id)) {
-      for (const instr of block.instructions) {
-        switch (instr.value.kind) {
-          case 'LoadLocal': {
-            if (
-              unconditionalSetStateFunctions.has(
-                instr.value.place.identifier.id
-              )
-            ) {
-              unconditionalSetStateFunctions.add(instr.lvalue.identifier.id);
-            }
-            break;
+    for (const instr of block.instructions) {
+      switch (instr.value.kind) {
+        case 'LoadLocal': {
+          if (
+            unconditionalSetStateFunctions.has(instr.value.place.identifier.id)
+          ) {
+            unconditionalSetStateFunctions.add(instr.lvalue.identifier.id);
           }
-          case 'StoreLocal': {
-            if (
-              unconditionalSetStateFunctions.has(
-                instr.value.value.identifier.id
-              )
-            ) {
-              unconditionalSetStateFunctions.add(
-                instr.value.lvalue.place.identifier.id
-              );
-              unconditionalSetStateFunctions.add(instr.lvalue.identifier.id);
-            }
-            break;
+          break;
+        }
+        case 'StoreLocal': {
+          if (
+            unconditionalSetStateFunctions.has(instr.value.value.identifier.id)
+          ) {
+            unconditionalSetStateFunctions.add(
+              instr.value.lvalue.place.identifier.id
+            );
+            unconditionalSetStateFunctions.add(instr.lvalue.identifier.id);
           }
-          case 'ObjectMethod':
-          case 'FunctionExpression': {
-            if (
-              [...eachInstructionValueOperand(instr.value)].some(
-                operand =>
-                  isSetStateType(operand.identifier) ||
-                  unconditionalSetStateFunctions.has(operand.identifier.id)
-              ) &&
-              validateNoSetStateInRenderImpl(
-                instr.value.loweredFunc.func,
-                unconditionalSetStateFunctions
-              ).isErr()
-            ) {
-              unconditionalSetStateFunctions.add(instr.lvalue.identifier.id);
-            }
-            break;
+          break;
+        }
+        case 'ObjectMethod':
+        case 'FunctionExpression': {
+          if (
+            [...eachInstructionValueOperand(instr.value)].some(
+              operand =>
+                isSetStateType(operand.identifier) ||
+                unconditionalSetStateFunctions.has(operand.identifier.id)
+            ) &&
+            validateNoSetStateInRenderImpl(
+              instr.value.loweredFunc.func,
+              unconditionalSetStateFunctions
+            ).isErr()
+          ) {
+            unconditionalSetStateFunctions.add(instr.lvalue.identifier.id);
           }
-          case 'CallExpression': {
-            validateNonSetState(
-              errors,
-              unconditionalSetStateFunctions,
-              instr.value.callee
-            );
-            break;
+          break;
+        }
+        case 'StartMemoize': {
+          CompilerError.invariant(activeManualMemoId === null, {
+            reason: 'Unexpected nested StartMemoize instructions',
+            loc: instr.value.loc,
+          });
+          activeManualMemoId = instr.value.manualMemoId;
+          break;
+        }
+        case 'FinishMemoize': {
+          CompilerError.invariant(
+            activeManualMemoId === instr.value.manualMemoId,
+            {
+              reason:
+                'Expected FinishMemoize to align with previous StartMemoize instruction',
+              loc: instr.value.loc,
+            }
+          );
+          activeManualMemoId = null;
+          break;
+        }
+        case 'CallExpression': {
+          const callee = instr.value.callee;
+          if (
+            isSetStateType(callee.identifier) ||
+            unconditionalSetStateFunctions.has(callee.identifier.id)
+          ) {
+            if (activeManualMemoId !== null) {
+              errors.push({
+                reason:
+                  'Calling setState from useMemo may trigger an infinite loop. (https://react.dev/reference/react/useState)',
+                description: null,
+                severity: exports.ErrorSeverity.InvalidReact,
+                loc: callee.loc,
+                suggestions: null,
+              });
+            } else if (unconditionalBlocks.has(block.id)) {
+              errors.push({
+                reason:
+                  'This is an unconditional set state during render, which will trigger an infinite loop. (https://react.dev/reference/react/useState)',
+                description: null,
+                severity: exports.ErrorSeverity.InvalidReact,
+                loc: callee.loc,
+                suggestions: null,
+              });
+            }
           }
+          break;
         }
       }
     }
@@ -167438,21 +167410,6 @@ function validateNoSetStateInRenderImpl(fn, unconditionalSetStateFunctions) {
     return Ok(undefined);
   }
 }
-function validateNonSetState(errors, unconditionalSetStateFunctions, operand) {
-  if (
-    isSetStateType(operand.identifier) ||
-    unconditionalSetStateFunctions.has(operand.identifier.id)
-  ) {
-    errors.push({
-      reason:
-        'This is an unconditional set state during render, which will trigger an infinite loop. (https://react.dev/reference/react/useState)',
-      description: null,
-      severity: exports.ErrorSeverity.InvalidReact,
-      loc: typeof operand.loc !== 'symbol' ? operand.loc : null,
-      suggestions: null,
-    });
-  }
-}
 function validatePreservedManualMemoization(fn) {
   const state = {errors: new CompilerError(), manualMemoState: null};
   visitReactiveFunction(fn, new Visitor(), state);
@@ -167557,7 +167514,7 @@ function validateInferredDep(
   for (const decl of declsWithinMemoBlock) {
     if (
       normalizedDep.root.kind === 'NamedLocal' &&
-      decl === normalizedDep.root.value.identifier.id
+      decl === normalizedDep.root.value.identifier.declarationId
     ) {
       return;
     }
@@ -167622,7 +167579,7 @@ class Visitor extends ReactiveFunctionVisitor {
           const storeTarget = value.lvalue.place;
           (_a = state.manualMemoState) === null || _a === void 0
             ? void 0
-            : _a.decls.add(storeTarget.identifier.id);
+            : _a.decls.add(storeTarget.identifier.declarationId);
           if (
             ((_b = storeTarget.identifier.name) === null || _b === void 0
               ? void 0
@@ -167642,24 +167599,23 @@ class Visitor extends ReactiveFunctionVisitor {
     }
   }
   recordTemporaries(instr, state) {
-    var _a, _b, _c;
+    var _a;
     const temporaries = this.temporaries;
-    const {value: value} = instr;
+    const {lvalue: lvalue, value: value} = instr;
     const lvalId =
-      (_a = instr.lvalue) === null || _a === void 0 ? void 0 : _a.identifier.id;
+      lvalue === null || lvalue === void 0 ? void 0 : lvalue.identifier.id;
     if (lvalId != null && temporaries.has(lvalId)) {
       return;
     }
     const isNamedLocal =
-      lvalId != null &&
-      ((_c =
-        (_b = instr.lvalue) === null || _b === void 0
+      ((_a =
+        lvalue === null || lvalue === void 0
           ? void 0
-          : _b.identifier.name) === null || _c === void 0
+          : lvalue.identifier.name) === null || _a === void 0
         ? void 0
-        : _c.kind) === 'named';
-    if (isNamedLocal && state.manualMemoState != null) {
-      state.manualMemoState.decls.add(lvalId);
+        : _a.kind) === 'named';
+    if (lvalue !== null && isNamedLocal && state.manualMemoState != null) {
+      state.manualMemoState.decls.add(lvalue.identifier.declarationId);
     }
     const maybeDep = this.recordDepsInValue(value, state);
     if (lvalId != null) {
@@ -167945,7 +167901,33 @@ function getContextReassignment(
           break;
         }
         default: {
-          for (const operand of eachInstructionValueOperand(value)) {
+          let operands = eachInstructionValueOperand(value);
+          if (value.kind === 'CallExpression') {
+            const signature = getFunctionCallSignature(
+              fn.env,
+              value.callee.identifier.type
+            );
+            if (
+              signature === null || signature === void 0
+                ? void 0
+                : signature.noAlias
+            ) {
+              operands = [value.callee];
+            }
+          } else if (value.kind === 'MethodCall') {
+            const signature = getFunctionCallSignature(
+              fn.env,
+              value.property.identifier.type
+            );
+            if (
+              signature === null || signature === void 0
+                ? void 0
+                : signature.noAlias
+            ) {
+              operands = [value.receiver, value.property];
+            }
+          }
+          for (const operand of operands) {
             CompilerError.invariant(operand.effect !== exports.Effect.Unknown, {
               reason: `Expected effects to be inferred prior to ValidateLocalsNotReassignedAfterRender`,
               loc: operand.loc,
@@ -167953,11 +167935,14 @@ function getContextReassignment(
             const reassignment = reassigningFunctions.get(
               operand.identifier.id
             );
-            if (
-              reassignment !== undefined &&
-              operand.effect === exports.Effect.Freeze
-            ) {
-              return reassignment;
+            if (reassignment !== undefined) {
+              if (operand.effect === exports.Effect.Freeze) {
+                return reassignment;
+              } else {
+                for (const lval of eachInstructionLValue(instr)) {
+                  reassigningFunctions.set(lval.identifier.id, reassignment);
+                }
+              }
             }
           }
           break;
@@ -167973,21 +167958,22 @@ function getContextReassignment(
   }
   return null;
 }
-function outlineFunctions(fn) {
+function outlineFunctions(fn, fbtOperands) {
   for (const [, block] of fn.body.blocks) {
     for (const instr of block.instructions) {
-      const {value: value} = instr;
+      const {value: value, lvalue: lvalue} = instr;
       if (
         value.kind === 'FunctionExpression' ||
         value.kind === 'ObjectMethod'
       ) {
-        outlineFunctions(value.loweredFunc.func);
+        outlineFunctions(value.loweredFunc.func, fbtOperands);
       }
       if (
         value.kind === 'FunctionExpression' &&
         value.loweredFunc.dependencies.length === 0 &&
         value.loweredFunc.func.context.length === 0 &&
-        value.loweredFunc.func.id === null
+        value.loweredFunc.func.id === null &&
+        !fbtOperands.has(lvalue.identifier.id)
       ) {
         const loweredFunc = value.loweredFunc.func;
         const id = fn.env.generateGloballyUniqueIdentifierName(loweredFunc.id);
@@ -168002,6 +167988,46 @@ function outlineFunctions(fn) {
     }
   }
 }
+function propagatePhiTypes(fn) {
+  const propagated = new Set();
+  for (const [, block] of fn.body.blocks) {
+    for (const phi of block.phis) {
+      if (phi.id.type.kind !== 'Type' || phi.id.name !== null) {
+        continue;
+      }
+      let type = null;
+      for (const [, operand] of phi.operands) {
+        if (type === null) {
+          type = operand.type;
+        } else if (!typeEquals(type, operand.type)) {
+          type = null;
+          break;
+        }
+      }
+      if (type !== null) {
+        phi.id.type = type;
+        phi.type = type;
+        propagated.add(phi.id.id);
+      }
+    }
+    for (const instr of block.instructions) {
+      const {value: value} = instr;
+      switch (value.kind) {
+        case 'StoreLocal': {
+          const lvalue = value.lvalue.place;
+          if (
+            propagated.has(value.value.identifier.id) &&
+            lvalue.identifier.type.kind === 'Type' &&
+            lvalue.identifier.name === null
+          ) {
+            lvalue.identifier.type = value.value.identifier.type;
+            propagated.add(lvalue.identifier.id);
+          }
+        }
+      }
+    }
+  }
+}
 function* run(
   func,
   config,
@@ -168022,11 +168048,11 @@ function* run(
     code,
     useMemoCacheIdentifier
   );
-  yield {
+  yield log({
     kind: 'debug',
     name: 'EnvironmentConfig',
     value: prettyFormat$1(env.config),
-  };
+  });
   const ast = yield* runWithEnvironment(func, env);
   return ast;
 }
@@ -168096,24 +168122,30 @@ function* runWithEnvironment(func, env) {
   }
   inferReactivePlaces(hir);
   yield log({kind: 'hir', name: 'InferReactivePlaces', value: hir});
-  leaveSSA(hir);
-  yield log({kind: 'hir', name: 'LeaveSSA', value: hir});
+  rewriteInstructionKindsBasedOnReassignment(hir);
+  yield log({
+    kind: 'hir',
+    name: 'RewriteInstructionKindsBasedOnReassignment',
+    value: hir,
+  });
+  propagatePhiTypes(hir);
+  yield log({kind: 'hir', name: 'PropagatePhiTypes', value: hir});
   inferReactiveScopeVariables(hir);
   yield log({kind: 'hir', name: 'InferReactiveScopeVariables', value: hir});
+  const fbtOperands = memoizeFbtAndMacroOperandsInSameScope(hir);
+  yield log({
+    kind: 'hir',
+    name: 'MemoizeFbtAndMacroOperandsInSameScope',
+    value: hir,
+  });
   if (env.config.enableFunctionOutlining) {
-    outlineFunctions(hir);
+    outlineFunctions(hir, fbtOperands);
     yield log({kind: 'hir', name: 'OutlineFunctions', value: hir});
   }
   alignMethodCallScopes(hir);
   yield log({kind: 'hir', name: 'AlignMethodCallScopes', value: hir});
   alignObjectMethodScopes(hir);
   yield log({kind: 'hir', name: 'AlignObjectMethodScopes', value: hir});
-  const fbtOperands = memoizeFbtAndMacroOperandsInSameScope(hir);
-  yield log({
-    kind: 'hir',
-    name: 'MemoizeFbtAndMacroOperandsInSameScope',
-    value: hir,
-  });
   if (env.config.enableReactiveScopesInHIR) {
     pruneUnusedLabelsHIR(hir);
     yield log({kind: 'hir', name: 'PruneUnusedLabelsHIR', value: hir});
@@ -168250,7 +168282,7 @@ function* runWithEnvironment(func, env) {
     name: 'PromoteUsedTemporaries',
     value: reactiveFunction,
   });
-  pruneTemporaryLValues(reactiveFunction);
+  pruneUnusedLValues(reactiveFunction);
   yield log({
     kind: 'reactive',
     name: 'PruneUnusedLValues',
@@ -168619,8 +168651,8 @@ function createNewFunctionNode(originalFn, compiledFn) {
   ALREADY_COMPILED.add(transformedFn);
   return transformedFn;
 }
-function insertNewFunctionNode(originalFn, compiledFn) {
-  var _a, _b, _c, _d;
+function insertNewOutlinedFunctionNode(program, originalFn, compiledFn) {
+  var _a, _b, _c;
   switch (originalFn.type) {
     case 'FunctionDeclaration': {
       return originalFn.insertAfter(
@@ -168629,51 +168661,28 @@ function insertNewFunctionNode(originalFn, compiledFn) {
     }
     case 'ArrowFunctionExpression':
     case 'FunctionExpression': {
-      const funcExpr = createNewFunctionNode(originalFn, compiledFn);
-      CompilerError.invariant(
-        t__namespace.isArrowFunctionExpression(funcExpr) ||
-          t__namespace.isFunctionExpression(funcExpr),
-        {
-          reason: 'Expected an (arrow) function expression to be created',
-          description: `Got: ${funcExpr.type}`,
-          loc: (_a = funcExpr.loc) !== null && _a !== void 0 ? _a : null,
-        }
-      );
-      CompilerError.invariant(compiledFn.id != null, {
-        reason: 'Expected compiled function to have an identifier',
-        loc: compiledFn.loc,
+      const fn = {
+        type: 'FunctionDeclaration',
+        id: compiledFn.id,
+        loc: (_a = originalFn.node.loc) !== null && _a !== void 0 ? _a : null,
+        async: compiledFn.async,
+        generator: compiledFn.generator,
+        params: compiledFn.params,
+        body: compiledFn.body,
+      };
+      const insertedFuncDecl = program.pushContainer('body', [fn])[0];
+      CompilerError.invariant(insertedFuncDecl.isFunctionDeclaration(), {
+        reason: 'Expected inserted function declaration',
+        description: `Got: ${insertedFuncDecl}`,
+        loc:
+          (_c =
+            (_b = insertedFuncDecl.node) === null || _b === void 0
+              ? void 0
+              : _b.loc) !== null && _c !== void 0
+            ? _c
+            : null,
       });
-      CompilerError.invariant(
-        originalFn.parentPath.isVariableDeclarator() &&
-          originalFn.parentPath.parentPath.isVariableDeclaration(),
-        {
-          reason: 'Expected a variable declarator parent',
-          loc: (_b = originalFn.node.loc) !== null && _b !== void 0 ? _b : null,
-        }
-      );
-      const varDecl = originalFn.parentPath.parentPath;
-      varDecl.insertAfter(
-        t__namespace.variableDeclaration('const', [
-          t__namespace.variableDeclarator(compiledFn.id, funcExpr),
-        ])
-      );
-      const insertedFuncExpr = varDecl.get('declarations')[0].get('init');
-      CompilerError.invariant(
-        insertedFuncExpr.isArrowFunctionExpression() ||
-          insertedFuncExpr.isFunctionExpression(),
-        {
-          reason: 'Expected inserted (arrow) function expression',
-          description: `Got: ${insertedFuncExpr}`,
-          loc:
-            (_d =
-              (_c = insertedFuncExpr.node) === null || _c === void 0
-                ? void 0
-                : _c.loc) !== null && _d !== void 0
-              ? _d
-              : null,
-        }
-      );
-      return insertedFuncExpr;
+      return insertedFuncDecl;
     }
     default: {
       assertExhaustive(
@@ -168857,7 +168866,11 @@ function compileProgram(program, pass) {
         reason: 'Unexpected nested outlined functions',
         loc: outlined.fn.loc,
       });
-      const fn = insertNewFunctionNode(current.fn, outlined.fn);
+      const fn = insertNewOutlinedFunctionNode(
+        program,
+        current.fn,
+        outlined.fn
+      );
       fn.skip();
       ALREADY_COMPILED.add(fn.node);
       if (outlined.type !== null) {