babel-plugin-react-compiler 0.0.0-experimental-487cb0e-20240529 → 0.0.0-experimental-696af53-20240625

package/dist/index.js

@@ -135799,21 +135799,37 @@ function insertGatedFunctionDeclaration(fnPath, compiled, gating) {
     buildFunctionExpression(compiled),
     buildFunctionExpression(fnPath.node)
   );
-  let compiledFn;
   if (
     fnPath.parentPath.node.type !== "ExportDefaultDeclaration" &&
     fnPath.node.type === "FunctionDeclaration" &&
     fnPath.node.id != null
   ) {
-    compiledFn = fnPath.replaceWith(
+    fnPath.replaceWith(
       t__namespace.variableDeclaration("const", [
         t__namespace.variableDeclarator(fnPath.node.id, gatingExpression),
       ])
-    )[0];
+    );
+  } else if (
+    fnPath.parentPath.node.type === "ExportDefaultDeclaration" &&
+    fnPath.node.type !== "ArrowFunctionExpression" &&
+    fnPath.node.id != null
+  ) {
+    fnPath.insertAfter(
+      t__namespace.exportDefaultDeclaration(
+        t__namespace.identifier(fnPath.node.id.name)
+      )
+    );
+    fnPath.parentPath.replaceWith(
+      t__namespace.variableDeclaration("const", [
+        t__namespace.variableDeclarator(
+          t__namespace.identifier(fnPath.node.id.name),
+          gatingExpression
+        ),
+      ])
+    );
   } else {
-    compiledFn = fnPath.replaceWith(gatingExpression)[0];
+    fnPath.replaceWith(gatingExpression);
   }
-  return compiledFn;
 }
 function buildFunctionExpression(node) {
   var _a, _b;
@@ -135848,6 +135864,15 @@ function retainWhere(array, predicate) {
   }
   array.length = writeIndex;
 }
+function getOrInsertWith(m, key, makeDefault) {
+  if (m.has(key)) {
+    return m.get(key);
+  } else {
+    const defaultValue = makeDefault();
+    m.set(key, defaultValue);
+    return defaultValue;
+  }
+}
 function getOrInsertDefault(m, key, defaultValue) {
   if (m.has(key)) {
     return m.get(key);
@@ -136071,10 +136096,12 @@ function objectMethodTypeEquals(tA, tB) {
 }
 function propTypeEquals(tA, tB) {
   if (tA.kind === "Property" && tB.kind === "Property") {
-    if (!typeEquals(tA.object, tB.object)) {
+    if (!typeEquals(tA.objectType, tB.objectType)) {
       return false;
     }
-    return tA.propertyName === tB.propertyName;
+    return (
+      tA.propertyName === tB.propertyName && tA.objectName === tB.objectName
+    );
   }
   return false;
 }
@@ -136111,6 +136138,12 @@ function phiTypeEquals(tA, tB) {
   return false;
 }
 const GeneratedSource = Symbol();
+function isStatementBlockKind(kind) {
+  return kind === "block" || kind === "catch";
+}
+function isExpressionBlockKind(kind) {
+  return !isStatementBlockKind(kind);
+}
 var GotoVariant;
 (function (GotoVariant) {
   GotoVariant["Break"] = "Break";
@@ -136165,6 +136198,7 @@ var ValueReason;
   ValueReason["KnownReturnSignature"] = "known-return-signature";
   ValueReason["Context"] = "context";
   ValueReason["State"] = "state";
+  ValueReason["ReducerState"] = "reducer-state";
   ValueReason["ReactiveFunctionArgument"] = "reactive-function-argument";
   ValueReason["Other"] = "other";
 })(ValueReason || (ValueReason = {}));
@@ -136266,9 +136300,23 @@ function isRefValueType(id) {
 function isUseRefType(id) {
   return id.type.kind === "Object" && id.type.shapeId === "BuiltInUseRefId";
 }
+function isUseStateType(id) {
+  return id.type.kind === "Object" && id.type.shapeId === "BuiltInUseState";
+}
 function isSetStateType(id) {
   return id.type.kind === "Function" && id.type.shapeId === "BuiltInSetState";
 }
+function isSetActionStateType(id) {
+  return (
+    id.type.kind === "Function" && id.type.shapeId === "BuiltInSetActionState"
+  );
+}
+function isDispatcherType(id) {
+  return id.type.kind === "Function" && id.type.shapeId === "BuiltInDispatch";
+}
+function isStableType(id) {
+  return isSetStateType(id) || isSetActionStateType(id) || isDispatcherType(id);
+}
 function isUseEffectHookType(id) {
   return (
     id.type.kind === "Function" && id.type.shapeId === "BuiltInUseEffectHook"
@@ -136401,6 +136449,11 @@ function writeReactiveBlock(writer, block) {
   writeReactiveInstructions(writer, block.instructions);
   writer.writeLine("}");
 }
+function writePrunedScope(writer, block) {
+  writer.writeLine(`<pruned> ${printReactiveScopeSummary(block.scope)} {`);
+  writeReactiveInstructions(writer, block.instructions);
+  writer.writeLine("}");
+}
 function printDependency(dependency) {
   const identifier =
     printIdentifier(dependency.identifier) +
@@ -136434,6 +136487,10 @@ function writeReactiveInstruction(writer, instr) {
       writeReactiveBlock(writer, instr);
       break;
     }
+    case "pruned-scope": {
+      writePrunedScope(writer, instr);
+      break;
+    }
     case "terminal": {
       if (instr.label !== null) {
         writer.write(`bb${instr.label.id}: `);
@@ -136823,7 +136880,8 @@ function printMixedHIR(value) {
     case "do-while":
     case "for-in":
     case "for-of":
-    case "scope": {
+    case "scope":
+    case "pruned-scope": {
       const terminal = printTerminal(value);
       if (Array.isArray(terminal)) {
         return terminal.join("; ");
@@ -136953,6 +137011,10 @@ function printTerminal(terminal) {
       value = `Scope ${printReactiveScopeSummary(terminal.scope)} block=bb${terminal.block} fallthrough=bb${terminal.fallthrough}`;
       break;
     }
+    case "pruned-scope": {
+      value = `<pruned> Scope ${printReactiveScopeSummary(terminal.scope)} block=bb${terminal.block} fallthrough=bb${terminal.fallthrough}`;
+      break;
+    }
     case "try": {
       value = `Try block=bb${terminal.block} handler=bb${terminal.handler}${terminal.handlerBinding !== null ? ` handlerBinding=(${printPlace(terminal.handlerBinding)})` : ""} fallthrough=${terminal.fallthrough != null ? `bb${terminal.fallthrough}` : ""}`;
       break;
@@ -137253,6 +137315,10 @@ function printInstructionValue(instrValue) {
       value = `RegExp /${instrValue.pattern}/${instrValue.flags}`;
       break;
     }
+    case "MetaProperty": {
+      value = `MetaProperty ${instrValue.meta}.${instrValue.property}`;
+      break;
+    }
     case "Await": {
       value = `Await ${printPlace(instrValue.value)}`;
       break;
@@ -137651,6 +137717,7 @@ function* eachInstructionValueOperand(instrValue) {
     }
     case "Debugger":
     case "RegExpLiteral":
+    case "MetaProperty":
     case "LoadGlobal":
     case "UnsupportedNode":
     case "Primitive":
@@ -137949,6 +138016,7 @@ function mapInstructionValueOperands(instrValue, fn) {
     }
     case "Debugger":
     case "RegExpLiteral":
+    case "MetaProperty":
     case "LoadGlobal":
     case "UnsupportedNode":
     case "Primitive":
@@ -138213,11 +138281,12 @@ function mapTerminalSuccessors(terminal, fn) {
         loc: terminal.loc,
       };
     }
-    case "scope": {
+    case "scope":
+    case "pruned-scope": {
       const block = fn(terminal.block);
       const fallthrough = fn(terminal.fallthrough);
       return {
-        kind: "scope",
+        kind: terminal.kind,
         scope: terminal.scope,
         block: block,
         fallthrough: fallthrough,
@@ -138262,7 +138331,8 @@ function terminalHasFallthrough(terminal) {
     case "switch":
     case "ternary":
     case "while":
-    case "scope": {
+    case "scope":
+    case "pruned-scope": {
       terminal.fallthrough;
       return true;
     }
@@ -138352,7 +138422,8 @@ function* eachTerminalSuccessor(terminal) {
       yield terminal.block;
       break;
     }
-    case "scope": {
+    case "scope":
+    case "pruned-scope": {
       yield terminal.block;
       break;
     }
@@ -138414,7 +138485,8 @@ function mapTerminalOperands(terminal, fn) {
     case "goto":
     case "unreachable":
     case "unsupported":
-    case "scope": {
+    case "scope":
+    case "pruned-scope": {
       break;
     }
     default: {
@@ -138470,7 +138542,8 @@ function* eachTerminalOperand(terminal) {
     case "goto":
     case "unreachable":
     case "unsupported":
-    case "scope": {
+    case "scope":
+    case "pruned-scope": {
       break;
     }
     default: {
@@ -138896,7 +138969,7 @@ class HIRBuilder {
     ).at(-1);
     return handler !== null && handler !== void 0 ? handler : null;
   }
-  makeTemporary() {
+  makeTemporary(loc) {
     const id = this.nextIdentifierId;
     return {
       id: id,
@@ -138904,6 +138977,7 @@ class HIRBuilder {
       mutableRange: { start: makeInstructionId(0), end: makeInstructionId(0) },
       scope: null,
       type: makeType(),
+      loc: loc,
     };
   }
   resolveIdentifier(path) {
@@ -138984,6 +139058,7 @@ class HIRBuilder {
     }
   }
   resolveBinding(node) {
+    var _a;
     const originalName = node.name;
     let name = originalName;
     let index = 0;
@@ -139004,6 +139079,7 @@ class HIRBuilder {
           },
           scope: null,
           type: makeType(),
+          loc: (_a = node.loc) !== null && _a !== void 0 ? _a : GeneratedSource,
         };
         __classPrivateFieldGet(this, _HIRBuilder_bindings, "f").set(name, {
           node: node,
@@ -139436,7 +139512,7 @@ function removeUnnecessaryTryCatch(fn) {
     }
   }
 }
-function createTemporaryPlace(env) {
+function createTemporaryPlace(env, loc) {
   return {
     kind: "Identifier",
     identifier: {
@@ -139445,6 +139521,7 @@ function createTemporaryPlace(env) {
       name: null,
       scope: null,
       type: makeType(),
+      loc: loc,
     },
     reactive: false,
     effect: exports.Effect.Unknown,
@@ -139487,12 +139564,15 @@ function addShape(registry, id, properties, functionType) {
   registry.set(id, shape);
   return shape;
 }
+const BuiltInPropsId = "BuiltInProps";
 const BuiltInArrayId = "BuiltInArray";
 const BuiltInFunctionId = "BuiltInFunction";
 const BuiltInJsxId = "BuiltInJsx";
 const BuiltInObjectId = "BuiltInObject";
 const BuiltInUseStateId = "BuiltInUseState";
 const BuiltInSetStateId = "BuiltInSetState";
+const BuiltInUseActionStateId = "BuiltInUseActionState";
+const BuiltInSetActionStateId = "BuiltInSetActionState";
 const BuiltInUseRefId = "BuiltInUseRefId";
 const BuiltInRefValueId = "BuiltInRefValue";
 const BuiltInMixedReadonlyId = "BuiltInMixedReadonly";
@@ -139500,7 +139580,12 @@ const BuiltInUseEffectHookId = "BuiltInUseEffectHook";
 const BuiltInUseLayoutEffectHookId = "BuiltInUseLayoutEffectHook";
 const BuiltInUseInsertionEffectHookId = "BuiltInUseInsertionEffectHook";
 const BuiltInUseOperatorId = "BuiltInUseOperator";
+const BuiltInUseReducerId = "BuiltInUseReducer";
+const BuiltInDispatchId = "BuiltInDispatch";
 const BUILTIN_SHAPES = new Map();
+addObject(BUILTIN_SHAPES, BuiltInPropsId, [
+  ["ref", { kind: "Object", shapeId: BuiltInUseRefId }],
+]);
 addObject(BUILTIN_SHAPES, BuiltInArrayId, [
   [
     "at",
@@ -139646,6 +139731,42 @@ addObject(BUILTIN_SHAPES, BuiltInUseStateId, [
     ),
   ],
 ]);
+addObject(BUILTIN_SHAPES, BuiltInUseActionStateId, [
+  ["0", { kind: "Poly" }],
+  [
+    "1",
+    addFunction(
+      BUILTIN_SHAPES,
+      [],
+      {
+        positionalParams: [],
+        restParam: exports.Effect.Freeze,
+        returnType: PRIMITIVE_TYPE,
+        calleeEffect: exports.Effect.Read,
+        returnValueKind: exports.ValueKind.Primitive,
+      },
+      BuiltInSetActionStateId
+    ),
+  ],
+]);
+addObject(BUILTIN_SHAPES, BuiltInUseReducerId, [
+  ["0", { kind: "Poly" }],
+  [
+    "1",
+    addFunction(
+      BUILTIN_SHAPES,
+      [],
+      {
+        positionalParams: [],
+        restParam: exports.Effect.Freeze,
+        returnType: PRIMITIVE_TYPE,
+        calleeEffect: exports.Effect.Read,
+        returnValueKind: exports.ValueKind.Primitive,
+      },
+      BuiltInDispatchId
+    ),
+  ],
+]);
 addObject(BUILTIN_SHAPES, BuiltInUseRefId, [
   ["current", { kind: "Object", shapeId: BuiltInRefValueId }],
 ]);
@@ -139742,7 +139863,7 @@ function lower$1(func, env, bindings = null, capturedRefs = [], parent = null) {
   }
   const params = [];
   func.get("params").forEach((param) => {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     if (param.isIdentifier()) {
       const binding = builder.resolveIdentifier(param);
       if (binding.kind !== "Identifier") {
@@ -139772,18 +139893,20 @@ function lower$1(func, env, bindings = null, capturedRefs = [], parent = null) {
     ) {
       const place = {
         kind: "Identifier",
-        identifier: builder.makeTemporary(),
+        identifier: builder.makeTemporary(
+          (_c = param.node.loc) !== null && _c !== void 0 ? _c : GeneratedSource
+        ),
         effect: exports.Effect.Unknown,
         reactive: false,
         loc:
-          (_c = param.node.loc) !== null && _c !== void 0
-            ? _c
+          (_d = param.node.loc) !== null && _d !== void 0
+            ? _d
             : GeneratedSource,
       };
       params.push(place);
       lowerAssignment(
         builder,
-        (_d = param.node.loc) !== null && _d !== void 0 ? _d : GeneratedSource,
+        (_e = param.node.loc) !== null && _e !== void 0 ? _e : GeneratedSource,
         InstructionKind.Let,
         param,
         place,
@@ -139792,18 +139915,20 @@ function lower$1(func, env, bindings = null, capturedRefs = [], parent = null) {
     } else if (param.isRestElement()) {
       const place = {
         kind: "Identifier",
-        identifier: builder.makeTemporary(),
+        identifier: builder.makeTemporary(
+          (_f = param.node.loc) !== null && _f !== void 0 ? _f : GeneratedSource
+        ),
         effect: exports.Effect.Unknown,
         reactive: false,
         loc:
-          (_e = param.node.loc) !== null && _e !== void 0
-            ? _e
+          (_g = param.node.loc) !== null && _g !== void 0
+            ? _g
             : GeneratedSource,
       };
       params.push({ kind: "Spread", place: place });
       lowerAssignment(
         builder,
-        (_f = param.node.loc) !== null && _f !== void 0 ? _f : GeneratedSource,
+        (_h = param.node.loc) !== null && _h !== void 0 ? _h : GeneratedSource,
         InstructionKind.Let,
         param.get("argument"),
         place,
@@ -139813,7 +139938,7 @@ function lower$1(func, env, bindings = null, capturedRefs = [], parent = null) {
       builder.errors.push({
         reason: `(BuildHIR::lower) Handle ${param.node.type} params`,
         severity: exports.ErrorSeverity.Todo,
-        loc: (_g = param.node.loc) !== null && _g !== void 0 ? _g : null,
+        loc: (_j = param.node.loc) !== null && _j !== void 0 ? _j : null,
         suggestions: null,
       });
     }
@@ -139928,7 +140053,8 @@ function lowerStatement(builder, stmtPath, label = null) {
     _28,
     _29,
     _30,
-    _31;
+    _31,
+    _32;
   const stmtNode = stmtPath.node;
   switch (stmtNode.type) {
     case "ThrowStatement": {
@@ -140955,12 +141081,16 @@ function lowerStatement(builder, stmtPath, label = null) {
       if (hasNode(handlerBindingPath)) {
         const place = {
           kind: "Identifier",
-          identifier: builder.makeTemporary(),
+          identifier: builder.makeTemporary(
+            (_27 = handlerBindingPath.node.loc) !== null && _27 !== void 0
+              ? _27
+              : GeneratedSource
+          ),
           effect: exports.Effect.Unknown,
           reactive: false,
           loc:
-            (_27 = handlerBindingPath.node.loc) !== null && _27 !== void 0
-              ? _27
+            (_28 = handlerBindingPath.node.loc) !== null && _28 !== void 0
+              ? _28
               : GeneratedSource,
         };
         promoteTemporary(place.identifier);
@@ -140972,8 +141102,8 @@ function lowerStatement(builder, stmtPath, label = null) {
           },
           type: null,
           loc:
-            (_28 = handlerBindingPath.node.loc) !== null && _28 !== void 0
-              ? _28
+            (_29 = handlerBindingPath.node.loc) !== null && _29 !== void 0
+              ? _29
               : GeneratedSource,
         });
         handlerBinding = { path: handlerBindingPath, place: place };
@@ -141033,8 +141163,8 @@ function lowerStatement(builder, stmtPath, label = null) {
           fallthrough: continuationBlock.id,
           id: makeInstructionId(0),
           loc:
-            (_29 = stmt.node.loc) !== null && _29 !== void 0
-              ? _29
+            (_30 = stmt.node.loc) !== null && _30 !== void 0
+              ? _30
               : GeneratedSource,
         },
         continuationBlock
@@ -141074,14 +141204,14 @@ function lowerStatement(builder, stmtPath, label = null) {
       builder.errors.push({
         reason: `(BuildHIR::lowerStatement) Handle ${stmtPath.type} statements`,
         severity: exports.ErrorSeverity.Todo,
-        loc: (_30 = stmtPath.node.loc) !== null && _30 !== void 0 ? _30 : null,
+        loc: (_31 = stmtPath.node.loc) !== null && _31 !== void 0 ? _31 : null,
         suggestions: null,
       });
       lowerValueToTemporary(builder, {
         kind: "UnsupportedNode",
         loc:
-          (_31 = stmtPath.node.loc) !== null && _31 !== void 0
-            ? _31
+          (_32 = stmtPath.node.loc) !== null && _32 !== void 0
+            ? _32
             : GeneratedSource,
         node: stmtPath.node,
       });
@@ -141173,7 +141303,12 @@ function lowerExpression(builder, exprPath) {
     _12,
     _13,
     _14,
-    _15;
+    _15,
+    _16,
+    _17,
+    _18,
+    _19,
+    _20;
   const exprNode = exprPath.node;
   const exprLoc =
     (_a = exprNode.loc) !== null && _a !== void 0 ? _a : GeneratedSource;
@@ -141228,6 +141363,18 @@ function lowerExpression(builder, exprPath) {
           );
           properties.push({ kind: "Spread", place: place });
         } else if (propertyPath.isObjectMethod()) {
+          if (propertyPath.node.kind !== "method") {
+            builder.errors.push({
+              reason: `(BuildHIR::lowerExpression) Handle ${propertyPath.node.kind} functions in ObjectExpression`,
+              severity: exports.ErrorSeverity.Todo,
+              loc:
+                (_c = propertyPath.node.loc) !== null && _c !== void 0
+                  ? _c
+                  : null,
+              suggestions: null,
+            });
+            continue;
+          }
           const method = lowerObjectMethod(builder, propertyPath);
           const place = lowerValueToTemporary(builder, method);
           const loweredKey = lowerObjectPropertyKey(builder, propertyPath);
@@ -141245,8 +141392,8 @@ function lowerExpression(builder, exprPath) {
             reason: `(BuildHIR::lowerExpression) Handle ${propertyPath.type} properties in ObjectExpression`,
             severity: exports.ErrorSeverity.Todo,
             loc:
-              (_c = propertyPath.node.loc) !== null && _c !== void 0
-                ? _c
+              (_d = propertyPath.node.loc) !== null && _d !== void 0
+                ? _d
                 : null,
             suggestions: null,
           });
@@ -141274,7 +141421,7 @@ function lowerExpression(builder, exprPath) {
           builder.errors.push({
             reason: `(BuildHIR::lowerExpression) Handle ${element.type} elements in ArrayExpression`,
             severity: exports.ErrorSeverity.Todo,
-            loc: (_d = element.node.loc) !== null && _d !== void 0 ? _d : null,
+            loc: (_e = element.node.loc) !== null && _e !== void 0 ? _e : null,
             suggestions: null,
           });
           continue;
@@ -141290,7 +141437,7 @@ function lowerExpression(builder, exprPath) {
           reason: `Expected an expression as the \`new\` expression receiver (v8 intrinsics are not supported)`,
           description: `Got a \`${calleePath.node.type}\``,
           severity: exports.ErrorSeverity.InvalidJS,
-          loc: (_e = calleePath.node.loc) !== null && _e !== void 0 ? _e : null,
+          loc: (_f = calleePath.node.loc) !== null && _f !== void 0 ? _f : null,
           suggestions: null,
         });
         return { kind: "UnsupportedNode", node: exprNode, loc: exprLoc };
@@ -141315,7 +141462,7 @@ function lowerExpression(builder, exprPath) {
         builder.errors.push({
           reason: `Expected Expression, got ${calleePath.type} in CallExpression (v8 intrinsics not supported). This error is likely caused by a bug in React Compiler. Please file an issue`,
           severity: exports.ErrorSeverity.Todo,
-          loc: (_f = calleePath.node.loc) !== null && _f !== void 0 ? _f : null,
+          loc: (_g = calleePath.node.loc) !== null && _g !== void 0 ? _g : null,
           suggestions: null,
         });
         return { kind: "UnsupportedNode", node: exprNode, loc: exprLoc };
@@ -141349,7 +141496,7 @@ function lowerExpression(builder, exprPath) {
         builder.errors.push({
           reason: `(BuildHIR::lowerExpression) Expected Expression, got ${leftPath.type} lval in BinaryExpression`,
           severity: exports.ErrorSeverity.Todo,
-          loc: (_g = leftPath.node.loc) !== null && _g !== void 0 ? _g : null,
+          loc: (_h = leftPath.node.loc) !== null && _h !== void 0 ? _h : null,
           suggestions: null,
         });
         return { kind: "UnsupportedNode", node: exprNode, loc: exprLoc };
@@ -141357,6 +141504,15 @@ function lowerExpression(builder, exprPath) {
       const left = lowerExpressionToTemporary(builder, leftPath);
       const right = lowerExpressionToTemporary(builder, expr.get("right"));
       const operator = expr.node.operator;
+      if (operator === "|>") {
+        builder.errors.push({
+          reason: `(BuildHIR::lowerExpression) Pipe operator not supported`,
+          severity: exports.ErrorSeverity.Todo,
+          loc: (_j = leftPath.node.loc) !== null && _j !== void 0 ? _j : null,
+          suggestions: null,
+        });
+        return { kind: "UnsupportedNode", node: exprNode, loc: exprLoc };
+      }
       return {
         kind: "BinaryExpression",
         operator: operator,
@@ -141368,7 +141524,7 @@ function lowerExpression(builder, exprPath) {
     case "SequenceExpression": {
       const expr = exprPath;
       const exprLoc =
-        (_h = expr.node.loc) !== null && _h !== void 0 ? _h : GeneratedSource;
+        (_k = expr.node.loc) !== null && _k !== void 0 ? _k : GeneratedSource;
       const continuationBlock = builder.reserve(builder.currentBlockKind());
       const place = buildTemporaryPlace(builder, exprLoc);
       const sequenceBlock = builder.enter("sequence", (_) => {
@@ -141419,7 +141575,7 @@ function lowerExpression(builder, exprPath) {
     case "ConditionalExpression": {
       const expr = exprPath;
       const exprLoc =
-        (_j = expr.node.loc) !== null && _j !== void 0 ? _j : GeneratedSource;
+        (_l = expr.node.loc) !== null && _l !== void 0 ? _l : GeneratedSource;
       const continuationBlock = builder.reserve(builder.currentBlockKind());
       const testBlock = builder.reserve("value");
       const place = buildTemporaryPlace(builder, exprLoc);
@@ -141500,14 +141656,14 @@ function lowerExpression(builder, exprPath) {
     case "LogicalExpression": {
       const expr = exprPath;
       const exprLoc =
-        (_k = expr.node.loc) !== null && _k !== void 0 ? _k : GeneratedSource;
+        (_m = expr.node.loc) !== null && _m !== void 0 ? _m : GeneratedSource;
       const continuationBlock = builder.reserve(builder.currentBlockKind());
       const testBlock = builder.reserve("value");
       const place = buildTemporaryPlace(builder, exprLoc);
       const leftPlace = buildTemporaryPlace(
         builder,
-        (_l = expr.get("left").node.loc) !== null && _l !== void 0
-          ? _l
+        (_o = expr.get("left").node.loc) !== null && _o !== void 0
+          ? _o
           : GeneratedSource
       );
       const consequent = builder.enter("value", () => {
@@ -141587,7 +141743,7 @@ function lowerExpression(builder, exprPath) {
         const left = expr.get("left");
         return lowerAssignment(
           builder,
-          (_m = left.node.loc) !== null && _m !== void 0 ? _m : GeneratedSource,
+          (_p = left.node.loc) !== null && _p !== void 0 ? _p : GeneratedSource,
           InstructionKind.Reassign,
           left,
           lowerExpressionToTemporary(builder, expr.get("right")),
@@ -141615,7 +141771,7 @@ function lowerExpression(builder, exprPath) {
         builder.errors.push({
           reason: `(BuildHIR::lowerExpression) Handle ${operator} operators in AssignmentExpression`,
           severity: exports.ErrorSeverity.Todo,
-          loc: (_o = expr.node.loc) !== null && _o !== void 0 ? _o : null,
+          loc: (_q = expr.node.loc) !== null && _q !== void 0 ? _q : null,
           suggestions: null,
         });
         return { kind: "UnsupportedNode", node: exprNode, loc: exprLoc };
@@ -141675,8 +141831,8 @@ function lowerExpression(builder, exprPath) {
             left: Object.assign({}, previousValuePlace),
             right: lowerExpressionToTemporary(builder, expr.get("right")),
             loc:
-              (_p = leftExpr.node.loc) !== null && _p !== void 0
-                ? _p
+              (_r = leftExpr.node.loc) !== null && _r !== void 0
+                ? _r
                 : GeneratedSource,
           });
           if (typeof property === "string") {
@@ -141686,8 +141842,8 @@ function lowerExpression(builder, exprPath) {
               property: property,
               value: Object.assign({}, newValuePlace),
               loc:
-                (_q = leftExpr.node.loc) !== null && _q !== void 0
-                  ? _q
+                (_s = leftExpr.node.loc) !== null && _s !== void 0
+                  ? _s
                   : GeneratedSource,
             };
           } else {
@@ -141697,8 +141853,8 @@ function lowerExpression(builder, exprPath) {
               property: Object.assign({}, property),
               value: Object.assign({}, newValuePlace),
               loc:
-                (_r = leftExpr.node.loc) !== null && _r !== void 0
-                  ? _r
+                (_t = leftExpr.node.loc) !== null && _t !== void 0
+                  ? _t
                   : GeneratedSource,
             };
           }
@@ -141707,7 +141863,7 @@ function lowerExpression(builder, exprPath) {
           builder.errors.push({
             reason: `(BuildHIR::lowerExpression) Expected Identifier or MemberExpression, got ${expr.type} lval in AssignmentExpression`,
             severity: exports.ErrorSeverity.Todo,
-            loc: (_s = expr.node.loc) !== null && _s !== void 0 ? _s : null,
+            loc: (_u = expr.node.loc) !== null && _u !== void 0 ? _u : null,
             suggestions: null,
           });
           return { kind: "UnsupportedNode", node: exprNode, loc: exprLoc };
@@ -141733,8 +141889,8 @@ function lowerExpression(builder, exprPath) {
       const expr = exprPath;
       const opening = expr.get("openingElement");
       const openingLoc =
-        (_t = opening.node.loc) !== null && _t !== void 0
-          ? _t
+        (_v = opening.node.loc) !== null && _v !== void 0
+          ? _v
           : GeneratedSource;
       const tag = lowerJsxElementName(builder, opening.get("name"));
       const props = [];
@@ -141752,7 +141908,7 @@ function lowerExpression(builder, exprPath) {
             reason: `(BuildHIR::lowerExpression) Handle ${attribute.type} attributes in JSXElement`,
             severity: exports.ErrorSeverity.Todo,
             loc:
-              (_u = attribute.node.loc) !== null && _u !== void 0 ? _u : null,
+              (_w = attribute.node.loc) !== null && _w !== void 0 ? _w : null,
             suggestions: null,
           });
           continue;
@@ -141766,7 +141922,7 @@ function lowerExpression(builder, exprPath) {
               reason: `(BuildHIR::lowerExpression) Unexpected colon in attribute name \`${name}\``,
               severity: exports.ErrorSeverity.Todo,
               loc:
-                (_v = namePath.node.loc) !== null && _v !== void 0 ? _v : null,
+                (_x = namePath.node.loc) !== null && _x !== void 0 ? _x : null,
               suggestions: null,
             });
           }
@@ -141774,7 +141930,7 @@ function lowerExpression(builder, exprPath) {
           CompilerError.invariant(namePath.isJSXNamespacedName(), {
             reason: "Refinement",
             description: null,
-            loc: (_w = namePath.node.loc) !== null && _w !== void 0 ? _w : null,
+            loc: (_y = namePath.node.loc) !== null && _y !== void 0 ? _y : null,
             suggestions: null,
           });
           const namespace = namePath.node.namespace.name;
@@ -141790,8 +141946,8 @@ function lowerExpression(builder, exprPath) {
             kind: "Primitive",
             value: true,
             loc:
-              (_x = attribute.node.loc) !== null && _x !== void 0
-                ? _x
+              (_z = attribute.node.loc) !== null && _z !== void 0
+                ? _z
                 : GeneratedSource,
           });
         } else {
@@ -141800,11 +141956,11 @@ function lowerExpression(builder, exprPath) {
               reason: `(BuildHIR::lowerExpression) Handle ${valueExpr.type} attribute values in JSXElement`,
               severity: exports.ErrorSeverity.Todo,
               loc:
-                (_z =
-                  (_y = valueExpr.node) === null || _y === void 0
+                (_1 =
+                  (_0 = valueExpr.node) === null || _0 === void 0
                     ? void 0
-                    : _y.loc) !== null && _z !== void 0
-                  ? _z
+                    : _0.loc) !== null && _1 !== void 0
+                  ? _1
                   : null,
               suggestions: null,
             });
@@ -141816,7 +141972,7 @@ function lowerExpression(builder, exprPath) {
               reason: `(BuildHIR::lowerExpression) Handle ${expression.type} expressions in JSXExpressionContainer within JSXElement`,
               severity: exports.ErrorSeverity.Todo,
               loc:
-                (_0 = valueExpr.node.loc) !== null && _0 !== void 0 ? _0 : null,
+                (_2 = valueExpr.node.loc) !== null && _2 !== void 0 ? _2 : null,
               suggestions: null,
             });
             continue;
@@ -141838,8 +141994,8 @@ function lowerExpression(builder, exprPath) {
           CompilerError.throwTodo({
             reason: `Support <${tagName}> tags where '${tagName}' is a local variable instead of a global`,
             loc:
-              (_1 = openingIdentifier.node.loc) !== null && _1 !== void 0
-                ? _1
+              (_3 = openingIdentifier.node.loc) !== null && _3 !== void 0
+                ? _3
                 : GeneratedSource,
             description: null,
             suggestions: null,
@@ -141865,8 +142021,8 @@ function lowerExpression(builder, exprPath) {
           CompilerError.throwTodo({
             reason: `Support <${tagName}> tags with multiple <${tagName}:enum> values`,
             loc:
-              (_2 = fbtEnumLocations.at(-1)) !== null && _2 !== void 0
-                ? _2
+              (_4 = fbtEnumLocations.at(-1)) !== null && _4 !== void 0
+                ? _4
                 : GeneratedSource,
             description: null,
             suggestions: null,
@@ -141910,11 +142066,11 @@ function lowerExpression(builder, exprPath) {
         loc: exprLoc,
         openingLoc: openingLoc,
         closingLoc:
-          (_4 =
-            (_3 = expr.get("closingElement").node) === null || _3 === void 0
+          (_6 =
+            (_5 = expr.get("closingElement").node) === null || _5 === void 0
               ? void 0
-              : _3.loc) !== null && _4 !== void 0
-            ? _4
+              : _5.loc) !== null && _6 !== void 0
+            ? _6
             : GeneratedSource,
       };
     }
@@ -141938,7 +142094,7 @@ function lowerExpression(builder, exprPath) {
           reason:
             "(BuildHIR::lowerExpression) Handle tagged template with interpolations",
           severity: exports.ErrorSeverity.Todo,
-          loc: (_5 = exprPath.node.loc) !== null && _5 !== void 0 ? _5 : null,
+          loc: (_7 = exprPath.node.loc) !== null && _7 !== void 0 ? _7 : null,
           suggestions: null,
         });
         return { kind: "UnsupportedNode", node: exprNode, loc: exprLoc };
@@ -141947,7 +142103,7 @@ function lowerExpression(builder, exprPath) {
         reason:
           "there should be only one quasi as we don't support interpolations yet",
         description: null,
-        loc: (_6 = expr.node.loc) !== null && _6 !== void 0 ? _6 : null,
+        loc: (_8 = expr.node.loc) !== null && _8 !== void 0 ? _8 : null,
         suggestions: null,
       });
       const value = expr.get("quasi").get("quasis").at(0).node.value;
@@ -141956,7 +142112,7 @@ function lowerExpression(builder, exprPath) {
           reason:
             "(BuildHIR::lowerExpression) Handle tagged template where cooked value is different from raw value",
           severity: exports.ErrorSeverity.Todo,
-          loc: (_7 = exprPath.node.loc) !== null && _7 !== void 0 ? _7 : null,
+          loc: (_9 = exprPath.node.loc) !== null && _9 !== void 0 ? _9 : null,
           suggestions: null,
         });
         return { kind: "UnsupportedNode", node: exprNode, loc: exprLoc };
@@ -141976,7 +142132,8 @@ function lowerExpression(builder, exprPath) {
         builder.errors.push({
           reason: `Unexpected quasi and subexpression lengths in template literal`,
           severity: exports.ErrorSeverity.InvalidJS,
-          loc: (_8 = exprPath.node.loc) !== null && _8 !== void 0 ? _8 : null,
+          loc:
+            (_10 = exprPath.node.loc) !== null && _10 !== void 0 ? _10 : null,
           suggestions: null,
         });
         return { kind: "UnsupportedNode", node: exprNode, loc: exprLoc };
@@ -141985,7 +142142,8 @@ function lowerExpression(builder, exprPath) {
         builder.errors.push({
           reason: `(BuildHIR::lowerAssignment) Handle TSType in TemplateLiteral.`,
           severity: exports.ErrorSeverity.Todo,
-          loc: (_9 = exprPath.node.loc) !== null && _9 !== void 0 ? _9 : null,
+          loc:
+            (_11 = exprPath.node.loc) !== null && _11 !== void 0 ? _11 : null,
           suggestions: null,
         });
         return { kind: "UnsupportedNode", node: exprNode, loc: exprLoc };
@@ -142028,7 +142186,7 @@ function lowerExpression(builder, exprPath) {
           builder.errors.push({
             reason: `Only object properties can be deleted`,
             severity: exports.ErrorSeverity.InvalidJS,
-            loc: (_10 = expr.node.loc) !== null && _10 !== void 0 ? _10 : null,
+            loc: (_12 = expr.node.loc) !== null && _12 !== void 0 ? _12 : null,
             suggestions: [
               {
                 description: "Remove this line",
@@ -142039,6 +142197,20 @@ function lowerExpression(builder, exprPath) {
           });
           return { kind: "UnsupportedNode", node: expr.node, loc: exprLoc };
         }
+      } else if (expr.node.operator === "throw") {
+        builder.errors.push({
+          reason: `Throw expressions are not supported`,
+          severity: exports.ErrorSeverity.InvalidJS,
+          loc: (_13 = expr.node.loc) !== null && _13 !== void 0 ? _13 : null,
+          suggestions: [
+            {
+              description: "Remove this line",
+              range: [expr.node.start, expr.node.end],
+              op: exports.CompilerSuggestionOperation.Remove,
+            },
+          ],
+        });
+        return { kind: "UnsupportedNode", node: expr.node, loc: exprLoc };
       } else {
         return {
           kind: "UnaryExpression",
@@ -142086,7 +142258,7 @@ function lowerExpression(builder, exprPath) {
           reason: `(BuildHIR::lowerExpression) Handle UpdateExpression with ${argument.type} argument`,
           severity: exports.ErrorSeverity.Todo,
           loc:
-            (_11 = exprPath.node.loc) !== null && _11 !== void 0 ? _11 : null,
+            (_14 = exprPath.node.loc) !== null && _14 !== void 0 ? _14 : null,
           suggestions: null,
         });
         return { kind: "UnsupportedNode", node: exprNode, loc: exprLoc };
@@ -142095,15 +142267,15 @@ function lowerExpression(builder, exprPath) {
           reason: `(BuildHIR::lowerExpression) Handle UpdateExpression to variables captured within lambdas.`,
           severity: exports.ErrorSeverity.Todo,
           loc:
-            (_12 = exprPath.node.loc) !== null && _12 !== void 0 ? _12 : null,
+            (_15 = exprPath.node.loc) !== null && _15 !== void 0 ? _15 : null,
           suggestions: null,
         });
         return { kind: "UnsupportedNode", node: exprNode, loc: exprLoc };
       }
       const lvalue = lowerIdentifierForAssignment(
         builder,
-        (_13 = argument.node.loc) !== null && _13 !== void 0
-          ? _13
+        (_16 = argument.node.loc) !== null && _16 !== void 0
+          ? _16
           : GeneratedSource,
         InstructionKind.Reassign,
         argument
@@ -142153,8 +142325,8 @@ function lowerExpression(builder, exprPath) {
         pattern: expr.node.pattern,
         flags: expr.node.flags,
         loc:
-          (_14 = expr.node.loc) !== null && _14 !== void 0
-            ? _14
+          (_17 = expr.node.loc) !== null && _17 !== void 0
+            ? _17
             : GeneratedSource,
       };
     }
@@ -142162,11 +142334,35 @@ function lowerExpression(builder, exprPath) {
       let expr = exprPath;
       return lowerExpression(builder, expr.get("expression"));
     }
+    case "MetaProperty": {
+      let expr = exprPath;
+      if (
+        expr.node.meta.name === "import" &&
+        expr.node.property.name === "meta"
+      ) {
+        return {
+          kind: "MetaProperty",
+          meta: expr.node.meta.name,
+          property: expr.node.property.name,
+          loc:
+            (_18 = expr.node.loc) !== null && _18 !== void 0
+              ? _18
+              : GeneratedSource,
+        };
+      }
+      builder.errors.push({
+        reason: `(BuildHIR::lowerExpression) Handle MetaProperty expressions other than import.meta`,
+        severity: exports.ErrorSeverity.Todo,
+        loc: (_19 = exprPath.node.loc) !== null && _19 !== void 0 ? _19 : null,
+        suggestions: null,
+      });
+      return { kind: "UnsupportedNode", node: exprNode, loc: exprLoc };
+    }
     default: {
       builder.errors.push({
         reason: `(BuildHIR::lowerExpression) Handle ${exprPath.type} expressions`,
         severity: exports.ErrorSeverity.Todo,
-        loc: (_15 = exprPath.node.loc) !== null && _15 !== void 0 ? _15 : null,
+        loc: (_20 = exprPath.node.loc) !== null && _20 !== void 0 ? _20 : null,
         suggestions: null,
       });
       return { kind: "UnsupportedNode", node: exprNode, loc: exprLoc };
@@ -142872,7 +143068,7 @@ function lowerIdentifier(builder, exprPath) {
 function buildTemporaryPlace(builder, loc) {
   const place = {
     kind: "Identifier",
-    identifier: builder.makeTemporary(),
+    identifier: builder.makeTemporary(loc),
     effect: exports.Effect.Unknown,
     reactive: false,
     loc: loc,
@@ -149675,6 +149871,30 @@ const REACT_APIS = [
       returnValueReason: ValueReason.State,
     }),
   ],
+  [
+    "useActionState",
+    addHook(DEFAULT_SHAPES, {
+      positionalParams: [],
+      restParam: exports.Effect.Freeze,
+      returnType: { kind: "Object", shapeId: BuiltInUseActionStateId },
+      calleeEffect: exports.Effect.Read,
+      hookKind: "useActionState",
+      returnValueKind: exports.ValueKind.Frozen,
+      returnValueReason: ValueReason.State,
+    }),
+  ],
+  [
+    "useReducer",
+    addHook(DEFAULT_SHAPES, {
+      positionalParams: [],
+      restParam: exports.Effect.Freeze,
+      returnType: { kind: "Object", shapeId: BuiltInUseReducerId },
+      calleeEffect: exports.Effect.Read,
+      hookKind: "useReducer",
+      returnValueKind: exports.ValueKind.Frozen,
+      returnValueReason: ValueReason.ReducerState,
+    }),
+  ],
   [
     "useRef",
     addHook(DEFAULT_SHAPES, {
@@ -149921,9 +150141,11 @@ const HookSchema = z.object({
 });
 const EnvironmentConfigSchema = z.object({
   customHooks: z.map(z.string(), HookSchema).optional().default(new Map()),
+  customMacros: z.nullable(z.array(z.string())).default(null),
   enableResetCacheOnSourceFileChanges: z.boolean().default(false),
   enablePreserveExistingMemoizationGuarantees: z.boolean().default(false),
   validatePreserveExistingMemoizationGuarantees: z.boolean().default(true),
+  enablePreserveExistingManualUseMemo: z.boolean().default(false),
   enableForest: z.boolean().default(false),
   enableUseTypeAnnotations: z.boolean().default(false),
   enableReactiveScopesInHIR: z.boolean().default(true),
@@ -149936,6 +150158,7 @@ const EnvironmentConfigSchema = z.object({
   enableTransitivelyFreezeFunctionExpressions: z.boolean().default(true),
   enableEmitFreeze: ExternalFunctionSchema.nullish(),
   enableEmitHookGuards: ExternalFunctionSchema.nullish(),
+  enableInstructionReordering: z.boolean().default(false),
   enableEmitInstrumentForget: InstrumentationSchema.nullish(),
   assertValidMutableRanges: z.boolean().default(false),
   enableChangeVariableCodegen: z.boolean().default(false),
@@ -149943,8 +150166,11 @@ const EnvironmentConfigSchema = z.object({
   throwUnknownException__testonly: z.boolean().default(false),
   enableSharedRuntime__testonly: z.boolean().default(false),
   enableTreatFunctionDepsAsConditional: z.boolean().default(false),
+  disableMemoizationForDebugging: z.boolean().default(false),
+  enableChangeDetectionForDebugging: ExternalFunctionSchema.nullish(),
   enableCustomTypeDefinitionForReanimated: z.boolean().default(false),
   hookPattern: z.string().nullable().default(null),
+  enableTreatRefLikeIdentifiersAsRefs: z.boolean().nullable().default(false),
 });
 function parseConfigPragma(pragma) {
   const maybeConfig = {};
@@ -149959,6 +150185,16 @@ function parseConfigPragma(pragma) {
       maybeConfig[key] = [];
       continue;
     }
+    if (
+      key === "enableChangeDetectionForDebugging" &&
+      (val === undefined || val === "true")
+    ) {
+      maybeConfig[key] = {
+        source: "react-compiler-runtime",
+        importSpecifierName: "$structuralCheck",
+      };
+      continue;
+    }
     if (typeof defaultConfig[key] !== "boolean") {
       continue;
     }
@@ -150016,6 +150252,17 @@ class Environment {
       new Map(DEFAULT_GLOBALS),
       "f"
     );
+    if (
+      config.disableMemoizationForDebugging &&
+      config.enableChangeDetectionForDebugging != null
+    ) {
+      CompilerError.throwInvalidConfig({
+        reason: `Invalid environment config: the 'disableMemoizationForDebugging' and 'enableChangeDetectionForDebugging' options cannot be used together`,
+        description: null,
+        loc: null,
+        suggestions: null,
+      });
+    }
     for (const [hookName, hook] of this.config.customHooks) {
       CompilerError.invariant(
         !__classPrivateFieldGet(this, _Environment_globals, "f").has(hookName),
@@ -150629,6 +150876,12 @@ class ReactiveFunctionVisitor {
   traverseScope(scope, state) {
     this.visitBlock(scope.instructions, state);
   }
+  visitPrunedScope(scopeBlock, state) {
+    this.traversePrunedScope(scopeBlock, state);
+  }
+  traversePrunedScope(scopeBlock, state) {
+    this.visitBlock(scopeBlock.instructions, state);
+  }
   visitBlock(block, state) {
     this.traverseBlock(block, state);
   }
@@ -150643,6 +150896,10 @@ class ReactiveFunctionVisitor {
           this.visitScope(instr, state);
           break;
         }
+        case "pruned-scope": {
+          this.visitPrunedScope(instr, state);
+          break;
+        }
         case "terminal": {
           this.visitTerminal(instr, state);
           break;
@@ -150692,6 +150949,10 @@ class ReactiveFunctionTransform extends ReactiveFunctionVisitor {
           transformed = this.transformScope(instr, state);
           break;
         }
+        case "pruned-scope": {
+          transformed = this.transformPrunedScope(instr, state);
+          break;
+        }
         case "terminal": {
           transformed = this.transformTerminal(instr, state);
           break;
@@ -150749,6 +151010,10 @@ class ReactiveFunctionTransform extends ReactiveFunctionVisitor {
     this.visitScope(scope, state);
     return { kind: "keep" };
   }
+  transformPrunedScope(scope, state) {
+    this.visitPrunedScope(scope, state);
+    return { kind: "keep" };
+  }
   transformValue(id, value, state) {
     this.visitValue(id, value, state);
     return { kind: "keep" };
@@ -151189,6 +151454,7 @@ function visitBlock(context, block) {
         context.append(stmt, stmt.label);
         break;
       }
+      case "pruned-scope":
       case "scope": {
         CompilerError.invariant(false, {
           reason: "Expected the function to not have scopes already assigned",
@@ -153036,9 +153302,9 @@ function alignObjectMethodScopes(fn) {
 var _Context_blockScopes, _Context_unclosedScopes, _Context_seenScopes;
 function alignReactiveScopesToBlockScopes(fn) {
   const context = new Context$4();
-  visitReactiveFunction(fn, new Visitor$c(), context);
+  visitReactiveFunction(fn, new Visitor$d(), context);
 }
-let Visitor$c = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$d = class Visitor extends ReactiveFunctionVisitor {
   visitID(id, state) {
     state.visitId(id);
   }
@@ -153188,9 +153454,9 @@ class CheckInstructionsAgainstScopesVisitor extends ReactiveFunctionVisitor {
   }
 }
 function assertWellFormedBreakTargets(fn) {
-  visitReactiveFunction(fn, new Visitor$b(), new Set());
+  visitReactiveFunction(fn, new Visitor$c(), new Set());
 }
-let Visitor$b = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$c = class Visitor extends ReactiveFunctionVisitor {
   visitTerminal(stmt, seenLabels) {
     if (stmt.label != null) {
       seenLabels.add(stmt.label.id);
@@ -153895,6 +154161,7 @@ class Driver {
         }
         break;
       }
+      case "pruned-scope":
       case "scope": {
         const fallthroughId = !this.cx.isScheduled(terminal.fallthrough)
           ? terminal.fallthrough
@@ -153915,7 +154182,7 @@ class Driver {
         }
         this.cx.unscheduleAll(scheduleIds);
         blockValue.push({
-          kind: "scope",
+          kind: terminal.kind,
           instructions: block,
           scope: terminal.scope,
         });
@@ -154003,12 +154270,15 @@ class Driver {
         const instr = defaultBlock.instructions[0];
         let place = instr.lvalue;
         let value = instr.value;
-        if (instr.value.kind === "StoreLocal") {
-          place = instr.value.lvalue.place;
+        if (
+          value.kind === "StoreLocal" &&
+          value.lvalue.place.identifier.name === null
+        ) {
+          place = value.lvalue.place;
           value = {
             kind: "LoadLocal",
-            place: instr.value.value,
-            loc: instr.value.value.loc,
+            place: value.value,
+            loc: value.value.loc,
           };
         }
         return {
@@ -154021,12 +154291,15 @@ class Driver {
         const instr = defaultBlock.instructions.at(-1);
         let place = instr.lvalue;
         let value = instr.value;
-        if (instr.value.kind === "StoreLocal") {
-          place = instr.value.lvalue.place;
+        if (
+          value.kind === "StoreLocal" &&
+          value.lvalue.place.identifier.name === null
+        ) {
+          place = value.lvalue.place;
           value = {
             kind: "LoadLocal",
-            place: instr.value.value,
-            loc: instr.value.value.loc,
+            place: value.value,
+            loc: value.value.loc,
           };
         }
         const sequence = {
@@ -154494,11 +154767,16 @@ var GuardKind;
   GuardKind[(GuardKind["AllowHook"] = 2)] = "AllowHook";
   GuardKind[(GuardKind["DisallowHook"] = 3)] = "DisallowHook";
 })(GuardKind || (GuardKind = {}));
-function memoizeFbtOperandsInSameScope(fn) {
+function memoizeFbtAndMacroOperandsInSameScope(fn) {
+  var _a;
+  const fbtMacroTags = new Set([
+    ...FBT_TAGS,
+    ...((_a = fn.env.config.customMacros) !== null && _a !== void 0 ? _a : []),
+  ]);
   const fbtValues = new Set();
   while (true) {
     let size = fbtValues.size;
-    visit$1(fn, fbtValues);
+    visit$1(fn, fbtMacroTags, fbtValues);
     if (size === fbtValues.size) {
       break;
     }
@@ -154506,28 +154784,28 @@ function memoizeFbtOperandsInSameScope(fn) {
 }
 const FBT_TAGS = new Set(["fbt", "fbt:param", "fbs", "fbs:param"]);
 const SINGLE_CHILD_FBT_TAGS = new Set(["fbt:param", "fbs:param"]);
-function visit$1(fn, fbtValues) {
+function visit$1(fn, fbtMacroTags, fbtValues) {
   for (const [, block] of fn.body.blocks) {
     for (const instruction of block.instructions) {
       const { lvalue: lvalue, value: value } = instruction;
       if (lvalue === null) {
-        return;
+        continue;
       }
       if (
         value.kind === "Primitive" &&
         typeof value.value === "string" &&
-        FBT_TAGS.has(value.value)
+        fbtMacroTags.has(value.value)
       ) {
         fbtValues.add(lvalue.identifier.id);
       } else if (
         value.kind === "LoadGlobal" &&
-        FBT_TAGS.has(value.binding.name)
+        fbtMacroTags.has(value.binding.name)
       ) {
         fbtValues.add(lvalue.identifier.id);
       } else if (isFbtCallExpression(fbtValues, value)) {
         const fbtScope = lvalue.identifier.scope;
         if (fbtScope === null) {
-          return;
+          continue;
         }
         for (const operand of eachReactiveValueOperand(value)) {
           operand.identifier.scope = fbtScope;
@@ -154537,14 +154815,15 @@ function visit$1(fn, fbtValues) {
               operand.identifier.mutableRange.start
             )
           );
+          fbtValues.add(operand.identifier.id);
         }
       } else if (
-        isFbtJsxExpression(fbtValues, value) ||
+        isFbtJsxExpression(fbtMacroTags, fbtValues, value) ||
         isFbtJsxChild(fbtValues, lvalue, value)
       ) {
         const fbtScope = lvalue.identifier.scope;
         if (fbtScope === null) {
-          return;
+          continue;
         }
         for (const operand of eachReactiveValueOperand(value)) {
           operand.identifier.scope = fbtScope;
@@ -154556,6 +154835,26 @@ function visit$1(fn, fbtValues) {
           );
           fbtValues.add(operand.identifier.id);
         }
+      } else if (fbtValues.has(lvalue.identifier.id)) {
+        const fbtScope = lvalue.identifier.scope;
+        if (fbtScope === null) {
+          return;
+        }
+        for (const operand of eachReactiveValueOperand(value)) {
+          if (
+            operand.identifier.name !== null &&
+            operand.identifier.name.kind === "named"
+          ) {
+            continue;
+          }
+          operand.identifier.scope = fbtScope;
+          fbtScope.range.start = makeInstructionId(
+            Math.min(
+              fbtScope.range.start,
+              operand.identifier.mutableRange.start
+            )
+          );
+        }
       }
     }
   }
@@ -154565,12 +154864,12 @@ function isFbtCallExpression(fbtValues, value) {
     value.kind === "CallExpression" && fbtValues.has(value.callee.identifier.id)
   );
 }
-function isFbtJsxExpression(fbtValues, value) {
+function isFbtJsxExpression(fbtMacroTags, fbtValues, value) {
   return (
     value.kind === "JsxExpression" &&
     ((value.tag.kind === "Identifier" &&
       fbtValues.has(value.tag.identifier.id)) ||
-      (value.tag.kind === "BuiltinTag" && FBT_TAGS.has(value.tag.name)))
+      (value.tag.kind === "BuiltinTag" && fbtMacroTags.has(value.tag.name)))
   );
 }
 function isFbtJsxChild(fbtValues, lvalue, value) {
@@ -154591,13 +154890,13 @@ function codegenFunction(fn, uniqueIdentifiers) {
     uniqueIdentifiers,
     null
   );
-  let hotModuleReloadState = null;
+  let fastRefreshState = null;
   if (
     fn.env.config.enableResetCacheOnSourceFileChanges &&
     fn.env.code !== null
   ) {
     const hash = crypto$2.createHmac("sha256", fn.env.code).digest("hex");
-    hotModuleReloadState = { cacheIndex: cx.nextCacheIndex, hash: hash };
+    fastRefreshState = { cacheIndex: cx.nextCacheIndex, hash: hash };
   }
   const compileResult = codegenReactiveFunction(cx, fn);
   if (compileResult.isErr()) {
@@ -154629,7 +154928,7 @@ function codegenFunction(fn, uniqueIdentifiers) {
         ),
       ])
     );
-    if (hotModuleReloadState !== null) {
+    if (fastRefreshState !== null) {
       const index = cx.synthesizeName("$i");
       preface.push(
         t__namespace.ifStatement(
@@ -154637,10 +154936,10 @@ function codegenFunction(fn, uniqueIdentifiers) {
             "!==",
             t__namespace.memberExpression(
               t__namespace.identifier(cx.synthesizeName("$")),
-              t__namespace.numericLiteral(hotModuleReloadState.cacheIndex),
+              t__namespace.numericLiteral(fastRefreshState.cacheIndex),
               true
             ),
-            t__namespace.stringLiteral(hotModuleReloadState.hash)
+            t__namespace.stringLiteral(fastRefreshState.hash)
           ),
           t__namespace.blockStatement([
             t__namespace.forStatement(
@@ -154685,10 +154984,10 @@ function codegenFunction(fn, uniqueIdentifiers) {
                 "=",
                 t__namespace.memberExpression(
                   t__namespace.identifier(cx.synthesizeName("$")),
-                  t__namespace.numericLiteral(hotModuleReloadState.cacheIndex),
+                  t__namespace.numericLiteral(fastRefreshState.cacheIndex),
                   true
                 ),
-                t__namespace.stringLiteral(hotModuleReloadState.hash)
+                t__namespace.stringLiteral(fastRefreshState.hash)
               )
             ),
           ])
@@ -154763,7 +155062,7 @@ function codegenReactiveFunction(cx, fn) {
   if (cx.errors.hasErrors()) {
     return Err(cx.errors);
   }
-  const countMemoBlockVisitor = new CountMemoBlockVisitor();
+  const countMemoBlockVisitor = new CountMemoBlockVisitor(fn.env);
   visitReactiveFunction(fn, countMemoBlockVisitor, undefined);
   return Ok({
     type: "CodegenFunction",
@@ -154774,17 +155073,30 @@ function codegenReactiveFunction(cx, fn) {
     generator: fn.generator,
     async: fn.async,
     memoSlotsUsed: cx.nextCacheIndex,
-    memoBlocks: countMemoBlockVisitor.count,
+    memoBlocks: countMemoBlockVisitor.memoBlocks,
+    memoValues: countMemoBlockVisitor.memoValues,
+    prunedMemoBlocks: countMemoBlockVisitor.prunedMemoBlocks,
+    prunedMemoValues: countMemoBlockVisitor.prunedMemoValues,
   });
 }
 class CountMemoBlockVisitor extends ReactiveFunctionVisitor {
-  constructor() {
-    super(...arguments);
-    this.count = 0;
+  constructor(env) {
+    super();
+    this.memoBlocks = 0;
+    this.memoValues = 0;
+    this.prunedMemoBlocks = 0;
+    this.prunedMemoValues = 0;
+    this.env = env;
   }
-  visitScope(scope, state) {
-    this.count += 1;
-    this.traverseScope(scope, state);
+  visitScope(scopeBlock, state) {
+    this.memoBlocks += 1;
+    this.memoValues += scopeBlock.scope.declarations.size;
+    this.traverseScope(scopeBlock, state);
+  }
+  visitPrunedScope(scopeBlock, state) {
+    this.prunedMemoBlocks += 1;
+    this.prunedMemoValues += scopeBlock.scope.declarations.size;
+    this.traversePrunedScope(scopeBlock, state);
   }
 }
 function convertParameter(param) {
@@ -154875,6 +155187,11 @@ function codegenBlockNoReset(cx, block) {
         }
         break;
       }
+      case "pruned-scope": {
+        const scopeBlock = codegenBlockNoReset(cx, item.instructions);
+        statements.push(...scopeBlock.body);
+        break;
+      }
       case "scope": {
         const temp = new Map(cx.temp);
         codegenReactiveScope(cx, statements, item.scope, item.instructions);
@@ -154930,6 +155247,7 @@ function wrapCacheDep(cx, value) {
 function codegenReactiveScope(cx, statements, scope, block) {
   const cacheStoreStatements = [];
   const cacheLoadStatements = [];
+  const cacheLoads = [];
   const changeExpressions = [];
   const changeExpressionComments = [];
   const outputComments = [];
@@ -154979,8 +155297,8 @@ function codegenReactiveScope(cx, statements, scope, block) {
       firstOutputIndex = index;
     }
     CompilerError.invariant(identifier.name != null, {
-      reason: `Expected identifier '@${identifier.id}' to be named`,
-      description: null,
+      reason: `Expected scope declaration identifier to be named`,
+      description: `Declaration \`${printIdentifier(identifier)}\` is unnamed in scope @${scope.id}`,
       loc: null,
       suggestions: null,
     });
@@ -154993,32 +155311,11 @@ function codegenReactiveScope(cx, statements, scope, block) {
         ])
       );
     }
-    cacheStoreStatements.push(
-      t__namespace.expressionStatement(
-        t__namespace.assignmentExpression(
-          "=",
-          t__namespace.memberExpression(
-            t__namespace.identifier(cx.synthesizeName("$")),
-            t__namespace.numericLiteral(index),
-            true
-          ),
-          wrapCacheDep(cx, name)
-        )
-      )
-    );
-    cacheLoadStatements.push(
-      t__namespace.expressionStatement(
-        t__namespace.assignmentExpression(
-          "=",
-          name,
-          t__namespace.memberExpression(
-            t__namespace.identifier(cx.synthesizeName("$")),
-            t__namespace.numericLiteral(index),
-            true
-          )
-        )
-      )
-    );
+    cacheLoads.push({
+      name: name,
+      index: index,
+      value: wrapCacheDep(cx, name),
+    });
     cx.declare(identifier);
   }
   for (const reassignment of scope.reassignments) {
@@ -155028,32 +155325,11 @@ function codegenReactiveScope(cx, statements, scope, block) {
     }
     const name = convertIdentifier(reassignment);
     outputComments.push(name.name);
-    cacheStoreStatements.push(
-      t__namespace.expressionStatement(
-        t__namespace.assignmentExpression(
-          "=",
-          t__namespace.memberExpression(
-            t__namespace.identifier(cx.synthesizeName("$")),
-            t__namespace.numericLiteral(index),
-            true
-          ),
-          wrapCacheDep(cx, name)
-        )
-      )
-    );
-    cacheLoadStatements.push(
-      t__namespace.expressionStatement(
-        t__namespace.assignmentExpression(
-          "=",
-          name,
-          t__namespace.memberExpression(
-            t__namespace.identifier(cx.synthesizeName("$")),
-            t__namespace.numericLiteral(index),
-            true
-          )
-        )
-      )
-    );
+    cacheLoads.push({
+      name: name,
+      index: index,
+      value: wrapCacheDep(cx, name),
+    });
   }
   let testCondition = changeExpressions.reduce((acc, ident) => {
     if (acc == null) {
@@ -155084,14 +155360,153 @@ function codegenReactiveScope(cx, statements, scope, block) {
       )
     );
   }
+  if (cx.env.config.disableMemoizationForDebugging) {
+    CompilerError.invariant(
+      cx.env.config.enableChangeDetectionForDebugging == null,
+      {
+        reason: `Expected to not have both change detection enabled and memoization disabled`,
+        description: `Incompatible config options`,
+        loc: null,
+      }
+    );
+    testCondition = t__namespace.logicalExpression(
+      "||",
+      testCondition,
+      t__namespace.booleanLiteral(true)
+    );
+  }
   let computationBlock = codegenBlock(cx, block);
-  computationBlock.body.push(...cacheStoreStatements);
-  const memoBlock = t__namespace.blockStatement(cacheLoadStatements);
-  const memoStatement = t__namespace.ifStatement(
-    testCondition,
-    computationBlock,
-    memoBlock
-  );
+  let memoStatement;
+  if (
+    cx.env.config.enableChangeDetectionForDebugging != null &&
+    changeExpressions.length > 0
+  ) {
+    const loc =
+      typeof scope.loc === "symbol"
+        ? "unknown location"
+        : `(${scope.loc.start.line}:${scope.loc.end.line})`;
+    const detectionFunction =
+      cx.env.config.enableChangeDetectionForDebugging.importSpecifierName;
+    const cacheLoadOldValueStatements = [];
+    const changeDetectionStatements = [];
+    const idempotenceDetectionStatements = [];
+    for (const { name: name, index: index, value: value } of cacheLoads) {
+      const loadName = cx.synthesizeName(`old$${name.name}`);
+      const slot = t__namespace.memberExpression(
+        t__namespace.identifier(cx.synthesizeName("$")),
+        t__namespace.numericLiteral(index),
+        true
+      );
+      cacheStoreStatements.push(
+        t__namespace.expressionStatement(
+          t__namespace.assignmentExpression("=", slot, value)
+        )
+      );
+      cacheLoadOldValueStatements.push(
+        t__namespace.variableDeclaration("let", [
+          t__namespace.variableDeclarator(
+            t__namespace.identifier(loadName),
+            slot
+          ),
+        ])
+      );
+      changeDetectionStatements.push(
+        t__namespace.expressionStatement(
+          t__namespace.callExpression(
+            t__namespace.identifier(detectionFunction),
+            [
+              t__namespace.identifier(loadName),
+              name,
+              t__namespace.stringLiteral(name.name),
+              t__namespace.stringLiteral(cx.fnName),
+              t__namespace.stringLiteral("cached"),
+              t__namespace.stringLiteral(loc),
+            ]
+          )
+        )
+      );
+      idempotenceDetectionStatements.push(
+        t__namespace.expressionStatement(
+          t__namespace.callExpression(
+            t__namespace.identifier(detectionFunction),
+            [
+              slot,
+              name,
+              t__namespace.stringLiteral(name.name),
+              t__namespace.stringLiteral(cx.fnName),
+              t__namespace.stringLiteral("recomputed"),
+              t__namespace.stringLiteral(loc),
+            ]
+          )
+        )
+      );
+      idempotenceDetectionStatements.push(
+        t__namespace.expressionStatement(
+          t__namespace.assignmentExpression("=", name, slot)
+        )
+      );
+    }
+    const condition = cx.synthesizeName("condition");
+    memoStatement = t__namespace.blockStatement([
+      ...computationBlock.body,
+      t__namespace.variableDeclaration("let", [
+        t__namespace.variableDeclarator(
+          t__namespace.identifier(condition),
+          testCondition
+        ),
+      ]),
+      t__namespace.ifStatement(
+        t__namespace.unaryExpression("!", t__namespace.identifier(condition)),
+        t__namespace.blockStatement([
+          ...cacheLoadOldValueStatements,
+          ...changeDetectionStatements,
+        ])
+      ),
+      ...cacheStoreStatements,
+      t__namespace.ifStatement(
+        t__namespace.identifier(condition),
+        t__namespace.blockStatement([
+          ...computationBlock.body,
+          ...idempotenceDetectionStatements,
+        ])
+      ),
+    ]);
+  } else {
+    for (const { name: name, index: index, value: value } of cacheLoads) {
+      cacheStoreStatements.push(
+        t__namespace.expressionStatement(
+          t__namespace.assignmentExpression(
+            "=",
+            t__namespace.memberExpression(
+              t__namespace.identifier(cx.synthesizeName("$")),
+              t__namespace.numericLiteral(index),
+              true
+            ),
+            value
+          )
+        )
+      );
+      cacheLoadStatements.push(
+        t__namespace.expressionStatement(
+          t__namespace.assignmentExpression(
+            "=",
+            name,
+            t__namespace.memberExpression(
+              t__namespace.identifier(cx.synthesizeName("$")),
+              t__namespace.numericLiteral(index),
+              true
+            )
+          )
+        )
+      );
+    }
+    computationBlock.body.push(...cacheStoreStatements);
+    memoStatement = t__namespace.ifStatement(
+      testCondition,
+      computationBlock,
+      t__namespace.blockStatement(cacheLoadStatements)
+    );
+  }
   if (cx.env.config.enableMemoizationComments) {
     if (changeExpressionComments.length) {
       t__namespace.addComment(
@@ -155128,9 +155543,9 @@ function codegenReactiveScope(cx, statements, scope, block) {
         true
       );
     }
-    if (memoBlock.body.length > 0) {
+    if (cacheLoadStatements.length > 0) {
       t__namespace.addComment(
-        memoBlock.body[0],
+        cacheLoadStatements[0],
         "leading",
         ` Inputs did not change, use cached value`,
         true
@@ -156328,6 +156743,13 @@ function codegenInstructionValue(cx, instrValue) {
       value = t__namespace.regExpLiteral(instrValue.pattern, instrValue.flags);
       break;
     }
+    case "MetaProperty": {
+      value = t__namespace.metaProperty(
+        t__namespace.identifier(instrValue.meta),
+        t__namespace.identifier(instrValue.property)
+      );
+      break;
+    }
     case "Await": {
       value = t__namespace.awaitExpression(
         codegenPlaceToExpression(cx, instrValue.value)
@@ -156412,7 +156834,8 @@ function codegenInstructionValue(cx, instrValue) {
   }
   return value;
 }
-const STRING_REQUIRES_EXPR_CONTAINER_PATTERN = /[\u{0080}-\u{FFFF}]|"/u;
+const STRING_REQUIRES_EXPR_CONTAINER_PATTERN =
+  /[\u{0000}-\u{001F}|\u{007F}|\u{0080}-\u{FFFF}]|"/u;
 function codegenJsxAttribute(cx, attribute) {
   switch (attribute.kind) {
     case "JsxAttribute": {
@@ -156651,7 +157074,7 @@ function convertIdentifier(identifier) {
 }
 function extractScopeDeclarationsFromDestructuring(fn) {
   const state = new State$2(fn.env);
-  visitReactiveFunction(fn, new Visitor$a(), state);
+  visitReactiveFunction(fn, new Visitor$b(), state);
 }
 let State$2 = class State {
   constructor(env) {
@@ -156659,7 +157082,7 @@ let State$2 = class State {
     this.env = env;
   }
 };
-let Visitor$a = class Visitor extends ReactiveFunctionTransform {
+let Visitor$b = class Visitor extends ReactiveFunctionTransform {
   visitScope(scope, state) {
     for (const [, declaration] of scope.scope.declarations) {
       state.declared.add(declaration.identifier.id);
@@ -156741,7 +157164,14 @@ let Transform$6 = class Transform extends ReactiveFunctionTransform {
   transformScope(scope, isWithinLoop) {
     this.visitScope(scope, isWithinLoop);
     if (isWithinLoop) {
-      return { kind: "replace-many", value: scope.instructions };
+      return {
+        kind: "replace",
+        value: {
+          kind: "pruned-scope",
+          scope: scope.scope,
+          instructions: scope.instructions,
+        },
+      };
     } else {
       return { kind: "keep" };
     }
@@ -156785,7 +157215,17 @@ let Transform$5 = class Transform extends ReactiveFunctionTransform {
     this.visitScope(scope, innerState);
     outerState.hasHook || (outerState.hasHook = innerState.hasHook);
     if (innerState.hasHook) {
-      return { kind: "replace-many", value: scope.instructions };
+      if (scope.instructions.length === 1) {
+        return { kind: "replace-many", value: scope.instructions };
+      }
+      return {
+        kind: "replace",
+        value: {
+          kind: "pruned-scope",
+          scope: scope.scope,
+          instructions: scope.instructions,
+        },
+      };
     } else {
       return { kind: "keep" };
     }
@@ -156816,10 +157256,10 @@ let Transform$5 = class Transform extends ReactiveFunctionTransform {
 };
 function mergeOverlappingReactiveScopes(fn) {
   const context = new Context$1();
-  visitReactiveFunction(fn, new Visitor$9(), context);
+  visitReactiveFunction(fn, new Visitor$a(), context);
   context.complete();
 }
-let Visitor$9 = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$a = class Visitor extends ReactiveFunctionVisitor {
   visitID(id, state) {
     state.visitId(id);
   }
@@ -157011,13 +157451,26 @@ let Transform$4 = class Transform extends ReactiveFunctionTransform {
           }
           break;
         }
+        case "pruned-scope": {
+          if (current !== null) {
+            log$1(
+              `Reset scope @${current.block.scope.id} from pruned scope @${instr.scope.id}`
+            );
+            reset();
+          }
+          break;
+        }
         case "instruction": {
           switch (instr.instruction.value.kind) {
+            case "BinaryExpression":
             case "ComputedLoad":
             case "JSXText":
+            case "LoadGlobal":
             case "LoadLocal":
             case "Primitive":
-            case "PropertyLoad": {
+            case "PropertyLoad":
+            case "TemplateLiteral":
+            case "UnaryExpression": {
               if (current !== null && instr.instruction.lvalue !== null) {
                 current.lvalues.add(instr.instruction.lvalue.identifier.id);
               }
@@ -157258,21 +157711,36 @@ function scopeIsEligibleForMerging(scopeBlock) {
     isAlwaysInvalidatingType(decl.identifier.type)
   );
 }
-let Visitor$8 = class Visitor extends ReactiveFunctionVisitor {
-  visitScope(block, state) {
-    this.traverseScope(block, state);
-    for (const dep of block.scope.dependencies) {
+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) {
         promoteIdentifier(identifier, state);
       }
     }
-    for (const [, declaration] of block.scope.declarations) {
+    for (const [, declaration] of scopeBlock.scope.declarations) {
       if (declaration.identifier.name == null) {
         promoteIdentifier(declaration.identifier, 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
+          ? void 0
+          : _a.usedOutsideScope) === true
+      ) {
+        promoteIdentifier(declaration.identifier, state);
+      }
+    }
+  }
   visitParam(place, state) {
     if (place.identifier.name === null) {
       promoteIdentifier(place.identifier, state);
@@ -157294,25 +157762,52 @@ let Visitor$8 = class Visitor extends ReactiveFunctionVisitor {
     visitReactiveFunction(fn, this, state);
   }
 };
-class CollectJsxTagsVisitor extends ReactiveFunctionVisitor {
+class CollectPromotableTemporaries extends ReactiveFunctionVisitor {
+  constructor() {
+    super(...arguments);
+    this.activeScopes = [];
+  }
+  visitPlace(_id, place, state) {
+    if (
+      this.activeScopes.length !== 0 &&
+      state.pruned.has(place.identifier.id)
+    ) {
+      const prunedPlace = state.pruned.get(place.identifier.id);
+      if (prunedPlace.activeScopes.indexOf(this.activeScopes.at(-1)) === -1) {
+        prunedPlace.usedOutsideScope = true;
+      }
+    }
+  }
   visitValue(id, value, state) {
     this.traverseValue(id, value, state);
     if (value.kind === "JsxExpression" && value.tag.kind === "Identifier") {
-      state.add(value.tag.identifier.id);
+      state.tags.add(value.tag.identifier.id);
+    }
+  }
+  visitPrunedScope(scopeBlock, state) {
+    for (const [id] of scopeBlock.scope.declarations) {
+      state.pruned.set(id, {
+        activeScopes: [...this.activeScopes],
+        usedOutsideScope: false,
+      });
     }
   }
+  visitScope(scopeBlock, state) {
+    this.activeScopes.push(scopeBlock.scope.id);
+    this.traverseScope(scopeBlock, state);
+    this.activeScopes.pop();
+  }
 }
 function promoteUsedTemporaries(fn) {
-  const tags = new Set();
-  visitReactiveFunction(fn, new CollectJsxTagsVisitor(), tags);
-  const state = { tags: tags };
+  const state = { tags: new Set(), pruned: new Map() };
+  visitReactiveFunction(fn, new CollectPromotableTemporaries(), state);
   for (const operand of fn.params) {
     const place = operand.kind === "Identifier" ? operand : operand.place;
     if (place.identifier.name === null) {
       promoteIdentifier(place.identifier, state);
     }
   }
-  visitReactiveFunction(fn, new Visitor$8(), state);
+  visitReactiveFunction(fn, new Visitor$9(), state);
 }
 function promoteIdentifier(identifier, state) {
   CompilerError.invariant(identifier.name === null, {
@@ -157355,10 +157850,10 @@ let Transform$3 = class Transform extends ReactiveFunctionTransform {
         });
         const instructions = scopeBlock.instructions;
         const loc = earlyReturnValue.loc;
-        const sentinelTemp = createTemporaryPlace(this.env);
-        const symbolTemp = createTemporaryPlace(this.env);
-        const forTemp = createTemporaryPlace(this.env);
-        const argTemp = createTemporaryPlace(this.env);
+        const sentinelTemp = createTemporaryPlace(this.env, loc);
+        const symbolTemp = createTemporaryPlace(this.env, loc);
+        const forTemp = createTemporaryPlace(this.env, loc);
+        const argTemp = createTemporaryPlace(this.env, loc);
         scopeBlock.instructions = [
           {
             kind: "instruction",
@@ -157462,7 +157957,7 @@ let Transform$3 = class Transform extends ReactiveFunctionTransform {
       if (state.earlyReturnValue !== null) {
         earlyReturnValue = state.earlyReturnValue;
       } else {
-        const identifier = createTemporaryPlace(this.env).identifier;
+        const identifier = createTemporaryPlace(this.env, loc).identifier;
         promoteTemporary(identifier);
         earlyReturnValue = {
           label: this.env.nextBlockId,
@@ -158592,6 +159087,11 @@ class PropagationVisitor extends ReactiveFunctionVisitor {
     });
     scope.scope.dependencies = scopeDependencies;
   }
+  visitPrunedScope(scopeBlock, context) {
+    context.enter(scopeBlock.scope, () => {
+      this.visitBlock(scopeBlock.instructions, context);
+    });
+  }
   visitInstruction(instruction, context) {
     const { id: id, value: value, lvalue: lvalue } = instruction;
     this.visitInstructionValue(context, id, value, lvalue);
@@ -158888,9 +159388,9 @@ class PropagationVisitor extends ReactiveFunctionVisitor {
 }
 function pruneHoistedContexts(fn) {
   const hoistedIdentifiers = new Set();
-  visitReactiveFunction(fn, new Visitor$7(), hoistedIdentifiers);
+  visitReactiveFunction(fn, new Visitor$8(), hoistedIdentifiers);
 }
-let Visitor$7 = class Visitor extends ReactiveFunctionTransform {
+let Visitor$8 = class Visitor extends ReactiveFunctionTransform {
   transformInstruction(instruction, state) {
     this.visitInstruction(instruction, state);
     if (
@@ -158926,12 +159426,12 @@ let Visitor$7 = class Visitor extends ReactiveFunctionTransform {
 };
 function validateMemoizedEffectDependencies(fn) {
   const errors = new CompilerError();
-  visitReactiveFunction(fn, new Visitor$6(), errors);
+  visitReactiveFunction(fn, new Visitor$7(), errors);
   if (errors.hasErrors()) {
     throw errors;
   }
 }
-let Visitor$6 = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$7 = class Visitor extends ReactiveFunctionVisitor {
   constructor() {
     super(...arguments);
     this.scopes = new Set();
@@ -159067,7 +159567,9 @@ function inferReferenceEffects(fn, options = { isFunctionExpression: false }) {
     let queuedState = queuedStates.get(blockId);
     if (queuedState != null) {
       state =
-        (_a = queuedState.merge(state)) !== null && _a !== void 0 ? _a : state;
+        (_a = queuedState.merge(state)) !== null && _a !== void 0
+          ? _a
+          : queuedState;
       queuedStates.set(blockId, state);
     } else {
       const prevState = statesByBlock.get(blockId);
@@ -159352,7 +159854,8 @@ class InferenceState {
         break;
       }
       case exports.Effect.Mutate: {
-        if (valueKind.kind === exports.ValueKind.Context) {
+        if (isRefValueType(place.identifier) || isUseRefType(place.identifier));
+        else if (valueKind.kind === exports.ValueKind.Context) {
           functionEffect = {
             kind: "ContextMutation",
             loc: place.loc,
@@ -159390,7 +159893,8 @@ class InferenceState {
         break;
       }
       case exports.Effect.Store: {
-        if (valueKind.kind === exports.ValueKind.Context) {
+        if (isRefValueType(place.identifier) || isUseRefType(place.identifier));
+        else if (valueKind.kind === exports.ValueKind.Context) {
           functionEffect = {
             kind: "ContextMutation",
             loc: place.loc,
@@ -159608,7 +160112,7 @@ class InferenceState {
       _InferenceState_variables,
       "f"
     )) {
-      result.variables[variable] = [...values].map(identify);
+      result.variables[`$${variable}`] = [...values].map(identify);
     }
     return result;
   }
@@ -159857,16 +160361,55 @@ function inferBlock(env, functionEffects, state, block) {
         break;
       }
       case "JsxExpression": {
-        valueKind = {
+        if (instrValue.tag.kind === "Identifier") {
+          state.referenceAndRecordEffects(
+            instrValue.tag,
+            exports.Effect.Freeze,
+            ValueReason.JsxCaptured,
+            functionEffects
+          );
+        }
+        if (instrValue.children !== null) {
+          for (const child of instrValue.children) {
+            state.referenceAndRecordEffects(
+              child,
+              exports.Effect.Freeze,
+              ValueReason.JsxCaptured,
+              functionEffects
+            );
+          }
+        }
+        for (const attr of instrValue.props) {
+          if (attr.kind === "JsxSpreadAttribute") {
+            state.referenceAndRecordEffects(
+              attr.argument,
+              exports.Effect.Freeze,
+              ValueReason.JsxCaptured,
+              functionEffects
+            );
+          } else {
+            const propEffects = [];
+            state.referenceAndRecordEffects(
+              attr.place,
+              exports.Effect.Freeze,
+              ValueReason.JsxCaptured,
+              propEffects
+            );
+            functionEffects.push(
+              ...propEffects.filter(
+                (propEffect) => propEffect.kind !== "GlobalMutation"
+              )
+            );
+          }
+        }
+        state.initialize(instrValue, {
           kind: exports.ValueKind.Frozen,
           reason: new Set([ValueReason.Other]),
           context: new Set(),
-        };
-        effect = {
-          kind: exports.Effect.Freeze,
-          reason: ValueReason.JsxCaptured,
-        };
-        break;
+        });
+        state.define(instr.lvalue, instrValue);
+        instr.lvalue.effect = exports.Effect.ConditionallyMutate;
+        continue;
       }
       case "JsxFragment": {
         valueKind = {
@@ -159910,6 +160453,17 @@ function inferBlock(env, functionEffects, state, block) {
         };
         break;
       }
+      case "MetaProperty": {
+        if (instrValue.meta !== "import" || instrValue.property !== "meta") {
+          continue;
+        }
+        valueKind = {
+          kind: exports.ValueKind.Global,
+          reason: new Set([ValueReason.Global]),
+          context: new Set(),
+        };
+        break;
+      }
       case "LoadGlobal":
         valueKind = {
           kind: exports.ValueKind.Global,
@@ -160662,6 +161216,8 @@ function getWriteErrorReason(abstractValue) {
     return "Mutating component props or hook arguments is not allowed. Consider using a local variable instead";
   } else if (abstractValue.reason.has(ValueReason.State)) {
     return "Mutating a value returned from 'useState()', which should not be mutated. Use the setter function to update instead";
+  } else if (abstractValue.reason.has(ValueReason.ReducerState)) {
+    return "Mutating a value returned from 'useReducer()', which should not be mutated. Use the dispatch function to update instead";
   } else {
     return "This mutates a variable that React considers immutable";
   }
@@ -160880,6 +161436,7 @@ function computeMemoizationInputs(env, value, lvalue, options) {
     case "ComputedDelete":
     case "PropertyDelete":
     case "LoadGlobal":
+    case "MetaProperty":
     case "TemplateLiteral":
     case "Primitive":
     case "JSXText":
@@ -161285,7 +161842,7 @@ class PruneScopesTransform extends ReactiveFunctionTransform {
     return { kind: "keep" };
   }
 }
-let Visitor$5 = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$6 = class Visitor extends ReactiveFunctionVisitor {
   visitLValue(id, lvalue, state) {
     this.visitPlace(id, lvalue, state);
   }
@@ -161294,18 +161851,26 @@ let Visitor$5 = class Visitor extends ReactiveFunctionVisitor {
       state.add(place.identifier.id);
     }
   }
+  visitPrunedScope(scopeBlock, state) {
+    this.traversePrunedScope(scopeBlock, state);
+    for (const [id, decl] of scopeBlock.scope.declarations) {
+      if (!isPrimitiveType(decl.identifier)) {
+        state.add(id);
+      }
+    }
+  }
 };
 function collectReactiveIdentifiers(fn) {
-  const visitor = new Visitor$5();
+  const visitor = new Visitor$6();
   const state = new Set();
   visitReactiveFunction(fn, visitor, state);
   return state;
 }
 function pruneNonReactiveDependencies(fn) {
   const reactiveIdentifiers = collectReactiveIdentifiers(fn);
-  visitReactiveFunction(fn, new Visitor$4(), reactiveIdentifiers);
+  visitReactiveFunction(fn, new Visitor$5(), reactiveIdentifiers);
 }
-let Visitor$4 = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$5 = class Visitor extends ReactiveFunctionVisitor {
   visitInstruction(instruction, state) {
     this.traverseInstruction(instruction, state);
     const { lvalue: lvalue, value: value } = instruction;
@@ -161328,7 +161893,7 @@ let Visitor$4 = class Visitor extends ReactiveFunctionVisitor {
       case "Destructure": {
         if (state.has(value.value.identifier.id)) {
           for (const lvalue of eachPatternOperand(value.lvalue.pattern)) {
-            if (isSetStateType(lvalue.identifier)) {
+            if (isStableType(lvalue.identifier)) {
               continue;
             }
             state.add(lvalue.identifier.id);
@@ -161343,7 +161908,7 @@ let Visitor$4 = class Visitor extends ReactiveFunctionVisitor {
         if (
           lvalue !== null &&
           state.has(value.object.identifier.id) &&
-          !isSetStateType(lvalue.identifier)
+          !isStableType(lvalue.identifier)
         ) {
           state.add(lvalue.identifier.id);
         }
@@ -161381,12 +161946,12 @@ let Visitor$4 = class Visitor extends ReactiveFunctionVisitor {
 };
 function pruneTemporaryLValues(fn) {
   const lvalues = new Map();
-  visitReactiveFunction(fn, new Visitor$3(), lvalues);
+  visitReactiveFunction(fn, new Visitor$4(), lvalues);
   for (const [, instr] of lvalues) {
     instr.lvalue = null;
   }
 }
-let Visitor$3 = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$4 = class Visitor extends ReactiveFunctionVisitor {
   visitPlace(id, place, state) {
     state.delete(place.identifier);
   }
@@ -161454,7 +162019,14 @@ let Transform$1 = class Transform extends ReactiveFunctionTransform {
       (scopeBlock.scope.declarations.size === 0 ||
         !hasOwnDeclaration(scopeBlock))
     ) {
-      return { kind: "replace-many", value: scopeBlock.instructions };
+      return {
+        kind: "replace",
+        value: {
+          kind: "pruned-scope",
+          scope: scopeBlock.scope,
+          instructions: scopeBlock.instructions,
+        },
+      };
     } else {
       return { kind: "keep" };
     }
@@ -161470,10 +162042,10 @@ function hasOwnDeclaration(block) {
 }
 function collectReferencedGlobals(fn) {
   const identifiers = new Set();
-  visitReactiveFunction(fn, new Visitor$2(), identifiers);
+  visitReactiveFunction(fn, new Visitor$3(), identifiers);
   return identifiers;
 }
-let Visitor$2 = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$3 = class Visitor extends ReactiveFunctionVisitor {
   visitValue(id, value, state) {
     this.traverseValue(id, value, state);
     if (value.kind === "FunctionExpression" || value.kind === "ObjectMethod") {
@@ -161494,7 +162066,7 @@ var _Scopes_instances,
 function renameVariables(fn) {
   const globals = collectReferencedGlobals(fn);
   const scopes = new Scopes(globals);
-  renameVariablesImpl(fn, new Visitor$1(), scopes);
+  renameVariablesImpl(fn, new Visitor$2(), scopes);
   return new Set([...scopes.names, ...globals]);
 }
 function renameVariablesImpl(fn, visitor, scopes) {
@@ -161509,7 +162081,7 @@ function renameVariablesImpl(fn, visitor, scopes) {
     visitReactiveFunction(fn, visitor, scopes);
   });
 }
-let Visitor$1 = class Visitor extends ReactiveFunctionVisitor {
+let Visitor$2 = class Visitor extends ReactiveFunctionVisitor {
   visitParam(place, state) {
     state.visit(place.identifier);
   }
@@ -161524,6 +162096,9 @@ let Visitor$1 = class Visitor extends ReactiveFunctionVisitor {
       this.traverseBlock(block, state);
     });
   }
+  visitPrunedScope(scopeBlock, state) {
+    this.traverseBlock(scopeBlock.instructions, state);
+  }
   visitScope(scope, state) {
     for (const [_, declaration] of scope.scope.declarations) {
       state.visit(declaration.identifier);
@@ -161699,6 +162274,7 @@ function inferReactiveScopeVariables(fn) {
         reassignments: new Set(),
         earlyReturnValue: null,
         merged: new Set(),
+        loc: identifier.loc,
       };
       scopes.set(groupIdentifier, scope);
     } else {
@@ -161708,6 +162284,7 @@ function inferReactiveScopeVariables(fn) {
       scope.range.end = makeInstructionId(
         Math.max(scope.range.end, identifier.mutableRange.end)
       );
+      scope.loc = mergeLocation(scope.loc, identifier.loc);
     }
     identifier.scope = scope;
     identifier.mutableRange = scope.range;
@@ -161736,6 +162313,24 @@ function inferReactiveScopeVariables(fn) {
     }
   }
 }
+function mergeLocation(l, r) {
+  if (l === GeneratedSource) {
+    return r;
+  } else if (r === GeneratedSource) {
+    return l;
+  } else {
+    return {
+      start: {
+        line: Math.min(l.start.line, r.start.line),
+        column: Math.min(l.start.column, r.start.column),
+      },
+      end: {
+        line: Math.max(l.end.line, r.end.line),
+        column: Math.max(l.end.column, r.end.column),
+      },
+    };
+  }
+}
 function isMutable({ id: id }, place) {
   const range = place.identifier.mutableRange;
   return id >= range.start && id < range.end;
@@ -161753,6 +162348,7 @@ function mayAllocate(env, instruction) {
     case "DeclareContext":
     case "StoreLocal":
     case "LoadGlobal":
+    case "MetaProperty":
     case "TypeCastExpression":
     case "LoadLocal":
     case "LoadContext":
@@ -162205,7 +162801,7 @@ function addMemoCacheFunctionImportDeclaration(program, moduleName, localName) {
   );
 }
 z.enum(["all_errors", "critical_errors", "none"]);
-z.enum(["infer", "annotation", "all"]);
+z.enum(["infer", "syntax", "annotation", "all"]);
 const defaultOptions = {
   compilationMode: "infer",
   panicThreshold: "none",
@@ -162218,6 +162814,7 @@ const defaultOptions = {
   flowSuppressions: false,
   ignoreUseNoForget: false,
   sources: (filename) => filename.indexOf("node_modules") === -1,
+  enableReanimatedCheck: true,
 };
 function parsePluginOptions(obj) {
   if (obj == null || typeof obj !== "object") {
@@ -162537,6 +163134,7 @@ class SSABuilder {
       mutableRange: { start: makeInstructionId(0), end: makeInstructionId(0) },
       scope: null,
       type: makeType(),
+      loc: oldId.loc,
     };
   }
   defineContext(oldPlace) {
@@ -163270,6 +163868,25 @@ function evaluateInstruction(env, constants, instr) {
       }
       return null;
     }
+    case "UnaryExpression": {
+      switch (value.operator) {
+        case "!": {
+          const operand = read(constants, value.value);
+          if (operand !== null && operand.kind === "Primitive") {
+            const result = {
+              kind: "Primitive",
+              value: !operand.value,
+              loc: value.loc,
+            };
+            instr.value = result;
+            return result;
+          }
+          return null;
+        }
+        default:
+          return null;
+      }
+    }
     case "BinaryExpression": {
       const lhsValue = read(constants, value.left);
       const rhsValue = read(constants, value.right);
@@ -163309,44 +163926,100 @@ function evaluateInstruction(env, constants, instr) {
             }
             break;
           }
-          case "<": {
+          case "|": {
             if (typeof lhs === "number" && typeof rhs === "number") {
-              result = { kind: "Primitive", value: lhs < rhs, loc: value.loc };
+              result = { kind: "Primitive", value: lhs | rhs, loc: value.loc };
             }
             break;
           }
-          case "<=": {
+          case "&": {
             if (typeof lhs === "number" && typeof rhs === "number") {
-              result = { kind: "Primitive", value: lhs <= rhs, loc: value.loc };
+              result = { kind: "Primitive", value: lhs & rhs, loc: value.loc };
             }
             break;
           }
-          case ">": {
+          case "^": {
             if (typeof lhs === "number" && typeof rhs === "number") {
-              result = { kind: "Primitive", value: lhs > rhs, loc: value.loc };
+              result = { kind: "Primitive", value: lhs ^ rhs, loc: value.loc };
             }
             break;
           }
-          case ">=": {
+          case "<<": {
             if (typeof lhs === "number" && typeof rhs === "number") {
-              result = { kind: "Primitive", value: lhs >= rhs, loc: value.loc };
+              result = { kind: "Primitive", value: lhs << rhs, loc: value.loc };
             }
             break;
           }
-          case "==": {
-            result = { kind: "Primitive", value: lhs == rhs, loc: value.loc };
-            break;
-          }
-          case "===": {
-            result = { kind: "Primitive", value: lhs === rhs, loc: value.loc };
+          case ">>": {
+            if (typeof lhs === "number" && typeof rhs === "number") {
+              result = { kind: "Primitive", value: lhs >> rhs, loc: value.loc };
+            }
             break;
           }
-          case "!=": {
-            result = { kind: "Primitive", value: lhs != rhs, loc: value.loc };
+          case ">>>": {
+            if (typeof lhs === "number" && typeof rhs === "number") {
+              result = {
+                kind: "Primitive",
+                value: lhs >>> rhs,
+                loc: value.loc,
+              };
+            }
             break;
           }
-          case "!==": {
-            result = { kind: "Primitive", value: lhs !== rhs, loc: value.loc };
+          case "%": {
+            if (typeof lhs === "number" && typeof rhs === "number") {
+              result = { kind: "Primitive", value: lhs % rhs, loc: value.loc };
+            }
+            break;
+          }
+          case "**": {
+            if (typeof lhs === "number" && typeof rhs === "number") {
+              result = {
+                kind: "Primitive",
+                value: Math.pow(lhs, rhs),
+                loc: value.loc,
+              };
+            }
+            break;
+          }
+          case "<": {
+            if (typeof lhs === "number" && typeof rhs === "number") {
+              result = { kind: "Primitive", value: lhs < rhs, loc: value.loc };
+            }
+            break;
+          }
+          case "<=": {
+            if (typeof lhs === "number" && typeof rhs === "number") {
+              result = { kind: "Primitive", value: lhs <= rhs, loc: value.loc };
+            }
+            break;
+          }
+          case ">": {
+            if (typeof lhs === "number" && typeof rhs === "number") {
+              result = { kind: "Primitive", value: lhs > rhs, loc: value.loc };
+            }
+            break;
+          }
+          case ">=": {
+            if (typeof lhs === "number" && typeof rhs === "number") {
+              result = { kind: "Primitive", value: lhs >= rhs, loc: value.loc };
+            }
+            break;
+          }
+          case "==": {
+            result = { kind: "Primitive", value: lhs == rhs, loc: value.loc };
+            break;
+          }
+          case "===": {
+            result = { kind: "Primitive", value: lhs === rhs, loc: value.loc };
+            break;
+          }
+          case "!=": {
+            result = { kind: "Primitive", value: lhs != rhs, loc: value.loc };
+            break;
+          }
+          case "!==": {
+            result = { kind: "Primitive", value: lhs !== rhs, loc: value.loc };
             break;
           }
         }
@@ -163633,6 +164306,7 @@ function pruneableValue(value, state) {
       return false;
     }
     case "RegExpLiteral":
+    case "MetaProperty":
     case "LoadGlobal":
     case "ArrayExpression":
     case "BinaryExpression":
@@ -164285,7 +164959,7 @@ function makeManualMemoizationMarkers(
   return [
     {
       id: makeInstructionId(0),
-      lvalue: createTemporaryPlace(env),
+      lvalue: createTemporaryPlace(env, fnExpr.loc),
       value: {
         kind: "StartMemoize",
         manualMemoId: manualMemoId,
@@ -164296,7 +164970,7 @@ function makeManualMemoizationMarkers(
     },
     {
       id: makeInstructionId(0),
-      lvalue: createTemporaryPlace(env),
+      lvalue: createTemporaryPlace(env, fnExpr.loc),
       value: {
         kind: "FinishMemoize",
         manualMemoId: manualMemoId,
@@ -164559,7 +165233,7 @@ function inferReactivePlaces(fn) {
         }
         if (hasReactiveInput) {
           for (const lvalue of eachInstructionLValue(instruction)) {
-            if (isSetStateType(lvalue.identifier)) {
+            if (isStableType(lvalue.identifier)) {
               continue;
             }
             reactiveIdentifiers.markReactive(lvalue);
@@ -164819,6 +165493,7 @@ function rewriteBlock(env, block, returnTarget, returnValue) {
         name: null,
         scope: null,
         type: makeType(),
+        loc: terminal.loc,
       },
       kind: "Identifier",
       reactive: false,
@@ -164858,6 +165533,7 @@ function declareTemporary(env, block, result) {
         name: null,
         scope: null,
         type: makeType(),
+        loc: result.loc,
       },
       kind: "Identifier",
       reactive: false,
@@ -164871,6 +165547,268 @@ function declareTemporary(env, block, result) {
     },
   });
 }
+function instructionReordering(fn) {
+  var _a;
+  const shared = new Map();
+  const references = findReferencedRangeOfTemporaries(fn);
+  for (const [, block] of fn.body.blocks) {
+    reorderBlock(fn.env, block, shared, references);
+  }
+  CompilerError.invariant(shared.size === 0, {
+    reason: `InstructionReordering: expected all reorderable nodes to have been emitted`,
+    loc:
+      (_a = [...shared.values()]
+        .map((node) => {
+          var _a;
+          return (_a = node.instruction) === null || _a === void 0
+            ? void 0
+            : _a.loc;
+        })
+        .filter((loc) => loc != null)[0]) !== null && _a !== void 0
+        ? _a
+        : GeneratedSource,
+  });
+  markInstructionIds(fn.body);
+}
+var ReferenceKind;
+(function (ReferenceKind) {
+  ReferenceKind[(ReferenceKind["Read"] = 0)] = "Read";
+  ReferenceKind[(ReferenceKind["Write"] = 1)] = "Write";
+})(ReferenceKind || (ReferenceKind = {}));
+function findReferencedRangeOfTemporaries(fn) {
+  const singleUseIdentifiers = new Map();
+  const lastAssignments = new Map();
+  function reference(instr, place, kind) {
+    var _a;
+    if (
+      place.identifier.name !== null &&
+      place.identifier.name.kind === "named"
+    ) {
+      if (kind === ReferenceKind.Write) {
+        const name = place.identifier.name.value;
+        const previous = lastAssignments.get(name);
+        if (previous === undefined) {
+          lastAssignments.set(name, instr);
+        } else {
+          lastAssignments.set(
+            name,
+            makeInstructionId(Math.max(previous, instr))
+          );
+        }
+      }
+      return;
+    } else if (kind === ReferenceKind.Read) {
+      const previousCount =
+        (_a = singleUseIdentifiers.get(place.identifier.id)) !== null &&
+        _a !== void 0
+          ? _a
+          : 0;
+      singleUseIdentifiers.set(place.identifier.id, previousCount + 1);
+    }
+  }
+  for (const [, block] of fn.body.blocks) {
+    for (const instr of block.instructions) {
+      for (const operand of eachInstructionValueLValue(instr.value)) {
+        reference(instr.id, operand, ReferenceKind.Read);
+      }
+      for (const lvalue of eachInstructionLValue(instr)) {
+        reference(instr.id, lvalue, ReferenceKind.Write);
+      }
+    }
+    for (const operand of eachTerminalOperand(block.terminal)) {
+      reference(block.terminal.id, operand, ReferenceKind.Read);
+    }
+  }
+  return {
+    singleUseIdentifiers: new Set(
+      [...singleUseIdentifiers]
+        .filter(([, count]) => count === 1)
+        .map(([id]) => id)
+    ),
+    lastAssignments: lastAssignments,
+  };
+}
+function reorderBlock(env, block, shared, references) {
+  var _a, _b;
+  const locals = new Map();
+  const named = new Map();
+  let previous = null;
+  for (const instr of block.instructions) {
+    const { lvalue: lvalue, value: value } = instr;
+    const reorderability = getReorderability(instr, references);
+    const node = getOrInsertWith(locals, lvalue.identifier.id, () => ({
+      instruction: instr,
+      dependencies: new Set(),
+      reorderability: reorderability,
+      depth: null,
+    }));
+    if (reorderability === Reorderability.Nonreorderable) {
+      if (previous !== null) {
+        node.dependencies.add(previous);
+      }
+      previous = lvalue.identifier.id;
+    }
+    for (const operand of eachInstructionValueOperand(value)) {
+      const { name: name, id: id } = operand.identifier;
+      if (name !== null && name.kind === "named") {
+        const previous = named.get(name.value);
+        if (previous !== undefined) {
+          node.dependencies.add(previous);
+        }
+        named.set(name.value, lvalue.identifier.id);
+      } else if (locals.has(id) || shared.has(id)) {
+        node.dependencies.add(id);
+      }
+    }
+    for (const lvalueOperand of eachInstructionValueLValue(value)) {
+      const lvalueNode = getOrInsertWith(
+        locals,
+        lvalueOperand.identifier.id,
+        () => ({ instruction: null, dependencies: new Set(), depth: null })
+      );
+      lvalueNode.dependencies.add(lvalue.identifier.id);
+      const name = lvalueOperand.identifier.name;
+      if (name !== null && name.kind === "named") {
+        const previous = named.get(name.value);
+        if (previous !== undefined) {
+          node.dependencies.add(previous);
+        }
+        named.set(name.value, lvalue.identifier.id);
+      }
+    }
+  }
+  const nextInstructions = [];
+  if (isExpressionBlockKind(block.kind)) {
+    if (previous !== null) {
+      emit(env, locals, shared, nextInstructions, previous);
+    }
+    if (block.instructions.length !== 0) {
+      emit(
+        env,
+        locals,
+        shared,
+        nextInstructions,
+        block.instructions.at(-1).lvalue.identifier.id
+      );
+    }
+    for (const operand of eachTerminalOperand(block.terminal)) {
+      emit(env, locals, shared, nextInstructions, operand.identifier.id);
+    }
+    for (const [id, node] of locals) {
+      if (node.instruction == null) {
+        continue;
+      }
+      CompilerError.invariant(
+        node.reorderability === Reorderability.Reorderable,
+        {
+          reason: `Expected all remaining instructions to be reorderable`,
+          loc:
+            (_b =
+              (_a = node.instruction) === null || _a === void 0
+                ? void 0
+                : _a.loc) !== null && _b !== void 0
+              ? _b
+              : block.terminal.loc,
+          description:
+            node.instruction != null
+              ? `Instruction [${node.instruction.id}] was not emitted yet but is not reorderable`
+              : `Lvalue $${id} was not emitted yet but is not reorderable`,
+        }
+      );
+      shared.set(id, node);
+    }
+  } else {
+    for (const operand of eachTerminalOperand(block.terminal)) {
+      emit(env, locals, shared, nextInstructions, operand.identifier.id);
+    }
+    for (const id of Array.from(locals.keys()).reverse()) {
+      const node = locals.get(id);
+      if (node === undefined) {
+        continue;
+      }
+      if (node.reorderability === Reorderability.Reorderable) {
+        shared.set(id, node);
+      } else {
+        emit(env, locals, shared, nextInstructions, id);
+      }
+    }
+  }
+  block.instructions = nextInstructions;
+}
+function getDepth(env, nodes, id) {
+  const node = nodes.get(id);
+  if (node == null) {
+    return 0;
+  }
+  if (node.depth != null) {
+    return node.depth;
+  }
+  node.depth = 0;
+  let depth = node.reorderability === Reorderability.Reorderable ? 1 : 10;
+  for (const dep of node.dependencies) {
+    depth += getDepth(env, nodes, dep);
+  }
+  node.depth = depth;
+  return depth;
+}
+function emit(env, locals, shared, instructions, id) {
+  var _a;
+  const node =
+    (_a = locals.get(id)) !== null && _a !== void 0 ? _a : shared.get(id);
+  if (node == null) {
+    return;
+  }
+  locals.delete(id);
+  shared.delete(id);
+  const deps = [...node.dependencies];
+  deps.sort((a, b) => {
+    const aDepth = getDepth(env, locals, a);
+    const bDepth = getDepth(env, locals, b);
+    return bDepth - aDepth;
+  });
+  for (const dep of deps) {
+    emit(env, locals, shared, instructions, dep);
+  }
+  if (node.instruction !== null) {
+    instructions.push(node.instruction);
+  }
+}
+var Reorderability;
+(function (Reorderability) {
+  Reorderability[(Reorderability["Reorderable"] = 0)] = "Reorderable";
+  Reorderability[(Reorderability["Nonreorderable"] = 1)] = "Nonreorderable";
+})(Reorderability || (Reorderability = {}));
+function getReorderability(instr, references) {
+  switch (instr.value.kind) {
+    case "JsxExpression":
+    case "JsxFragment":
+    case "JSXText":
+    case "LoadGlobal":
+    case "Primitive":
+    case "TemplateLiteral":
+    case "BinaryExpression":
+    case "UnaryExpression": {
+      return Reorderability.Reorderable;
+    }
+    case "LoadLocal": {
+      const name = instr.value.place.identifier.name;
+      if (name !== null && name.kind === "named") {
+        const lastAssignment = references.lastAssignments.get(name.value);
+        if (
+          lastAssignment !== undefined &&
+          lastAssignment < instr.id &&
+          references.singleUseIdentifiers.has(instr.lvalue.identifier.id)
+        ) {
+          return Reorderability.Reorderable;
+        }
+      }
+      return Reorderability.Nonreorderable;
+    }
+    default: {
+      return Reorderability.Nonreorderable;
+    }
+  }
+}
 function alignMethodCallScopes(fn) {
   const scopeMapping = new Map();
   const mergedScopes = new DisjointSet();
@@ -165059,6 +165997,127 @@ function alignReactiveScopesToBlockScopesHIR(fn) {
     });
   }
 }
+function flattenReactiveLoopsHIR(fn) {
+  const activeLoops = Array();
+  for (const [, block] of fn.body.blocks) {
+    retainWhere(activeLoops, (id) => id !== block.id);
+    const { terminal: terminal } = block;
+    switch (terminal.kind) {
+      case "do-while":
+      case "for":
+      case "for-in":
+      case "for-of":
+      case "while": {
+        activeLoops.push(terminal.fallthrough);
+        break;
+      }
+      case "scope": {
+        if (activeLoops.length !== 0) {
+          block.terminal = {
+            kind: "pruned-scope",
+            block: terminal.block,
+            fallthrough: terminal.fallthrough,
+            id: terminal.id,
+            loc: terminal.loc,
+            scope: terminal.scope,
+          };
+        }
+        break;
+      }
+      case "branch":
+      case "goto":
+      case "if":
+      case "label":
+      case "logical":
+      case "maybe-throw":
+      case "optional":
+      case "pruned-scope":
+      case "return":
+      case "sequence":
+      case "switch":
+      case "ternary":
+      case "throw":
+      case "try":
+      case "unreachable":
+      case "unsupported": {
+        break;
+      }
+      default: {
+        assertExhaustive(
+          terminal,
+          `Unexpected terminal kind \`${terminal.kind}\``
+        );
+      }
+    }
+  }
+}
+function flattenScopesWithHooksOrUseHIR(fn) {
+  var _a, _b;
+  const activeScopes = [];
+  const prune = [];
+  for (const [, block] of fn.body.blocks) {
+    const firstId =
+      (_b =
+        (_a = block.instructions[0]) === null || _a === void 0
+          ? void 0
+          : _a.id) !== null && _b !== void 0
+        ? _b
+        : block.terminal.id;
+    retainWhere(activeScopes, (current) => current.scope.range.end > firstId);
+    for (const instr of block.instructions) {
+      const { value: value } = instr;
+      switch (value.kind) {
+        case "MethodCall":
+        case "CallExpression": {
+          const callee =
+            value.kind === "MethodCall" ? value.property : value.callee;
+          if (
+            getHookKind(fn.env, callee.identifier) != null ||
+            isUseOperator(callee.identifier)
+          ) {
+            prune.push(...activeScopes.map((entry) => entry.block));
+            activeScopes.length = 0;
+          }
+        }
+      }
+    }
+    if (block.terminal.kind === "scope") {
+      activeScopes.push({ block: block.id, scope: block.terminal.scope });
+    }
+  }
+  for (const id of prune) {
+    const block = fn.body.blocks.get(id);
+    const terminal = block.terminal;
+    CompilerError.invariant(terminal.kind === "scope", {
+      reason: `Expected block to have a scope terminal`,
+      description: `Expected block bb${block.id} to end in a scope terminal`,
+      loc: terminal.loc,
+    });
+    const body = fn.body.blocks.get(terminal.block);
+    if (
+      body.instructions.length === 1 &&
+      body.terminal.kind === "goto" &&
+      body.terminal.block === terminal.fallthrough
+    ) {
+      block.terminal = {
+        kind: "label",
+        block: terminal.block,
+        fallthrough: terminal.fallthrough,
+        id: terminal.id,
+        loc: terminal.loc,
+      };
+      continue;
+    }
+    block.terminal = {
+      kind: "pruned-scope",
+      block: terminal.block,
+      fallthrough: terminal.fallthrough,
+      id: terminal.id,
+      loc: terminal.loc,
+      scope: terminal.scope,
+    };
+  }
+}
 function pruneAlwaysInvalidatingScopes(fn) {
   visitReactiveFunction(fn, new Transform(), false);
 }
@@ -165126,12 +166185,229 @@ class Transform extends ReactiveFunctionTransform {
             this.unmemoizedValues.add(identifier);
           }
         }
-        return { kind: "replace-many", value: scopeBlock.instructions };
+        return {
+          kind: "replace",
+          value: {
+            kind: "pruned-scope",
+            scope: scopeBlock.scope,
+            instructions: scopeBlock.instructions,
+          },
+        };
       }
     }
     return { kind: "keep" };
   }
 }
+let Visitor$1 = class Visitor extends ReactiveFunctionVisitor {
+  constructor(env, aliases, paths) {
+    super();
+    this.map = new Map();
+    this.aliases = aliases;
+    this.paths = paths;
+    this.env = env;
+  }
+  join(values) {
+    function join2(l, r) {
+      if (l === "Update" || r === "Update") {
+        return "Update";
+      } else if (l === "Create" || r === "Create") {
+        return "Create";
+      } else if (l === "Unknown" || r === "Unknown") {
+        return "Unknown";
+      }
+      assertExhaustive(r, `Unhandled variable kind ${r}`);
+    }
+    return values.reduce(join2, "Unknown");
+  }
+  isCreateOnlyHook(id) {
+    return isUseStateType(id) || isUseRefType(id);
+  }
+  visitPlace(_, place, state) {
+    var _a;
+    this.map.set(
+      place.identifier.id,
+      this.join([
+        state,
+        (_a = this.map.get(place.identifier.id)) !== null && _a !== void 0
+          ? _a
+          : "Unknown",
+      ])
+    );
+  }
+  visitBlock(block, state) {
+    super.visitBlock([...block].reverse(), state);
+  }
+  visitInstruction(instruction) {
+    const state = this.join(
+      [...eachInstructionLValue(instruction)].map((operand) => {
+        var _a;
+        return (_a = this.map.get(operand.identifier.id)) !== null &&
+          _a !== void 0
+          ? _a
+          : "Unknown";
+      })
+    );
+    const visitCallOrMethodNonArgs = () => {
+      switch (instruction.value.kind) {
+        case "CallExpression": {
+          this.visitPlace(instruction.id, instruction.value.callee, state);
+          break;
+        }
+        case "MethodCall": {
+          this.visitPlace(instruction.id, instruction.value.property, state);
+          this.visitPlace(instruction.id, instruction.value.receiver, state);
+          break;
+        }
+      }
+    };
+    const isHook = () => {
+      let callee = null;
+      switch (instruction.value.kind) {
+        case "CallExpression": {
+          callee = instruction.value.callee.identifier;
+          break;
+        }
+        case "MethodCall": {
+          callee = instruction.value.property.identifier;
+          break;
+        }
+      }
+      return callee != null && getHookKind(this.env, callee) != null;
+    };
+    switch (instruction.value.kind) {
+      case "CallExpression":
+      case "MethodCall": {
+        if (
+          instruction.lvalue &&
+          this.isCreateOnlyHook(instruction.lvalue.identifier)
+        ) {
+          [...eachCallArgument(instruction.value.args)].forEach((operand) =>
+            this.visitPlace(instruction.id, operand, "Create")
+          );
+          visitCallOrMethodNonArgs();
+        } else {
+          this.traverseInstruction(instruction, isHook() ? "Update" : state);
+        }
+        break;
+      }
+      default: {
+        this.traverseInstruction(instruction, state);
+      }
+    }
+  }
+  visitScope(scope) {
+    const state = this.join(
+      [
+        ...scope.scope.declarations.keys(),
+        ...[...scope.scope.reassignments.values()].map((ident) => ident.id),
+      ].map((id) => {
+        var _a;
+        return (_a = this.map.get(id)) !== null && _a !== void 0
+          ? _a
+          : "Unknown";
+      })
+    );
+    super.visitScope(scope, state);
+    [...scope.scope.dependencies].forEach((ident) => {
+      var _a;
+      let target =
+        (_a = this.aliases.find(ident.identifier.id)) !== null && _a !== void 0
+          ? _a
+          : ident.identifier.id;
+      ident.path.forEach((key) => {
+        var _a;
+        target &&
+          (target =
+            (_a = this.paths.get(target)) === null || _a === void 0
+              ? void 0
+              : _a.get(key));
+      });
+      if (target && this.map.get(target) === "Create") {
+        scope.scope.dependencies.delete(ident);
+      }
+    });
+  }
+  visitTerminal(stmt, state) {
+    CompilerError.invariant(state !== "Create", {
+      reason: "Visiting a terminal statement with state 'Create'",
+      loc: stmt.terminal.loc,
+    });
+    super.visitTerminal(stmt, state);
+  }
+  visitReactiveFunctionValue(_id, _dependencies, fn, state) {
+    visitReactiveFunction(fn, this, state);
+  }
+};
+function pruneInitializationDependencies(fn) {
+  const [aliases, paths] = getAliases(fn);
+  visitReactiveFunction(fn, new Visitor$1(fn.env, aliases, paths), "Update");
+}
+function update(map, key, path, value) {
+  var _a;
+  const inner = (_a = map.get(key)) !== null && _a !== void 0 ? _a : new Map();
+  inner.set(path, value);
+  map.set(key, inner);
+}
+class AliasVisitor extends ReactiveFunctionVisitor {
+  constructor() {
+    super(...arguments);
+    this.scopeIdentifiers = new DisjointSet();
+    this.scopePaths = new Map();
+  }
+  visitInstruction(instr) {
+    if (
+      instr.value.kind === "StoreLocal" ||
+      instr.value.kind === "StoreContext"
+    ) {
+      this.scopeIdentifiers.union([
+        instr.value.lvalue.place.identifier.id,
+        instr.value.value.identifier.id,
+      ]);
+    } else if (
+      instr.value.kind === "LoadLocal" ||
+      instr.value.kind === "LoadContext"
+    ) {
+      instr.lvalue &&
+        this.scopeIdentifiers.union([
+          instr.lvalue.identifier.id,
+          instr.value.place.identifier.id,
+        ]);
+    } else if (instr.value.kind === "PropertyLoad") {
+      instr.lvalue &&
+        update(
+          this.scopePaths,
+          instr.value.object.identifier.id,
+          instr.value.property,
+          instr.lvalue.identifier.id
+        );
+    } else if (instr.value.kind === "PropertyStore") {
+      update(
+        this.scopePaths,
+        instr.value.object.identifier.id,
+        instr.value.property,
+        instr.value.value.identifier.id
+      );
+    }
+  }
+}
+function getAliases(fn) {
+  var _a, _b;
+  const visitor = new AliasVisitor();
+  visitReactiveFunction(fn, visitor, null);
+  let disjoint = visitor.scopeIdentifiers;
+  let scopePaths = new Map();
+  for (const [key, value] of visitor.scopePaths) {
+    for (const [path, id] of value) {
+      update(
+        scopePaths,
+        (_a = disjoint.find(key)) !== null && _a !== void 0 ? _a : key,
+        path,
+        (_b = disjoint.find(id)) !== null && _b !== void 0 ? _b : id
+      );
+    }
+  }
+  return [disjoint, scopePaths];
+}
 function isPrimitiveBinaryOp(op) {
   switch (op) {
     case "+":
@@ -165190,7 +166466,13 @@ function equation(left, right) {
 }
 function* generate(func) {
   if (func.env.fnType === "Component") {
-    const [_, ref] = func.params;
+    const [props, ref] = func.params;
+    if (props && props.kind === "Identifier") {
+      yield equation(props.identifier.type, {
+        kind: "Object",
+        shapeId: BuiltInPropsId,
+      });
+    }
     if (ref && ref.kind === "Identifier") {
       yield equation(ref.identifier.type, {
         kind: "Object",
@@ -165198,6 +166480,7 @@ function* generate(func) {
       });
     }
   }
+  const names = new Map();
   for (const [_, block] of func.body.blocks) {
     for (const phi of block.phis) {
       yield equation(phi.type, {
@@ -165206,11 +166489,23 @@ function* generate(func) {
       });
     }
     for (const instr of block.instructions) {
-      yield* generateInstructionTypes(func.env, instr);
+      yield* generateInstructionTypes(func.env, names, instr);
     }
   }
 }
-function* generateInstructionTypes(env, instr) {
+function setName(names, id, name) {
+  var _a;
+  if (
+    ((_a = name.name) === null || _a === void 0 ? void 0 : _a.kind) === "named"
+  ) {
+    names.set(id, name.name.value);
+  }
+}
+function getName(names, id) {
+  var _a;
+  return (_a = names.get(id)) !== null && _a !== void 0 ? _a : "";
+}
+function* generateInstructionTypes(env, names, instr) {
   const { lvalue: lvalue, value: value } = instr;
   const left = lvalue.identifier.type;
   switch (value.kind) {
@@ -165225,6 +166520,7 @@ function* generateInstructionTypes(env, instr) {
       break;
     }
     case "LoadLocal": {
+      setName(names, lvalue.identifier.id, value.place.identifier);
       yield equation(left, value.place.identifier.type);
       break;
     }
@@ -165307,7 +166603,8 @@ function* generateInstructionTypes(env, instr) {
     case "PropertyLoad": {
       yield equation(left, {
         kind: "Property",
-        object: value.object.identifier.type,
+        objectType: value.object.identifier.type,
+        objectName: getName(names, value.object.identifier.id),
         propertyName: value.property,
       });
       break;
@@ -165331,7 +166628,8 @@ function* generateInstructionTypes(env, instr) {
             const propertyName = String(i);
             yield equation(item.identifier.type, {
               kind: "Property",
-              object: value.value.identifier.type,
+              objectType: value.value.identifier.type,
+              objectName: getName(names, value.value.identifier.id),
               propertyName: propertyName,
             });
           } else {
@@ -165347,7 +166645,8 @@ function* generateInstructionTypes(env, instr) {
             ) {
               yield equation(property.place.identifier.type, {
                 kind: "Property",
-                object: value.value.identifier.type,
+                objectType: value.value.identifier.type,
+                objectName: getName(names, value.value.identifier.id),
                 propertyName: property.key.name,
               });
             }
@@ -165389,10 +166688,11 @@ function* generateInstructionTypes(env, instr) {
       yield equation(left, { kind: "Object", shapeId: BuiltInJsxId });
       break;
     }
+    case "PropertyStore":
     case "DeclareLocal":
     case "NewExpression":
     case "RegExpLiteral":
-    case "PropertyStore":
+    case "MetaProperty":
     case "ComputedStore":
     case "ComputedLoad":
     case "TaggedTemplateExpression":
@@ -165416,7 +166716,15 @@ class Unifier {
   }
   unify(tA, tB) {
     if (tB.kind === "Property") {
-      const objectType = this.get(tB.object);
+      if (
+        this.env.config.enableTreatRefLikeIdentifiersAsRefs &&
+        isRefLikeName(tB)
+      ) {
+        this.unify(tB.objectType, { kind: "Object", shapeId: BuiltInUseRefId });
+        this.unify(tA, { kind: "Object", shapeId: BuiltInRefValueId });
+        return;
+      }
+      const objectType = this.get(tB.objectType);
       const propertyType = this.env.getPropertyType(
         objectType,
         tB.propertyName
@@ -165498,6 +166806,10 @@ class Unifier {
     return type;
   }
 }
+const RefLikeNameRE = /^(?:[a-zA-Z$_][a-zA-Z$_0-9]*)Ref$|^ref$/;
+function isRefLikeName(t) {
+  return RefLikeNameRE.test(t.objectName) && t.propertyName === "current";
+}
 function validateContextVariableLValues(fn) {
   const identifierKinds = new Map();
   validateContextVariableLValuesImpl(fn, identifierKinds);
@@ -166064,7 +167376,12 @@ function validateNoRefAccessInRenderImpl(fn, refAccessingFunctions) {
         case "MethodCall": {
           if (!isEffectHook(instr.value.property.identifier)) {
             for (const operand of eachInstructionValueOperand(instr.value)) {
-              validateNoRefAccess(errors, refAccessingFunctions, operand);
+              validateNoRefAccess(
+                errors,
+                refAccessingFunctions,
+                operand,
+                operand.loc
+              );
             }
           }
           break;
@@ -166084,7 +167401,12 @@ function validateNoRefAccessInRenderImpl(fn, refAccessingFunctions) {
               });
             }
             for (const operand of eachInstructionValueOperand(instr.value)) {
-              validateNoRefAccess(errors, refAccessingFunctions, operand);
+              validateNoRefAccess(
+                errors,
+                refAccessingFunctions,
+                operand,
+                operand.loc
+              );
             }
           }
           break;
@@ -166092,7 +167414,30 @@ function validateNoRefAccessInRenderImpl(fn, refAccessingFunctions) {
         case "ObjectExpression":
         case "ArrayExpression": {
           for (const operand of eachInstructionValueOperand(instr.value)) {
-            validateNoRefAccess(errors, refAccessingFunctions, operand);
+            validateNoRefAccess(
+              errors,
+              refAccessingFunctions,
+              operand,
+              operand.loc
+            );
+          }
+          break;
+        }
+        case "PropertyDelete":
+        case "PropertyStore":
+        case "ComputedDelete":
+        case "ComputedStore": {
+          validateNoRefAccess(
+            errors,
+            refAccessingFunctions,
+            instr.value.object,
+            instr.loc
+          );
+          for (const operand of eachInstructionValueOperand(instr.value)) {
+            if (operand === instr.value.object) {
+              continue;
+            }
+            validateNoRefValueAccess(errors, refAccessingFunctions, operand);
           }
           break;
         }
@@ -166114,14 +167459,10 @@ function validateNoRefAccessInRenderImpl(fn, refAccessingFunctions) {
     return Ok(undefined);
   }
 }
-function validateNoRefValueAccess(
-  errors,
-  unconditionalSetStateFunctions,
-  operand
-) {
+function validateNoRefValueAccess(errors, refAccessingFunctions, operand) {
   if (
     isRefValueType(operand.identifier) ||
-    unconditionalSetStateFunctions.has(operand.identifier.id)
+    refAccessingFunctions.has(operand.identifier.id)
   ) {
     errors.push({
       severity: exports.ErrorSeverity.InvalidReact,
@@ -166133,18 +167474,22 @@ function validateNoRefValueAccess(
     });
   }
 }
-function validateNoRefAccess(errors, unconditionalSetStateFunctions, operand) {
+function validateNoRefAccess(errors, refAccessingFunctions, operand, loc) {
   if (
     isRefValueType(operand.identifier) ||
     isUseRefType(operand.identifier) ||
-    unconditionalSetStateFunctions.has(operand.identifier.id)
+    refAccessingFunctions.has(operand.identifier.id)
   ) {
     errors.push({
       severity: exports.ErrorSeverity.InvalidReact,
       reason:
         "Ref values (the `current` property) may not be accessed during render. (https://react.dev/reference/react/useRef)",
-      loc: operand.loc,
-      description: `Cannot access ref value at ${printPlace(operand)}`,
+      loc: loc,
+      description:
+        operand.identifier.name !== null &&
+        operand.identifier.name.kind === "named"
+          ? `Cannot access ref value \`${operand.identifier.name.value}\``
+          : null,
       suggestions: null,
     });
   }
@@ -166632,8 +167977,14 @@ function* runWithEnvironment(func, env) {
   yield log({ kind: "hir", name: "PruneMaybeThrows", value: hir });
   validateContextVariableLValues(hir);
   validateUseMemo(hir);
-  dropManualMemoization(hir);
-  yield log({ kind: "hir", name: "DropManualMemoization", value: hir });
+  if (
+    !env.config.enablePreserveExistingManualUseMemo &&
+    !env.config.disableMemoizationForDebugging &&
+    !env.config.enableChangeDetectionForDebugging
+  ) {
+    dropManualMemoization(hir);
+    yield log({ kind: "hir", name: "DropManualMemoization", value: hir });
+  }
   inlineImmediatelyInvokedFunctionExpressions(hir);
   yield log({
     kind: "hir",
@@ -166665,6 +168016,10 @@ function* runWithEnvironment(func, env) {
   yield log({ kind: "hir", name: "InferReferenceEffects", value: hir });
   deadCodeElimination(hir);
   yield log({ kind: "hir", name: "DeadCodeElimination", value: hir });
+  if (env.config.enableInstructionReordering) {
+    instructionReordering(hir);
+    yield log({ kind: "hir", name: "InstructionReordering", value: hir });
+  }
   pruneMaybeThrows(hir);
   yield log({ kind: "hir", name: "PruneMaybeThrows", value: hir });
   inferMutableRanges(hir);
@@ -166688,8 +168043,12 @@ function* runWithEnvironment(func, env) {
   yield log({ kind: "hir", name: "AlignMethodCallScopes", value: hir });
   alignObjectMethodScopes(hir);
   yield log({ kind: "hir", name: "AlignObjectMethodScopes", value: hir });
-  memoizeFbtOperandsInSameScope(hir);
-  yield log({ kind: "hir", name: "MemoizeFbtOperandsInSameScope", value: hir });
+  memoizeFbtAndMacroOperandsInSameScope(hir);
+  yield log({
+    kind: "hir",
+    name: "MemoizeFbtAndMacroOperandsInSameScope",
+    value: hir,
+  });
   if (env.config.enableReactiveScopesInHIR) {
     pruneUnusedLabelsHIR(hir);
     yield log({ kind: "hir", name: "PruneUnusedLabelsHIR", value: hir });
@@ -166713,6 +168072,14 @@ function* runWithEnvironment(func, env) {
       value: hir,
     });
     assertValidBlockNesting(hir);
+    flattenReactiveLoopsHIR(hir);
+    yield log({ kind: "hir", name: "FlattenReactiveLoopsHIR", value: hir });
+    flattenScopesWithHooksOrUseHIR(hir);
+    yield log({
+      kind: "hir",
+      name: "FlattenScopesWithHooksOrUseHIR",
+      value: hir,
+    });
   }
   const reactiveFunction = buildReactiveFunction(hir);
   yield log({
@@ -166746,20 +168113,20 @@ function* runWithEnvironment(func, env) {
       name: "BuildReactiveBlocks",
       value: reactiveFunction,
     });
+    flattenReactiveLoops(reactiveFunction);
+    yield log({
+      kind: "reactive",
+      name: "FlattenReactiveLoops",
+      value: reactiveFunction,
+    });
+    flattenScopesWithHooksOrUse(reactiveFunction);
+    yield log({
+      kind: "reactive",
+      name: "FlattenScopesWithHooks",
+      value: reactiveFunction,
+    });
   }
-  flattenReactiveLoops(reactiveFunction);
-  yield log({
-    kind: "reactive",
-    name: "FlattenReactiveLoops",
-    value: reactiveFunction,
-  });
   assertScopeInstructionsWithinScopes(reactiveFunction);
-  flattenScopesWithHooksOrUse(reactiveFunction);
-  yield log({
-    kind: "reactive",
-    name: "FlattenScopesWithHooks",
-    value: reactiveFunction,
-  });
   propagateScopeDependencies(reactiveFunction);
   yield log({
     kind: "reactive",
@@ -166796,6 +168163,14 @@ function* runWithEnvironment(func, env) {
     name: "PruneAlwaysInvalidatingScopes",
     value: reactiveFunction,
   });
+  if (env.config.enableChangeDetectionForDebugging != null) {
+    pruneInitializationDependencies(reactiveFunction);
+    yield log({
+      kind: "reactive",
+      name: "PruneInitializationDependencies",
+      value: reactiveFunction,
+    });
+  }
   propagateEarlyReturns(reactiveFunction);
   yield log({
     kind: "reactive",
@@ -167184,9 +168559,8 @@ function isFilePartOfSources(sources, filename) {
   return false;
 }
 function compileProgram(program, pass) {
-  var _a, _b, _c, _d, _e, _f, _g;
-  const options = parsePluginOptions(pass.opts);
-  if (options.sources) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  if (pass.opts.sources) {
     if (pass.filename === null) {
       const error = new CompilerError();
       error.pushErrorDetail(
@@ -167201,12 +168575,13 @@ function compileProgram(program, pass) {
       handleError(error, pass, null);
       return;
     }
-    if (!isFilePartOfSources(options.sources, pass.filename)) {
+    if (!isFilePartOfSources(pass.opts.sources, pass.filename)) {
       return;
     }
   }
   if (
-    findDirectiveDisablingMemoization(program.node.directives, options) != null
+    findDirectiveDisablingMemoization(program.node.directives, pass.opts) !=
+    null
   ) {
     return;
   }
@@ -167215,7 +168590,7 @@ function compileProgram(program, pass) {
   );
   const useMemoCacheIdentifier = program.scope.generateUidIdentifier("c");
   const moduleName =
-    (_b = options.runtimeModule) !== null && _b !== void 0
+    (_b = pass.opts.runtimeModule) !== null && _b !== void 0
       ? _b
       : "react/compiler-runtime";
   if (hasMemoCacheFunctionImport(program, moduleName)) {
@@ -167223,10 +168598,10 @@ function compileProgram(program, pass) {
   }
   const suppressions = findProgramSuppressions(
     pass.comments,
-    (_c = options.eslintSuppressionRules) !== null && _c !== void 0
+    (_c = pass.opts.eslintSuppressionRules) !== null && _c !== void 0
       ? _c
       : DEFAULT_ESLINT_SUPPRESSIONS,
-    options.flowSuppressions
+    pass.opts.flowSuppressions
   );
   const lintError = suppressionsToCompilerError(suppressions);
   let hasCriticalError = lintError != null;
@@ -167269,11 +168644,11 @@ function compileProgram(program, pass) {
         config,
         fnType,
         useMemoCacheIdentifier.name,
-        options.logger,
+        pass.opts.logger,
         pass.filename,
         pass.code
       );
-      (_b = options.logger) === null || _b === void 0
+      (_b = pass.opts.logger) === null || _b === void 0
         ? void 0
         : _b.logEvent(pass.filename, {
             kind: "CompileSuccess",
@@ -167287,6 +168662,9 @@ function compileProgram(program, pass) {
                 : null,
             memoSlots: compiledFn.memoSlotsUsed,
             memoBlocks: compiledFn.memoBlocks,
+            memoValues: compiledFn.memoValues,
+            prunedMemoBlocks: compiledFn.prunedMemoBlocks,
+            prunedMemoValues: compiledFn.prunedMemoValues,
           });
     } catch (err) {
       hasCriticalError || (hasCriticalError = isCriticalError(err));
@@ -167316,11 +168694,11 @@ function compileProgram(program, pass) {
       ArrowFunctionExpression: traverseFunction,
     },
     Object.assign(Object.assign({}, pass), {
-      opts: Object.assign(Object.assign({}, pass.opts), options),
+      opts: Object.assign(Object.assign({}, pass.opts), pass.opts),
       filename: (_d = pass.filename) !== null && _d !== void 0 ? _d : null,
     })
   );
-  if (options.gating != null) {
+  if (pass.opts.gating != null) {
     const error = checkFunctionReferencedBeforeDeclarationAtTopLevel(
       program,
       compiledFns.map(({ originalFn: originalFn }) => originalFn)
@@ -167333,12 +168711,12 @@ function compileProgram(program, pass) {
   const externalFunctions = [];
   let gating = null;
   try {
-    if (options.gating != null) {
-      gating = tryParseExternalFunction(options.gating);
+    if (pass.opts.gating != null) {
+      gating = tryParseExternalFunction(pass.opts.gating);
       externalFunctions.push(gating);
     }
     const enableEmitInstrumentForget =
-      (_e = options.environment) === null || _e === void 0
+      (_e = pass.opts.environment) === null || _e === void 0
         ? void 0
         : _e.enableEmitInstrumentForget;
     if (enableEmitInstrumentForget != null) {
@@ -167352,25 +168730,35 @@ function compileProgram(program, pass) {
       }
     }
     if (
-      ((_f = options.environment) === null || _f === void 0
+      ((_f = pass.opts.environment) === null || _f === void 0
         ? void 0
         : _f.enableEmitFreeze) != null
     ) {
       const enableEmitFreeze = tryParseExternalFunction(
-        options.environment.enableEmitFreeze
+        pass.opts.environment.enableEmitFreeze
       );
       externalFunctions.push(enableEmitFreeze);
     }
     if (
-      ((_g = options.environment) === null || _g === void 0
+      ((_g = pass.opts.environment) === null || _g === void 0
         ? void 0
         : _g.enableEmitHookGuards) != null
     ) {
       const enableEmitHookGuards = tryParseExternalFunction(
-        options.environment.enableEmitHookGuards
+        pass.opts.environment.enableEmitHookGuards
       );
       externalFunctions.push(enableEmitHookGuards);
     }
+    if (
+      ((_h = pass.opts.environment) === null || _h === void 0
+        ? void 0
+        : _h.enableChangeDetectionForDebugging) != null
+    ) {
+      const enableChangeDetectionForDebugging = tryParseExternalFunction(
+        pass.opts.environment.enableChangeDetectionForDebugging
+      );
+      externalFunctions.push(enableChangeDetectionForDebugging);
+    }
   } catch (err) {
     handleError(err, pass, null);
     return;
@@ -167441,19 +168829,25 @@ function getReactFunctionType(fn, pass) {
         : "Other";
     }
   }
+  let componentSyntaxType = null;
+  if (fn.isFunctionDeclaration()) {
+    if (isComponentDeclaration(fn.node)) {
+      componentSyntaxType = "Component";
+    } else if (isHookDeclaration(fn.node)) {
+      componentSyntaxType = "Hook";
+    }
+  }
   switch (pass.opts.compilationMode) {
     case "annotation": {
       return null;
     }
     case "infer": {
-      if (fn.isFunctionDeclaration()) {
-        if (isComponentDeclaration(fn.node)) {
-          return "Component";
-        } else if (isHookDeclaration(fn.node)) {
-          return "Hook";
-        }
-      }
-      return getComponentOrHookLike(fn, hookPattern);
+      return componentSyntaxType !== null && componentSyntaxType !== void 0
+        ? componentSyntaxType
+        : getComponentOrHookLike(fn, hookPattern);
+    }
+    case "syntax": {
+      return componentSyntaxType;
     }
     case "all": {
       if (fn.scope.getProgramParent() !== fn.scope.parent) {
@@ -167543,15 +168937,62 @@ function isMemoCallback(path) {
     isReactAPI(path.parentPath.get("callee"), "memo")
   );
 }
+function isValidPropsAnnotation(annot) {
+  if (annot == null) {
+    return true;
+  } else if (annot.type === "TSTypeAnnotation") {
+    switch (annot.typeAnnotation.type) {
+      case "TSArrayType":
+      case "TSBigIntKeyword":
+      case "TSBooleanKeyword":
+      case "TSConstructorType":
+      case "TSFunctionType":
+      case "TSLiteralType":
+      case "TSNeverKeyword":
+      case "TSNumberKeyword":
+      case "TSStringKeyword":
+      case "TSSymbolKeyword":
+      case "TSTupleType":
+        return false;
+    }
+    return true;
+  } else if (annot.type === "TypeAnnotation") {
+    switch (annot.typeAnnotation.type) {
+      case "ArrayTypeAnnotation":
+      case "BooleanLiteralTypeAnnotation":
+      case "BooleanTypeAnnotation":
+      case "EmptyTypeAnnotation":
+      case "FunctionTypeAnnotation":
+      case "NumberLiteralTypeAnnotation":
+      case "NumberTypeAnnotation":
+      case "StringLiteralTypeAnnotation":
+      case "StringTypeAnnotation":
+      case "SymbolTypeAnnotation":
+      case "ThisTypeAnnotation":
+      case "TupleTypeAnnotation":
+        return false;
+    }
+    return true;
+  } else if (annot.type === "Noop") {
+    return true;
+  } else {
+    assertExhaustive(annot, `Unexpected annotation node \`${annot}\``);
+  }
+}
 function isValidComponentParams(params) {
   if (params.length === 0) {
     return true;
-  } else if (params.length === 1) {
-    return !params[0].isRestElement();
-  } else if (params.length === 2) {
-    if (params[1].isIdentifier()) {
+  } else if (params.length > 0 && params.length <= 2) {
+    if (!isValidPropsAnnotation(params[0].node.typeAnnotation)) {
+      return false;
+    }
+    if (params.length === 1) {
+      return !params[0].isRestElement();
+    } else if (params[1].isIdentifier()) {
       const { name: name } = params[1].node;
       return name.includes("ref") || name.includes("Ref");
+    } else {
+      return false;
     }
   }
   return false;
@@ -167561,7 +169002,8 @@ function getComponentOrHookLike(node, hookPattern) {
   if (functionName !== null && isComponentName(functionName)) {
     let isComponent =
       callsHooksOrCreatesJsx(node, hookPattern) &&
-      isValidComponentParams(node.get("params"));
+      isValidComponentParams(node.get("params")) &&
+      !returnsNonNode(node);
     return isComponent ? "Component" : null;
   } else if (functionName !== null && isHook(functionName, hookPattern)) {
     return callsHooksOrCreatesJsx(node, hookPattern) ? "Hook" : null;
@@ -167573,6 +169015,13 @@ function getComponentOrHookLike(node, hookPattern) {
   }
   return null;
 }
+function skipNestedFunctions(node) {
+  return (fn) => {
+    if (fn.node !== node.node) {
+      fn.skip();
+    }
+  };
+}
 function callsHooksOrCreatesJsx(node, hookPattern) {
   let invokesHooks = false;
   let createsJsx = false;
@@ -167586,9 +169035,39 @@ function callsHooksOrCreatesJsx(node, hookPattern) {
         invokesHooks = true;
       }
     },
+    ArrowFunctionExpression: skipNestedFunctions(node),
+    FunctionExpression: skipNestedFunctions(node),
+    FunctionDeclaration: skipNestedFunctions(node),
   });
   return invokesHooks || createsJsx;
 }
+function returnsNonNode(node) {
+  let hasReturn = false;
+  let returnsNonNode = false;
+  node.traverse({
+    ReturnStatement(ret) {
+      hasReturn = true;
+      const argument = ret.node.argument;
+      if (argument == null) {
+        returnsNonNode = true;
+      } else {
+        switch (argument.type) {
+          case "ObjectExpression":
+          case "ArrowFunctionExpression":
+          case "FunctionExpression":
+          case "BigIntLiteral":
+          case "ClassExpression":
+          case "NewExpression":
+            returnsNonNode = true;
+        }
+      }
+    },
+    ArrowFunctionExpression: skipNestedFunctions(node),
+    FunctionExpression: skipNestedFunctions(node),
+    FunctionDeclaration: skipNestedFunctions(node),
+  });
+  return !hasReturn || returnsNonNode;
+}
 function getFunctionName(path) {
   if (path.isFunctionDeclaration()) {
     const id = path.get("id");
@@ -167719,10 +169198,16 @@ function BabelPluginReactCompiler(_babel) {
       Program(prog, pass) {
         var _a, _b;
         let opts = parsePluginOptions(pass.opts);
-        if (pipelineUsesReanimatedPlugin(pass.file.opts.plugins)) {
+        const isDev =
+          (typeof __DEV__ !== "undefined" && __DEV__ === true) ||
+          process.env["NODE_ENV"] === "development";
+        if (
+          opts.enableReanimatedCheck === true &&
+          pipelineUsesReanimatedPlugin(pass.file.opts.plugins)
+        ) {
           opts = injectReanimatedFlag(opts);
         }
-        if (process.env["NODE_ENV"] === "development") {
+        if (isDev) {
           opts = Object.assign(Object.assign({}, opts), {
             environment: Object.assign(Object.assign({}, opts.environment), {
               enableResetCacheOnSourceFileChanges: true,