babel-plugin-react-compiler 0.0.0-experimental-63a5f0f-20250501 → 0.0.0-experimental-7bde208-20250505

package/dist/index.d.ts

@@ -242,6 +242,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     validateNoCapitalizedCalls: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
     validateBlocklistedImports: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
     validateNoImpureFunctionsInRender: z.ZodDefault<z.ZodBoolean>;
+    validateNoFreezingKnownMutableFunctions: z.ZodDefault<z.ZodBoolean>;
     enableAssumeHooksFollowRulesOfReact: z.ZodDefault<z.ZodBoolean>;
     enableTransitivelyFreezeFunctionExpressions: z.ZodDefault<z.ZodBoolean>;
     enableEmitFreeze: z.ZodDefault<z.ZodNullable<z.ZodObject<{
@@ -402,6 +403,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     validateNoCapitalizedCalls: string[] | null;
     validateBlocklistedImports: string[] | null;
     validateNoImpureFunctionsInRender: boolean;
+    validateNoFreezingKnownMutableFunctions: boolean;
     enableAssumeHooksFollowRulesOfReact: boolean;
     enableTransitivelyFreezeFunctionExpressions: boolean;
     enableEmitFreeze: {
@@ -486,6 +488,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     validateNoCapitalizedCalls?: string[] | null | undefined;
     validateBlocklistedImports?: string[] | null | undefined;
     validateNoImpureFunctionsInRender?: boolean | undefined;
+    validateNoFreezingKnownMutableFunctions?: boolean | undefined;
     enableAssumeHooksFollowRulesOfReact?: boolean | undefined;
     enableTransitivelyFreezeFunctionExpressions?: boolean | undefined;
     enableEmitFreeze?: {

package/dist/index.js

@@ -5855,7 +5855,7 @@ var require_parentheses = __commonJS({
     exports2.DoExpression = DoExpression;
     exports2.FunctionExpression = FunctionExpression7;
     exports2.FunctionTypeAnnotation = FunctionTypeAnnotation;
-    exports2.Identifier = Identifier27;
+    exports2.Identifier = Identifier28;
     exports2.LogicalExpression = LogicalExpression;
     exports2.NullableTypeAnnotation = NullableTypeAnnotation;
     exports2.ObjectExpression = ObjectExpression;
@@ -6070,7 +6070,7 @@ var require_parentheses = __commonJS({
           return parent.operator !== "??";
       }
     }
-    function Identifier27(node, parent, tokenContext, _inForInit, getRawIdentifier) {
+    function Identifier28(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 = Identifier27;
+    exports2.Identifier = Identifier28;
     exports2.NullLiteral = NullLiteral;
     exports2.NumericLiteral = NumericLiteral;
     exports2.ObjectPattern = exports2.ObjectExpression = ObjectExpression;
@@ -8077,7 +8077,7 @@ var require_types = __commonJS({
       }
       return lastRawIdentResult = node.name;
     }
-    function Identifier27(node) {
+    function Identifier28(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 = Identifier27;
+    exports2.Identifier = Identifier28;
     exports2.LogicalExpression = LogicalExpression;
     exports2.NullableTypeAnnotation = NullableTypeAnnotation;
     exports2.ObjectExpression = ObjectExpression;
@@ -34981,7 +34981,7 @@ var require_parentheses2 = __commonJS({
           return parent.operator !== "??";
       }
     }
-    function Identifier27(node, parent, tokenContext, _inForInit, getRawIdentifier) {
+    function Identifier28(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 = Identifier27;
+    exports2.Identifier = Identifier28;
     exports2.NullLiteral = NullLiteral;
     exports2.NumericLiteral = NumericLiteral;
     exports2.ObjectPattern = exports2.ObjectExpression = ObjectExpression;
@@ -36988,7 +36988,7 @@ var require_types2 = __commonJS({
       }
       return lastRawIdentResult = node.name;
     }
-    function Identifier27(node) {
+    function Identifier28(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 = Identifier27;
+    exports2.Identifier = Identifier28;
     exports2.SpreadElement = exports2.RestElement = RestElement;
     exports2.ObjectPattern = exports2.ObjectExpression = ObjectExpression;
     exports2.ObjectMethod = ObjectMethod3;
@@ -59120,7 +59120,7 @@ var require_types3 = __commonJS({
         return newObj;
       }
     }
-    function Identifier27(node) {
+    function Identifier28(node) {
       this.exactSource(node.loc, () => {
         this.word(node.name);
       });
@@ -68579,6 +68579,9 @@ function isUseStateType(id) {
 function isRefOrRefValue(id) {
   return isUseRefType(id) || isRefValueType(id);
 }
+function isRefOrRefLikeMutableType(type) {
+  return type.kind === "Object" && (type.shapeId === "BuiltInUseRefId" || type.shapeId == "ReanimatedSharedValueId");
+}
 function isSetStateType(id) {
   return id.type.kind === "Function" && id.type.shapeId === "BuiltInSetState";
 }
@@ -71773,6 +71776,8 @@ var BuiltInPropsId = "BuiltInProps";
 var BuiltInArrayId = "BuiltInArray";
 var BuiltInSetId = "BuiltInSet";
 var BuiltInMapId = "BuiltInMap";
+var BuiltInWeakSetId = "BuiltInWeakSet";
+var BuiltInWeakMapId = "BuiltInWeakMap";
 var BuiltInFunctionId = "BuiltInFunction";
 var BuiltInJsxId = "BuiltInJsx";
 var BuiltInObjectId = "BuiltInObject";
@@ -71794,6 +71799,7 @@ var BuiltInUseTransitionId = "BuiltInUseTransition";
 var BuiltInStartTransitionId = "BuiltInStartTransition";
 var BuiltInFireId = "BuiltInFire";
 var BuiltInFireFunctionId = "BuiltInFireFunction";
+var ReanimatedSharedValueId = "ReanimatedSharedValueId";
 var BUILTIN_SHAPES = /* @__PURE__ */ new Map();
 addObject(BUILTIN_SHAPES, BuiltInPropsId, [
   ["ref", { kind: "Object", shapeId: BuiltInUseRefId }]
@@ -72323,6 +72329,99 @@ addObject(BUILTIN_SHAPES, BuiltInMapId, [
     })
   ]
 ]);
+addObject(BUILTIN_SHAPES, BuiltInWeakSetId, [
+  [
+    /**
+     * add(value)
+     * Parameters
+     *   value: the value of the element to add to the Set object.
+     * Returns the Set object with added value.
+     */
+    "add",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: ["capture" /* Capture */],
+      restParam: null,
+      returnType: { kind: "Object", shapeId: BuiltInWeakSetId },
+      calleeEffect: "store" /* Store */,
+      // returnValueKind is technically dependent on the ValueKind of the set itself
+      returnValueKind: "mutable" /* Mutable */
+    })
+  ],
+  [
+    /**
+     * setInstance.delete(value)
+     * Returns true if value was already in Set; otherwise false.
+     */
+    "delete",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: ["read" /* Read */],
+      restParam: null,
+      returnType: PRIMITIVE_TYPE,
+      calleeEffect: "store" /* Store */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    "has",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: ["read" /* Read */],
+      restParam: null,
+      returnType: PRIMITIVE_TYPE,
+      calleeEffect: "read" /* Read */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ]
+]);
+addObject(BUILTIN_SHAPES, BuiltInWeakMapId, [
+  [
+    "delete",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: ["read" /* Read */],
+      restParam: null,
+      returnType: PRIMITIVE_TYPE,
+      calleeEffect: "store" /* Store */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    "get",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: ["read" /* Read */],
+      restParam: null,
+      returnType: { kind: "Poly" },
+      calleeEffect: "capture" /* Capture */,
+      returnValueKind: "mutable" /* Mutable */
+    })
+  ],
+  [
+    "has",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: ["read" /* Read */],
+      restParam: null,
+      returnType: PRIMITIVE_TYPE,
+      calleeEffect: "read" /* Read */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    /**
+     * Params
+     *   key: the key of the element to add to the Map object. The key may be
+     *   any JavaScript type (any primitive value or any type of JavaScript
+     *   object).
+     *   value: the value of the element to add to the Map object.
+     * Returns the Map object.
+     */
+    "set",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: ["capture" /* Capture */, "capture" /* Capture */],
+      restParam: null,
+      returnType: { kind: "Object", shapeId: BuiltInWeakMapId },
+      calleeEffect: "store" /* Store */,
+      returnValueKind: "mutable" /* Mutable */
+    })
+  ]
+]);
 addObject(BUILTIN_SHAPES, BuiltInUseStateId, [
   ["0", { kind: "Poly" }],
   [
@@ -77066,6 +77165,38 @@ var TYPED_GLOBALS = [
       null,
       true
     )
+  ],
+  [
+    "WeakMap",
+    addFunction(
+      DEFAULT_SHAPES,
+      [],
+      {
+        positionalParams: ["mutate-iterator?" /* ConditionallyMutateIterator */],
+        restParam: null,
+        returnType: { kind: "Object", shapeId: BuiltInWeakMapId },
+        calleeEffect: "read" /* Read */,
+        returnValueKind: "mutable" /* Mutable */
+      },
+      null,
+      true
+    )
+  ],
+  [
+    "WeakSet",
+    addFunction(
+      DEFAULT_SHAPES,
+      [],
+      {
+        positionalParams: ["mutate-iterator?" /* ConditionallyMutateIterator */],
+        restParam: null,
+        returnType: { kind: "Object", shapeId: BuiltInWeakSetId },
+        calleeEffect: "read" /* Read */,
+        returnValueKind: "mutable" /* Mutable */
+      },
+      null,
+      true
+    )
   ]
   // TODO: rest of Global objects
 ];
@@ -77457,7 +77588,7 @@ function getReanimatedModuleType(registry) {
       addHook(registry, {
         positionalParams: [],
         restParam: "freeze" /* Freeze */,
-        returnType: { kind: "Poly" },
+        returnType: { kind: "Object", shapeId: ReanimatedSharedValueId },
         returnValueKind: "mutable" /* Mutable */,
         noAlias: true,
         calleeEffect: "read" /* Read */,
@@ -77796,6 +77927,10 @@ var EnvironmentConfigSchema = z.object({
    * Validate against impure functions called during render
    */
   validateNoImpureFunctionsInRender: z.boolean().default(false),
+  /**
+   * Validate against passing mutable functions to hooks
+   */
+  validateNoFreezingKnownMutableFunctions: z.boolean().default(false),
   /*
    * When enabled, the compiler assumes that hooks follow the Rules of React:
    * - Hooks may memoize computation based on any of their parameters, thus
@@ -85025,7 +85160,7 @@ function codegenInstructionValue(cx, instrValue) {
   }
   return value;
 }
-var STRING_REQUIRES_EXPR_CONTAINER_PATTERN = /[\u{0000}-\u{001F}\u{007F}\u{0080}-\u{FFFF}]|"|\\/u;
+var STRING_REQUIRES_EXPR_CONTAINER_PATTERN = /[\u{0000}-\u{001F}\u{007F}\u{0080}-\u{FFFF}\u{010000}-\u{10FFFF}]|"|\\/u;
 function codegenJsxAttribute(cx, attribute) {
   switch (attribute.kind) {
     case "JsxAttribute": {
@@ -86274,7 +86409,8 @@ var EMPTY = new Empty();
 // src/ReactiveScopes/PruneHoistedContexts.ts
 function pruneHoistedContexts(fn) {
   visitReactiveFunction(fn, new Visitor3(), {
-    activeScopes: empty()
+    activeScopes: empty(),
+    uninitialized: /* @__PURE__ */ new Map()
   });
 }
 var Visitor3 = class extends ReactiveFunctionTransform {
@@ -86282,16 +86418,39 @@ var Visitor3 = class extends ReactiveFunctionTransform {
     state.activeScopes = state.activeScopes.push(
       new Set(scope.scope.declarations.keys())
     );
+    for (const decl of scope.scope.declarations.values()) {
+      state.uninitialized.set(decl.identifier.id, { kind: "unknown-kind" });
+    }
     this.traverseScope(scope, state);
     state.activeScopes.pop();
+    for (const decl of scope.scope.declarations.values()) {
+      state.uninitialized.delete(decl.identifier.id);
+    }
+  }
+  visitPlace(_id, place, state) {
+    const maybeHoistedFn = state.uninitialized.get(place.identifier.id);
+    if ((maybeHoistedFn == null ? void 0 : maybeHoistedFn.kind) === "func" && maybeHoistedFn.definition !== place) {
+      CompilerError.throwTodo({
+        reason: "[PruneHoistedContexts] Rewrite hoisted function references",
+        loc: place.loc
+      });
+    }
   }
   transformInstruction(instruction, state) {
-    this.visitInstruction(instruction, state);
     if (instruction.value.kind === "DeclareContext") {
       const maybeNonHoisted = convertHoistedLValueKind(
         instruction.value.lvalue.kind
       );
       if (maybeNonHoisted != null) {
+        if (maybeNonHoisted === "Function" /* Function */ && state.uninitialized.has(instruction.value.lvalue.place.identifier.id)) {
+          state.uninitialized.set(
+            instruction.value.lvalue.place.identifier.id,
+            {
+              kind: "func",
+              definition: null
+            }
+          );
+        }
         return { kind: "remove" };
       }
     }
@@ -86301,9 +86460,28 @@ var Visitor3 = class extends ReactiveFunctionTransform {
         (scope) => scope.has(lvalueId)
       );
       if (isDeclaredByScope) {
-        instruction.value.lvalue.kind = "Reassign" /* Reassign */;
+        if (instruction.value.lvalue.kind === "Let" /* Let */ || instruction.value.lvalue.kind === "Const" /* Const */) {
+          instruction.value.lvalue.kind = "Reassign" /* Reassign */;
+        } else if (instruction.value.lvalue.kind === "Function" /* Function */) {
+          const maybeHoistedFn = state.uninitialized.get(lvalueId);
+          if (maybeHoistedFn != null) {
+            CompilerError.invariant(maybeHoistedFn.kind === "func", {
+              reason: "[PruneHoistedContexts] Unexpected hoisted function",
+              loc: instruction.loc
+            });
+            maybeHoistedFn.definition = instruction.value.lvalue.place;
+            state.uninitialized.delete(lvalueId);
+          }
+        } else {
+          CompilerError.throwTodo({
+            reason: "[PruneHoistedContexts] Unexpected kind",
+            description: `(${instruction.value.lvalue.kind})`,
+            loc: instruction.loc
+          });
+        }
       }
     }
+    this.visitInstruction(instruction, state);
     return { kind: "keep" };
   }
 };
@@ -89204,6 +89382,48 @@ var RewriteBlockIds = class extends ReactiveFunctionVisitor {
   }
 };
 
+// src/Inference/InerAliasForUncalledFunctions.ts
+function inferAliasForUncalledFunctions(fn, aliases) {
+  var _a;
+  for (const block of fn.body.blocks.values()) {
+    instrs: for (const instr of block.instructions) {
+      const { lvalue, value } = instr;
+      if (value.kind !== "ObjectMethod" && value.kind !== "FunctionExpression") {
+        continue;
+      }
+      const range = lvalue.identifier.mutableRange;
+      if (range.end > range.start + 1) {
+        continue;
+      }
+      for (const operand of eachInstructionValueOperand(value)) {
+        if (isMutable2(instr, operand)) {
+          continue instrs;
+        }
+      }
+      const operands = /* @__PURE__ */ new Set();
+      for (const effect of (_a = value.loweredFunc.func.effects) != null ? _a : []) {
+        if (effect.kind !== "ContextMutation") {
+          continue;
+        }
+        if (effect.effect === "store" /* Store */ || effect.effect === "mutate" /* Mutate */) {
+          for (const operand of effect.places) {
+            if (isMutableEffect(operand.effect, operand.loc) && !isRefOrRefLikeMutableType(operand.identifier.type)) {
+              operands.add(operand.identifier);
+            }
+          }
+        }
+      }
+      if (operands.size !== 0) {
+        operands.add(lvalue.identifier);
+        aliases.union([...operands]);
+        for (const operand of operands) {
+          operand.mutableRange.end = makeInstructionId(instr.id + 1);
+        }
+      }
+    }
+  }
+}
+
 // src/Inference/InferAlias.ts
 function inferAliases(func) {
   const aliases = new DisjointSet();
@@ -89455,6 +89675,7 @@ function inferMutableRanges(ir) {
   while (true) {
     inferMutableRangesForAlias(ir, aliases);
     inferAliasForPhis(ir, aliases);
+    inferAliasForUncalledFunctions(ir, aliases);
     const nextAliases = aliases.canonicalize();
     if (areEqualMaps(prevAliases, nextAliases)) {
       break;
@@ -94432,14 +94653,14 @@ function merge2(a, b) {
 function getCompareDependencyResultDescription(result) {
   switch (result) {
     case 0 /* Ok */:
-      return "dependencies equal";
+      return "Dependencies equal";
     case 1 /* RootDifference */:
     case 2 /* PathDifference */:
-      return "inferred different dependency than source";
+      return "Inferred different dependency than source";
     case 4 /* RefAccessDifference */:
-      return "differences in ref.current access";
+      return "Differences in ref.current access";
     case 3 /* Subpath */:
-      return "inferred less specific property than source";
+      return "Inferred less specific property than source";
   }
 }
 function compareDeps(inferred, source2) {
@@ -94516,9 +94737,10 @@ function validateInferredDep(dep, temporaries, declsWithinMemoBlock, validDepsIn
   errorState.push({
     severity: "CannotPreserveMemoization" /* CannotPreserveMemoization */,
     reason: "React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. The inferred dependencies did not match the manually specified dependencies, which could cause the value to change more or less frequently than expected",
-    description: DEBUG4 ? `The inferred dependency was \`${prettyPrintScopeDependency(
+    description: DEBUG4 || // If the dependency is a named variable then we can report it. Otherwise only print in debug mode
+    dep.identifier.name != null && dep.identifier.name.kind === "named" ? `The inferred dependency was \`${prettyPrintScopeDependency(
       dep
-    )}\`, but the source dependencies were [${validDepsInMemoBlock.map((dep2) => printManualMemoDependency(dep2, true)).join(", ")}]. Detail: ${errorDiagnostic ? getCompareDependencyResultDescription(errorDiagnostic) : "none"}` : null,
+    )}\`, but the source dependencies were [${validDepsInMemoBlock.map((dep2) => printManualMemoDependency(dep2, true)).join(", ")}]. ${errorDiagnostic ? getCompareDependencyResultDescription(errorDiagnostic) : "Inferred dependency not present in source"}` : null,
     loc: memoLocation,
     suggestions: null
   });
@@ -96376,6 +96598,78 @@ function validateStaticComponents(fn) {
   return error.asResult();
 }
 
+// src/Validation/ValidateNoFreezingKnownMutableFunctions.ts
+function validateNoFreezingKnownMutableFunctions(fn) {
+  var _a;
+  const errors = new CompilerError();
+  const contextMutationEffects = /* @__PURE__ */ new Map();
+  function visitOperand(operand) {
+    if (operand.effect === "freeze" /* Freeze */) {
+      const effect = contextMutationEffects.get(operand.identifier.id);
+      if (effect != null) {
+        errors.push({
+          reason: `This argument is a function which modifies local variables when called, which can bypass memoization and cause the UI not to update`,
+          description: `Functions that are returned from hooks, passed as arguments to hooks, or passed as props to components may not mutate local variables`,
+          loc: operand.loc,
+          severity: "InvalidReact" /* InvalidReact */
+        });
+        errors.push({
+          reason: `The function modifies a local variable here`,
+          loc: effect.loc,
+          severity: "InvalidReact" /* InvalidReact */
+        });
+      }
+    }
+  }
+  for (const block of fn.body.blocks.values()) {
+    for (const instr of block.instructions) {
+      const { lvalue, value } = instr;
+      switch (value.kind) {
+        case "LoadLocal": {
+          const effect = contextMutationEffects.get(value.place.identifier.id);
+          if (effect != null) {
+            contextMutationEffects.set(lvalue.identifier.id, effect);
+          }
+          break;
+        }
+        case "StoreLocal": {
+          const effect = contextMutationEffects.get(value.value.identifier.id);
+          if (effect != null) {
+            contextMutationEffects.set(lvalue.identifier.id, effect);
+            contextMutationEffects.set(
+              value.lvalue.place.identifier.id,
+              effect
+            );
+          }
+          break;
+        }
+        case "FunctionExpression": {
+          const knownMutation = ((_a = value.loweredFunc.func.effects) != null ? _a : []).find(
+            (effect) => {
+              return effect.kind === "ContextMutation" && (effect.effect === "store" /* Store */ || effect.effect === "mutate" /* Mutate */) && Iterable_some(effect.places, (place) => {
+                return isMutableEffect(place.effect, place.loc) && !isRefOrRefLikeMutableType(place.identifier.type);
+              });
+            }
+          );
+          if (knownMutation && knownMutation.kind === "ContextMutation") {
+            contextMutationEffects.set(lvalue.identifier.id, knownMutation);
+          }
+          break;
+        }
+        default: {
+          for (const operand of eachInstructionValueOperand(value)) {
+            visitOperand(operand);
+          }
+        }
+      }
+    }
+    for (const operand of eachTerminalOperand(block.terminal)) {
+      visitOperand(operand);
+    }
+  }
+  return errors.asResult();
+}
+
 // src/Entrypoint/Pipeline.ts
 function run(func, config, fnType, mode, programContext, logger, filename, code) {
   var _a, _b;
@@ -96488,6 +96782,9 @@ function runWithEnvironment(func, env) {
     if (env.config.validateNoImpureFunctionsInRender) {
       validateNoImpureFunctionsInRender(hir).unwrap();
     }
+    if (env.config.validateNoFreezingKnownMutableFunctions) {
+      validateNoFreezingKnownMutableFunctions(hir).unwrap();
+    }
   }
   inferReactivePlaces(hir);
   log2({ kind: "hir", name: "InferReactivePlaces", value: hir });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-react-compiler",
-  "version": "0.0.0-experimental-63a5f0f-20250501",
+  "version": "0.0.0-experimental-7bde208-20250505",
   "description": "Babel plugin for React Compiler.",
   "main": "dist/index.js",
   "license": "MIT",