babel-plugin-react-compiler 0.0.0-experimental-f980e29-20250522 → 0.0.0-experimental-8f8b1db-20250523

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import * as BabelCore from '@babel/core';
 import { NodePath as NodePath$1 } from '@babel/core';
 import * as t from '@babel/types';
 import { z } from 'zod';
-import { Scope, NodePath } from '@babel/traverse';
+import { NodePath, Scope } from '@babel/traverse';
 
 interface Result<T, E> {
     map<U>(fn: (val: T) => U): Result<U, E>;
@@ -546,7 +546,8 @@ declare class Environment {
     hasFireRewrite: boolean;
     hasInferredEffect: boolean;
     inferredEffectLocations: Set<SourceLocation>;
-    constructor(scope: Scope, fnType: ReactFunctionType, compilerMode: CompilerMode, config: EnvironmentConfig, contextIdentifiers: Set<t.Identifier>, logger: Logger | null, filename: string | null, code: string | null, programContext: ProgramContext);
+    parentFunction: NodePath<t.Function>;
+    constructor(scope: Scope, fnType: ReactFunctionType, compilerMode: CompilerMode, config: EnvironmentConfig, contextIdentifiers: Set<t.Identifier>, parentFunction: NodePath<t.Function>, logger: Logger | null, filename: string | null, code: string | null, programContext: ProgramContext);
     get isInferredMemoEnabled(): boolean;
     get nextIdentifierId(): IdentifierId;
     get nextBlockId(): BlockId;
@@ -1412,6 +1413,7 @@ type DependencyPathEntry = {
 type DependencyPath = Array<DependencyPathEntry>;
 type ReactiveScopeDependency = {
     identifier: Identifier;
+    reactive: boolean;
     path: DependencyPath;
 };
 declare const opaqueBlockId: unique symbol;

package/dist/index.js

@@ -5855,7 +5855,7 @@ var require_parentheses = __commonJS({
     exports2.DoExpression = DoExpression;
     exports2.FunctionExpression = FunctionExpression7;
     exports2.FunctionTypeAnnotation = FunctionTypeAnnotation;
-    exports2.Identifier = Identifier28;
+    exports2.Identifier = Identifier29;
     exports2.LogicalExpression = LogicalExpression;
     exports2.NullableTypeAnnotation = NullableTypeAnnotation;
     exports2.ObjectExpression = ObjectExpression;
@@ -6070,7 +6070,7 @@ var require_parentheses = __commonJS({
           return parent.operator !== "??";
       }
     }
-    function Identifier28(node, parent, tokenContext, _inForInit, getRawIdentifier) {
+    function Identifier29(node, parent, tokenContext, _inForInit, getRawIdentifier) {
       var _node$extra;
       const parentType = parent.type;
       if ((_node$extra = node.extra) != null && _node$extra.parenthesized && parentType === "AssignmentExpression" && parent.left === node) {
@@ -8040,7 +8040,7 @@ var require_types = __commonJS({
     exports2.ArrayPattern = exports2.ArrayExpression = ArrayExpression5;
     exports2.BigIntLiteral = BigIntLiteral;
     exports2.BooleanLiteral = BooleanLiteral;
-    exports2.Identifier = Identifier28;
+    exports2.Identifier = Identifier29;
     exports2.NullLiteral = NullLiteral;
     exports2.NumericLiteral = NumericLiteral;
     exports2.ObjectPattern = exports2.ObjectExpression = ObjectExpression;
@@ -8077,7 +8077,7 @@ var require_types = __commonJS({
       }
       return lastRawIdentResult = node.name;
     }
-    function Identifier28(node) {
+    function Identifier29(node) {
       var _node$loc;
       this.sourceIdentifierName(((_node$loc = node.loc) == null ? void 0 : _node$loc.identifierName) || node.name);
       this.word(this.tokenMap ? this._getRawIdentifier(node) : node.name);
@@ -34766,7 +34766,7 @@ var require_parentheses2 = __commonJS({
     exports2.DoExpression = DoExpression;
     exports2.FunctionExpression = FunctionExpression7;
     exports2.FunctionTypeAnnotation = FunctionTypeAnnotation;
-    exports2.Identifier = Identifier28;
+    exports2.Identifier = Identifier29;
     exports2.LogicalExpression = LogicalExpression;
     exports2.NullableTypeAnnotation = NullableTypeAnnotation;
     exports2.ObjectExpression = ObjectExpression;
@@ -34981,7 +34981,7 @@ var require_parentheses2 = __commonJS({
           return parent.operator !== "??";
       }
     }
-    function Identifier28(node, parent, tokenContext, _inForInit, getRawIdentifier) {
+    function Identifier29(node, parent, tokenContext, _inForInit, getRawIdentifier) {
       var _node$extra;
       const parentType = parent.type;
       if ((_node$extra = node.extra) != null && _node$extra.parenthesized && parentType === "AssignmentExpression" && parent.left === node) {
@@ -36951,7 +36951,7 @@ var require_types2 = __commonJS({
     exports2.ArrayPattern = exports2.ArrayExpression = ArrayExpression5;
     exports2.BigIntLiteral = BigIntLiteral;
     exports2.BooleanLiteral = BooleanLiteral;
-    exports2.Identifier = Identifier28;
+    exports2.Identifier = Identifier29;
     exports2.NullLiteral = NullLiteral;
     exports2.NumericLiteral = NumericLiteral;
     exports2.ObjectPattern = exports2.ObjectExpression = ObjectExpression;
@@ -36988,7 +36988,7 @@ var require_types2 = __commonJS({
       }
       return lastRawIdentResult = node.name;
     }
-    function Identifier28(node) {
+    function Identifier29(node) {
       var _node$loc;
       this.sourceIdentifierName(((_node$loc = node.loc) == null ? void 0 : _node$loc.identifierName) || node.name);
       this.word(this.tokenMap ? this._getRawIdentifier(node) : node.name);
@@ -59070,7 +59070,7 @@ var require_types3 = __commonJS({
     Object.defineProperty(exports2, "__esModule", {
       value: true
     });
-    exports2.Identifier = Identifier28;
+    exports2.Identifier = Identifier29;
     exports2.SpreadElement = exports2.RestElement = RestElement;
     exports2.ObjectPattern = exports2.ObjectExpression = ObjectExpression;
     exports2.ObjectMethod = ObjectMethod3;
@@ -59120,7 +59120,7 @@ var require_types3 = __commonJS({
         return newObj;
       }
     }
-    function Identifier28(node) {
+    function Identifier29(node) {
       this.exactSource(node.loc, () => {
         this.word(node.name);
       });
@@ -71106,7 +71106,7 @@ function newBlock(id, kind) {
 }
 var _completed, _current, _entry, _scopes, _context, _bindings, _env, _exceptionHandlerStack, _HIRBuilder_instances, resolveBabelBinding_fn;
 var HIRBuilder = class {
-  constructor(env, parentFunction, bindings = null, context = null) {
+  constructor(env, options) {
     __privateAdd(this, _HIRBuilder_instances);
     __privateAdd(this, _completed, /* @__PURE__ */ new Map());
     __privateAdd(this, _current);
@@ -71122,12 +71122,12 @@ var HIRBuilder = class {
      * of the current babel node.
      */
     this.fbtDepth = 0;
+    var _a, _b, _c;
     __privateSet(this, _env, env);
-    __privateSet(this, _bindings, bindings != null ? bindings : /* @__PURE__ */ new Map());
-    this.parentFunction = parentFunction;
-    __privateSet(this, _context, context != null ? context : []);
+    __privateSet(this, _bindings, (_a = options == null ? void 0 : options.bindings) != null ? _a : /* @__PURE__ */ new Map());
+    __privateSet(this, _context, (_b = options == null ? void 0 : options.context) != null ? _b : []);
     __privateSet(this, _entry, makeBlockId(env.nextBlockId));
-    __privateSet(this, _current, newBlock(__privateGet(this, _entry), "block"));
+    __privateSet(this, _current, newBlock(__privateGet(this, _entry), (_c = options == null ? void 0 : options.entryBlockKind) != null ? _c : "block"));
   }
   get nextIdentifierId() {
     return __privateGet(this, _env).nextIdentifierId;
@@ -71211,7 +71211,7 @@ var HIRBuilder = class {
     if (babelBinding == null) {
       return { kind: "Global", name: originalName };
     }
-    const outerBinding = this.parentFunction.scope.parent.getBinding(originalName);
+    const outerBinding = __privateGet(this, _env).parentFunction.scope.parent.getBinding(originalName);
     if (babelBinding === outerBinding) {
       const path2 = babelBinding.path;
       if (path2.isImportDefaultSpecifier()) {
@@ -71256,7 +71256,7 @@ var HIRBuilder = class {
   isContextIdentifier(path) {
     const binding = __privateMethod(this, _HIRBuilder_instances, resolveBabelBinding_fn).call(this, path);
     if (binding) {
-      const outerBinding = this.parentFunction.scope.parent.getBinding(
+      const outerBinding = __privateGet(this, _env).parentFunction.scope.parent.getBinding(
         path.node.name
       );
       if (binding === outerBinding) {
@@ -71347,6 +71347,7 @@ var HIRBuilder = class {
       const nextId = __privateGet(this, _env).nextBlockId;
       __privateSet(this, _current, newBlock(nextId, nextBlockKind));
     }
+    return blockId;
   }
   /*
    * Terminate the current block w the given terminal, and set the previously
@@ -71588,6 +71589,11 @@ function getReversePostorderedBlocks(func) {
       return;
     }
     const block = func.blocks.get(blockId);
+    CompilerError.invariant(block != null, {
+      reason: "[HIRBuilder] Unexpected null block",
+      description: `expected block ${blockId} to exist`,
+      loc: GeneratedSource
+    });
     const successors = [...eachTerminalSuccessor(block.terminal)].reverse();
     const fallthrough = terminalFallthrough(block.terminal);
     if (fallthrough != null) {
@@ -72696,9 +72702,12 @@ var DefaultNonmutatingHook = addHook(
 );
 
 // src/HIR/BuildHIR.ts
-function lower(func, env, bindings = null, capturedRefs = [], parent = null) {
+function lower(func, env, bindings = null, capturedRefs = []) {
   var _a, _b, _c;
-  const builder = new HIRBuilder(env, parent != null ? parent : func, bindings, capturedRefs);
+  const builder = new HIRBuilder(env, {
+    bindings,
+    context: capturedRefs
+  });
   const context = [];
   for (const ref of capturedRefs != null ? capturedRefs : []) {
     context.push({
@@ -72827,7 +72836,7 @@ function lower(func, env, bindings = null, capturedRefs = [], parent = null) {
   return Ok({
     id,
     params,
-    fnType: parent == null ? env.fnType : "Other",
+    fnType: bindings == null ? env.fnType : "Other",
     returnTypeAnnotation: null,
     // TODO: extract the actual return type node if present
     returnType: makeType(),
@@ -75620,15 +75629,12 @@ function lowerFunctionToValue(builder, expr) {
   };
 }
 function lowerFunction(builder, expr) {
-  const componentScope = builder.parentFunction.scope;
+  const componentScope = builder.environment.parentFunction.scope;
   const capturedContext = gatherCapturedContext(expr, componentScope);
-  const lowering = lower(
-    expr,
-    builder.environment,
-    builder.bindings,
-    [...builder.context, ...capturedContext],
-    builder.parentFunction
-  );
+  const lowering = lower(expr, builder.environment, builder.bindings, [
+    ...builder.context,
+    ...capturedContext
+  ]);
   let loweredFunc;
   if (lowering.isErr()) {
     lowering.unwrapErr().details.forEach((detail) => builder.errors.pushErrorDetail(detail));
@@ -78179,7 +78185,7 @@ var EnvironmentConfigSchema = z.object({
 });
 var _globals, _shapes, _moduleTypes, _nextIdentifer, _nextBlock, _nextScope, _scope, _outlinedFunctions, _contextIdentifiers, _hoistedIdentifiers, _Environment_instances, resolveModuleType_fn, isKnownReactModule_fn, getCustomHookType_fn;
 var Environment = class {
-  constructor(scope, fnType, compilerMode, config, contextIdentifiers, logger, filename, code, programContext) {
+  constructor(scope, fnType, compilerMode, config, contextIdentifiers, parentFunction, logger, filename, code, programContext) {
     __privateAdd(this, _Environment_instances);
     __privateAdd(this, _globals);
     __privateAdd(this, _shapes);
@@ -78236,6 +78242,7 @@ var Environment = class {
       const reanimatedModuleType = getReanimatedModuleType(__privateGet(this, _shapes));
       __privateGet(this, _moduleTypes).set(REANIMATED_MODULE_NAME, reanimatedModuleType);
     }
+    this.parentFunction = parentFunction;
     __privateSet(this, _contextIdentifiers, contextIdentifiers);
     __privateSet(this, _hoistedIdentifiers, /* @__PURE__ */ new Set());
   }
@@ -85690,6 +85697,7 @@ function canMergeScopes(current, next) {
     new Set(
       [...current.scope.declarations.values()].map((declaration) => ({
         identifier: declaration.identifier,
+        reactive: true,
         path: []
       }))
     ),
@@ -90193,6 +90201,29 @@ function inferReactivePlaces(fn) {
       }
     }
   } while (reactiveIdentifiers.snapshot());
+  function propagateReactivityToInnerFunctions(fn2, isOutermost) {
+    for (const [, block] of fn2.body.blocks) {
+      for (const instr of block.instructions) {
+        if (!isOutermost) {
+          for (const operand of eachInstructionOperand(instr)) {
+            reactiveIdentifiers.isReactive(operand);
+          }
+        }
+        if (instr.value.kind === "ObjectMethod" || instr.value.kind === "FunctionExpression") {
+          propagateReactivityToInnerFunctions(
+            instr.value.loweredFunc.func,
+            false
+          );
+        }
+      }
+      if (!isOutermost) {
+        for (const operand of eachTerminalOperand(block.terminal)) {
+          reactiveIdentifiers.isReactive(operand);
+        }
+      }
+    }
+  }
+  propagateReactivityToInnerFunctions(fn, true);
 }
 function postDominatorFrontier(fn, postDominators, targetId) {
   const visited = /* @__PURE__ */ new Set();
@@ -90452,7 +90483,7 @@ var PropertyPathRegistry = class _PropertyPathRegistry {
   constructor() {
     this.roots = /* @__PURE__ */ new Map();
   }
-  getOrCreateIdentifier(identifier4) {
+  getOrCreateIdentifier(identifier4, reactive) {
     let rootNode = this.roots.get(identifier4.id);
     if (rootNode === void 0) {
       rootNode = {
@@ -90461,12 +90492,18 @@ var PropertyPathRegistry = class _PropertyPathRegistry {
         optionalProperties: /* @__PURE__ */ new Map(),
         fullPath: {
           identifier: identifier4,
+          reactive,
           path: []
         },
         hasOptional: false,
         parent: null
       };
       this.roots.set(identifier4.id, rootNode);
+    } else {
+      CompilerError.invariant(reactive === rootNode.fullPath.reactive, {
+        reason: "[HoistablePropertyLoads] Found inconsistencies in `reactive` flag when deduping identifier reads within the same scope",
+        loc: identifier4.loc
+      });
     }
     return rootNode;
   }
@@ -90480,6 +90517,7 @@ var PropertyPathRegistry = class _PropertyPathRegistry {
         parent,
         fullPath: {
           identifier: parent.fullPath.identifier,
+          reactive: parent.fullPath.reactive,
           path: parent.fullPath.path.concat(entry)
         },
         hasOptional: parent.hasOptional || entry.optional
@@ -90489,7 +90527,7 @@ var PropertyPathRegistry = class _PropertyPathRegistry {
     return child;
   }
   getOrCreateProperty(n) {
-    let currNode = this.getOrCreateIdentifier(n.identifier);
+    let currNode = this.getOrCreateIdentifier(n.identifier, n.reactive);
     if (n.path.length === 0) {
       return currNode;
     }
@@ -90511,6 +90549,7 @@ function getMaybeNonNullInInstruction(instr, context) {
   if (instr.kind === "PropertyLoad") {
     path = (_a = context.temporaries.get(instr.object.identifier.id)) != null ? _a : {
       identifier: instr.object.identifier,
+      reactive: instr.object.reactive,
       path: []
     };
   } else if (instr.kind === "Destructure") {
@@ -90539,7 +90578,7 @@ function collectNonNullsInBlocks(fn, context) {
   if (fn.fnType === "Component" && fn.params.length > 0 && fn.params[0].kind === "Identifier") {
     const identifier4 = fn.params[0].identifier;
     knownNonNullIdentifiers.add(
-      context.registry.getOrCreateIdentifier(identifier4)
+      context.registry.getOrCreateIdentifier(identifier4, true)
     );
   }
   const nodes = /* @__PURE__ */ new Map();
@@ -90684,8 +90723,11 @@ function reduceMaybeOptionalChains(nodes, registry) {
   do {
     changed = false;
     for (const original of optionalChainNodes) {
-      let { identifier: identifier4, path: origPath } = original.fullPath;
-      let currNode = registry.getOrCreateIdentifier(identifier4);
+      let { identifier: identifier4, path: origPath, reactive } = original.fullPath;
+      let currNode = registry.getOrCreateIdentifier(
+        identifier4,
+        reactive
+      );
       for (let i = 0; i < origPath.length; i++) {
         const entry = origPath[i];
         const nextEntry = entry.optional && nodes.has(currNode) ? { property: entry.property, optional: false } : entry;
@@ -90905,6 +90947,7 @@ function traverseOptionalBlock(optional, context, outerAlternate) {
     );
     baseObject = {
       identifier: maybeTest.instructions[0].value.place.identifier,
+      reactive: maybeTest.instructions[0].value.place.reactive,
       path
     };
     test = maybeTest.terminal;
@@ -90960,6 +91003,7 @@ function traverseOptionalBlock(optional, context, outerAlternate) {
   );
   const load = {
     identifier: baseObject.identifier,
+    reactive: baseObject.reactive,
     path: [
       ...baseObject.path,
       {
@@ -90996,8 +91040,8 @@ var _ReactiveScopeDependencyTreeHIR = class _ReactiveScopeDependencyTreeHIR {
     __privateAdd(this, _hoistableObjects, /* @__PURE__ */ new Map());
     __privateAdd(this, _deps, /* @__PURE__ */ new Map());
     var _a, _b;
-    for (const { path, identifier: identifier4 } of hoistableObjects) {
-      let currNode = __privateMethod(_a = _ReactiveScopeDependencyTreeHIR, _ReactiveScopeDependencyTreeHIR_static, getOrCreateRoot_fn).call(_a, identifier4, __privateGet(this, _hoistableObjects), path.length > 0 && path[0].optional ? "Optional" : "NonNull");
+    for (const { path, identifier: identifier4, reactive } of hoistableObjects) {
+      let currNode = __privateMethod(_a = _ReactiveScopeDependencyTreeHIR, _ReactiveScopeDependencyTreeHIR_static, getOrCreateRoot_fn).call(_a, identifier4, reactive, __privateGet(this, _hoistableObjects), path.length > 0 && path[0].optional ? "Optional" : "NonNull");
       for (let i = 0; i < path.length; i++) {
         const prevAccessType = (_b = currNode.properties.get(
           path[i].property
@@ -91029,8 +91073,8 @@ var _ReactiveScopeDependencyTreeHIR = class _ReactiveScopeDependencyTreeHIR {
    */
   addDependency(dep) {
     var _a;
-    const { identifier: identifier4, path } = dep;
-    let depCursor = __privateMethod(_a = _ReactiveScopeDependencyTreeHIR, _ReactiveScopeDependencyTreeHIR_static, getOrCreateRoot_fn).call(_a, identifier4, __privateGet(this, _deps), "UnconditionalAccess" /* UnconditionalAccess */);
+    const { identifier: identifier4, reactive, path } = dep;
+    let depCursor = __privateMethod(_a = _ReactiveScopeDependencyTreeHIR, _ReactiveScopeDependencyTreeHIR_static, getOrCreateRoot_fn).call(_a, identifier4, reactive, __privateGet(this, _deps), "UnconditionalAccess" /* UnconditionalAccess */);
     let hoistableCursor = __privateGet(this, _hoistableObjects).get(identifier4);
     for (const entry of path) {
       let nextHoistableCursor;
@@ -91071,7 +91115,13 @@ var _ReactiveScopeDependencyTreeHIR = class _ReactiveScopeDependencyTreeHIR {
   deriveMinimalDependencies() {
     const results = /* @__PURE__ */ new Set();
     for (const [rootId, rootNode] of __privateGet(this, _deps).entries()) {
-      collectMinimalDependenciesInSubtree(rootNode, rootId, [], results);
+      collectMinimalDependenciesInSubtree(
+        rootNode,
+        rootNode.reactive,
+        rootId,
+        [],
+        results
+      );
     }
     return results;
   }
@@ -91103,14 +91153,21 @@ var _ReactiveScopeDependencyTreeHIR = class _ReactiveScopeDependencyTreeHIR {
 _hoistableObjects = new WeakMap();
 _deps = new WeakMap();
 _ReactiveScopeDependencyTreeHIR_static = new WeakSet();
-getOrCreateRoot_fn = function(identifier4, roots, defaultAccessType) {
+getOrCreateRoot_fn = function(identifier4, reactive, roots, defaultAccessType) {
   let rootNode = roots.get(identifier4);
   if (rootNode === void 0) {
     rootNode = {
       properties: /* @__PURE__ */ new Map(),
+      reactive,
       accessType: defaultAccessType
     };
     roots.set(identifier4, rootNode);
+  } else {
+    CompilerError.invariant(reactive === rootNode.reactive, {
+      reason: "[DeriveMinimalDependenciesHIR] Conflicting reactive root flag",
+      description: `Identifier ${printIdentifier(identifier4)}`,
+      loc: GeneratedSource
+    });
   }
   return rootNode;
 };
@@ -91145,13 +91202,14 @@ function merge(access1, access2) {
     }
   }
 }
-function collectMinimalDependenciesInSubtree(node, rootIdentifier, path, results) {
+function collectMinimalDependenciesInSubtree(node, reactive, rootIdentifier, path, results) {
   if (isDependency(node.accessType)) {
-    results.add({ identifier: rootIdentifier, path });
+    results.add({ identifier: rootIdentifier, reactive, path });
   } else {
     for (const [childName, childNode] of node.properties) {
       collectMinimalDependenciesInSubtree(
         childNode,
+        reactive,
         rootIdentifier,
         [
           ...path,
@@ -91319,6 +91377,7 @@ function collectTemporariesSidemapImpl(fn, usedOutsideDeclaringScope, temporarie
         )) {
           temporaries.set(lvalue.identifier.id, {
             identifier: value.place.identifier,
+            reactive: value.place.reactive,
             path: []
           });
         }
@@ -91339,11 +91398,13 @@ function getProperty(object, propertyName, optional, temporaries) {
   if (resolvedDependency == null) {
     property = {
       identifier: object.identifier,
+      reactive: object.reactive,
       path: [{ property: propertyName, optional }]
     };
   } else {
     property = {
       identifier: resolvedDependency.identifier,
+      reactive: resolvedDependency.reactive,
       path: [...resolvedDependency.path, { property: propertyName, optional }]
     };
   }
@@ -91432,6 +91493,7 @@ var DependencyCollectionContext = class {
     this.visitDependency(
       (_a = __privateGet(this, _temporaries).get(place.identifier.id)) != null ? _a : {
         identifier: place.identifier,
+        reactive: place.reactive,
         path: []
       }
     );
@@ -91466,6 +91528,7 @@ var DependencyCollectionContext = class {
     if (isUseRefType(maybeDependency.identifier) && ((_a = maybeDependency.path.at(0)) == null ? void 0 : _a.property) === "current") {
       maybeDependency = {
         identifier: maybeDependency.identifier,
+        reactive: maybeDependency.reactive,
         path: []
       };
     }
@@ -91482,7 +91545,11 @@ var DependencyCollectionContext = class {
     if (currentScope != null && !Iterable_some(
       currentScope.reassignments,
       (identifier4) => identifier4.declarationId === place.identifier.declarationId
-    ) && __privateMethod(this, _DependencyCollectionContext_instances, checkValidDependency_fn).call(this, { identifier: place.identifier, path: [] })) {
+    ) && __privateMethod(this, _DependencyCollectionContext_instances, checkValidDependency_fn).call(this, {
+      identifier: place.identifier,
+      reactive: place.reactive,
+      path: []
+    })) {
       currentScope.reassignments.add(place.identifier);
     }
   }
@@ -91654,10 +91721,215 @@ function collectDependencies(fn, usedOutsideDeclaringScope, temporaries, process
   return context.deps;
 }
 
+// src/HIR/ScopeDependencyUtils.ts
+function buildDependencyInstructions(dep, env) {
+  const builder = new HIRBuilder(env, {
+    entryBlockKind: "value"
+  });
+  let dependencyValue;
+  if (dep.path.every((path) => !path.optional)) {
+    dependencyValue = writeNonOptionalDependency(dep, env, builder);
+  } else {
+    dependencyValue = writeOptionalDependency(dep, builder, null);
+  }
+  const exitBlockId = builder.terminate(
+    {
+      kind: "unsupported",
+      loc: GeneratedSource,
+      id: makeInstructionId(0)
+    },
+    null
+  );
+  return {
+    place: {
+      kind: "Identifier",
+      identifier: dependencyValue,
+      effect: "freeze" /* Freeze */,
+      reactive: dep.reactive,
+      loc: GeneratedSource
+    },
+    value: builder.build(),
+    exitBlockId
+  };
+}
+function writeNonOptionalDependency(dep, env, builder) {
+  const loc = dep.identifier.loc;
+  let curr = makeTemporaryIdentifier(env.nextIdentifierId, loc);
+  builder.push({
+    lvalue: {
+      identifier: curr,
+      kind: "Identifier",
+      effect: "mutate" /* Mutate */,
+      reactive: dep.reactive,
+      loc
+    },
+    value: {
+      kind: "LoadLocal",
+      place: {
+        identifier: dep.identifier,
+        kind: "Identifier",
+        effect: "freeze" /* Freeze */,
+        reactive: dep.reactive,
+        loc
+      },
+      loc
+    },
+    id: makeInstructionId(1),
+    loc
+  });
+  for (const path of dep.path) {
+    const next = makeTemporaryIdentifier(env.nextIdentifierId, loc);
+    builder.push({
+      lvalue: {
+        identifier: next,
+        kind: "Identifier",
+        effect: "mutate" /* Mutate */,
+        reactive: dep.reactive,
+        loc
+      },
+      value: {
+        kind: "PropertyLoad",
+        object: {
+          identifier: curr,
+          kind: "Identifier",
+          effect: "freeze" /* Freeze */,
+          reactive: dep.reactive,
+          loc
+        },
+        property: path.property,
+        loc
+      },
+      id: makeInstructionId(1),
+      loc
+    });
+    curr = next;
+  }
+  return curr;
+}
+function writeOptionalDependency(dep, builder, parentAlternate) {
+  const env = builder.environment;
+  const dependencyValue = {
+    kind: "Identifier",
+    identifier: makeTemporaryIdentifier(env.nextIdentifierId, GeneratedSource),
+    effect: "mutate" /* Mutate */,
+    reactive: dep.reactive,
+    loc: GeneratedSource
+  };
+  const continuationBlock = builder.reserve(builder.currentBlockKind());
+  let alternate;
+  if (parentAlternate != null) {
+    alternate = parentAlternate;
+  } else {
+    alternate = builder.enter("value", () => {
+      const temp = lowerValueToTemporary(builder, {
+        kind: "Primitive",
+        value: void 0,
+        loc: GeneratedSource
+      });
+      lowerValueToTemporary(builder, {
+        kind: "StoreLocal",
+        lvalue: { kind: "Const" /* Const */, place: __spreadValues({}, dependencyValue) },
+        value: __spreadValues({}, temp),
+        type: null,
+        loc: GeneratedSource
+      });
+      return {
+        kind: "goto",
+        variant: "Break" /* Break */,
+        block: continuationBlock.id,
+        id: makeInstructionId(0),
+        loc: GeneratedSource
+      };
+    });
+  }
+  const consequent = builder.reserve("value");
+  let testIdentifier = null;
+  const testBlock = builder.enter("value", () => {
+    const testDependency = __spreadProps(__spreadValues({}, dep), {
+      path: dep.path.slice(0, dep.path.length - 1)
+    });
+    const firstOptional = dep.path.findIndex((path) => path.optional);
+    CompilerError.invariant(firstOptional !== -1, {
+      reason: "[ScopeDependencyUtils] Internal invariant broken: expected optional path",
+      loc: dep.identifier.loc,
+      description: null,
+      suggestions: null
+    });
+    if (firstOptional === dep.path.length - 1) {
+      testIdentifier = writeNonOptionalDependency(testDependency, env, builder);
+    } else {
+      testIdentifier = writeOptionalDependency(
+        testDependency,
+        builder,
+        alternate
+      );
+    }
+    return {
+      kind: "branch",
+      test: {
+        identifier: testIdentifier,
+        effect: "freeze" /* Freeze */,
+        kind: "Identifier",
+        loc: GeneratedSource,
+        reactive: dep.reactive
+      },
+      consequent: consequent.id,
+      alternate,
+      id: makeInstructionId(0),
+      loc: GeneratedSource,
+      fallthrough: continuationBlock.id
+    };
+  });
+  builder.enterReserved(consequent, () => {
+    CompilerError.invariant(testIdentifier !== null, {
+      reason: "Satisfy type checker",
+      description: null,
+      loc: null,
+      suggestions: null
+    });
+    lowerValueToTemporary(builder, {
+      kind: "StoreLocal",
+      lvalue: { kind: "Const" /* Const */, place: __spreadValues({}, dependencyValue) },
+      value: lowerValueToTemporary(builder, {
+        kind: "PropertyLoad",
+        object: {
+          identifier: testIdentifier,
+          kind: "Identifier",
+          effect: "freeze" /* Freeze */,
+          reactive: dep.reactive,
+          loc: GeneratedSource
+        },
+        property: dep.path.at(-1).property,
+        loc: GeneratedSource
+      }),
+      type: null,
+      loc: GeneratedSource
+    });
+    return {
+      kind: "goto",
+      variant: "Break" /* Break */,
+      block: continuationBlock.id,
+      id: makeInstructionId(0),
+      loc: GeneratedSource
+    };
+  });
+  builder.terminateWithContinuation(
+    {
+      kind: "optional",
+      optional: dep.path.at(-1).optional,
+      test: testBlock,
+      fallthrough: continuationBlock.id,
+      id: makeInstructionId(0),
+      loc: GeneratedSource
+    },
+    continuationBlock
+  );
+  return dependencyValue.identifier;
+}
+
 // src/Inference/InferEffectDependencies.ts
 function inferEffectDependencies(fn) {
   var _a, _b;
-  let hasRewrite = false;
   const fnExpressions = /* @__PURE__ */ new Map();
   const autodepFnConfigs = /* @__PURE__ */ new Map();
   for (const effectTarget of fn.env.config.inferEffectDependencies) {
@@ -91676,6 +91948,7 @@ function inferEffectDependencies(fn) {
   const scopeInfos = /* @__PURE__ */ new Map();
   const loadGlobals = /* @__PURE__ */ new Set();
   const reactiveIds = inferReactiveIdentifiers(fn);
+  const rewriteBlocks = [];
   for (const [, block] of fn.body.blocks) {
     if (block.terminal.kind === "scope") {
       const scopeBlock = fn.body.blocks.get(block.terminal.block);
@@ -91686,7 +91959,7 @@ function inferEffectDependencies(fn) {
         );
       }
     }
-    const rewriteInstrs = /* @__PURE__ */ new Map();
+    const rewriteInstrs = [];
     for (const instr of block.instructions) {
       const { value, lvalue } = instr;
       if (value.kind === "FunctionExpression") {
@@ -91727,7 +92000,6 @@ function inferEffectDependencies(fn) {
         const callee = value.kind === "CallExpression" ? value.callee : value.property;
         if (value.args.length === autodepFnLoads.get(callee.identifier.id) && value.args[0].kind === "Identifier") {
           const effectDeps = [];
-          const newInstructions = [];
           const deps = {
             kind: "ArrayExpression",
             elements: effectDeps,
@@ -91745,17 +92017,21 @@ function inferEffectDependencies(fn) {
               minimalDeps = inferMinimalDependencies(fnExpr);
             }
             const usedDeps = [];
-            for (const dep of minimalDeps) {
-              if ((isUseRefType(dep.identifier) || isSetStateType(dep.identifier)) && !reactiveIds.has(dep.identifier.id) || isFireFunctionType(dep.identifier)) {
+            for (const maybeDep of minimalDeps) {
+              if ((isUseRefType(maybeDep.identifier) || isSetStateType(maybeDep.identifier)) && !reactiveIds.has(maybeDep.identifier.id) || isFireFunctionType(maybeDep.identifier)) {
                 continue;
               }
-              const { place, instructions } = writeDependencyToInstructions(
+              const dep = truncateDepAtCurrent(maybeDep);
+              const { place, value: value2, exitBlockId } = buildDependencyInstructions(
                 dep,
-                reactiveIds.has(dep.identifier.id),
-                fn.env,
-                fnExpr.loc
+                fn.env
               );
-              newInstructions.push(...instructions);
+              rewriteInstrs.push({
+                kind: "block",
+                location: instr.id,
+                value: value2,
+                exitBlockId
+              });
               effectDeps.push(place);
               usedDeps.push(dep);
             }
@@ -91773,24 +92049,30 @@ function inferEffectDependencies(fn) {
                 decorations
               });
             }
-            newInstructions.push({
-              id: makeInstructionId(0),
-              loc: GeneratedSource,
-              lvalue: __spreadProps(__spreadValues({}, depsPlace), { effect: "mutate" /* Mutate */ }),
-              value: deps
+            rewriteInstrs.push({
+              kind: "instr",
+              location: instr.id,
+              value: {
+                id: makeInstructionId(0),
+                loc: GeneratedSource,
+                lvalue: __spreadProps(__spreadValues({}, depsPlace), { effect: "mutate" /* Mutate */ }),
+                value: deps
+              }
             });
             value.args.push(__spreadProps(__spreadValues({}, depsPlace), { effect: "freeze" /* Freeze */ }));
-            rewriteInstrs.set(instr.id, newInstructions);
             fn.env.inferredEffectLocations.add(callee.loc);
           } else if (loadGlobals.has(value.args[0].identifier.id)) {
-            newInstructions.push({
-              id: makeInstructionId(0),
-              loc: GeneratedSource,
-              lvalue: __spreadProps(__spreadValues({}, depsPlace), { effect: "mutate" /* Mutate */ }),
-              value: deps
+            rewriteInstrs.push({
+              kind: "instr",
+              location: instr.id,
+              value: {
+                id: makeInstructionId(0),
+                loc: GeneratedSource,
+                lvalue: __spreadProps(__spreadValues({}, depsPlace), { effect: "mutate" /* Mutate */ }),
+                value: deps
+              }
             });
             value.args.push(__spreadProps(__spreadValues({}, depsPlace), { effect: "freeze" /* Freeze */ }));
-            rewriteInstrs.set(instr.id, newInstructions);
             fn.env.inferredEffectLocations.add(callee.loc);
           }
         } else if (value.args.length >= 2 && value.args.length - 1 === autodepFnLoads.get(callee.identifier.id) && value.args[0] != null && value.args[0].kind === "Identifier") {
@@ -91809,70 +92091,81 @@ function inferEffectDependencies(fn) {
         }
       }
     }
-    if (rewriteInstrs.size > 0) {
-      hasRewrite = true;
-      const newInstrs = [];
-      for (const instr of block.instructions) {
-        const newInstr = rewriteInstrs.get(instr.id);
-        if (newInstr != null) {
-          newInstrs.push(...newInstr, instr);
-        } else {
-          newInstrs.push(instr);
-        }
-      }
-      block.instructions = newInstrs;
-    }
+    rewriteSplices(block, rewriteInstrs, rewriteBlocks);
   }
-  if (hasRewrite) {
+  if (rewriteBlocks.length > 0) {
+    for (const block of rewriteBlocks) {
+      fn.body.blocks.set(block.id, block);
+    }
+    reversePostorderBlocks(fn.body);
+    markPredecessors(fn.body);
     markInstructionIds(fn.body);
     fixScopeAndIdentifierRanges(fn.body);
     fn.env.hasInferredEffect = true;
   }
 }
-function writeDependencyToInstructions(dep, reactive, env, loc) {
-  const instructions = [];
-  let currValue = createTemporaryPlace(env, GeneratedSource);
-  currValue.reactive = reactive;
-  instructions.push({
-    id: makeInstructionId(0),
-    loc: GeneratedSource,
-    lvalue: __spreadProps(__spreadValues({}, currValue), { effect: "mutate" /* Mutate */ }),
-    value: {
-      kind: "LoadLocal",
-      place: {
-        kind: "Identifier",
-        identifier: dep.identifier,
-        effect: "capture" /* Capture */,
-        reactive,
-        loc
-      },
-      loc
-    }
-  });
-  for (const path of dep.path) {
-    if (path.optional) {
-      break;
-    }
-    if (path.property === "current") {
-      break;
+function truncateDepAtCurrent(dep) {
+  const idx = dep.path.findIndex((path) => path.property === "current");
+  if (idx === -1) {
+    return dep;
+  } else {
+    return __spreadProps(__spreadValues({}, dep), { path: dep.path.slice(0, idx) });
+  }
+}
+function rewriteSplices(originalBlock, splices, rewriteBlocks) {
+  if (splices.length === 0) {
+    return;
+  }
+  const originalInstrs = originalBlock.instructions;
+  let currBlock = __spreadProps(__spreadValues({}, originalBlock), { instructions: [] });
+  rewriteBlocks.push(currBlock);
+  let cursor = 0;
+  for (const rewrite of splices) {
+    while (originalInstrs[cursor].id < rewrite.location) {
+      CompilerError.invariant(
+        originalInstrs[cursor].id < originalInstrs[cursor + 1].id,
+        {
+          reason: "[InferEffectDependencies] Internal invariant broken: expected block instructions to be sorted",
+          loc: originalInstrs[cursor].loc
+        }
+      );
+      currBlock.instructions.push(originalInstrs[cursor]);
+      cursor++;
     }
-    const nextValue = createTemporaryPlace(env, GeneratedSource);
-    nextValue.reactive = reactive;
-    instructions.push({
-      id: makeInstructionId(0),
-      loc: GeneratedSource,
-      lvalue: __spreadProps(__spreadValues({}, nextValue), { effect: "mutate" /* Mutate */ }),
-      value: {
-        kind: "PropertyLoad",
-        object: __spreadProps(__spreadValues({}, currValue), { effect: "capture" /* Capture */ }),
-        property: path.property,
-        loc
-      }
+    CompilerError.invariant(originalInstrs[cursor].id === rewrite.location, {
+      reason: "[InferEffectDependencies] Internal invariant broken: splice location not found",
+      loc: originalInstrs[cursor].loc
     });
-    currValue = nextValue;
+    if (rewrite.kind === "instr") {
+      currBlock.instructions.push(rewrite.value);
+    } else {
+      const { entry, blocks } = rewrite.value;
+      const entryBlock = blocks.get(entry);
+      currBlock.instructions.push(...entryBlock.instructions);
+      if (blocks.size > 1) {
+        CompilerError.invariant(
+          terminalFallthrough(entryBlock.terminal) === rewrite.exitBlockId,
+          {
+            reason: "[InferEffectDependencies] Internal invariant broken: expected entry block to have a fallthrough",
+            loc: entryBlock.terminal.loc
+          }
+        );
+        const originalTerminal = currBlock.terminal;
+        currBlock.terminal = entryBlock.terminal;
+        for (const [id, block] of blocks) {
+          if (id === entry) {
+            continue;
+          }
+          if (id === rewrite.exitBlockId) {
+            block.terminal = originalTerminal;
+            currBlock = block;
+          }
+          rewriteBlocks.push(block);
+        }
+      }
+    }
   }
-  currValue.effect = "freeze" /* Freeze */;
-  return { place: currValue, instructions };
+  currBlock.instructions.push(...originalInstrs.slice(cursor));
 }
 function inferReactiveIdentifiers(fn) {
   const reactiveIds = /* @__PURE__ */ new Set();
@@ -96587,6 +96880,7 @@ function run(func, config, fnType, mode, programContext, logger, filename, code)
     mode,
     config,
     contextIdentifiers,
+    func,
     logger,
     filename,
     code,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-react-compiler",
-  "version": "0.0.0-experimental-f980e29-20250522",
+  "version": "0.0.0-experimental-8f8b1db-20250523",
   "description": "Babel plugin for React Compiler.",
   "main": "dist/index.js",
   "license": "MIT",