babel-plugin-react-compiler 0.0.0-experimental-afa1d5a-20250319 → 0.0.0-experimental-3cea1f4-20250324

package/dist/index.js

@@ -7408,7 +7408,7 @@ var require_expressions = __commonJS({
     exports2.MemberExpression = MemberExpression;
     exports2.MetaProperty = MetaProperty;
     exports2.ModuleExpression = ModuleExpression;
-    exports2.NewExpression = NewExpression;
+    exports2.NewExpression = NewExpression2;
     exports2.OptionalCallExpression = OptionalCallExpression;
     exports2.OptionalMemberExpression = OptionalMemberExpression;
     exports2.ParenthesizedExpression = ParenthesizedExpression;
@@ -7478,7 +7478,7 @@ var require_expressions = __commonJS({
       this.space();
       this.print(node.alternate);
     }
-    function NewExpression(node, parent) {
+    function NewExpression2(node, parent) {
       this.word("new");
       this.space();
       this.print(node.callee);
@@ -12152,7 +12152,7 @@ var require_inferers = __commonJS({
       }
     });
     exports2.LogicalExpression = LogicalExpression;
-    exports2.NewExpression = NewExpression;
+    exports2.NewExpression = NewExpression2;
     exports2.NullLiteral = NullLiteral;
     exports2.NumericLiteral = NumericLiteral;
     exports2.ObjectExpression = ObjectExpression;
@@ -12207,7 +12207,7 @@ var require_inferers = __commonJS({
     function TSNonNullExpression() {
       return this.get("expression").getTypeAnnotation();
     }
-    function NewExpression(node) {
+    function NewExpression2(node) {
       if (node.callee.type === "Identifier") {
         return genericTypeAnnotation(node.callee);
       }
@@ -53254,7 +53254,7 @@ var require_expressions2 = __commonJS({
     exports2.MemberExpression = MemberExpression;
     exports2.MetaProperty = MetaProperty;
     exports2.ModuleExpression = ModuleExpression;
-    exports2.NewExpression = NewExpression;
+    exports2.NewExpression = NewExpression2;
     exports2.OptionalCallExpression = OptionalCallExpression;
     exports2.OptionalMemberExpression = OptionalMemberExpression;
     exports2.ParenthesizedExpression = ParenthesizedExpression;
@@ -53324,7 +53324,7 @@ var require_expressions2 = __commonJS({
       this.space();
       this.print(node.alternate);
     }
-    function NewExpression(node, parent) {
+    function NewExpression2(node, parent) {
       this.word("new");
       this.space();
       this.print(node.callee);
@@ -58020,7 +58020,7 @@ var require_inferers2 = __commonJS({
     });
     exports2.VariableDeclarator = VariableDeclarator;
     exports2.TypeCastExpression = TypeCastExpression;
-    exports2.NewExpression = NewExpression;
+    exports2.NewExpression = NewExpression2;
     exports2.TemplateLiteral = TemplateLiteral;
     exports2.UnaryExpression = UnaryExpression;
     exports2.BinaryExpression = BinaryExpression;
@@ -58107,7 +58107,7 @@ var require_inferers2 = __commonJS({
       return node.typeAnnotation;
     }
     TypeCastExpression.validParent = true;
-    function NewExpression(node) {
+    function NewExpression2(node) {
       if (this.get("callee").isIdentifier()) {
         return t5.genericTypeAnnotation(node.callee);
       }
@@ -97512,7 +97512,7 @@ var require_parentheses3 = __commonJS({
     exports2.ConditionalExpression = ConditionalExpression;
     exports2.OptionalMemberExpression = OptionalMemberExpression;
     exports2.AssignmentExpression = AssignmentExpression;
-    exports2.NewExpression = NewExpression;
+    exports2.NewExpression = NewExpression2;
     function t5() {
       const data = _interopRequireWildcard(require("@babel/types"));
       t5 = function() {
@@ -97675,7 +97675,7 @@ var require_parentheses3 = __commonJS({
         return ConditionalExpression(...arguments);
       }
     }
-    function NewExpression(node, parent) {
+    function NewExpression2(node, parent) {
       return isClassExtendsClause(node, parent);
     }
     function isFirstInStatement(printStack, {
@@ -97879,7 +97879,7 @@ var require_expressions3 = __commonJS({
     exports2.ParenthesizedExpression = ParenthesizedExpression;
     exports2.UpdateExpression = UpdateExpression;
     exports2.ConditionalExpression = ConditionalExpression;
-    exports2.NewExpression = NewExpression;
+    exports2.NewExpression = NewExpression2;
     exports2.SequenceExpression = SequenceExpression;
     exports2.ThisExpression = ThisExpression;
     exports2.Super = Super;
@@ -97967,7 +97967,7 @@ var require_expressions3 = __commonJS({
       this.space();
       this.print(node.alternate, node);
     }
-    function NewExpression(node, parent) {
+    function NewExpression2(node, parent) {
       this.word("new");
       this.space();
       this.print(node.callee, node);
@@ -110425,6 +110425,7 @@ __export(index_exports, {
   ErrorSeverity: () => ErrorSeverity,
   OPT_IN_DIRECTIVES: () => OPT_IN_DIRECTIVES,
   OPT_OUT_DIRECTIVES: () => OPT_OUT_DIRECTIVES,
+  ProgramContext: () => ProgramContext2,
   ValueKind: () => ValueKind,
   compile: () => compileFn,
   compileProgram: () => compileProgram,
@@ -110448,6 +110449,126 @@ var import_invariant4 = __toESM(require_invariant());
 // src/Entrypoint/Gating.ts
 var t = __toESM(require("@babel/types"));
 
+// src/Utils/Result.ts
+function Ok(val) {
+  return new OkImpl(val);
+}
+var OkImpl = class _OkImpl {
+  constructor(val) {
+    this.val = val;
+  }
+  map(fn) {
+    return new _OkImpl(fn(this.val));
+  }
+  mapErr(_fn) {
+    return this;
+  }
+  mapOr(_fallback, fn) {
+    return fn(this.val);
+  }
+  mapOrElse(_fallback, fn) {
+    return fn(this.val);
+  }
+  andThen(fn) {
+    return fn(this.val);
+  }
+  and(res) {
+    return res;
+  }
+  or(_res) {
+    return this;
+  }
+  orElse(_fn) {
+    return this;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return false;
+  }
+  expect(_msg) {
+    return this.val;
+  }
+  expectErr(msg) {
+    throw new Error(`${msg}: ${this.val}`);
+  }
+  unwrap() {
+    return this.val;
+  }
+  unwrapOr(_fallback) {
+    return this.val;
+  }
+  unwrapOrElse(_fallback) {
+    return this.val;
+  }
+  unwrapErr() {
+    if (this.val instanceof Error) {
+      throw this.val;
+    }
+    throw new Error(`Can't unwrap \`Ok\` to \`Err\`: ${this.val}`);
+  }
+};
+function Err(val) {
+  return new ErrImpl(val);
+}
+var ErrImpl = class _ErrImpl {
+  constructor(val) {
+    this.val = val;
+  }
+  map(_fn) {
+    return this;
+  }
+  mapErr(fn) {
+    return new _ErrImpl(fn(this.val));
+  }
+  mapOr(fallback, _fn) {
+    return fallback;
+  }
+  mapOrElse(fallback, _fn) {
+    return fallback();
+  }
+  andThen(_fn) {
+    return this;
+  }
+  and(_res) {
+    return this;
+  }
+  or(res) {
+    return res;
+  }
+  orElse(fn) {
+    return fn(this.val);
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return true;
+  }
+  expect(msg) {
+    throw new Error(`${msg}: ${this.val}`);
+  }
+  expectErr(_msg) {
+    return this.val;
+  }
+  unwrap() {
+    if (this.val instanceof Error) {
+      throw this.val;
+    }
+    throw new Error(`Can't unwrap \`Err\` to \`Ok\`: ${this.val}`);
+  }
+  unwrapOr(fallback) {
+    return fallback;
+  }
+  unwrapOrElse(fallback) {
+    return fallback(this.val);
+  }
+  unwrapErr() {
+    return this.val;
+  }
+};
+
 // src/Utils/utils.ts
 function assertExhaustive(_, errorMsg) {
   throw new Error(errorMsg);
@@ -110682,6 +110803,9 @@ var CompilerError = class _CompilerError extends Error {
   hasErrors() {
     return this.details.length > 0;
   }
+  asResult() {
+    return this.hasErrors() ? Err(this) : Ok(void 0);
+  }
   /*
    * An error is critical if it means the compiler has entered into a broken state and cannot
    * continue safely. Other expected errors such as Todos mean that we can skip over that component
@@ -110706,7 +110830,7 @@ var CompilerError = class _CompilerError extends Error {
 };
 
 // src/Entrypoint/Gating.ts
-function insertAdditionalFunctionDeclaration(fnPath, compiled, gating) {
+function insertAdditionalFunctionDeclaration(fnPath, compiled, programContext, gatingFunctionIdentifierName) {
   var _a, _b;
   const originalFnName = fnPath.node.id;
   const originalFnParams = fnPath.node.params;
@@ -110719,14 +110843,14 @@ function insertAdditionalFunctionDeclaration(fnPath, compiled, gating) {
     reason: "Expected React Compiler optimized function declarations to have the same number of parameters as source",
     loc: (_b = fnPath.node.loc) != null ? _b : null
   });
-  const gatingCondition = fnPath.scope.generateUidIdentifier(
-    `${gating.importSpecifierName}_result`
+  const gatingCondition = t.identifier(
+    programContext.newUid(`${gatingFunctionIdentifierName}_result`)
   );
-  const unoptimizedFnName = fnPath.scope.generateUidIdentifier(
-    `${originalFnName.name}_unoptimized`
+  const unoptimizedFnName = t.identifier(
+    programContext.newUid(`${originalFnName.name}_unoptimized`)
   );
-  const optimizedFnName = fnPath.scope.generateUidIdentifier(
-    `${originalFnName.name}_optimized`
+  const optimizedFnName = t.identifier(
+    programContext.newUid(`${originalFnName.name}_optimized`)
   );
   compiled.id.name = optimizedFnName.name;
   fnPath.get("id").replaceInline(unoptimizedFnName);
@@ -110769,24 +110893,30 @@ function insertAdditionalFunctionDeclaration(fnPath, compiled, gating) {
     t.variableDeclaration("const", [
       t.variableDeclarator(
         gatingCondition,
-        t.callExpression(t.identifier(gating.importSpecifierName), [])
+        t.callExpression(t.identifier(gatingFunctionIdentifierName), [])
       )
     ])
   );
   fnPath.insertBefore(compiled);
 }
-function insertGatedFunctionDeclaration(fnPath, compiled, gating, referencedBeforeDeclaration) {
+function insertGatedFunctionDeclaration(fnPath, compiled, programContext, gating, referencedBeforeDeclaration) {
   var _a;
+  const gatingImportedName = programContext.addImportSpecifier(gating).name;
   if (referencedBeforeDeclaration && fnPath.isFunctionDeclaration()) {
     CompilerError.invariant(compiled.type === "FunctionDeclaration", {
       reason: "Expected compiled node type to match input type",
       description: `Got ${compiled.type} but expected FunctionDeclaration`,
       loc: (_a = fnPath.node.loc) != null ? _a : null
     });
-    insertAdditionalFunctionDeclaration(fnPath, compiled, gating);
+    insertAdditionalFunctionDeclaration(
+      fnPath,
+      compiled,
+      programContext,
+      gatingImportedName
+    );
   } else {
     const gatingExpression = t.conditionalExpression(
-      t.callExpression(t.identifier(gating.importSpecifierName), []),
+      t.callExpression(t.identifier(gatingImportedName), []),
       buildFunctionExpression(compiled),
       buildFunctionExpression(fnPath.node)
     );
@@ -110832,7 +110962,7 @@ function buildFunctionExpression(node) {
 }
 
 // src/Entrypoint/Imports.ts
-var t3 = __toESM(require("@babel/types"));
+var t4 = __toESM(require("@babel/types"));
 
 // src/HIR/HIR.ts
 var t2 = __toESM(require("@babel/types"));
@@ -114640,6 +114770,7 @@ var Effect = /* @__PURE__ */ ((Effect2) => {
   Effect2["Freeze"] = "freeze";
   Effect2["Read"] = "read";
   Effect2["Capture"] = "capture";
+  Effect2["ConditionallyMutateIterator"] = "mutate-iterator?";
   Effect2["ConditionallyMutate"] = "mutate?";
   Effect2["Mutate"] = "mutate";
   Effect2["Store"] = "store";
@@ -114649,6 +114780,7 @@ var EffectSchema = z.enum([
   "read" /* Read */,
   "mutate" /* Mutate */,
   "mutate?" /* ConditionallyMutate */,
+  "mutate-iterator?" /* ConditionallyMutateIterator */,
   "capture" /* Capture */,
   "store" /* Store */,
   "freeze" /* Freeze */
@@ -114658,6 +114790,7 @@ function isMutableEffect(effect, location) {
     case "capture" /* Capture */:
     case "store" /* Store */:
     case "mutate?" /* ConditionallyMutate */:
+    case "mutate-iterator?" /* ConditionallyMutateIterator */:
     case "mutate" /* Mutate */: {
       return true;
     }
@@ -114759,6 +114892,12 @@ function isPrimitiveType(id) {
 function isArrayType(id) {
   return id.type.kind === "Object" && id.type.shapeId === "BuiltInArray";
 }
+function isMapType(id) {
+  return id.type.kind === "Object" && id.type.shapeId === "BuiltInMap";
+}
+function isSetType(id) {
+  return id.type.kind === "Object" && id.type.shapeId === "BuiltInSet";
+}
 function isPropsType(id) {
   return id.type.kind === "Object" && id.type.shapeId === "BuiltInProps";
 }
@@ -117244,126 +117383,6 @@ function validateMutableRange(mutableRange) {
 // src/HIR/BuildHIR.ts
 var import_invariant2 = __toESM(require_invariant());
 
-// src/Utils/Result.ts
-function Ok(val) {
-  return new OkImpl(val);
-}
-var OkImpl = class _OkImpl {
-  constructor(val) {
-    this.val = val;
-  }
-  map(fn) {
-    return new _OkImpl(fn(this.val));
-  }
-  mapErr(_fn) {
-    return this;
-  }
-  mapOr(_fallback, fn) {
-    return fn(this.val);
-  }
-  mapOrElse(_fallback, fn) {
-    return fn(this.val);
-  }
-  andThen(fn) {
-    return fn(this.val);
-  }
-  and(res) {
-    return res;
-  }
-  or(_res) {
-    return this;
-  }
-  orElse(_fn) {
-    return this;
-  }
-  isOk() {
-    return true;
-  }
-  isErr() {
-    return false;
-  }
-  expect(_msg) {
-    return this.val;
-  }
-  expectErr(msg) {
-    throw new Error(`${msg}: ${this.val}`);
-  }
-  unwrap() {
-    return this.val;
-  }
-  unwrapOr(_fallback) {
-    return this.val;
-  }
-  unwrapOrElse(_fallback) {
-    return this.val;
-  }
-  unwrapErr() {
-    if (this.val instanceof Error) {
-      throw this.val;
-    }
-    throw new Error(`Can't unwrap \`Ok\` to \`Err\`: ${this.val}`);
-  }
-};
-function Err(val) {
-  return new ErrImpl(val);
-}
-var ErrImpl = class _ErrImpl {
-  constructor(val) {
-    this.val = val;
-  }
-  map(_fn) {
-    return this;
-  }
-  mapErr(fn) {
-    return new _ErrImpl(fn(this.val));
-  }
-  mapOr(fallback, _fn) {
-    return fallback;
-  }
-  mapOrElse(fallback, _fn) {
-    return fallback();
-  }
-  andThen(_fn) {
-    return this;
-  }
-  and(_res) {
-    return this;
-  }
-  or(res) {
-    return res;
-  }
-  orElse(fn) {
-    return fn(this.val);
-  }
-  isOk() {
-    return false;
-  }
-  isErr() {
-    return true;
-  }
-  expect(msg) {
-    throw new Error(`${msg}: ${this.val}`);
-  }
-  expectErr(_msg) {
-    return this.val;
-  }
-  unwrap() {
-    if (this.val instanceof Error) {
-      throw this.val;
-    }
-    throw new Error(`Can't unwrap \`Err\` to \`Ok\`: ${this.val}`);
-  }
-  unwrapOr(fallback) {
-    return fallback;
-  }
-  unwrapOrElse(fallback) {
-    return fallback(this.val);
-  }
-  unwrapErr() {
-    return this.val;
-  }
-};
-
 // src/HIR/HIRBuilder.ts
 function newBlock(id, kind) {
   return { id, kind, instructions: [] };
@@ -117558,6 +117577,7 @@ var HIRBuilder = class {
           type: makeType(),
           loc: (_b = node.loc) != null ? _b : GeneratedSource
         };
+        __privateGet(this, _env).programContext.addNewReference(name);
         __privateGet(this, _bindings).set(name, { node, identifier: identifier4 });
         return identifier4;
       } else if (mapping.node === node) {
@@ -117991,7 +118011,7 @@ var nextAnonId = 0;
 function createAnonId() {
   return `<generated_${nextAnonId++}>`;
 }
-function addFunction(registry, properties, fn, id = null) {
+function addFunction(registry, properties, fn, id = null, isConstructor = false) {
   const shapeId = id != null ? id : createAnonId();
   addShape(registry, shapeId, properties, __spreadProps(__spreadValues({}, fn), {
     hookKind: null
@@ -117999,7 +118019,8 @@ function addFunction(registry, properties, fn, id = null) {
   return {
     kind: "Function",
     return: fn.returnType,
-    shapeId
+    shapeId,
+    isConstructor
   };
 }
 function addHook(registry, fn, id = null) {
@@ -118008,7 +118029,8 @@ function addHook(registry, fn, id = null) {
   return {
     kind: "Function",
     return: fn.returnType,
-    shapeId
+    shapeId,
+    isConstructor: false
   };
 }
 function addObject(registry, id, properties) {
@@ -118035,6 +118057,8 @@ function addShape(registry, id, properties, functionType2) {
 }
 var BuiltInPropsId = "BuiltInProps";
 var BuiltInArrayId = "BuiltInArray";
+var BuiltInSetId = "BuiltInSet";
+var BuiltInMapId = "BuiltInMap";
 var BuiltInFunctionId = "BuiltInFunction";
 var BuiltInJsxId = "BuiltInJsx";
 var BuiltInObjectId = "BuiltInObject";
@@ -118279,6 +118303,311 @@ addObject(BUILTIN_SHAPES, BuiltInObjectId, [
    * hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, valueOf
    */
 ]);
+addObject(BUILTIN_SHAPES, BuiltInSetId, [
+  [
+    /**
+     * 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: BuiltInSetId },
+      calleeEffect: "store" /* Store */,
+      // returnValueKind is technically dependent on the ValueKind of the set itself
+      returnValueKind: "mutable" /* Mutable */
+    })
+  ],
+  [
+    /**
+     * clear()
+     * Parameters none
+     * Returns undefined
+     */
+    "clear",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: [],
+      restParam: null,
+      returnType: PRIMITIVE_TYPE,
+      calleeEffect: "store" /* Store */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    /**
+     * 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 */
+    })
+  ],
+  ["size", PRIMITIVE_TYPE],
+  [
+    /**
+     * difference(other)
+     * Parameters
+     *   other: A Set object, or set-like object.
+     * Returns a new Set object containing elements in this set but not in the other set.
+     */
+    "difference",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: ["capture" /* Capture */],
+      restParam: null,
+      returnType: { kind: "Object", shapeId: BuiltInSetId },
+      calleeEffect: "capture" /* Capture */,
+      returnValueKind: "mutable" /* Mutable */
+    })
+  ],
+  [
+    /**
+     * union(other)
+     * Parameters
+     *   other: A Set object, or set-like object.
+     * Returns a new Set object containing elements in either this set or the other set.
+     */
+    "union",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: ["capture" /* Capture */],
+      restParam: null,
+      returnType: { kind: "Object", shapeId: BuiltInSetId },
+      calleeEffect: "capture" /* Capture */,
+      returnValueKind: "mutable" /* Mutable */
+    })
+  ],
+  [
+    /**
+     * symmetricalDifference(other)
+     * Parameters
+     *   other: A Set object, or set-like object.
+     * A new Set object containing elements which are in either this set or the other set, but not in both.
+     */
+    "symmetricalDifference",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: ["capture" /* Capture */],
+      restParam: null,
+      returnType: { kind: "Object", shapeId: BuiltInSetId },
+      calleeEffect: "capture" /* Capture */,
+      returnValueKind: "mutable" /* Mutable */
+    })
+  ],
+  [
+    /**
+     * isSubsetOf(other)
+     * Parameters
+     *   other: A Set object, or set-like object.
+     * Returns true if all elements in this set are also in the other set, and false otherwise.
+     */
+    "isSubsetOf",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: ["read" /* Read */],
+      restParam: null,
+      returnType: PRIMITIVE_TYPE,
+      calleeEffect: "read" /* Read */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    /**
+     * isSupersetOf(other)
+     * Parameters
+     *  other: A Set object, or set-like object.
+     * Returns true if all elements in the other set are also in this set, and false otherwise.
+     */
+    "isSupersetOf",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: ["read" /* Read */],
+      restParam: null,
+      returnType: PRIMITIVE_TYPE,
+      calleeEffect: "read" /* Read */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    /**
+     * forEach(callbackFn)
+     * forEach(callbackFn, thisArg)
+     */
+    "forEach",
+    addFunction(BUILTIN_SHAPES, [], {
+      /**
+       * see Array.map explanation for why arguments are marked `ConditionallyMutate`
+       */
+      positionalParams: [],
+      restParam: "mutate?" /* ConditionallyMutate */,
+      returnType: PRIMITIVE_TYPE,
+      calleeEffect: "mutate?" /* ConditionallyMutate */,
+      returnValueKind: "primitive" /* Primitive */,
+      noAlias: true,
+      mutableOnlyIfOperandsAreMutable: true
+    })
+  ],
+  /**
+   * Iterators
+   */
+  [
+    "entries",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: [],
+      restParam: null,
+      returnType: { kind: "Poly" },
+      calleeEffect: "capture" /* Capture */,
+      returnValueKind: "mutable" /* Mutable */
+    })
+  ],
+  [
+    "keys",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: [],
+      restParam: null,
+      returnType: { kind: "Poly" },
+      calleeEffect: "capture" /* Capture */,
+      returnValueKind: "mutable" /* Mutable */
+    })
+  ],
+  [
+    "values",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: [],
+      restParam: null,
+      returnType: { kind: "Poly" },
+      calleeEffect: "capture" /* Capture */,
+      returnValueKind: "mutable" /* Mutable */
+    })
+  ]
+]);
+addObject(BUILTIN_SHAPES, BuiltInMapId, [
+  [
+    /**
+     * clear()
+     * Parameters none
+     * Returns undefined
+     */
+    "clear",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: [],
+      restParam: null,
+      returnType: PRIMITIVE_TYPE,
+      calleeEffect: "store" /* Store */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    "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: BuiltInMapId },
+      calleeEffect: "store" /* Store */,
+      returnValueKind: "mutable" /* Mutable */
+    })
+  ],
+  ["size", PRIMITIVE_TYPE],
+  [
+    "forEach",
+    addFunction(BUILTIN_SHAPES, [], {
+      /**
+       * see Array.map explanation for why arguments are marked `ConditionallyMutate`
+       */
+      positionalParams: [],
+      restParam: "mutate?" /* ConditionallyMutate */,
+      returnType: PRIMITIVE_TYPE,
+      calleeEffect: "mutate?" /* ConditionallyMutate */,
+      returnValueKind: "primitive" /* Primitive */,
+      noAlias: true,
+      mutableOnlyIfOperandsAreMutable: true
+    })
+  ],
+  /**
+   * Iterators
+   */
+  [
+    "entries",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: [],
+      restParam: null,
+      returnType: { kind: "Poly" },
+      calleeEffect: "capture" /* Capture */,
+      returnValueKind: "mutable" /* Mutable */
+    })
+  ],
+  [
+    "keys",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: [],
+      restParam: null,
+      returnType: { kind: "Poly" },
+      calleeEffect: "capture" /* Capture */,
+      returnValueKind: "mutable" /* Mutable */
+    })
+  ],
+  [
+    "values",
+    addFunction(BUILTIN_SHAPES, [], {
+      positionalParams: [],
+      restParam: null,
+      returnType: { kind: "Poly" },
+      calleeEffect: "capture" /* Capture */,
+      returnValueKind: "mutable" /* Mutable */
+    })
+  ]
+]);
 addObject(BUILTIN_SHAPES, BuiltInUseStateId, [
   ["0", { kind: "Poly" }],
   [
@@ -122558,29 +122887,23 @@ function fromZodError(zodError, options = {}) {
 // src/HIR/Globals.ts
 var DEFAULT_SHAPES = new Map(BUILTIN_SHAPES);
 var UNTYPED_GLOBALS = /* @__PURE__ */ new Set([
-  "String",
   "Object",
   "Function",
-  "Number",
   "RegExp",
   "Date",
   "Error",
-  "Function",
   "TypeError",
   "RangeError",
   "ReferenceError",
   "SyntaxError",
   "URIError",
   "EvalError",
-  "Boolean",
   "DataView",
   "Float32Array",
   "Float64Array",
   "Int8Array",
   "Int16Array",
   "Int32Array",
-  "Map",
-  "Set",
   "WeakMap",
   "Uint8Array",
   "Uint8ClampedArray",
@@ -122588,16 +122911,8 @@ var UNTYPED_GLOBALS = /* @__PURE__ */ new Set([
   "Uint32Array",
   "ArrayBuffer",
   "JSON",
-  "parseFloat",
-  "parseInt",
   "console",
-  "isNaN",
-  "eval",
-  "isFinite",
-  "encodeURI",
-  "decodeURI",
-  "encodeURIComponent",
-  "decodeURIComponent"
+  "eval"
 ]);
 var TYPED_GLOBALS = [
   [
@@ -122612,6 +122927,23 @@ var TYPED_GLOBALS = [
           calleeEffect: "read" /* Read */,
           returnValueKind: "mutable" /* Mutable */
         })
+      ],
+      [
+        /**
+         * Object.fromEntries(iterable)
+         * iterable: An iterable, such as an Array or Map, containing a list of
+         *           objects. Each object should have two properties.
+         * Returns a new object whose properties are given by the entries of the
+         * iterable.
+         */
+        "fromEntries",
+        addFunction(DEFAULT_SHAPES, [], {
+          positionalParams: ["mutate?" /* ConditionallyMutate */],
+          restParam: null,
+          returnType: { kind: "Object", shapeId: BuiltInObjectId },
+          calleeEffect: "read" /* Read */,
+          returnValueKind: "mutable" /* Mutable */
+        })
       ]
     ])
   ],
@@ -122644,7 +122976,7 @@ var TYPED_GLOBALS = [
         "from",
         addFunction(DEFAULT_SHAPES, [], {
           positionalParams: [
-            "mutate?" /* ConditionallyMutate */,
+            "mutate-iterator?" /* ConditionallyMutateIterator */,
             "mutate?" /* ConditionallyMutate */,
             "mutate?" /* ConditionallyMutate */
           ],
@@ -122889,6 +123221,118 @@ var TYPED_GLOBALS = [
       calleeEffect: "read" /* Read */,
       returnValueKind: "primitive" /* Primitive */
     })
+  ],
+  [
+    "parseInt",
+    addFunction(DEFAULT_SHAPES, [], {
+      positionalParams: [],
+      restParam: "read" /* Read */,
+      returnType: { kind: "Primitive" },
+      calleeEffect: "read" /* Read */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    "parseFloat",
+    addFunction(DEFAULT_SHAPES, [], {
+      positionalParams: [],
+      restParam: "read" /* Read */,
+      returnType: { kind: "Primitive" },
+      calleeEffect: "read" /* Read */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    "isNaN",
+    addFunction(DEFAULT_SHAPES, [], {
+      positionalParams: [],
+      restParam: "read" /* Read */,
+      returnType: { kind: "Primitive" },
+      calleeEffect: "read" /* Read */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    "isFinite",
+    addFunction(DEFAULT_SHAPES, [], {
+      positionalParams: [],
+      restParam: "read" /* Read */,
+      returnType: { kind: "Primitive" },
+      calleeEffect: "read" /* Read */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    "encodeURI",
+    addFunction(DEFAULT_SHAPES, [], {
+      positionalParams: [],
+      restParam: "read" /* Read */,
+      returnType: { kind: "Primitive" },
+      calleeEffect: "read" /* Read */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    "encodeURIComponent",
+    addFunction(DEFAULT_SHAPES, [], {
+      positionalParams: [],
+      restParam: "read" /* Read */,
+      returnType: { kind: "Primitive" },
+      calleeEffect: "read" /* Read */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    "decodeURI",
+    addFunction(DEFAULT_SHAPES, [], {
+      positionalParams: [],
+      restParam: "read" /* Read */,
+      returnType: { kind: "Primitive" },
+      calleeEffect: "read" /* Read */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    "decodeURIComponent",
+    addFunction(DEFAULT_SHAPES, [], {
+      positionalParams: [],
+      restParam: "read" /* Read */,
+      returnType: { kind: "Primitive" },
+      calleeEffect: "read" /* Read */,
+      returnValueKind: "primitive" /* Primitive */
+    })
+  ],
+  [
+    "Map",
+    addFunction(
+      DEFAULT_SHAPES,
+      [],
+      {
+        positionalParams: ["mutate-iterator?" /* ConditionallyMutateIterator */],
+        restParam: null,
+        returnType: { kind: "Object", shapeId: BuiltInMapId },
+        calleeEffect: "read" /* Read */,
+        returnValueKind: "mutable" /* Mutable */
+      },
+      null,
+      true
+    )
+  ],
+  [
+    "Set",
+    addFunction(
+      DEFAULT_SHAPES,
+      [],
+      {
+        positionalParams: ["mutate-iterator?" /* ConditionallyMutateIterator */],
+        restParam: null,
+        returnType: { kind: "Object", shapeId: BuiltInSetId },
+        calleeEffect: "read" /* Read */,
+        returnValueKind: "mutable" /* Mutable */
+      },
+      null,
+      true
+    )
   ]
   // TODO: rest of Global objects
 ];
@@ -123382,6 +123826,8 @@ var InstrumentationSchema = z.object({
   (opts) => opts.gating != null || opts.globalGating != null,
   "Expected at least one of gating or globalGating"
 );
+var USE_FIRE_FUNCTION_NAME = "useFire";
+var EMIT_FREEZE_GLOBAL_GATING = "__DEV__";
 var MacroMethodSchema = z.union([
   z.object({ type: z.literal("wildcard") }),
   z.object({ type: z.literal("name"), name: z.string() })
@@ -123583,6 +124029,10 @@ var EnvironmentConfigSchema = z.object({
    * instead.
    */
   validateNoJSXInTryStatements: z.boolean().default(false),
+  /**
+   * Validates against dynamically creating components during render.
+   */
+  validateStaticComponents: z.boolean().default(false),
   /**
    * Validates that the dependencies of all effect hooks are memoized. This helps ensure
    * that Forget does not introduce infinite renders caused by a dependency changing,
@@ -124002,7 +124452,7 @@ function parseConfigPragmaForTests(pragma, defaults) {
 }
 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, useMemoCacheIdentifier) {
+  constructor(scope, fnType, compilerMode, config, contextIdentifiers, logger, filename, code, programContext) {
     __privateAdd(this, _Environment_instances);
     __privateAdd(this, _globals);
     __privateAdd(this, _shapes);
@@ -124021,11 +124471,11 @@ var Environment = class {
     this.filename = filename;
     this.code = code;
     this.logger = logger;
-    this.useMemoCacheIdentifier = useMemoCacheIdentifier;
+    this.programContext = programContext;
     __privateSet(this, _shapes, new Map(DEFAULT_SHAPES));
     __privateSet(this, _globals, new Map(DEFAULT_GLOBALS));
-    this.hasLoweredContextAccess = false;
     this.hasFireRewrite = false;
+    this.hasInferredEffect = false;
     if (config.disableMemoizationForDebugging && config.enableChangeDetectionForDebugging != null) {
       CompilerError.throwInvalidConfig({
         reason: `Invalid environment config: the 'disableMemoizationForDebugging' and 'enableChangeDetectionForDebugging' options cannot be used together`,
@@ -124073,6 +124523,21 @@ var Environment = class {
   get nextScopeId() {
     return makeScopeId(__privateWrapper(this, _nextScope)._++);
   }
+  get scope() {
+    return __privateGet(this, _scope);
+  }
+  logErrors(errors) {
+    if (errors.isOk() || this.logger == null) {
+      return;
+    }
+    for (const error of errors.unwrapErr().details) {
+      this.logger.logEvent(this.filename, {
+        kind: "CompileError",
+        detail: error,
+        fnLoc: null
+      });
+    }
+  }
   isContextIdentifier(node) {
     return __privateGet(this, _contextIdentifiers).has(node);
   }
@@ -124611,7 +125076,7 @@ function isMutable2(instr, place) {
 function inRange({ id }, range) {
   return id >= range.start && id < range.end;
 }
-function mayAllocate(_env5, instruction) {
+function mayAllocate(_env4, instruction) {
   const { value } = instruction;
   switch (value.kind) {
     case "Destructure": {
@@ -124949,260 +125414,14 @@ function pruneUnusedLabelsHIR(fn) {
   }
 }
 
-// src/Entrypoint/Imports.ts
-function validateRestrictedImports(path, { validateBlocklistedImports }) {
-  if (validateBlocklistedImports == null || validateBlocklistedImports.length === 0) {
-    return null;
-  }
-  const error = new CompilerError();
-  const restrictedImports = new Set(validateBlocklistedImports);
-  path.traverse({
-    ImportDeclaration(importDeclPath) {
-      var _a;
-      if (restrictedImports.has(importDeclPath.node.source.value)) {
-        error.push({
-          severity: "Todo" /* Todo */,
-          reason: "Bailing out due to blocklisted import",
-          description: `Import from module ${importDeclPath.node.source.value}`,
-          loc: (_a = importDeclPath.node.loc) != null ? _a : null
-        });
-      }
-    }
-  });
-  if (error.hasErrors()) {
-    return error;
-  } else {
-    return null;
-  }
-}
-function addImportsToProgram(path, importList) {
-  const identifiers = /* @__PURE__ */ new Set();
-  const sortedImports = /* @__PURE__ */ new Map();
-  for (const { importSpecifierName, source: source2 } of importList) {
-    CompilerError.invariant(identifiers.has(importSpecifierName) === false, {
-      reason: `Encountered conflicting import specifier for ${importSpecifierName} in Forget config.`,
-      description: null,
-      loc: GeneratedSource,
-      suggestions: null
-    });
-    CompilerError.invariant(
-      path.scope.hasBinding(importSpecifierName) === false,
-      {
-        reason: `Encountered conflicting import specifiers for ${importSpecifierName} in generated program.`,
-        description: null,
-        loc: GeneratedSource,
-        suggestions: null
-      }
-    );
-    identifiers.add(importSpecifierName);
-    const importSpecifierNameList = getOrInsertDefault(
-      sortedImports,
-      source2,
-      []
-    );
-    importSpecifierNameList.push(importSpecifierName);
-  }
-  const stmts = [];
-  for (const [source2, importSpecifierNameList] of sortedImports) {
-    const importSpecifiers = importSpecifierNameList.map((name) => {
-      const id = t3.identifier(name);
-      return t3.importSpecifier(id, id);
-    });
-    stmts.push(t3.importDeclaration(importSpecifiers, t3.stringLiteral(source2)));
-  }
-  path.unshiftContainer("body", stmts);
-}
-function isNonNamespacedImport(importDeclPath, moduleName) {
-  return importDeclPath.get("source").node.value === moduleName && importDeclPath.get("specifiers").every((specifier) => specifier.isImportSpecifier()) && importDeclPath.node.importKind !== "type" && importDeclPath.node.importKind !== "typeof";
-}
-function hasExistingNonNamespacedImportOfModule(program, moduleName) {
-  let hasExistingImport = false;
-  program.traverse({
-    ImportDeclaration(importDeclPath) {
-      if (isNonNamespacedImport(importDeclPath, moduleName)) {
-        hasExistingImport = true;
-      }
-    }
-  });
-  return hasExistingImport;
-}
-function addMemoCacheFunctionSpecifierToExistingImport(program, moduleName, identifierName) {
-  let didInsertUseMemoCache = false;
-  program.traverse({
-    ImportDeclaration(importDeclPath) {
-      if (!didInsertUseMemoCache && isNonNamespacedImport(importDeclPath, moduleName)) {
-        importDeclPath.pushContainer(
-          "specifiers",
-          t3.importSpecifier(t3.identifier(identifierName), t3.identifier("c"))
-        );
-        didInsertUseMemoCache = true;
-      }
-    }
-  });
-  return didInsertUseMemoCache;
-}
-function updateMemoCacheFunctionImport(program, moduleName, useMemoCacheIdentifier) {
-  const hasExistingImport = hasExistingNonNamespacedImportOfModule(
-    program,
-    moduleName
-  );
-  if (hasExistingImport) {
-    const didUpdateImport = addMemoCacheFunctionSpecifierToExistingImport(
-      program,
-      moduleName,
-      useMemoCacheIdentifier
-    );
-    if (!didUpdateImport) {
-      throw new Error(
-        `Expected an ImportDeclaration of \`${moduleName}\` in order to update ImportSpecifiers with useMemoCache`
-      );
-    }
-  } else {
-    addMemoCacheFunctionImportDeclaration(
-      program,
-      moduleName,
-      useMemoCacheIdentifier
-    );
-  }
-}
-function addMemoCacheFunctionImportDeclaration(program, moduleName, localName) {
-  program.unshiftContainer(
-    "body",
-    t3.importDeclaration(
-      [t3.importSpecifier(t3.identifier(localName), t3.identifier("c"))],
-      t3.stringLiteral(moduleName)
-    )
-  );
+// src/Utils/ComponentDeclaration.ts
+function isComponentDeclaration(node) {
+  return Object.prototype.hasOwnProperty.call(node, "__componentDeclaration");
 }
 
-// src/Entrypoint/Options.ts
-var PanicThresholdOptionsSchema = z.enum([
-  /*
-   * Any errors will panic the compiler by throwing an exception, which will
-   * bubble up to the nearest exception handler above the Forget transform.
-   * If Forget is invoked through `BabelPluginReactCompiler`, this will at the least
-   * skip Forget compilation for the rest of current file.
-   */
-  "all_errors",
-  /*
-   * Panic by throwing an exception only on critical or unrecognized errors.
-   * For all other errors, skip the erroring function without inserting
-   * a Forget-compiled version (i.e. same behavior as noEmit).
-   */
-  "critical_errors",
-  // Never panic by throwing an exception.
-  "none"
-]);
-var CompilerReactTargetSchema = z.union([
-  z.literal("17"),
-  z.literal("18"),
-  z.literal("19"),
-  /**
-   * Used exclusively for Meta apps which are guaranteed to have compatible
-   * react runtime and compiler versions. Note that only the FB-internal bundles
-   * re-export useMemoCache (see
-   * https://github.com/facebook/react/blob/5b0ef217ef32333a8e56f39be04327c89efa346f/packages/react/index.fb.js#L68-L70),
-   * so this option is invalid / creates runtime errors for open-source users.
-   */
-  z.object({
-    kind: z.literal("donotuse_meta_internal"),
-    runtimeModule: z.string().default("react")
-  })
-]);
-var CompilationModeSchema = z.enum([
-  /*
-   * Compiles functions annotated with "use forget" or component/hook-like functions.
-   * This latter includes:
-   * * Components declared with component syntax.
-   * * Functions which can be inferred to be a component or hook:
-   *   - Be named like a hook or component. This logic matches the ESLint rule.
-   *   - *and* create JSX and/or call a hook. This is an additional check to help prevent
-   *     false positives, since compilation has a greater impact than linting.
-   * This is the default mode
-   */
-  "infer",
-  // Compile only components using Flow component syntax and hooks using hook syntax.
-  "syntax",
-  // Compile only functions which are explicitly annotated with "use forget"
-  "annotation",
-  // Compile all top-level functions
-  "all"
-]);
-var defaultOptions = {
-  compilationMode: "infer",
-  panicThreshold: "none",
-  environment: parseEnvironmentConfig({}).unwrap(),
-  logger: null,
-  gating: null,
-  noEmit: false,
-  eslintSuppressionRules: null,
-  flowSuppressions: true,
-  ignoreUseNoForget: false,
-  sources: (filename) => {
-    return filename.indexOf("node_modules") === -1;
-  },
-  enableReanimatedCheck: true,
-  target: "19"
-};
-function parsePluginOptions(obj) {
-  if (obj == null || typeof obj !== "object") {
-    return defaultOptions;
-  }
-  const parsedOptions = /* @__PURE__ */ Object.create(null);
-  for (let [key2, value] of Object.entries(obj)) {
-    if (typeof value === "string") {
-      value = value.toLowerCase();
-    }
-    if (isCompilerFlag(key2)) {
-      switch (key2) {
-        case "environment": {
-          const environmentResult = parseEnvironmentConfig(value);
-          if (environmentResult.isErr()) {
-            CompilerError.throwInvalidConfig({
-              reason: "Error in validating environment config. This is an advanced setting and not meant to be used directly",
-              description: environmentResult.unwrapErr().toString(),
-              suggestions: null,
-              loc: null
-            });
-          }
-          parsedOptions[key2] = environmentResult.unwrap();
-          break;
-        }
-        case "target": {
-          parsedOptions[key2] = parseTargetConfig(value);
-          break;
-        }
-        case "gating": {
-          if (value == null) {
-            parsedOptions[key2] = null;
-          } else {
-            parsedOptions[key2] = tryParseExternalFunction(value);
-          }
-          break;
-        }
-        default: {
-          parsedOptions[key2] = value;
-        }
-      }
-    }
-  }
-  return __spreadValues(__spreadValues({}, defaultOptions), parsedOptions);
-}
-function parseTargetConfig(value) {
-  const parsed = CompilerReactTargetSchema.safeParse(value);
-  if (parsed.success) {
-    return parsed.data;
-  } else {
-    CompilerError.throwInvalidConfig({
-      reason: "Not a valid target",
-      description: `${fromZodError(parsed.error)}`,
-      suggestions: null,
-      loc: null
-    });
-  }
-}
-function isCompilerFlag(s) {
-  return hasOwnProperty2(defaultOptions, s);
+// src/Utils/HookDeclaration.ts
+function isHookDeclaration(node) {
+  return Object.prototype.hasOwnProperty.call(node, "__hookDeclaration");
 }
 
 // src/Entrypoint/Pipeline.ts
@@ -129011,7 +129230,7 @@ _catchHandlers = new WeakMap();
 _controlFlowStack = new WeakMap();
 
 // src/ReactiveScopes/CodegenReactiveFunction.ts
-var t4 = __toESM(require("@babel/types"));
+var t3 = __toESM(require("@babel/types"));
 var import_crypto = require("crypto");
 
 // src/ReactiveScopes/MemoizeFbtAndMacroOperandsInSameScope.ts
@@ -129176,10 +129395,11 @@ function codegenFunction(fn, {
   }
   const compiled = compileResult.unwrap();
   const hookGuard = fn.env.config.enableEmitHookGuards;
-  if (hookGuard != null) {
-    compiled.body = t4.blockStatement([
+  if (hookGuard != null && fn.env.isInferredMemoEnabled) {
+    compiled.body = t3.blockStatement([
       createHookGuard(
         hookGuard,
+        fn.env.programContext,
         compiled.body.body,
         0 /* PushHookGuard */,
         1 /* PopHookGuard */
@@ -129189,12 +129409,13 @@ function codegenFunction(fn, {
   const cacheCount = compiled.memoSlotsUsed;
   if (cacheCount !== 0) {
     const preface = [];
+    const useMemoCacheIdentifier = fn.env.programContext.addMemoCacheImport().name;
     preface.push(
-      t4.variableDeclaration("const", [
-        t4.variableDeclarator(
-          t4.identifier(cx.synthesizeName("$")),
-          t4.callExpression(t4.identifier(fn.env.useMemoCacheIdentifier), [
-            t4.numericLiteral(cacheCount)
+      t3.variableDeclaration("const", [
+        t3.variableDeclarator(
+          t3.identifier(cx.synthesizeName("$")),
+          t3.callExpression(t3.identifier(useMemoCacheIdentifier), [
+            t3.numericLiteral(cacheCount)
           ])
         )
       ])
@@ -129202,60 +129423,60 @@ function codegenFunction(fn, {
     if (fastRefreshState !== null) {
       const index = cx.synthesizeName("$i");
       preface.push(
-        t4.ifStatement(
-          t4.binaryExpression(
+        t3.ifStatement(
+          t3.binaryExpression(
             "!==",
-            t4.memberExpression(
-              t4.identifier(cx.synthesizeName("$")),
-              t4.numericLiteral(fastRefreshState.cacheIndex),
+            t3.memberExpression(
+              t3.identifier(cx.synthesizeName("$")),
+              t3.numericLiteral(fastRefreshState.cacheIndex),
               true
             ),
-            t4.stringLiteral(fastRefreshState.hash)
+            t3.stringLiteral(fastRefreshState.hash)
           ),
-          t4.blockStatement([
-            t4.forStatement(
-              t4.variableDeclaration("let", [
-                t4.variableDeclarator(t4.identifier(index), t4.numericLiteral(0))
+          t3.blockStatement([
+            t3.forStatement(
+              t3.variableDeclaration("let", [
+                t3.variableDeclarator(t3.identifier(index), t3.numericLiteral(0))
               ]),
-              t4.binaryExpression(
+              t3.binaryExpression(
                 "<",
-                t4.identifier(index),
-                t4.numericLiteral(cacheCount)
+                t3.identifier(index),
+                t3.numericLiteral(cacheCount)
               ),
-              t4.assignmentExpression(
+              t3.assignmentExpression(
                 "+=",
-                t4.identifier(index),
-                t4.numericLiteral(1)
+                t3.identifier(index),
+                t3.numericLiteral(1)
               ),
-              t4.blockStatement([
-                t4.expressionStatement(
-                  t4.assignmentExpression(
+              t3.blockStatement([
+                t3.expressionStatement(
+                  t3.assignmentExpression(
                     "=",
-                    t4.memberExpression(
-                      t4.identifier(cx.synthesizeName("$")),
-                      t4.identifier(index),
+                    t3.memberExpression(
+                      t3.identifier(cx.synthesizeName("$")),
+                      t3.identifier(index),
                       true
                     ),
-                    t4.callExpression(
-                      t4.memberExpression(
-                        t4.identifier("Symbol"),
-                        t4.identifier("for")
+                    t3.callExpression(
+                      t3.memberExpression(
+                        t3.identifier("Symbol"),
+                        t3.identifier("for")
                       ),
-                      [t4.stringLiteral(MEMO_CACHE_SENTINEL)]
+                      [t3.stringLiteral(MEMO_CACHE_SENTINEL)]
                     )
                   )
                 )
               ])
             ),
-            t4.expressionStatement(
-              t4.assignmentExpression(
+            t3.expressionStatement(
+              t3.assignmentExpression(
                 "=",
-                t4.memberExpression(
-                  t4.identifier(cx.synthesizeName("$")),
-                  t4.numericLiteral(fastRefreshState.cacheIndex),
+                t3.memberExpression(
+                  t3.identifier(cx.synthesizeName("$")),
+                  t3.numericLiteral(fastRefreshState.cacheIndex),
                   true
                 ),
-                t4.stringLiteral(fastRefreshState.hash)
+                t3.stringLiteral(fastRefreshState.hash)
               )
             )
           ])
@@ -129265,31 +129486,44 @@ function codegenFunction(fn, {
     compiled.body.body.unshift(...preface);
   }
   const emitInstrumentForget = fn.env.config.enableEmitInstrumentForget;
-  if (emitInstrumentForget != null && fn.id != null) {
-    let gating;
-    if (emitInstrumentForget.gating != null && emitInstrumentForget.globalGating != null) {
-      gating = t4.logicalExpression(
-        "&&",
-        t4.identifier(emitInstrumentForget.globalGating),
-        t4.identifier(emitInstrumentForget.gating.importSpecifierName)
+  if (emitInstrumentForget != null && fn.id != null && fn.env.isInferredMemoEnabled) {
+    const gating = emitInstrumentForget.gating != null ? t3.identifier(
+      fn.env.programContext.addImportSpecifier(
+        emitInstrumentForget.gating
+      ).name
+    ) : null;
+    const globalGating = emitInstrumentForget.globalGating != null ? t3.identifier(emitInstrumentForget.globalGating) : null;
+    if (emitInstrumentForget.globalGating != null) {
+      const assertResult = fn.env.programContext.assertGlobalBinding(
+        emitInstrumentForget.globalGating
       );
-    } else if (emitInstrumentForget.gating != null) {
-      gating = t4.identifier(emitInstrumentForget.gating.importSpecifierName);
+      if (assertResult.isErr()) {
+        return assertResult;
+      }
+    }
+    let ifTest;
+    if (gating != null && globalGating != null) {
+      ifTest = t3.logicalExpression("&&", globalGating, gating);
+    } else if (gating != null) {
+      ifTest = gating;
     } else {
-      CompilerError.invariant(emitInstrumentForget.globalGating != null, {
+      CompilerError.invariant(globalGating != null, {
         reason: "Bad config not caught! Expected at least one of gating or globalGating",
         loc: null,
         suggestions: null
       });
-      gating = t4.identifier(emitInstrumentForget.globalGating);
-    }
-    const test = t4.ifStatement(
-      gating,
-      t4.expressionStatement(
-        t4.callExpression(
-          t4.identifier(emitInstrumentForget.fn.importSpecifierName),
-          [t4.stringLiteral(fn.id), t4.stringLiteral((_b = fn.env.filename) != null ? _b : "")]
-        )
+      ifTest = globalGating;
+    }
+    const instrumentFnIdentifier = fn.env.programContext.addImportSpecifier(
+      emitInstrumentForget.fn
+    ).name;
+    const test = t3.ifStatement(
+      ifTest,
+      t3.expressionStatement(
+        t3.callExpression(t3.identifier(instrumentFnIdentifier), [
+          t3.stringLiteral(fn.id),
+          t3.stringLiteral((_b = fn.env.filename) != null ? _b : "")
+        ])
       )
     );
     compiled.body.body.unshift(test);
@@ -129328,7 +129562,7 @@ function codegenReactiveFunction(cx, fn) {
   }
   const params = fn.params.map((param) => convertParameter(param));
   const body = codegenBlock(cx, fn.body);
-  body.directives = fn.directives.map((d) => t4.directive(t4.directiveLiteral(d)));
+  body.directives = fn.directives.map((d) => t3.directive(t3.directiveLiteral(d)));
   const statements = body.body;
   if (statements.length !== 0) {
     const last = statements[statements.length - 1];
@@ -129344,7 +129578,7 @@ function codegenReactiveFunction(cx, fn) {
   return Ok({
     type: "CodegenFunction",
     loc: fn.loc,
-    id: fn.id !== null ? t4.identifier(fn.id) : null,
+    id: fn.id !== null ? t3.identifier(fn.id) : null,
     params,
     body,
     generator: fn.generator,
@@ -129355,8 +129589,8 @@ function codegenReactiveFunction(cx, fn) {
     prunedMemoBlocks: countMemoBlockVisitor.prunedMemoBlocks,
     prunedMemoValues: countMemoBlockVisitor.prunedMemoValues,
     outlined: [],
-    hasLoweredContextAccess: fn.env.hasLoweredContextAccess,
-    hasFireRewrite: fn.env.hasFireRewrite
+    hasFireRewrite: fn.env.hasFireRewrite,
+    hasInferredEffect: fn.env.hasInferredEffect
   });
 }
 var CountMemoBlockVisitor = class extends ReactiveFunctionVisitor {
@@ -129383,7 +129617,7 @@ function convertParameter(param) {
   if (param.kind === "Identifier") {
     return convertIdentifier(param.identifier);
   } else {
-    return t4.restElement(convertIdentifier(param.place.identifier));
+    return t3.restElement(convertIdentifier(param.place.identifier));
   }
 }
 var _nextCacheIndex, _declarations;
@@ -129477,8 +129711,8 @@ function codegenBlockNoReset(cx, block) {
         if (item.label !== null && !item.label.implicit) {
           const block2 = statement.type === "BlockStatement" && statement.body.length === 1 ? statement.body[0] : statement;
           statements.push(
-            t4.labeledStatement(
-              t4.identifier(codegenLabel(item.label.id)),
+            t3.labeledStatement(
+              t3.identifier(codegenLabel(item.label.id)),
               block2
             )
           );
@@ -129497,16 +129731,20 @@ function codegenBlockNoReset(cx, block) {
       }
     }
   }
-  return t4.blockStatement(statements);
+  return t3.blockStatement(statements);
 }
 function wrapCacheDep(cx, value) {
-  if (cx.env.config.enableEmitFreeze != null) {
-    return t4.conditionalExpression(
-      t4.identifier("__DEV__"),
-      t4.callExpression(
-        t4.identifier(cx.env.config.enableEmitFreeze.importSpecifierName),
-        [value, t4.stringLiteral(cx.fnName)]
-      ),
+  if (cx.env.config.enableEmitFreeze != null && cx.env.isInferredMemoEnabled) {
+    const emitFreezeIdentifier = cx.env.programContext.addImportSpecifier(
+      cx.env.config.enableEmitFreeze
+    ).name;
+    cx.env.programContext.assertGlobalBinding(EMIT_FREEZE_GLOBAL_GATING, cx.env.scope).unwrap();
+    return t3.conditionalExpression(
+      t3.identifier(EMIT_FREEZE_GLOBAL_GATING),
+      t3.callExpression(t3.identifier(emitFreezeIdentifier), [
+        value,
+        t3.stringLiteral(cx.fnName)
+      ]),
       value
     );
   } else {
@@ -129523,20 +129761,20 @@ function codegenReactiveScope(cx, statements, scope, block) {
   for (const dep of [...scope.dependencies].sort(compareScopeDependency)) {
     const index = cx.nextCacheIndex;
     changeExpressionComments.push(printDependencyComment(dep));
-    const comparison = t4.binaryExpression(
+    const comparison = t3.binaryExpression(
       "!==",
-      t4.memberExpression(
-        t4.identifier(cx.synthesizeName("$")),
-        t4.numericLiteral(index),
+      t3.memberExpression(
+        t3.identifier(cx.synthesizeName("$")),
+        t3.numericLiteral(index),
         true
       ),
       codegenDependency(cx, dep)
     );
     if (cx.env.config.enableChangeVariableCodegen) {
-      const changeIdentifier = t4.identifier(cx.synthesizeName(`c_${index}`));
+      const changeIdentifier = t3.identifier(cx.synthesizeName(`c_${index}`));
       statements.push(
-        t4.variableDeclaration("const", [
-          t4.variableDeclarator(changeIdentifier, comparison)
+        t3.variableDeclaration("const", [
+          t3.variableDeclarator(changeIdentifier, comparison)
         ])
       );
       changeExpressions.push(changeIdentifier);
@@ -129544,12 +129782,12 @@ function codegenReactiveScope(cx, statements, scope, block) {
       changeExpressions.push(comparison);
     }
     cacheStoreStatements.push(
-      t4.expressionStatement(
-        t4.assignmentExpression(
+      t3.expressionStatement(
+        t3.assignmentExpression(
           "=",
-          t4.memberExpression(
-            t4.identifier(cx.synthesizeName("$")),
-            t4.numericLiteral(index),
+          t3.memberExpression(
+            t3.identifier(cx.synthesizeName("$")),
+            t3.numericLiteral(index),
             true
           ),
           codegenDependency(cx, dep)
@@ -129577,7 +129815,7 @@ function codegenReactiveScope(cx, statements, scope, block) {
     outputComments.push(name.name);
     if (!cx.hasDeclared(identifier4)) {
       statements.push(
-        t4.variableDeclaration("let", [t4.variableDeclarator(name)])
+        t3.variableDeclaration("let", [t3.variableDeclarator(name)])
       );
     }
     cacheLoads.push({ name, index, value: wrapCacheDep(cx, name) });
@@ -129597,7 +129835,7 @@ function codegenReactiveScope(cx, statements, scope, block) {
       if (acc == null) {
         return ident;
       }
-      return t4.logicalExpression("||", acc, ident);
+      return t3.logicalExpression("||", acc, ident);
     },
     null
   );
@@ -129608,16 +129846,16 @@ function codegenReactiveScope(cx, statements, scope, block) {
       loc: null,
       suggestions: null
     });
-    testCondition = t4.binaryExpression(
+    testCondition = t3.binaryExpression(
       "===",
-      t4.memberExpression(
-        t4.identifier(cx.synthesizeName("$")),
-        t4.numericLiteral(firstOutputIndex),
+      t3.memberExpression(
+        t3.identifier(cx.synthesizeName("$")),
+        t3.numericLiteral(firstOutputIndex),
         true
       ),
-      t4.callExpression(
-        t4.memberExpression(t4.identifier("Symbol"), t4.identifier("for")),
-        [t4.stringLiteral(MEMO_CACHE_SENTINEL)]
+      t3.callExpression(
+        t3.memberExpression(t3.identifier("Symbol"), t3.identifier("for")),
+        [t3.stringLiteral(MEMO_CACHE_SENTINEL)]
       )
     );
   }
@@ -129630,81 +129868,82 @@ function codegenReactiveScope(cx, statements, scope, block) {
         loc: null
       }
     );
-    testCondition = t4.logicalExpression(
+    testCondition = t3.logicalExpression(
       "||",
       testCondition,
-      t4.booleanLiteral(true)
+      t3.booleanLiteral(true)
     );
   }
   let computationBlock = codegenBlock(cx, block);
   let memoStatement;
-  if (cx.env.config.enableChangeDetectionForDebugging != null && changeExpressions.length > 0) {
+  const detectionFunction = cx.env.config.enableChangeDetectionForDebugging;
+  if (detectionFunction != 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 importedDetectionFunctionIdentifier = cx.env.programContext.addImportSpecifier(detectionFunction).name;
     const cacheLoadOldValueStatements = [];
     const changeDetectionStatements = [];
     const idempotenceDetectionStatements = [];
     for (const { name, index, value } of cacheLoads) {
       const loadName = cx.synthesizeName(`old$${name.name}`);
-      const slot = t4.memberExpression(
-        t4.identifier(cx.synthesizeName("$")),
-        t4.numericLiteral(index),
+      const slot = t3.memberExpression(
+        t3.identifier(cx.synthesizeName("$")),
+        t3.numericLiteral(index),
         true
       );
       cacheStoreStatements.push(
-        t4.expressionStatement(t4.assignmentExpression("=", slot, value))
+        t3.expressionStatement(t3.assignmentExpression("=", slot, value))
       );
       cacheLoadOldValueStatements.push(
-        t4.variableDeclaration("let", [
-          t4.variableDeclarator(t4.identifier(loadName), slot)
+        t3.variableDeclaration("let", [
+          t3.variableDeclarator(t3.identifier(loadName), slot)
         ])
       );
       changeDetectionStatements.push(
-        t4.expressionStatement(
-          t4.callExpression(t4.identifier(detectionFunction), [
-            t4.identifier(loadName),
-            t4.cloneNode(name, true),
-            t4.stringLiteral(name.name),
-            t4.stringLiteral(cx.fnName),
-            t4.stringLiteral("cached"),
-            t4.stringLiteral(loc)
+        t3.expressionStatement(
+          t3.callExpression(t3.identifier(importedDetectionFunctionIdentifier), [
+            t3.identifier(loadName),
+            t3.cloneNode(name, true),
+            t3.stringLiteral(name.name),
+            t3.stringLiteral(cx.fnName),
+            t3.stringLiteral("cached"),
+            t3.stringLiteral(loc)
           ])
         )
       );
       idempotenceDetectionStatements.push(
-        t4.expressionStatement(
-          t4.callExpression(t4.identifier(detectionFunction), [
-            t4.cloneNode(slot, true),
-            t4.cloneNode(name, true),
-            t4.stringLiteral(name.name),
-            t4.stringLiteral(cx.fnName),
-            t4.stringLiteral("recomputed"),
-            t4.stringLiteral(loc)
+        t3.expressionStatement(
+          t3.callExpression(t3.identifier(importedDetectionFunctionIdentifier), [
+            t3.cloneNode(slot, true),
+            t3.cloneNode(name, true),
+            t3.stringLiteral(name.name),
+            t3.stringLiteral(cx.fnName),
+            t3.stringLiteral("recomputed"),
+            t3.stringLiteral(loc)
           ])
         )
       );
       idempotenceDetectionStatements.push(
-        t4.expressionStatement(t4.assignmentExpression("=", name, slot))
+        t3.expressionStatement(t3.assignmentExpression("=", name, slot))
       );
     }
     const condition = cx.synthesizeName("condition");
-    const recomputationBlock = t4.cloneNode(computationBlock, true);
-    memoStatement = t4.blockStatement([
+    const recomputationBlock = t3.cloneNode(computationBlock, true);
+    memoStatement = t3.blockStatement([
       ...computationBlock.body,
-      t4.variableDeclaration("let", [
-        t4.variableDeclarator(t4.identifier(condition), testCondition)
+      t3.variableDeclaration("let", [
+        t3.variableDeclarator(t3.identifier(condition), testCondition)
       ]),
-      t4.ifStatement(
-        t4.unaryExpression("!", t4.identifier(condition)),
-        t4.blockStatement([
+      t3.ifStatement(
+        t3.unaryExpression("!", t3.identifier(condition)),
+        t3.blockStatement([
           ...cacheLoadOldValueStatements,
           ...changeDetectionStatements
         ])
       ),
       ...cacheStoreStatements,
-      t4.ifStatement(
-        t4.identifier(condition),
-        t4.blockStatement([
+      t3.ifStatement(
+        t3.identifier(condition),
+        t3.blockStatement([
           ...recomputationBlock.body,
           ...idempotenceDetectionStatements
         ])
@@ -129713,12 +129952,12 @@ function codegenReactiveScope(cx, statements, scope, block) {
   } else {
     for (const { name, index, value } of cacheLoads) {
       cacheStoreStatements.push(
-        t4.expressionStatement(
-          t4.assignmentExpression(
+        t3.expressionStatement(
+          t3.assignmentExpression(
             "=",
-            t4.memberExpression(
-              t4.identifier(cx.synthesizeName("$")),
-              t4.numericLiteral(index),
+            t3.memberExpression(
+              t3.identifier(cx.synthesizeName("$")),
+              t3.numericLiteral(index),
               true
             ),
             value
@@ -129726,13 +129965,13 @@ function codegenReactiveScope(cx, statements, scope, block) {
         )
       );
       cacheLoadStatements.push(
-        t4.expressionStatement(
-          t4.assignmentExpression(
+        t3.expressionStatement(
+          t3.assignmentExpression(
             "=",
             name,
-            t4.memberExpression(
-              t4.identifier(cx.synthesizeName("$")),
-              t4.numericLiteral(index),
+            t3.memberExpression(
+              t3.identifier(cx.synthesizeName("$")),
+              t3.numericLiteral(index),
               true
             )
           )
@@ -129740,15 +129979,15 @@ function codegenReactiveScope(cx, statements, scope, block) {
       );
     }
     computationBlock.body.push(...cacheStoreStatements);
-    memoStatement = t4.ifStatement(
+    memoStatement = t3.ifStatement(
       testCondition,
       computationBlock,
-      t4.blockStatement(cacheLoadStatements)
+      t3.blockStatement(cacheLoadStatements)
     );
   }
   if (cx.env.config.enableMemoizationComments) {
     if (changeExpressionComments.length) {
-      t4.addComment(
+      t3.addComment(
         memoStatement,
         "leading",
         ` check if ${printDelimitedCommentList(
@@ -129757,20 +129996,20 @@ function codegenReactiveScope(cx, statements, scope, block) {
         )} changed`,
         true
       );
-      t4.addComment(
+      t3.addComment(
         memoStatement,
         "leading",
         ` "useMemo" for ${printDelimitedCommentList(outputComments, "and")}:`,
         true
       );
     } else {
-      t4.addComment(
+      t3.addComment(
         memoStatement,
         "leading",
         " cache value with no dependencies",
         true
       );
-      t4.addComment(
+      t3.addComment(
         memoStatement,
         "leading",
         ` "useMemo" for ${printDelimitedCommentList(outputComments, "and")}:`,
@@ -129778,7 +130017,7 @@ function codegenReactiveScope(cx, statements, scope, block) {
       );
     }
     if (computationBlock.body.length > 0) {
-      t4.addComment(
+      t3.addComment(
         computationBlock.body[0],
         "leading",
         ` Inputs changed, recompute`,
@@ -129786,7 +130025,7 @@ function codegenReactiveScope(cx, statements, scope, block) {
       );
     }
     if (cacheLoadStatements.length > 0) {
-      t4.addComment(
+      t3.addComment(
         cacheLoadStatements[0],
         "leading",
         ` Inputs did not change, use cached value`,
@@ -129808,16 +130047,16 @@ function codegenReactiveScope(cx, statements, scope, block) {
     );
     const name = earlyReturnValue.value.name.value;
     statements.push(
-      t4.ifStatement(
-        t4.binaryExpression(
+      t3.ifStatement(
+        t3.binaryExpression(
           "!==",
-          t4.identifier(name),
-          t4.callExpression(
-            t4.memberExpression(t4.identifier("Symbol"), t4.identifier("for")),
-            [t4.stringLiteral(EARLY_RETURN_SENTINEL)]
+          t3.identifier(name),
+          t3.callExpression(
+            t3.memberExpression(t3.identifier("Symbol"), t3.identifier("for")),
+            [t3.stringLiteral(EARLY_RETURN_SENTINEL)]
           )
         ),
-        t4.blockStatement([t4.returnStatement(t4.identifier(name))])
+        t3.blockStatement([t3.returnStatement(t3.identifier(name))])
       )
     );
   }
@@ -129828,20 +130067,20 @@ function codegenTerminal(cx, terminal) {
       if (terminal.targetKind === "implicit") {
         return null;
       }
-      return t4.breakStatement(
-        terminal.targetKind === "labeled" ? t4.identifier(codegenLabel(terminal.target)) : null
+      return t3.breakStatement(
+        terminal.targetKind === "labeled" ? t3.identifier(codegenLabel(terminal.target)) : null
       );
     }
     case "continue": {
       if (terminal.targetKind === "implicit") {
         return null;
       }
-      return t4.continueStatement(
-        terminal.targetKind === "labeled" ? t4.identifier(codegenLabel(terminal.target)) : null
+      return t3.continueStatement(
+        terminal.targetKind === "labeled" ? t3.identifier(codegenLabel(terminal.target)) : null
       );
     }
     case "for": {
-      return t4.forStatement(
+      return t3.forStatement(
         codegenForInit(cx, terminal.init),
         codegenInstructionValueToExpression(cx, terminal.test),
         terminal.update !== null ? codegenInstructionValueToExpression(cx, terminal.update) : null,
@@ -129915,13 +130154,13 @@ function codegenTerminal(cx, terminal) {
             `Unhandled lvalue kind: ${iterableItem.value.lvalue.kind}`
           );
       }
-      return t4.forInStatement(
+      return t3.forInStatement(
         /*
          * Special handling here since we only want the VariableDeclarators without any inits
          * This needs to be updated when we handle non-trivial ForOf inits
          */
         createVariableDeclaration(iterableItem.value.loc, varDeclKind, [
-          t4.variableDeclarator(lval, null)
+          t3.variableDeclarator(lval, null)
         ]),
         codegenInstructionValueToExpression(cx, iterableCollection.value),
         codegenBlock(cx, terminal.loop)
@@ -129997,13 +130236,13 @@ function codegenTerminal(cx, terminal) {
             `Unhandled lvalue kind: ${iterableItem.value.lvalue.kind}`
           );
       }
-      return t4.forOfStatement(
+      return t3.forOfStatement(
         /*
          * Special handling here since we only want the VariableDeclarators without any inits
          * This needs to be updated when we handle non-trivial ForOf inits
          */
         createVariableDeclaration(iterableItem.value.loc, varDeclKind, [
-          t4.variableDeclarator(lval, null)
+          t3.variableDeclarator(lval, null)
         ]),
         codegenInstructionValueToExpression(cx, iterableCollection),
         codegenBlock(cx, terminal.loop)
@@ -130019,35 +130258,35 @@ function codegenTerminal(cx, terminal) {
           alternate = block;
         }
       }
-      return t4.ifStatement(test, consequent, alternate);
+      return t3.ifStatement(test, consequent, alternate);
     }
     case "return": {
       const value = codegenPlaceToExpression(cx, terminal.value);
       if (value.type === "Identifier" && value.name === "undefined") {
-        return t4.returnStatement();
+        return t3.returnStatement();
       }
-      return t4.returnStatement(value);
+      return t3.returnStatement(value);
     }
     case "switch": {
-      return t4.switchStatement(
+      return t3.switchStatement(
         codegenPlaceToExpression(cx, terminal.test),
         terminal.cases.map((case_) => {
           const test = case_.test !== null ? codegenPlaceToExpression(cx, case_.test) : null;
           const block = codegenBlock(cx, case_.block);
-          return t4.switchCase(test, [block]);
+          return t3.switchCase(test, [block]);
         })
       );
     }
     case "throw": {
-      return t4.throwStatement(codegenPlaceToExpression(cx, terminal.value));
+      return t3.throwStatement(codegenPlaceToExpression(cx, terminal.value));
     }
     case "do-while": {
       const test = codegenInstructionValueToExpression(cx, terminal.test);
-      return t4.doWhileStatement(test, codegenBlock(cx, terminal.loop));
+      return t3.doWhileStatement(test, codegenBlock(cx, terminal.loop));
     }
     case "while": {
       const test = codegenInstructionValueToExpression(cx, terminal.test);
-      return t4.whileStatement(test, codegenBlock(cx, terminal.loop));
+      return t3.whileStatement(test, codegenBlock(cx, terminal.loop));
     }
     case "label": {
       return codegenBlock(cx, terminal.block);
@@ -130058,9 +130297,9 @@ function codegenTerminal(cx, terminal) {
         catchParam = convertIdentifier(terminal.handlerBinding.identifier);
         cx.temp.set(terminal.handlerBinding.identifier.declarationId, null);
       }
-      return t4.tryStatement(
+      return t3.tryStatement(
         codegenBlock(cx, terminal.block),
-        t4.catchClause(catchParam, codegenBlock(cx, terminal.handler))
+        t3.catchClause(catchParam, codegenBlock(cx, terminal.handler))
       );
     }
     default: {
@@ -130123,7 +130362,7 @@ function codegenInstructionNullable(cx, instr) {
           suggestions: null
         });
         return createVariableDeclaration(instr.loc, "const", [
-          t4.variableDeclarator(codegenLValue(cx, lvalue), value)
+          t3.variableDeclarator(codegenLValue(cx, lvalue), value)
         ]);
       }
       case "Function" /* Function */: {
@@ -130163,7 +130402,7 @@ function codegenInstructionNullable(cx, instr) {
           suggestions: null
         });
         return createVariableDeclaration(instr.loc, "let", [
-          t4.variableDeclarator(codegenLValue(cx, lvalue), value)
+          t3.variableDeclarator(codegenLValue(cx, lvalue), value)
         ]);
       }
       case "Reassign" /* Reassign */: {
@@ -130173,7 +130412,7 @@ function codegenInstructionNullable(cx, instr) {
           loc: instr.value.loc,
           suggestions: null
         });
-        const expr = t4.assignmentExpression(
+        const expr = t3.assignmentExpression(
           "=",
           codegenLValue(cx, lvalue),
           value
@@ -130194,7 +130433,7 @@ function codegenInstructionNullable(cx, instr) {
         }
       }
       case "Catch" /* Catch */: {
-        return t4.emptyStatement();
+        return t3.emptyStatement();
       }
       case "HoistedLet" /* HoistedLet */:
       case "HoistedConst" /* HoistedConst */:
@@ -130213,7 +130452,7 @@ function codegenInstructionNullable(cx, instr) {
   } else if (instr.value.kind === "StartMemoize" || instr.value.kind === "FinishMemoize") {
     return null;
   } else if (instr.value.kind === "Debugger") {
-    return t4.debuggerStatement();
+    return t3.debuggerStatement();
   } else if (instr.value.kind === "ObjectMethod") {
     CompilerError.invariant(instr.lvalue, {
       reason: "Expected object methods to have a temp lvalue",
@@ -130269,7 +130508,7 @@ function codegenForInit(cx, init) {
       description: null,
       suggestions: null
     });
-    return t4.variableDeclaration(kind, declarators);
+    return t3.variableDeclaration(kind, declarators);
   } else {
     return codegenInstructionValueToExpression(cx, init);
   }
@@ -130308,17 +130547,17 @@ function codegenDependency(cx, dependency) {
   if (dependency.path.length !== 0) {
     const hasOptional = dependency.path.some((path) => path.optional);
     for (const path of dependency.path) {
-      const property = typeof path.property === "string" ? t4.identifier(path.property) : t4.numericLiteral(path.property);
+      const property = typeof path.property === "string" ? t3.identifier(path.property) : t3.numericLiteral(path.property);
       const isComputed = typeof path.property !== "string";
       if (hasOptional) {
-        object = t4.optionalMemberExpression(
+        object = t3.optionalMemberExpression(
           object,
           property,
           isComputed,
           path.optional
         );
       } else {
-        object = t4.memberExpression(object, property, isComputed);
+        object = t3.memberExpression(object, property, isComputed);
       }
     }
   }
@@ -130333,60 +130572,60 @@ function withLoc(fn) {
     return node;
   };
 }
-var createBinaryExpression = withLoc(t4.binaryExpression);
-var createExpressionStatement = withLoc(t4.expressionStatement);
-var _createLabelledStatement = withLoc(t4.labeledStatement);
-var createVariableDeclaration = withLoc(t4.variableDeclaration);
-var createFunctionDeclaration = withLoc(t4.functionDeclaration);
-var _createWhileStatement = withLoc(t4.whileStatement);
-var createTaggedTemplateExpression = withLoc(t4.taggedTemplateExpression);
-var createLogicalExpression = withLoc(t4.logicalExpression);
-var createSequenceExpression = withLoc(t4.sequenceExpression);
-var createConditionalExpression = withLoc(t4.conditionalExpression);
-var createTemplateLiteral = withLoc(t4.templateLiteral);
-var createJsxNamespacedName = withLoc(t4.jsxNamespacedName);
-var createJsxElement = withLoc(t4.jsxElement);
-var createJsxAttribute = withLoc(t4.jsxAttribute);
-var createJsxIdentifier = withLoc(t4.jsxIdentifier);
-var createJsxExpressionContainer = withLoc(t4.jsxExpressionContainer);
-var createJsxText = withLoc(t4.jsxText);
-var createJsxClosingElement = withLoc(t4.jsxClosingElement);
-var createJsxOpeningElement = withLoc(t4.jsxOpeningElement);
-var createStringLiteral = withLoc(t4.stringLiteral);
-function createHookGuard(guard, stmts, before, after) {
+var createBinaryExpression = withLoc(t3.binaryExpression);
+var createExpressionStatement = withLoc(t3.expressionStatement);
+var _createLabelledStatement = withLoc(t3.labeledStatement);
+var createVariableDeclaration = withLoc(t3.variableDeclaration);
+var createFunctionDeclaration = withLoc(t3.functionDeclaration);
+var _createWhileStatement = withLoc(t3.whileStatement);
+var createTaggedTemplateExpression = withLoc(t3.taggedTemplateExpression);
+var createLogicalExpression = withLoc(t3.logicalExpression);
+var createSequenceExpression = withLoc(t3.sequenceExpression);
+var createConditionalExpression = withLoc(t3.conditionalExpression);
+var createTemplateLiteral = withLoc(t3.templateLiteral);
+var createJsxNamespacedName = withLoc(t3.jsxNamespacedName);
+var createJsxElement = withLoc(t3.jsxElement);
+var createJsxAttribute = withLoc(t3.jsxAttribute);
+var createJsxIdentifier = withLoc(t3.jsxIdentifier);
+var createJsxExpressionContainer = withLoc(t3.jsxExpressionContainer);
+var createJsxText = withLoc(t3.jsxText);
+var createJsxClosingElement = withLoc(t3.jsxClosingElement);
+var createJsxOpeningElement = withLoc(t3.jsxOpeningElement);
+var createStringLiteral = withLoc(t3.stringLiteral);
+function createHookGuard(guard, context, stmts, before, after) {
+  const guardFnName = context.addImportSpecifier(guard).name;
   function createHookGuardImpl(kind) {
-    return t4.expressionStatement(
-      t4.callExpression(t4.identifier(guard.importSpecifierName), [
-        t4.numericLiteral(kind)
-      ])
+    return t3.expressionStatement(
+      t3.callExpression(t3.identifier(guardFnName), [t3.numericLiteral(kind)])
     );
   }
-  return t4.tryStatement(
-    t4.blockStatement([createHookGuardImpl(before), ...stmts]),
+  return t3.tryStatement(
+    t3.blockStatement([createHookGuardImpl(before), ...stmts]),
     null,
-    t4.blockStatement([createHookGuardImpl(after)])
+    t3.blockStatement([createHookGuardImpl(after)])
   );
 }
-function createCallExpression(config, callee, args, loc, isHook2) {
-  const callExpr = t4.callExpression(callee, args);
+function createCallExpression(env, callee, args, loc, isHook2) {
+  const callExpr = t3.callExpression(callee, args);
   if (loc != null && loc != GeneratedSource) {
     callExpr.loc = loc;
   }
-  const hookGuard = config.enableEmitHookGuards;
-  if (hookGuard != null && isHook2) {
-    const iife = t4.functionExpression(
+  const hookGuard = env.config.enableEmitHookGuards;
+  if (hookGuard != null && isHook2 && env.isInferredMemoEnabled) {
+    const iife = t3.functionExpression(
       null,
       [],
-      t4.blockStatement([
+      t3.blockStatement([
         createHookGuard(
           hookGuard,
-          [t4.returnStatement(callExpr)],
+          env.programContext,
+          [t3.returnStatement(callExpr)],
           2 /* AllowHook */,
           3 /* DisallowHook */
         )
       ])
     );
-    return t4.callExpression(iife, []);
+    return t3.callExpression(iife, []);
   } else {
     return callExpr;
   }
@@ -130395,21 +130634,21 @@ function codegenLabel(id) {
   return `bb${id}`;
 }
 function codegenInstruction(cx, instr, value) {
-  if (t4.isStatement(value)) {
+  if (t3.isStatement(value)) {
     return value;
   }
   if (instr.lvalue === null) {
-    return t4.expressionStatement(convertValueToExpression(value));
+    return t3.expressionStatement(convertValueToExpression(value));
   }
   if (instr.lvalue.identifier.name === null) {
     cx.temp.set(instr.lvalue.identifier.declarationId, value);
-    return t4.emptyStatement();
+    return t3.emptyStatement();
   } else {
     const expressionValue = convertValueToExpression(value);
     if (cx.hasDeclared(instr.lvalue.identifier)) {
       return createExpressionStatement(
         instr.loc,
-        t4.assignmentExpression(
+        t3.assignmentExpression(
           "=",
           convertIdentifier(instr.lvalue.identifier),
           expressionValue
@@ -130417,7 +130656,7 @@ function codegenInstruction(cx, instr, value) {
       );
     } else {
       return createVariableDeclaration(instr.loc, "const", [
-        t4.variableDeclarator(
+        t3.variableDeclarator(
           convertIdentifier(instr.lvalue.identifier),
           expressionValue
         )
@@ -130444,12 +130683,12 @@ function codegenInstructionValue(cx, instrValue) {
         if (element.kind === "Identifier") {
           return codegenPlaceToExpression(cx, element);
         } else if (element.kind === "Spread") {
-          return t4.spreadElement(codegenPlaceToExpression(cx, element.place));
+          return t3.spreadElement(codegenPlaceToExpression(cx, element.place));
         } else {
           return null;
         }
       });
-      value = t4.arrayExpression(elements);
+      value = t3.arrayExpression(elements);
       break;
     }
     case "BinaryExpression": {
@@ -130464,7 +130703,7 @@ function codegenInstructionValue(cx, instrValue) {
       break;
     }
     case "UnaryExpression": {
-      value = t4.unaryExpression(
+      value = t3.unaryExpression(
         instrValue.operator,
         // todo
         codegenPlaceToExpression(cx, instrValue.value)
@@ -130479,9 +130718,9 @@ function codegenInstructionValue(cx, instrValue) {
       if (cx.env.config.enableForest) {
         const callee2 = codegenPlaceToExpression(cx, instrValue.callee);
         const args2 = instrValue.args.map((arg) => codegenArgument(cx, arg));
-        value = t4.callExpression(callee2, args2);
+        value = t3.callExpression(callee2, args2);
         if (instrValue.typeArguments != null) {
-          value.typeArguments = t4.typeParameterInstantiation(
+          value.typeArguments = t3.typeParameterInstantiation(
             instrValue.typeArguments
           );
         }
@@ -130491,7 +130730,7 @@ function codegenInstructionValue(cx, instrValue) {
       const callee = codegenPlaceToExpression(cx, instrValue.callee);
       const args = instrValue.args.map((arg) => codegenArgument(cx, arg));
       value = createCallExpression(
-        cx.env.config,
+        cx.env,
         callee,
         args,
         instrValue.loc,
@@ -130507,13 +130746,13 @@ function codegenInstructionValue(cx, instrValue) {
       switch (optionalValue.type) {
         case "OptionalCallExpression":
         case "CallExpression": {
-          CompilerError.invariant(t4.isExpression(optionalValue.callee), {
+          CompilerError.invariant(t3.isExpression(optionalValue.callee), {
             reason: "v8 intrinsics are validated during lowering",
             description: null,
             loc: (_a = optionalValue.callee.loc) != null ? _a : null,
             suggestions: null
           });
-          value = t4.optionalCallExpression(
+          value = t3.optionalCallExpression(
             optionalValue.callee,
             optionalValue.arguments,
             instrValue.optional
@@ -130523,13 +130762,13 @@ function codegenInstructionValue(cx, instrValue) {
         case "OptionalMemberExpression":
         case "MemberExpression": {
           const property = optionalValue.property;
-          CompilerError.invariant(t4.isExpression(property), {
+          CompilerError.invariant(t3.isExpression(property), {
             reason: "Private names are validated during lowering",
             description: null,
             loc: (_b = property.loc) != null ? _b : null,
             suggestions: null
           });
-          value = t4.optionalMemberExpression(
+          value = t3.optionalMemberExpression(
             optionalValue.object,
             property,
             optionalValue.computed,
@@ -130552,7 +130791,7 @@ function codegenInstructionValue(cx, instrValue) {
       const isHook2 = getHookKind(cx.env, instrValue.property.identifier) != null;
       const memberExpr = codegenPlaceToExpression(cx, instrValue.property);
       CompilerError.invariant(
-        t4.isMemberExpression(memberExpr) || t4.isOptionalMemberExpression(memberExpr),
+        t3.isMemberExpression(memberExpr) || t3.isOptionalMemberExpression(memberExpr),
         {
           reason: `[Codegen] Internal error: MethodCall::property must be an unpromoted + unmemoized MemberExpression. Got a \`${memberExpr.type}\``,
           description: null,
@@ -130561,7 +130800,7 @@ function codegenInstructionValue(cx, instrValue) {
         }
       );
       CompilerError.invariant(
-        t4.isNodesEquivalent(
+        t3.isNodesEquivalent(
           memberExpr.object,
           codegenPlaceToExpression(cx, instrValue.receiver)
         ),
@@ -130574,7 +130813,7 @@ function codegenInstructionValue(cx, instrValue) {
       );
       const args = instrValue.args.map((arg) => codegenArgument(cx, arg));
       value = createCallExpression(
-        cx.env.config,
+        cx.env,
         memberExpr,
         args,
         instrValue.loc,
@@ -130585,7 +130824,7 @@ function codegenInstructionValue(cx, instrValue) {
     case "NewExpression": {
       const callee = codegenPlaceToExpression(cx, instrValue.callee);
       const args = instrValue.args.map((arg) => codegenArgument(cx, arg));
-      value = t4.newExpression(callee, args);
+      value = t3.newExpression(callee, args);
       break;
     }
     case "ObjectExpression": {
@@ -130597,7 +130836,7 @@ function codegenInstructionValue(cx, instrValue) {
             case "property": {
               const value2 = codegenPlaceToExpression(cx, property.place);
               properties.push(
-                t4.objectProperty(
+                t3.objectProperty(
                   key2,
                   value2,
                   property.key.kind === "computed",
@@ -130627,7 +130866,7 @@ function codegenInstructionValue(cx, instrValue) {
                 ),
                 reactiveFunction
               ).unwrap();
-              const babelNode = t4.objectMethod(
+              const babelNode = t3.objectMethod(
                 "method",
                 key2,
                 fn.params,
@@ -130647,11 +130886,11 @@ function codegenInstructionValue(cx, instrValue) {
           }
         } else {
           properties.push(
-            t4.spreadElement(codegenPlaceToExpression(cx, property.place))
+            t3.spreadElement(codegenPlaceToExpression(cx, property.place))
           );
         }
       }
-      value = t4.objectExpression(properties);
+      value = t3.objectExpression(properties);
       break;
     }
     case "JSXText": {
@@ -130663,7 +130902,7 @@ function codegenInstructionValue(cx, instrValue) {
       for (const attribute of instrValue.props) {
         attributes.push(codegenJsxAttribute(cx, attribute));
       }
-      let tagValue = instrValue.tag.kind === "Identifier" ? codegenPlaceToExpression(cx, instrValue.tag) : t4.stringLiteral(instrValue.tag.name);
+      let tagValue = instrValue.tag.kind === "Identifier" ? codegenPlaceToExpression(cx, instrValue.tag) : t3.stringLiteral(instrValue.tag.name);
       let tag;
       if (tagValue.type === "Identifier") {
         tag = createJsxIdentifier(instrValue.tag.loc, tagValue.name);
@@ -130716,16 +130955,16 @@ function codegenInstructionValue(cx, instrValue) {
       break;
     }
     case "JsxFragment": {
-      value = t4.jsxFragment(
-        t4.jsxOpeningFragment(),
-        t4.jsxClosingFragment(),
+      value = t3.jsxFragment(
+        t3.jsxOpeningFragment(),
+        t3.jsxClosingFragment(),
         instrValue.children.map((child) => codegenJsxElement(cx, child))
       );
       break;
     }
     case "UnsupportedNode": {
       const node = instrValue.node;
-      if (!t4.isExpression(node)) {
+      if (!t3.isExpression(node)) {
         return node;
       }
       value = node;
@@ -130736,19 +130975,19 @@ function codegenInstructionValue(cx, instrValue) {
     case "PropertyDelete": {
       let memberExpr;
       if (typeof instrValue.property === "string") {
-        memberExpr = t4.memberExpression(
+        memberExpr = t3.memberExpression(
           codegenPlaceToExpression(cx, instrValue.object),
-          t4.identifier(instrValue.property)
+          t3.identifier(instrValue.property)
         );
       } else {
-        memberExpr = t4.memberExpression(
+        memberExpr = t3.memberExpression(
           codegenPlaceToExpression(cx, instrValue.object),
-          t4.numericLiteral(instrValue.property),
+          t3.numericLiteral(instrValue.property),
           true
         );
       }
       if (instrValue.kind === "PropertyStore") {
-        value = t4.assignmentExpression(
+        value = t3.assignmentExpression(
           "=",
           memberExpr,
           codegenPlaceToExpression(cx, instrValue.value)
@@ -130756,14 +130995,14 @@ function codegenInstructionValue(cx, instrValue) {
       } else if (instrValue.kind === "PropertyLoad") {
         value = memberExpr;
       } else {
-        value = t4.unaryExpression("delete", memberExpr);
+        value = t3.unaryExpression("delete", memberExpr);
       }
       break;
     }
     case "ComputedStore": {
-      value = t4.assignmentExpression(
+      value = t3.assignmentExpression(
         "=",
-        t4.memberExpression(
+        t3.memberExpression(
           codegenPlaceToExpression(cx, instrValue.object),
           codegenPlaceToExpression(cx, instrValue.property),
           true
@@ -130775,13 +131014,13 @@ function codegenInstructionValue(cx, instrValue) {
     case "ComputedLoad": {
       const object = codegenPlaceToExpression(cx, instrValue.object);
       const property = codegenPlaceToExpression(cx, instrValue.property);
-      value = t4.memberExpression(object, property, true);
+      value = t3.memberExpression(object, property, true);
       break;
     }
     case "ComputedDelete": {
-      value = t4.unaryExpression(
+      value = t3.unaryExpression(
         "delete",
-        t4.memberExpression(
+        t3.memberExpression(
           codegenPlaceToExpression(cx, instrValue.object),
           codegenPlaceToExpression(cx, instrValue.property),
           true
@@ -130818,10 +131057,10 @@ function codegenInstructionValue(cx, instrValue) {
             body = stmt.argument;
           }
         }
-        value = t4.arrowFunctionExpression(fn.params, body, fn.async);
+        value = t3.arrowFunctionExpression(fn.params, body, fn.async);
       } else {
-        value = t4.functionExpression(
-          (_h = fn.id) != null ? _h : instrValue.name != null ? t4.identifier(instrValue.name) : null,
+        value = t3.functionExpression(
+          (_h = fn.id) != null ? _h : instrValue.name != null ? t3.identifier(instrValue.name) : null,
           fn.params,
           fn.body,
           fn.generator,
@@ -130834,20 +131073,20 @@ function codegenInstructionValue(cx, instrValue) {
       value = createTaggedTemplateExpression(
         instrValue.loc,
         codegenPlaceToExpression(cx, instrValue.tag),
-        t4.templateLiteral([t4.templateElement(instrValue.value)], [])
+        t3.templateLiteral([t3.templateElement(instrValue.value)], [])
       );
       break;
     }
     case "TypeCastExpression": {
-      if (t4.isTSType(instrValue.typeAnnotation)) {
-        value = t4.tsAsExpression(
+      if (t3.isTSType(instrValue.typeAnnotation)) {
+        value = t3.tsAsExpression(
           codegenPlaceToExpression(cx, instrValue.value),
           instrValue.typeAnnotation
         );
       } else {
-        value = t4.typeCastExpression(
+        value = t3.typeCastExpression(
           codegenPlaceToExpression(cx, instrValue.value),
-          t4.typeAnnotation(instrValue.typeAnnotation)
+          t3.typeAnnotation(instrValue.typeAnnotation)
         );
       }
       break;
@@ -130883,7 +131122,7 @@ function codegenInstructionValue(cx, instrValue) {
         if (stmt.type === "ExpressionStatement") {
           return stmt.expression;
         } else {
-          if (t4.isVariableDeclaration(stmt)) {
+          if (t3.isVariableDeclaration(stmt)) {
             const declarator = stmt.declarations[0];
             cx.errors.push({
               reason: `(CodegenReactiveFunction::codegenInstructionValue) Cannot declare variables in a value block, tried to declare '${declarator.id.name}'`,
@@ -130891,7 +131130,7 @@ function codegenInstructionValue(cx, instrValue) {
               loc: (_a2 = declarator.loc) != null ? _a2 : null,
               suggestions: null
             });
-            return t4.stringLiteral(`TODO handle ${declarator.id}`);
+            return t3.stringLiteral(`TODO handle ${declarator.id}`);
           } else {
             cx.errors.push({
               reason: `(CodegenReactiveFunction::codegenInstructionValue) Handle conversion of ${stmt.type} to expression`,
@@ -130899,7 +131138,7 @@ function codegenInstructionValue(cx, instrValue) {
               loc: (_b2 = stmt.loc) != null ? _b2 : null,
               suggestions: null
             });
-            return t4.stringLiteral(`TODO handle ${stmt.type}`);
+            return t3.stringLiteral(`TODO handle ${stmt.type}`);
           }
         }
       });
@@ -130916,28 +131155,28 @@ function codegenInstructionValue(cx, instrValue) {
     case "TemplateLiteral": {
       value = createTemplateLiteral(
         instrValue.loc,
-        instrValue.quasis.map((q) => t4.templateElement(q)),
+        instrValue.quasis.map((q) => t3.templateElement(q)),
         instrValue.subexprs.map((p) => codegenPlaceToExpression(cx, p))
       );
       break;
     }
     case "LoadGlobal": {
-      value = t4.identifier(instrValue.binding.name);
+      value = t3.identifier(instrValue.binding.name);
       break;
     }
     case "RegExpLiteral": {
-      value = t4.regExpLiteral(instrValue.pattern, instrValue.flags);
+      value = t3.regExpLiteral(instrValue.pattern, instrValue.flags);
       break;
     }
     case "MetaProperty": {
-      value = t4.metaProperty(
-        t4.identifier(instrValue.meta),
-        t4.identifier(instrValue.property)
+      value = t3.metaProperty(
+        t3.identifier(instrValue.meta),
+        t3.identifier(instrValue.property)
       );
       break;
     }
     case "Await": {
-      value = t4.awaitExpression(codegenPlaceToExpression(cx, instrValue.value));
+      value = t3.awaitExpression(codegenPlaceToExpression(cx, instrValue.value));
       break;
     }
     case "GetIterator": {
@@ -130953,7 +131192,7 @@ function codegenInstructionValue(cx, instrValue) {
       break;
     }
     case "PostfixUpdate": {
-      value = t4.updateExpression(
+      value = t3.updateExpression(
         instrValue.operation,
         codegenPlaceToExpression(cx, instrValue.lvalue),
         false
@@ -130961,7 +131200,7 @@ function codegenInstructionValue(cx, instrValue) {
       break;
     }
     case "PrefixUpdate": {
-      value = t4.updateExpression(
+      value = t3.updateExpression(
         instrValue.operation,
         codegenPlaceToExpression(cx, instrValue.lvalue),
         true
@@ -130978,7 +131217,7 @@ function codegenInstructionValue(cx, instrValue) {
           suggestions: null
         }
       );
-      value = t4.assignmentExpression(
+      value = t3.assignmentExpression(
         "=",
         codegenLValue(cx, instrValue.lvalue.place),
         codegenPlaceToExpression(cx, instrValue.value)
@@ -130986,9 +131225,9 @@ function codegenInstructionValue(cx, instrValue) {
       break;
     }
     case "StoreGlobal": {
-      value = t4.assignmentExpression(
+      value = t3.assignmentExpression(
         "=",
-        t4.identifier(instrValue.name),
+        t3.identifier(instrValue.name),
         codegenPlaceToExpression(cx, instrValue.value)
       );
       break;
@@ -131050,7 +131289,7 @@ function codegenJsxAttribute(cx, attribute) {
       return createJsxAttribute(attribute.place.loc, propName, value);
     }
     case "JsxSpreadAttribute": {
-      return t4.jsxSpreadAttribute(
+      return t3.jsxSpreadAttribute(
         codegenPlaceToExpression(cx, attribute.argument)
       );
     }
@@ -131105,9 +131344,9 @@ function convertMemberExpressionToJsx(expr) {
     loc: (_a = expr.loc) != null ? _a : null,
     suggestions: null
   });
-  const property = t4.jsxIdentifier(expr.property.name);
+  const property = t3.jsxIdentifier(expr.property.name);
   if (expr.object.type === "Identifier") {
-    return t4.jsxMemberExpression(t4.jsxIdentifier(expr.object.name), property);
+    return t3.jsxMemberExpression(t3.jsxIdentifier(expr.object.name), property);
   } else {
     CompilerError.invariant(expr.object.type === "MemberExpression", {
       reason: "Expected JSX member expression to be an identifier or nested member expression",
@@ -131116,20 +131355,20 @@ function convertMemberExpressionToJsx(expr) {
       suggestions: null
     });
     const object = convertMemberExpressionToJsx(expr.object);
-    return t4.jsxMemberExpression(object, property);
+    return t3.jsxMemberExpression(object, property);
   }
 }
 function codegenObjectPropertyKey(cx, key2) {
   switch (key2.kind) {
     case "string": {
-      return t4.stringLiteral(key2.name);
+      return t3.stringLiteral(key2.name);
     }
     case "identifier": {
-      return t4.identifier(key2.name);
+      return t3.identifier(key2.name);
     }
     case "computed": {
       const expr = codegenPlace(cx, key2.name);
-      CompilerError.invariant(t4.isExpression(expr), {
+      CompilerError.invariant(t3.isExpression(expr), {
         reason: "Expected object property key to be an expression",
         description: null,
         loc: key2.name.loc,
@@ -131138,14 +131377,14 @@ function codegenObjectPropertyKey(cx, key2) {
       return expr;
     }
     case "number": {
-      return t4.numericLiteral(key2.name);
+      return t3.numericLiteral(key2.name);
     }
   }
 }
 function codegenArrayPattern(cx, pattern) {
   const hasHoles = !pattern.items.every((e) => e.kind !== "Hole");
   if (hasHoles) {
-    const result = t4.arrayPattern([]);
+    const result = t3.arrayPattern([]);
     for (const item of pattern.items) {
       if (item.kind === "Hole") {
         result.elements.push(null);
@@ -131155,7 +131394,7 @@ function codegenArrayPattern(cx, pattern) {
     }
     return result;
   } else {
-    return t4.arrayPattern(
+    return t3.arrayPattern(
       pattern.items.map((item) => {
         if (item.kind === "Hole") {
           return null;
@@ -131171,25 +131410,25 @@ function codegenLValue(cx, pattern) {
       return codegenArrayPattern(cx, pattern);
     }
     case "ObjectPattern": {
-      return t4.objectPattern(
+      return t3.objectPattern(
         pattern.properties.map((property) => {
           if (property.kind === "ObjectProperty") {
             const key2 = codegenObjectPropertyKey(cx, property.key);
             const value = codegenLValue(cx, property.place);
-            return t4.objectProperty(
+            return t3.objectProperty(
               key2,
               value,
               property.key.kind === "computed",
               key2.type === "Identifier" && value.type === "Identifier" && value.name === key2.name
             );
           } else {
-            return t4.restElement(codegenLValue(cx, property.place));
+            return t3.restElement(codegenLValue(cx, property.place));
           }
         })
       );
     }
     case "Spread": {
-      return t4.restElement(codegenLValue(cx, pattern.place));
+      return t3.restElement(codegenLValue(cx, pattern.place));
     }
     case "Identifier": {
       return convertIdentifier(pattern.identifier);
@@ -131204,15 +131443,15 @@ function codegenLValue(cx, pattern) {
 }
 function codegenValue(cx, loc, value) {
   if (typeof value === "number") {
-    return t4.numericLiteral(value);
+    return t3.numericLiteral(value);
   } else if (typeof value === "boolean") {
-    return t4.booleanLiteral(value);
+    return t3.booleanLiteral(value);
   } else if (typeof value === "string") {
     return createStringLiteral(loc, value);
   } else if (value === null) {
-    return t4.nullLiteral();
+    return t3.nullLiteral();
   } else if (value === void 0) {
-    return t4.identifier("undefined");
+    return t3.identifier("undefined");
   } else {
     assertExhaustive(value, "Unexpected primitive value kind");
   }
@@ -131221,7 +131460,7 @@ function codegenArgument(cx, arg) {
   if (arg.kind === "Identifier") {
     return codegenPlaceToExpression(cx, arg);
   } else {
-    return t4.spreadElement(codegenPlaceToExpression(cx, arg.place));
+    return t3.spreadElement(codegenPlaceToExpression(cx, arg.place));
   }
 }
 function codegenPlaceToExpression(cx, place) {
@@ -131255,7 +131494,7 @@ function convertIdentifier(identifier4) {
       suggestions: null
     }
   );
-  return t4.identifier(identifier4.name.value);
+  return t3.identifier(identifier4.name.value);
 }
 function compareScopeDependency(a, b) {
   var _a, _b;
@@ -132599,10 +132838,9 @@ function inferReferenceEffects(fn, options = { isFunctionExpression: false }) {
     return transformFunctionEffectErrors(functionEffects);
   }
 }
-var _env3, _values, _variables;
+var _values, _variables;
 var _InferenceState = class _InferenceState {
   constructor(env, values, variables) {
-    __privateAdd(this, _env3);
     // The kind of each value, based on its allocation site
     __privateAdd(this, _values);
     /*
@@ -132611,7 +132849,7 @@ var _InferenceState = class _InferenceState {
      * values from different control flow paths).
      */
     __privateAdd(this, _variables);
-    __privateSet(this, _env3, env);
+    this.env = env;
     __privateSet(this, _values, values);
     __privateSet(this, _variables, variables);
   }
@@ -132723,7 +132961,7 @@ var _InferenceState = class _InferenceState {
         reason,
         context: /* @__PURE__ */ new Set()
       });
-      if (value.kind === "FunctionExpression" && (__privateGet(this, _env3).config.enablePreserveExistingMemoizationGuarantees || __privateGet(this, _env3).config.enableTransitivelyFreezeFunctionExpressions)) {
+      if (value.kind === "FunctionExpression" && (this.env.config.enablePreserveExistingMemoizationGuarantees || this.env.config.enableTransitivelyFreezeFunctionExpressions)) {
         for (const operand of value.loweredFunc.func.context) {
           const operandValues = __privateGet(this, _variables).get(operand.identifier.id);
           if (operandValues !== void 0) {
@@ -132768,6 +133006,18 @@ var _InferenceState = class _InferenceState {
         }
         break;
       }
+      case "mutate-iterator?" /* ConditionallyMutateIterator */: {
+        if (valueKind.kind === "mutable" /* Mutable */ || valueKind.kind === "context" /* Context */) {
+          if (isArrayType(place.identifier) || isSetType(place.identifier) || isMapType(place.identifier)) {
+            effect = "capture" /* Capture */;
+          } else {
+            effect = "mutate?" /* ConditionallyMutate */;
+          }
+        } else {
+          effect = "read" /* Read */;
+        }
+        break;
+      }
       case "mutate" /* Mutate */: {
         effect = "mutate" /* Mutate */;
         break;
@@ -132871,7 +133121,7 @@ var _InferenceState = class _InferenceState {
       return null;
     } else {
       return new _InferenceState(
-        __privateGet(this, _env3),
+        this.env,
         nextValues != null ? nextValues : new Map(__privateGet(this, _values)),
         nextVariables != null ? nextVariables : new Map(__privateGet(this, _variables))
       );
@@ -132884,7 +133134,7 @@ var _InferenceState = class _InferenceState {
    */
   clone() {
     return new _InferenceState(
-      __privateGet(this, _env3),
+      this.env,
       new Map(__privateGet(this, _values)),
       new Map(__privateGet(this, _variables))
     );
@@ -132927,7 +133177,6 @@ var _InferenceState = class _InferenceState {
     }
   }
 };
-_env3 = new WeakMap();
 _values = new WeakMap();
 _variables = new WeakMap();
 var InferenceState = _InferenceState;
@@ -133011,7 +133260,7 @@ function mergeAbstractValues(a, b) {
   return { kind, reason, context };
 }
 function inferBlock(env, state, block, functionEffects) {
-  var _a, _b, _c, _d, _e;
+  var _a, _b, _c;
   for (const phi of block.phis) {
     state.inferPhi(phi);
   }
@@ -133052,7 +133301,7 @@ function inferBlock(env, state, block, functionEffects) {
             state.referenceAndRecordEffects(
               freezeActions,
               element.place,
-              isArrayType(element.place.identifier) ? "capture" /* Capture */ : "mutate?" /* ConditionallyMutate */,
+              "mutate-iterator?" /* ConditionallyMutateIterator */,
               "other" /* Other */
             );
           } else if (element.kind === "Identifier") {
@@ -133075,28 +133324,12 @@ function inferBlock(env, state, block, functionEffects) {
         break;
       }
       case "NewExpression": {
-        const valueKind = {
-          kind: "mutable" /* Mutable */,
-          reason: /* @__PURE__ */ new Set(["other" /* Other */]),
-          context: /* @__PURE__ */ new Set()
-        };
-        state.referenceAndRecordEffects(
+        inferCallEffects(
+          state,
+          instr,
           freezeActions,
-          instrValue.callee,
-          "read" /* Read */,
-          "other" /* Other */
+          getFunctionCallSignature(env, instrValue.callee.identifier.type)
         );
-        for (const operand of eachCallArgument(instrValue.args)) {
-          state.referenceAndRecordEffects(
-            freezeActions,
-            operand,
-            "mutate?" /* ConditionallyMutate */,
-            "other" /* Other */
-          );
-        }
-        state.initialize(instrValue, valueKind);
-        state.define(instr.lvalue, instrValue);
-        instr.lvalue.effect = "mutate?" /* ConditionallyMutate */;
         continuation = { kind: "funeffects" };
         break;
       }
@@ -133369,53 +133602,12 @@ function inferBlock(env, state, block, functionEffects) {
         break;
       }
       case "CallExpression": {
-        const signature = getFunctionCallSignature(
-          env,
-          instrValue.callee.identifier.type
+        inferCallEffects(
+          state,
+          instr,
+          freezeActions,
+          getFunctionCallSignature(env, instrValue.callee.identifier.type)
         );
-        const effects = signature !== null ? getFunctionEffects(instrValue, signature) : null;
-        const returnValueKind = signature !== null ? {
-          kind: signature.returnValueKind,
-          reason: /* @__PURE__ */ new Set([
-            (_c = signature.returnValueReason) != null ? _c : "known-return-signature" /* KnownReturnSignature */
-          ]),
-          context: /* @__PURE__ */ new Set()
-        } : {
-          kind: "mutable" /* Mutable */,
-          reason: /* @__PURE__ */ new Set(["other" /* Other */]),
-          context: /* @__PURE__ */ new Set()
-        };
-        let hasCaptureArgument = false;
-        for (let i = 0; i < instrValue.args.length; i++) {
-          const arg = instrValue.args[i];
-          const place = arg.kind === "Identifier" ? arg : arg.place;
-          state.referenceAndRecordEffects(
-            freezeActions,
-            place,
-            getArgumentEffect(effects != null ? effects[i] : null, arg),
-            "other" /* Other */
-          );
-          hasCaptureArgument || (hasCaptureArgument = place.effect === "capture" /* Capture */);
-        }
-        if (signature !== null) {
-          state.referenceAndRecordEffects(
-            freezeActions,
-            instrValue.callee,
-            signature.calleeEffect,
-            "other" /* Other */
-          );
-        } else {
-          state.referenceAndRecordEffects(
-            freezeActions,
-            instrValue.callee,
-            "mutate?" /* ConditionallyMutate */,
-            "other" /* Other */
-          );
-        }
-        hasCaptureArgument || (hasCaptureArgument = instrValue.callee.effect === "capture" /* Capture */);
-        state.initialize(instrValue, returnValueKind);
-        state.define(instr.lvalue, instrValue);
-        instr.lvalue.effect = hasCaptureArgument ? "store" /* Store */ : "mutate?" /* ConditionallyMutate */;
         continuation = { kind: "funeffects" };
         break;
       }
@@ -133432,75 +133624,12 @@ function inferBlock(env, state, block, functionEffects) {
           "read" /* Read */,
           "other" /* Other */
         );
-        const signature = getFunctionCallSignature(
-          env,
-          instrValue.property.identifier.type
+        inferCallEffects(
+          state,
+          instr,
+          freezeActions,
+          getFunctionCallSignature(env, instrValue.property.identifier.type)
         );
-        const returnValueKind = signature !== null ? {
-          kind: signature.returnValueKind,
-          reason: /* @__PURE__ */ new Set([
-            (_d = signature.returnValueReason) != null ? _d : "known-return-signature" /* KnownReturnSignature */
-          ]),
-          context: /* @__PURE__ */ new Set()
-        } : {
-          kind: "mutable" /* Mutable */,
-          reason: /* @__PURE__ */ new Set(["other" /* Other */]),
-          context: /* @__PURE__ */ new Set()
-        };
-        if (signature !== null && signature.mutableOnlyIfOperandsAreMutable && areArgumentsImmutableAndNonMutating(state, instrValue.args)) {
-          for (const arg of instrValue.args) {
-            const place = arg.kind === "Identifier" ? arg : arg.place;
-            state.referenceAndRecordEffects(
-              freezeActions,
-              place,
-              "read" /* Read */,
-              "other" /* Other */
-            );
-          }
-          state.referenceAndRecordEffects(
-            freezeActions,
-            instrValue.receiver,
-            "capture" /* Capture */,
-            "other" /* Other */
-          );
-          state.initialize(instrValue, returnValueKind);
-          state.define(instr.lvalue, instrValue);
-          instr.lvalue.effect = instrValue.receiver.effect === "capture" /* Capture */ ? "store" /* Store */ : "mutate?" /* ConditionallyMutate */;
-          continuation = { kind: "funeffects" };
-          break;
-        }
-        const effects = signature !== null ? getFunctionEffects(instrValue, signature) : null;
-        let hasCaptureArgument = false;
-        for (let i = 0; i < instrValue.args.length; i++) {
-          const arg = instrValue.args[i];
-          const place = arg.kind === "Identifier" ? arg : arg.place;
-          state.referenceAndRecordEffects(
-            freezeActions,
-            place,
-            getArgumentEffect(effects != null ? effects[i] : null, arg),
-            "other" /* Other */
-          );
-          hasCaptureArgument || (hasCaptureArgument = place.effect === "capture" /* Capture */);
-        }
-        if (signature !== null) {
-          state.referenceAndRecordEffects(
-            freezeActions,
-            instrValue.receiver,
-            signature.calleeEffect,
-            "other" /* Other */
-          );
-        } else {
-          state.referenceAndRecordEffects(
-            freezeActions,
-            instrValue.receiver,
-            "mutate?" /* ConditionallyMutate */,
-            "other" /* Other */
-          );
-        }
-        hasCaptureArgument || (hasCaptureArgument = instrValue.receiver.effect === "capture" /* Capture */);
-        state.initialize(instrValue, returnValueKind);
-        state.define(instr.lvalue, instrValue);
-        instr.lvalue.effect = hasCaptureArgument ? "store" /* Store */ : "mutate?" /* ConditionallyMutate */;
         continuation = { kind: "funeffects" };
         break;
       }
@@ -133827,7 +133956,8 @@ function inferBlock(env, state, block, functionEffects) {
         const isMutable3 = kind === "mutable" /* Mutable */ || kind === "context" /* Context */;
         let effect;
         let valueKind;
-        if (!isMutable3 || isArrayType(instrValue.collection.identifier)) {
+        const iterator = instrValue.collection.identifier;
+        if (!isMutable3 || isArrayType(iterator) || isMapType(iterator) || isSetType(iterator)) {
           effect = {
             kind: "read" /* Read */,
             reason: "other" /* Other */
@@ -133856,7 +133986,7 @@ function inferBlock(env, state, block, functionEffects) {
         state.referenceAndRecordEffects(
           freezeActions,
           instrValue.iterator,
-          "mutate?" /* ConditionallyMutate */,
+          "mutate-iterator?" /* ConditionallyMutateIterator */,
           "other" /* Other */
         );
         state.referenceAndRecordEffects(
@@ -133905,7 +134035,7 @@ function inferBlock(env, state, block, functionEffects) {
       }
       state.initialize(instrValue, continuation.valueKind);
       state.define(instr.lvalue, instrValue);
-      instr.lvalue.effect = (_e = continuation.lvalueEffect) != null ? _e : defaultLvalueEffect;
+      instr.lvalue.effect = (_c = continuation.lvalueEffect) != null ? _c : defaultLvalueEffect;
     }
     functionEffects.push(...inferInstructionFunctionEffects(env, state, instr));
     freezeActions.forEach(
@@ -133969,12 +134099,43 @@ function getFunctionEffects(fn, sig) {
   }
   return results;
 }
+function isKnownMutableEffect(effect) {
+  switch (effect) {
+    case "store" /* Store */:
+    case "mutate?" /* ConditionallyMutate */:
+    case "mutate-iterator?" /* ConditionallyMutateIterator */:
+    case "mutate" /* Mutate */: {
+      return true;
+    }
+    case "<unknown>" /* Unknown */: {
+      CompilerError.invariant(false, {
+        reason: "Unexpected unknown effect",
+        description: null,
+        loc: GeneratedSource,
+        suggestions: null
+      });
+    }
+    case "read" /* Read */:
+    case "capture" /* Capture */:
+    case "freeze" /* Freeze */: {
+      return false;
+    }
+    default: {
+      assertExhaustive(effect, `Unexpected effect \`${effect}\``);
+    }
+  }
+}
 function areArgumentsImmutableAndNonMutating(state, args) {
   for (const arg of args) {
+    if (arg.kind === "Identifier" && arg.identifier.type.kind === "Function") {
+      const fnShape = state.env.getFunctionSignature(arg.identifier.type);
+      if (fnShape != null) {
+        return !fnShape.positionalParams.some(isKnownMutableEffect) && (fnShape.restParam == null || !isKnownMutableEffect(fnShape.restParam));
+      }
+    }
     const place = arg.kind === "Identifier" ? arg : arg.place;
     const kind = state.kind(place).kind;
     switch (kind) {
-      case "global" /* Global */:
       case "primitive" /* Primitive */:
       case "frozen" /* Frozen */: {
         break;
@@ -134009,12 +134170,81 @@ function getArgumentEffect(signatureEffect, arg) {
           loc: arg.place.loc
         });
       }
-      return "mutate?" /* ConditionallyMutate */;
+      return "mutate-iterator?" /* ConditionallyMutateIterator */;
     }
   } else {
     return "mutate?" /* ConditionallyMutate */;
   }
 }
+function inferCallEffects(state, instr, freezeActions, signature) {
+  var _a;
+  const instrValue = instr.value;
+  const returnValueKind = signature !== null ? {
+    kind: signature.returnValueKind,
+    reason: /* @__PURE__ */ new Set([
+      (_a = signature.returnValueReason) != null ? _a : "known-return-signature" /* KnownReturnSignature */
+    ]),
+    context: /* @__PURE__ */ new Set()
+  } : {
+    kind: "mutable" /* Mutable */,
+    reason: /* @__PURE__ */ new Set(["other" /* Other */]),
+    context: /* @__PURE__ */ new Set()
+  };
+  if (instrValue.kind === "MethodCall" && signature !== null && signature.mutableOnlyIfOperandsAreMutable && areArgumentsImmutableAndNonMutating(state, instrValue.args)) {
+    for (const arg of instrValue.args) {
+      const place = arg.kind === "Identifier" ? arg : arg.place;
+      state.referenceAndRecordEffects(
+        freezeActions,
+        place,
+        "read" /* Read */,
+        "other" /* Other */
+      );
+    }
+    state.referenceAndRecordEffects(
+      freezeActions,
+      instrValue.receiver,
+      "capture" /* Capture */,
+      "other" /* Other */
+    );
+    state.initialize(instrValue, returnValueKind);
+    state.define(instr.lvalue, instrValue);
+    instr.lvalue.effect = instrValue.receiver.effect === "capture" /* Capture */ ? "store" /* Store */ : "mutate?" /* ConditionallyMutate */;
+    return;
+  }
+  const effects = signature !== null ? getFunctionEffects(instrValue, signature) : null;
+  let hasCaptureArgument = false;
+  for (let i = 0; i < instrValue.args.length; i++) {
+    const arg = instrValue.args[i];
+    const place = arg.kind === "Identifier" ? arg : arg.place;
+    state.referenceAndRecordEffects(
+      freezeActions,
+      place,
+      getArgumentEffect(effects != null ? effects[i] : null, arg),
+      "other" /* Other */
+    );
+    hasCaptureArgument || (hasCaptureArgument = place.effect === "capture" /* Capture */);
+  }
+  const callee = instrValue.kind === "MethodCall" ? instrValue.receiver : instrValue.callee;
+  if (signature !== null) {
+    state.referenceAndRecordEffects(
+      freezeActions,
+      callee,
+      signature.calleeEffect,
+      "other" /* Other */
+    );
+  } else {
+    state.referenceAndRecordEffects(
+      freezeActions,
+      callee,
+      instrValue.kind === "NewExpression" ? "read" /* Read */ : "mutate?" /* ConditionallyMutate */,
+      "other" /* Other */
+    );
+  }
+  hasCaptureArgument || (hasCaptureArgument = callee.effect === "capture" /* Capture */);
+  state.initialize(instrValue, returnValueKind);
+  state.define(instr.lvalue, instrValue);
+  instr.lvalue.effect = hasCaptureArgument ? "store" /* Store */ : "mutate?" /* ConditionallyMutate */;
+}
 
 // src/ReactiveScopes/PruneNonEscapingScopes.ts
 function pruneNonEscapingScopes(fn) {
@@ -134910,7 +135140,7 @@ var Visitor7 = class extends ReactiveFunctionVisitor {
 // src/ReactiveScopes/RenameVariables.ts
 function renameVariables(fn) {
   const globals = collectReferencedGlobals(fn);
-  const scopes = new Scopes(globals);
+  const scopes = new Scopes(globals, fn.env.programContext);
   renameVariablesImpl(fn, new Visitor8(), scopes);
   return /* @__PURE__ */ new Set([...scopes.names, ...globals]);
 }
@@ -134960,15 +135190,17 @@ var Visitor8 = class extends ReactiveFunctionVisitor {
     renameVariablesImpl(_fn, this, _state);
   }
 };
-var _seen, _stack, _globals3, _Scopes_instances, lookup_fn;
+var _seen, _stack, _globals3, _programContext, _Scopes_instances, lookup_fn;
 var Scopes = class {
-  constructor(globals) {
+  constructor(globals, programContext) {
     __privateAdd(this, _Scopes_instances);
     __privateAdd(this, _seen, /* @__PURE__ */ new Map());
     __privateAdd(this, _stack, [/* @__PURE__ */ new Map()]);
     __privateAdd(this, _globals3);
+    __privateAdd(this, _programContext);
     this.names = /* @__PURE__ */ new Set();
     __privateSet(this, _globals3, globals);
+    __privateSet(this, _programContext, programContext);
   }
   visit(identifier4) {
     const originalName = identifier4.name;
@@ -134996,6 +135228,7 @@ var Scopes = class {
         name = `${originalName.value}$${id++}`;
       }
     }
+    __privateGet(this, _programContext).addNewReference(name);
     const identifierName = makeIdentifierName(name);
     identifier4.name = identifierName;
     __privateGet(this, _seen).set(identifier4.declarationId, identifierName);
@@ -135018,6 +135251,7 @@ var Scopes = class {
 _seen = new WeakMap();
 _stack = new WeakMap();
 _globals3 = new WeakMap();
+_programContext = new WeakMap();
 _Scopes_instances = new WeakSet();
 lookup_fn = function(name) {
   for (let i = __privateGet(this, _stack).length - 1; i >= 0; i--) {
@@ -135201,6 +135435,13 @@ function inferPlace(place, instrId, inferMutableRangeForStores) {
         infer(place, instrId);
       }
       return;
+    case "mutate-iterator?" /* ConditionallyMutateIterator */: {
+      const identifier4 = place.identifier;
+      if (!isArrayType(identifier4) && !isSetType(identifier4) && !isMapType(identifier4)) {
+        infer(place, instrId);
+      }
+      return;
+    }
     case "mutate?" /* ConditionallyMutate */:
     case "mutate" /* Mutate */: {
       infer(place, instrId);
@@ -135836,6 +136077,7 @@ function inferReactivePlaces(fn) {
               case "capture" /* Capture */:
               case "store" /* Store */:
               case "mutate?" /* ConditionallyMutate */:
+              case "mutate-iterator?" /* ConditionallyMutateIterator */:
               case "mutate" /* Mutate */: {
                 if (isMutable2(instruction, operand)) {
                   reactiveIdentifiers.markReactive(operand);
@@ -136203,6 +136445,7 @@ function inferEffectDependencies(fn) {
   if (hasRewrite) {
     markInstructionIds(fn.body);
     fixScopeAndIdentifierRanges(fn.body);
+    fn.env.hasInferredEffect = true;
   }
 }
 function writeDependencyToInstructions(dep, reactive, env, loc) {
@@ -137291,7 +137534,8 @@ function* generateInstructionTypes(env, names, instr) {
       yield equation(value.callee.identifier.type, {
         kind: "Function",
         shapeId: null,
-        return: returnType
+        return: returnType,
+        isConstructor: false
       });
       yield equation(left, returnType);
       break;
@@ -137301,7 +137545,8 @@ function* generateInstructionTypes(env, names, instr) {
       yield equation(value.tag.identifier.type, {
         kind: "Function",
         shapeId: null,
-        return: returnType
+        return: returnType,
+        isConstructor: false
       });
       yield equation(left, returnType);
       break;
@@ -137350,7 +137595,8 @@ function* generateInstructionTypes(env, names, instr) {
       yield equation(value.property.identifier.type, {
         kind: "Function",
         return: returnType,
-        shapeId: null
+        shapeId: null,
+        isConstructor: false
       });
       yield equation(left, returnType);
       break;
@@ -137413,7 +137659,8 @@ function* generateInstructionTypes(env, names, instr) {
       yield equation(left, {
         kind: "Function",
         shapeId: BuiltInFunctionId,
-        return: value.loweredFunc.func.returnType
+        return: value.loweredFunc.func.returnType,
+        isConstructor: false
       });
       break;
     }
@@ -137431,9 +137678,19 @@ function* generateInstructionTypes(env, names, instr) {
       yield equation(left, { kind: "Object", shapeId: BuiltInJsxId });
       break;
     }
+    case "NewExpression": {
+      const returnType = makeType();
+      yield equation(value.callee.identifier.type, {
+        kind: "Function",
+        return: returnType,
+        shapeId: null,
+        isConstructor: true
+      });
+      yield equation(left, returnType);
+      break;
+    }
     case "PropertyStore":
     case "DeclareLocal":
-    case "NewExpression":
     case "RegExpLiteral":
     case "MetaProperty":
     case "ComputedStore":
@@ -137492,7 +137749,7 @@ var Unifier = class {
       this.bindVariableTo(tB, tA);
       return;
     }
-    if (tB.kind === "Function" && tA.kind === "Function") {
+    if (tB.kind === "Function" && tA.kind === "Function" && tA.isConstructor === tB.isConstructor) {
       this.unify(tA.return, tB.return);
       return;
     }
@@ -137593,7 +137850,8 @@ var Unifier = class {
         return {
           kind: "Function",
           return: returnType,
-          shapeId: type.shapeId
+          shapeId: type.shapeId,
+          isConstructor: type.isConstructor
         };
       }
       case "ObjectMethod":
@@ -138033,9 +138291,7 @@ function validateHooksUsage(fn) {
   for (const [, error] of errorsByPlace) {
     errors.push(error);
   }
-  if (errors.hasErrors()) {
-    throw errors;
-  }
+  return errors.asResult();
 }
 function visitFunctionExpression(errors, fn) {
   for (const [, block] of fn.body.blocks) {
@@ -138072,9 +138328,7 @@ function visitFunctionExpression(errors, fn) {
 function validateMemoizedEffectDependencies(fn) {
   const errors = new CompilerError();
   visitReactiveFunction(fn, new Visitor10(), errors);
-  if (errors.hasErrors()) {
-    throw errors;
-  }
+  return errors.asResult();
 }
 var Visitor10 = class extends ReactiveFunctionVisitor {
   constructor() {
@@ -138136,6 +138390,7 @@ function validateNoCapitalizedCalls(fn) {
   const isAllowed = (name) => {
     return ALLOW_LIST.has(name) || hookPattern != null && hookPattern.test(name);
   };
+  const errors = new CompilerError();
   const capitalLoadGlobals = /* @__PURE__ */ new Map();
   const capitalizedProperties = /* @__PURE__ */ new Map();
   const reason = "Capitalized functions are reserved for components, which must be invoked with JSX. If this is a component, render it with JSX. Otherwise, ensure that it has no hook calls and rename it to begin with a lowercase letter. Alternatively, if you know for a fact that this function is not a component, you can allowlist it via the compiler config";
@@ -138172,7 +138427,8 @@ function validateNoCapitalizedCalls(fn) {
           const propertyIdentifier = value.property.identifier.id;
           const propertyName = capitalizedProperties.get(propertyIdentifier);
           if (propertyName != null) {
-            CompilerError.throwInvalidReact({
+            errors.push({
+              severity: "InvalidReact" /* InvalidReact */,
               reason,
               description: `${propertyName} may be a component.`,
               loc: value.loc,
@@ -138184,6 +138440,7 @@ function validateNoCapitalizedCalls(fn) {
       }
     }
   }
+  return errors.asResult();
 }
 
 // src/Validation/ValidateNoRefAccesInRender.ts
@@ -138225,7 +138482,7 @@ var Env = class extends Map {
 _changed = new WeakMap();
 function validateNoRefAccessInRender(fn) {
   const env = new Env();
-  validateNoRefAccessInRenderImpl(fn, env).unwrap();
+  return validateNoRefAccessInRenderImpl(fn, env).map((_) => void 0);
 }
 function refTypeOfType(place) {
   if (isRefValueType(place.identifier)) {
@@ -138687,7 +138944,7 @@ function validateNoDirectRefValueAccess(errors, operand, env) {
 // src/Validation/ValidateNoSetStateInRender.ts
 function validateNoSetStateInRender(fn) {
   const unconditionalSetStateFunctions = /* @__PURE__ */ new Set();
-  validateNoSetStateInRenderImpl(fn, unconditionalSetStateFunctions).unwrap();
+  return validateNoSetStateInRenderImpl(fn, unconditionalSetStateFunctions);
 }
 function validateNoSetStateInRenderImpl(fn, unconditionalSetStateFunctions) {
   const unconditionalBlocks = computeUnconditionalBlocks(fn);
@@ -138772,11 +139029,7 @@ function validateNoSetStateInRenderImpl(fn, unconditionalSetStateFunctions) {
       }
     }
   }
-  if (errors.hasErrors()) {
-    return Err(errors);
-  } else {
-    return Ok(void 0);
-  }
+  return errors.asResult();
 }
 
 // src/Validation/ValidatePreservedManualMemoization.ts
@@ -138786,9 +139039,7 @@ function validatePreservedManualMemoization(fn) {
     manualMemoState: null
   };
   visitReactiveFunction(fn, new Visitor11(), state);
-  if (state.errors.hasErrors()) {
-    throw state.errors;
-  }
+  return state.errors.asResult();
 }
 var DEBUG4 = false;
 function prettyPrintScopeDependency(val) {
@@ -139108,6 +139359,7 @@ function isUnmemoized2(operand, scopes) {
 
 // src/Validation/ValidateUseMemo.ts
 function validateUseMemo(fn) {
+  const errors = new CompilerError();
   const useMemos = /* @__PURE__ */ new Set();
   const react = /* @__PURE__ */ new Set();
   const functions = /* @__PURE__ */ new Map();
@@ -139150,7 +139402,8 @@ function validateUseMemo(fn) {
             continue;
           }
           if (body.loweredFunc.func.params.length > 0) {
-            CompilerError.throwInvalidReact({
+            errors.push({
+              severity: "InvalidReact" /* InvalidReact */,
               reason: "useMemo callbacks may not accept any arguments",
               description: null,
               loc: body.loc,
@@ -139158,7 +139411,8 @@ function validateUseMemo(fn) {
             });
           }
           if (body.loweredFunc.func.async || body.loweredFunc.func.generator) {
-            CompilerError.throwInvalidReact({
+            errors.push({
+              severity: "InvalidReact" /* InvalidReact */,
               reason: "useMemo callbacks may not be async or generator functions",
               description: null,
               loc: body.loc,
@@ -139170,6 +139424,7 @@ function validateUseMemo(fn) {
       }
     }
   }
+  return errors.asResult();
 }
 
 // src/Validation/ValidateLocalsNotReassignedAfterRender.ts
@@ -139398,7 +139653,7 @@ function propagatePhiTypes(fn) {
 }
 
 // src/Optimization/LowerContextAccess.ts
-function lowerContextAccess(fn, loweredContextCallee) {
+function lowerContextAccess(fn, loweredContextCalleeConfig) {
   const contextAccess = /* @__PURE__ */ new Map();
   const contextKeys = /* @__PURE__ */ new Map();
   for (const [, block] of fn.body.blocks) {
@@ -139426,6 +139681,7 @@ function lowerContextAccess(fn, loweredContextCallee) {
       }
     }
   }
+  let importLoweredContextCallee = null;
   if (contextAccess.size > 0 && contextKeys.size > 0) {
     for (const [, block] of fn.body.blocks) {
       let nextInstructions = null;
@@ -139433,9 +139689,12 @@ function lowerContextAccess(fn, loweredContextCallee) {
         const instr = block.instructions[i];
         const { lvalue, value } = instr;
         if (value.kind === "CallExpression" && isUseContextHookType(value.callee.identifier) && contextKeys.has(lvalue.identifier.id)) {
+          importLoweredContextCallee != null ? importLoweredContextCallee : importLoweredContextCallee = fn.env.programContext.addImportSpecifier(
+            loweredContextCalleeConfig
+          );
           const loweredContextCalleeInstr = emitLoadLoweredContextCallee(
             fn.env,
-            loweredContextCallee
+            importLoweredContextCallee
           );
           if (nextInstructions === null) {
             nextInstructions = block.instructions.slice(0, i);
@@ -139459,17 +139718,12 @@ function lowerContextAccess(fn, loweredContextCallee) {
     }
     markInstructionIds(fn.body);
     inferTypes(fn);
-    fn.env.hasLoweredContextAccess = true;
   }
 }
-function emitLoadLoweredContextCallee(env, loweredContextCallee) {
+function emitLoadLoweredContextCallee(env, importedLowerContextCallee) {
   const loadGlobal = {
     kind: "LoadGlobal",
-    binding: {
-      kind: "ImportNamespace",
-      module: loweredContextCallee.source,
-      name: loweredContextCallee.importSpecifierName
-    },
+    binding: __spreadValues({}, importedLowerContextCallee),
     loc: GeneratedSource
   };
   return {
@@ -139676,9 +139930,7 @@ function validateNoSetStateInPassiveEffects(fn) {
       }
     }
   }
-  if (errors.hasErrors()) {
-    throw errors;
-  }
+  return errors.asResult();
 }
 function getSetStateCall(fn, setStateFunctions) {
   for (const [, block] of fn.body.blocks) {
@@ -139744,9 +139996,7 @@ function validateNoJSXInTryStatement(fn) {
       activeTryBlocks.push(block.terminal.handler);
     }
   }
-  if (errors.hasErrors()) {
-    throw errors;
-  }
+  return errors.asResult();
 }
 
 // src/HIR/CollectHoistablePropertyLoads.ts
@@ -141180,7 +141430,7 @@ function process2(fn, jsx, globals) {
   if (fn.fnType === "Component") {
     return null;
   }
-  const props = collectProps(jsx);
+  const props = collectProps(fn.env, jsx);
   if (!props) return null;
   const outlinedTag = fn.env.generateGloballyUniqueIdentifierName(null).value;
   const newInstrs = emitOutlinedJsx(fn.env, jsx, props, outlinedTag);
@@ -141190,7 +141440,7 @@ function process2(fn, jsx, globals) {
   outlinedFn.id = outlinedTag;
   return { instrs: newInstrs, fn: outlinedFn };
 }
-function collectProps(instructions) {
+function collectProps(env, instructions) {
   let id = 1;
   function generateName(oldName) {
     let newName = oldName;
@@ -141198,6 +141448,7 @@ function collectProps(instructions) {
       newName = `${oldName}${id++}`;
     }
     seen.add(newName);
+    env.programContext.addNewReference(newName);
     return newName;
   }
   const attributes = [];
@@ -141460,6 +141711,7 @@ function transformFire(fn) {
   context.throwIfErrorsFound();
 }
 function replaceFireFunctions(fn, context) {
+  let importedUseFire = null;
   let hasRewrite = false;
   for (const [, block] of fn.body.blocks) {
     const rewriteInstrs = /* @__PURE__ */ new Map();
@@ -141483,7 +141735,14 @@ function replaceFireFunctions(fn, context) {
           ] of capturedCallees.entries()) {
             if (!context.hasCalleeWithInsertedFire(fireCalleePlace)) {
               context.addCalleeWithInsertedFire(fireCalleePlace);
-              const loadUseFireInstr = makeLoadUseFireInstruction(fn.env);
+              importedUseFire != null ? importedUseFire : importedUseFire = fn.env.programContext.addImportSpecifier({
+                source: fn.env.programContext.reactRuntimeModule,
+                importSpecifierName: USE_FIRE_FUNCTION_NAME
+              });
+              const loadUseFireInstr = makeLoadUseFireInstruction(
+                fn.env,
+                importedUseFire
+              );
               const loadFireCalleeInstr = makeLoadFireCalleeInstruction(
                 fn.env,
                 fireCalleeInfo.capturedCalleeIdentifier
@@ -141703,18 +141962,13 @@ function ensureNoMoreFireUses(fn, context) {
     }
   }
 }
-function makeLoadUseFireInstruction(env) {
+function makeLoadUseFireInstruction(env, importedLoadUseFire) {
   const useFirePlace = createTemporaryPlace(env, GeneratedSource);
   useFirePlace.effect = "read" /* Read */;
   useFirePlace.identifier.type = DefaultNonmutatingHook;
   const instrValue = {
     kind: "LoadGlobal",
-    binding: {
-      kind: "ImportSpecifier",
-      name: "useFire",
-      module: "react",
-      imported: "useFire"
-    },
+    binding: __spreadValues({}, importedLoadUseFire),
     loc: GeneratedSource
   };
   return {
@@ -141782,10 +142036,10 @@ function makeStoreUseFireInstruction(env, useFireCallResultPlace, fireFunctionBi
     loc: GeneratedSource
   };
 }
-var _env4, _errors, _callExpressions, _functionExpressions, _loadLocals, _fireCalleesToFireFunctions, _calleesWithInsertedFire, _capturedCalleeIdentifierIds, _inUseEffectLambda, _loadGlobalInstructionIds, _arrayExpressions;
+var _env3, _errors, _callExpressions, _functionExpressions, _loadLocals, _fireCalleesToFireFunctions, _calleesWithInsertedFire, _capturedCalleeIdentifierIds, _inUseEffectLambda, _loadGlobalInstructionIds, _arrayExpressions;
 var Context4 = class {
   constructor(env) {
-    __privateAdd(this, _env4);
+    __privateAdd(this, _env3);
     __privateAdd(this, _errors, new CompilerError());
     /*
      * Used to look up the call expression passed to a `fire(callExpr())`. Gives back
@@ -141834,7 +142088,7 @@ var Context4 = class {
      * to use the fire functions
      */
     __privateAdd(this, _arrayExpressions, /* @__PURE__ */ new Map());
-    __privateSet(this, _env4, env);
+    __privateSet(this, _env3, env);
   }
   pushError(error) {
     __privateGet(this, _errors).push(error);
@@ -141869,7 +142123,7 @@ var Context4 = class {
     const fireFunctionBinding = getOrInsertWith(
       __privateGet(this, _fireCalleesToFireFunctions),
       callee.identifier.id,
-      () => createTemporaryPlace(__privateGet(this, _env4), GeneratedSource)
+      () => createTemporaryPlace(__privateGet(this, _env3), GeneratedSource)
     );
     __privateGet(this, _capturedCalleeIdentifierIds).set(callee.identifier.id, {
       fireFunctionBinding,
@@ -141917,7 +142171,7 @@ var Context4 = class {
     if (this.hasErrors()) throw __privateGet(this, _errors);
   }
 };
-_env4 = new WeakMap();
+_env3 = new WeakMap();
 _errors = new WeakMap();
 _callExpressions = new WeakMap();
 _functionExpressions = new WeakMap();
@@ -141951,7 +142205,7 @@ function rewriteInstructions(rewriteInstrs, instructions) {
   return instructions;
 }
 
-// src/Validation/ValiateNoImpureFunctionsInRender.ts
+// src/Validation/ValidateNoImpureFunctionsInRender.ts
 function validateNoImpureFunctionsInRender(fn) {
   const errors = new CompilerError();
   for (const [, block] of fn.body.blocks) {
@@ -141975,13 +142229,79 @@ function validateNoImpureFunctionsInRender(fn) {
       }
     }
   }
-  if (errors.hasErrors()) {
-    throw errors;
+  return errors.asResult();
+}
+
+// src/Validation/ValidateStaticComponents.ts
+function validateStaticComponents(fn) {
+  const error = new CompilerError();
+  const knownDynamicComponents = /* @__PURE__ */ new Map();
+  for (const block of fn.body.blocks.values()) {
+    phis: for (const phi of block.phis) {
+      for (const operand of phi.operands.values()) {
+        const loc = knownDynamicComponents.get(operand.identifier.id);
+        if (loc != null) {
+          knownDynamicComponents.set(phi.place.identifier.id, loc);
+          continue phis;
+        }
+      }
+    }
+    for (const instr of block.instructions) {
+      const { lvalue, value } = instr;
+      switch (value.kind) {
+        case "FunctionExpression":
+        case "NewExpression":
+        case "MethodCall":
+        case "CallExpression": {
+          knownDynamicComponents.set(lvalue.identifier.id, value.loc);
+          break;
+        }
+        case "LoadLocal": {
+          const loc = knownDynamicComponents.get(value.place.identifier.id);
+          if (loc != null) {
+            knownDynamicComponents.set(lvalue.identifier.id, loc);
+          }
+          break;
+        }
+        case "StoreLocal": {
+          const loc = knownDynamicComponents.get(value.value.identifier.id);
+          if (loc != null) {
+            knownDynamicComponents.set(lvalue.identifier.id, loc);
+            knownDynamicComponents.set(value.lvalue.place.identifier.id, loc);
+          }
+          break;
+        }
+        case "JsxExpression": {
+          if (value.tag.kind === "Identifier") {
+            const location = knownDynamicComponents.get(
+              value.tag.identifier.id
+            );
+            if (location != null) {
+              error.push({
+                reason: `Components created during render will reset their state each time they are created. Declare components outside of render. `,
+                severity: "InvalidReact" /* InvalidReact */,
+                loc: value.tag.loc,
+                description: null,
+                suggestions: null
+              });
+              error.push({
+                reason: `The component may be created during render`,
+                severity: "InvalidReact" /* InvalidReact */,
+                loc: location,
+                description: null,
+                suggestions: null
+              });
+            }
+          }
+        }
+      }
+    }
   }
+  return error.asResult();
 }
 
 // src/Entrypoint/Pipeline.ts
-function run(func, config, fnType, mode, useMemoCacheIdentifier, logger, filename, code) {
+function run(func, config, fnType, mode, programContext, logger, filename, code) {
   var _a, _b;
   const contextIdentifiers = findContextIdentifiers(func);
   const env = new Environment(
@@ -141993,7 +142313,7 @@ function run(func, config, fnType, mode, useMemoCacheIdentifier, logger, filenam
     logger,
     filename,
     code,
-    useMemoCacheIdentifier
+    programContext
   );
   (_b = (_a = env.logger) == null ? void 0 : _a.debugLogIRs) == null ? void 0 : _b.call(_a, {
     kind: "debug",
@@ -142012,7 +142332,7 @@ function runWithEnvironment(func, env) {
   pruneMaybeThrows(hir);
   log2({ kind: "hir", name: "PruneMaybeThrows", value: hir });
   validateContextVariableLValues(hir);
-  validateUseMemo(hir);
+  validateUseMemo(hir).unwrap();
   if (env.isInferredMemoEnabled && !env.config.enablePreserveExistingManualUseMemo && !env.config.disableMemoizationForDebugging && !env.config.enableChangeDetectionForDebugging) {
     dropManualMemoization(hir);
     log2({ kind: "hir", name: "DropManualMemoization", value: hir });
@@ -142038,10 +142358,10 @@ function runWithEnvironment(func, env) {
   log2({ kind: "hir", name: "InferTypes", value: hir });
   if (env.isInferredMemoEnabled) {
     if (env.config.validateHooksUsage) {
-      validateHooksUsage(hir);
+      validateHooksUsage(hir).unwrap();
     }
     if (env.config.validateNoCapitalizedCalls) {
-      validateNoCapitalizedCalls(hir);
+      validateNoCapitalizedCalls(hir).unwrap();
     }
   }
   if (env.config.enableFire) {
@@ -142078,19 +142398,19 @@ function runWithEnvironment(func, env) {
       assertValidMutableRanges(hir);
     }
     if (env.config.validateRefAccessDuringRender) {
-      validateNoRefAccessInRender(hir);
+      validateNoRefAccessInRender(hir).unwrap();
     }
     if (env.config.validateNoSetStateInRender) {
-      validateNoSetStateInRender(hir);
+      validateNoSetStateInRender(hir).unwrap();
     }
     if (env.config.validateNoSetStateInPassiveEffects) {
-      validateNoSetStateInPassiveEffects(hir);
+      env.logErrors(validateNoSetStateInPassiveEffects(hir));
     }
     if (env.config.validateNoJSXInTryStatements) {
-      validateNoJSXInTryStatement(hir);
+      env.logErrors(validateNoJSXInTryStatement(hir));
     }
     if (env.config.validateNoImpureFunctionsInRender) {
-      validateNoImpureFunctionsInRender(hir);
+      validateNoImpureFunctionsInRender(hir).unwrap();
     }
   }
   inferReactivePlaces(hir);
@@ -142108,6 +142428,9 @@ function runWithEnvironment(func, env) {
     value: hir
   });
   if (env.isInferredMemoEnabled) {
+    if (env.config.validateStaticComponents) {
+      env.logErrors(validateStaticComponents(hir));
+    }
     inferReactiveScopeVariables(hir);
     log2({ kind: "hir", name: "InferReactiveScopeVariables", value: hir });
   }
@@ -142288,10 +142611,10 @@ function runWithEnvironment(func, env) {
     value: reactiveFunction
   });
   if (env.config.validateMemoizedEffectDependencies) {
-    validateMemoizedEffectDependencies(reactiveFunction);
+    validateMemoizedEffectDependencies(reactiveFunction).unwrap();
   }
   if (env.config.enablePreserveExistingMemoizationGuarantees || env.config.validatePreserveExistingMemoizationGuarantees) {
-    validatePreservedManualMemoization(reactiveFunction);
+    validatePreservedManualMemoization(reactiveFunction).unwrap();
   }
   const ast = codegenFunction(reactiveFunction, {
     uniqueIdentifiers,
@@ -142306,29 +142629,19 @@ function runWithEnvironment(func, env) {
   }
   return ast;
 }
-function compileFn(func, config, fnType, mode, useMemoCacheIdentifier, logger, filename, code) {
+function compileFn(func, config, fnType, mode, programContext, logger, filename, code) {
   return run(
     func,
     config,
     fnType,
     mode,
-    useMemoCacheIdentifier,
+    programContext,
     logger,
     filename,
     code
   );
 }
 
-// src/Utils/ComponentDeclaration.ts
-function isComponentDeclaration(node) {
-  return Object.prototype.hasOwnProperty.call(node, "__componentDeclaration");
-}
-
-// src/Utils/HookDeclaration.ts
-function isHookDeclaration(node) {
-  return Object.prototype.hasOwnProperty.call(node, "__hookDeclaration");
-}
-
 // src/Entrypoint/Suppression.ts
 function filterSuppressionsThatAffectFunction(suppressionRanges, fn) {
   const suppressionsInScope = [];
@@ -142631,7 +142944,11 @@ function compileProgram(program, pass) {
     handleError(restrictedImportsErr, pass, null);
     return null;
   }
-  const useMemoCacheIdentifier = program.scope.generateUidIdentifier("c");
+  const programContext = new ProgramContext2(
+    program,
+    pass.opts.target,
+    environment.hookPattern
+  );
   const suppressions = findProgramSuppressions(
     pass.comments,
     (_a = pass.opts.eslintSuppressionRules) != null ? _a : DEFAULT_ESLINT_SUPPRESSIONS,
@@ -142699,7 +143016,7 @@ function compileProgram(program, pass) {
             environment,
             fnType,
             "all_features",
-            useMemoCacheIdentifier.name,
+            programContext,
             pass.opts.logger,
             pass.filename,
             pass.code
@@ -142726,12 +143043,15 @@ function compileProgram(program, pass) {
             environment,
             fnType,
             "no_inferred_memo",
-            useMemoCacheIdentifier.name,
+            programContext,
             pass.opts.logger,
             pass.filename,
             pass.code
           )
         };
+        if (!compileResult.compiledFn.hasFireRewrite && !compileResult.compiledFn.hasInferredEffect) {
+          return null;
+        }
       } catch (err) {
         if (err instanceof CompilerError) {
           retryErrors.push({ fn, error: err });
@@ -142808,82 +143128,28 @@ function compileProgram(program, pass) {
   if (moduleScopeOptOutDirectives.length > 0) {
     return null;
   }
-  let gating = null;
-  if (pass.opts.gating != null) {
-    gating = {
-      gatingFn: pass.opts.gating,
-      referencedBeforeDeclared: getFunctionReferencedBeforeDeclarationAtTopLevel(program, compiledFns)
-    };
-  }
-  const hasLoweredContextAccess = compiledFns.some(
-    (c2) => c2.compiledFn.hasLoweredContextAccess
-  );
-  const externalFunctions = [];
-  try {
-    if (gating != null) {
-      externalFunctions.push(gating.gatingFn);
-    }
-    const lowerContextAccess2 = environment.lowerContextAccess;
-    if (lowerContextAccess2 && hasLoweredContextAccess) {
-      externalFunctions.push(lowerContextAccess2);
-    }
-    const enableEmitInstrumentForget = environment.enableEmitInstrumentForget;
-    if (enableEmitInstrumentForget != null) {
-      externalFunctions.push(enableEmitInstrumentForget.fn);
-      if (enableEmitInstrumentForget.gating != null) {
-        externalFunctions.push(enableEmitInstrumentForget.gating);
-      }
-    }
-    if (environment.enableEmitFreeze != null) {
-      externalFunctions.push(environment.enableEmitFreeze);
-    }
-    if (environment.enableEmitHookGuards != null) {
-      externalFunctions.push(environment.enableEmitHookGuards);
-    }
-    if (environment.enableChangeDetectionForDebugging != null) {
-      externalFunctions.push(environment.enableChangeDetectionForDebugging);
-    }
-    const hasFireRewrite = compiledFns.some((c2) => c2.compiledFn.hasFireRewrite);
-    if (environment.enableFire && hasFireRewrite) {
-      externalFunctions.push({
-        source: getReactCompilerRuntimeModule(pass.opts),
-        importSpecifierName: "useFire"
-      });
-    }
-  } catch (err) {
-    handleError(err, pass, null);
-    return null;
-  }
+  const referencedBeforeDeclared = pass.opts.gating != null ? getFunctionReferencedBeforeDeclarationAtTopLevel(program, compiledFns) : null;
   for (const result of compiledFns) {
     const { kind, originalFn, compiledFn } = result;
     const transformedFn = createNewFunctionNode(originalFn, compiledFn);
-    if (gating != null && kind === "original") {
+    if (referencedBeforeDeclared != null && kind === "original") {
+      CompilerError.invariant(pass.opts.gating != null, {
+        reason: "Expected 'gating' import to be present",
+        loc: null
+      });
       insertGatedFunctionDeclaration(
         originalFn,
         transformedFn,
-        gating.gatingFn,
-        gating.referencedBeforeDeclared.has(result)
+        programContext,
+        pass.opts.gating,
+        referencedBeforeDeclared.has(result)
       );
     } else {
       originalFn.replaceWith(transformedFn);
     }
   }
   if (compiledFns.length > 0) {
-    let needsMemoCacheFunctionImport = false;
-    for (const fn of compiledFns) {
-      if (fn.compiledFn.memoSlotsUsed > 0) {
-        needsMemoCacheFunctionImport = true;
-        break;
-      }
-    }
-    if (needsMemoCacheFunctionImport) {
-      updateMemoCacheFunctionImport(
-        program,
-        getReactCompilerRuntimeModule(pass.opts),
-        useMemoCacheIdentifier.name
-      );
-    }
-    addImportsToProgram(program, externalFunctions);
+    addImportsToProgram(program, programContext);
   }
   return { retryErrors };
 }
@@ -142908,7 +143174,7 @@ function shouldSkipCompilation(program, pass) {
   }
   if (hasMemoCacheFunctionImport(
     program,
-    getReactCompilerRuntimeModule(pass.opts)
+    getReactCompilerRuntimeModule(pass.opts.target)
   )) {
     return true;
   }
@@ -143102,26 +143368,32 @@ function callsHooksOrCreatesJsx(node, hookPattern) {
   });
   return invokesHooks || createsJsx;
 }
+function isNonNode(node) {
+  if (!node) {
+    return true;
+  }
+  switch (node.type) {
+    case "ObjectExpression":
+    case "ArrowFunctionExpression":
+    case "FunctionExpression":
+    case "BigIntLiteral":
+    case "ClassExpression":
+    case "NewExpression":
+      return true;
+  }
+  return false;
+}
 function returnsNonNode(node) {
-  let hasReturn = false;
   let returnsNonNode2 = false;
+  if (
+    // node.traverse#ArrowFunctionExpression isn't called for the root node
+    node.type === "ArrowFunctionExpression" && node.node.body.type !== "BlockStatement"
+  ) {
+    returnsNonNode2 = isNonNode(node.node.body);
+  }
   node.traverse({
     ReturnStatement(ret) {
-      hasReturn = true;
-      const argument = ret.node.argument;
-      if (argument == null) {
-        returnsNonNode2 = true;
-      } else {
-        switch (argument.type) {
-          case "ObjectExpression":
-          case "ArrowFunctionExpression":
-          case "FunctionExpression":
-          case "BigIntLiteral":
-          case "ClassExpression":
-          case "NewExpression":
-            returnsNonNode2 = true;
-        }
-      }
+      returnsNonNode2 = isNonNode(ret.node.argument);
     },
     // Skip traversing all nested functions and their return statements
     ArrowFunctionExpression: skipNestedFunctions(node),
@@ -143129,7 +143401,7 @@ function returnsNonNode(node) {
     FunctionDeclaration: skipNestedFunctions(node),
     ObjectMethod: (node2) => node2.skip()
   });
-  return !hasReturn || returnsNonNode2;
+  return returnsNonNode2;
 }
 function getFunctionName2(path) {
   if (path.isFunctionDeclaration()) {
@@ -143196,14 +143468,14 @@ function getFunctionReferencedBeforeDeclarationAtTopLevel(program, fns) {
   });
   return referencedBeforeDeclaration;
 }
-function getReactCompilerRuntimeModule(opts) {
-  if (opts.target === "19") {
+function getReactCompilerRuntimeModule(target) {
+  if (target === "19") {
     return "react/compiler-runtime";
-  } else if (opts.target === "17" || opts.target === "18") {
+  } else if (target === "17" || target === "18") {
     return "react-compiler-runtime";
   } else {
     CompilerError.invariant(
-      opts.target != null && opts.target.kind === "donotuse_meta_internal" && typeof opts.target.runtimeModule === "string",
+      target != null && target.kind === "donotuse_meta_internal" && typeof target.runtimeModule === "string",
       {
         reason: "Expected target to already be validated",
         description: null,
@@ -143211,8 +143483,313 @@ function getReactCompilerRuntimeModule(opts) {
         suggestions: null
       }
     );
-    return opts.target.runtimeModule;
+    return target.runtimeModule;
+  }
+}
+
+// src/Entrypoint/Imports.ts
+function validateRestrictedImports(path, { validateBlocklistedImports }) {
+  if (validateBlocklistedImports == null || validateBlocklistedImports.length === 0) {
+    return null;
   }
+  const error = new CompilerError();
+  const restrictedImports = new Set(validateBlocklistedImports);
+  path.traverse({
+    ImportDeclaration(importDeclPath) {
+      var _a;
+      if (restrictedImports.has(importDeclPath.node.source.value)) {
+        error.push({
+          severity: "Todo" /* Todo */,
+          reason: "Bailing out due to blocklisted import",
+          description: `Import from module ${importDeclPath.node.source.value}`,
+          loc: (_a = importDeclPath.node.loc) != null ? _a : null
+        });
+      }
+    }
+  });
+  if (error.hasErrors()) {
+    return error;
+  } else {
+    return null;
+  }
+}
+var ProgramContext2 = class {
+  constructor(program, reactRuntimeModule, hookPattern) {
+    // known generated or referenced identifiers in the program
+    this.knownReferencedNames = /* @__PURE__ */ new Set();
+    // generated imports
+    this.imports = /* @__PURE__ */ new Map();
+    this.hookPattern = hookPattern;
+    this.scope = program.scope;
+    this.reactRuntimeModule = getReactCompilerRuntimeModule(reactRuntimeModule);
+  }
+  isHookName(name) {
+    if (this.hookPattern == null) {
+      return isHookName(name);
+    } else {
+      const match = new RegExp(this.hookPattern).exec(name);
+      return match != null && typeof match[1] === "string" && isHookName(match[1]);
+    }
+  }
+  hasReference(name) {
+    return this.knownReferencedNames.has(name) || this.scope.hasBinding(name) || this.scope.hasGlobal(name) || this.scope.hasReference(name);
+  }
+  newUid(name) {
+    let uid;
+    if (this.isHookName(name)) {
+      uid = name;
+      let i = 0;
+      while (this.hasReference(uid)) {
+        this.knownReferencedNames.add(uid);
+        uid = `${name}_${i++}`;
+      }
+    } else if (!this.hasReference(name)) {
+      uid = name;
+    } else {
+      uid = this.scope.generateUid(name);
+    }
+    this.knownReferencedNames.add(uid);
+    return uid;
+  }
+  addMemoCacheImport() {
+    return this.addImportSpecifier(
+      {
+        source: this.reactRuntimeModule,
+        importSpecifierName: "c"
+      },
+      "_c"
+    );
+  }
+  /**
+   *
+   * @param externalFunction
+   * @param nameHint if defined, will be used as the name of the import specifier
+   * @returns
+   */
+  addImportSpecifier({ source: module2, importSpecifierName: specifier }, nameHint) {
+    var _a;
+    const maybeBinding = (_a = this.imports.get(module2)) == null ? void 0 : _a.get(specifier);
+    if (maybeBinding != null) {
+      return __spreadValues({}, maybeBinding);
+    }
+    const binding = {
+      kind: "ImportSpecifier",
+      name: this.newUid(nameHint != null ? nameHint : specifier),
+      module: module2,
+      imported: specifier
+    };
+    getOrInsertWith(this.imports, module2, () => /* @__PURE__ */ new Map()).set(specifier, __spreadValues({}, binding));
+    return binding;
+  }
+  addNewReference(name) {
+    this.knownReferencedNames.add(name);
+  }
+  assertGlobalBinding(name, localScope) {
+    var _a, _b;
+    const scope = localScope != null ? localScope : this.scope;
+    if (!scope.hasReference(name) && !scope.hasBinding(name)) {
+      return Ok(void 0);
+    }
+    const error = new CompilerError();
+    error.push({
+      severity: "Todo" /* Todo */,
+      reason: "Encountered conflicting global in generated program",
+      description: `Conflict from local binding ${name}`,
+      loc: (_b = (_a = scope.getBinding(name)) == null ? void 0 : _a.path.node.loc) != null ? _b : null,
+      suggestions: null
+    });
+    return Err(error);
+  }
+};
+function getExistingImports(program) {
+  const existingImports = /* @__PURE__ */ new Map();
+  program.traverse({
+    ImportDeclaration(path) {
+      if (isNonNamespacedImport(path)) {
+        existingImports.set(path.node.source.value, path);
+      }
+    }
+  });
+  return existingImports;
+}
+function addImportsToProgram(path, programContext) {
+  const existingImports = getExistingImports(path);
+  const stmts = [];
+  const sortedModules = [...programContext.imports.entries()].sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  for (const [moduleName, importsMap] of sortedModules) {
+    for (const [specifierName, loweredImport] of importsMap) {
+      CompilerError.invariant(
+        path.scope.getBinding(loweredImport.name) == null,
+        {
+          reason: "Encountered conflicting import specifiers in generated program",
+          description: `Conflict from import ${loweredImport.module}:(${loweredImport.imported} as ${loweredImport.name}).`,
+          loc: GeneratedSource,
+          suggestions: null
+        }
+      );
+      CompilerError.invariant(
+        loweredImport.module === moduleName && loweredImport.imported === specifierName,
+        {
+          reason: "Found inconsistent import specifier. This is an internal bug.",
+          description: `Expected import ${moduleName}:${specifierName} but found ${loweredImport.module}:${loweredImport.imported}`,
+          loc: GeneratedSource
+        }
+      );
+    }
+    const sortedImport = [
+      ...importsMap.values()
+    ].sort(({ imported: a }, { imported: b }) => a.localeCompare(b));
+    const importSpecifiers = sortedImport.map((specifier) => {
+      return t4.importSpecifier(
+        t4.identifier(specifier.name),
+        t4.identifier(specifier.imported)
+      );
+    });
+    const maybeExistingImports = existingImports.get(moduleName);
+    if (maybeExistingImports != null) {
+      maybeExistingImports.pushContainer("specifiers", importSpecifiers);
+    } else {
+      stmts.push(
+        t4.importDeclaration(importSpecifiers, t4.stringLiteral(moduleName))
+      );
+    }
+  }
+  path.unshiftContainer("body", stmts);
+}
+function isNonNamespacedImport(importDeclPath) {
+  return importDeclPath.get("specifiers").every((specifier) => specifier.isImportSpecifier()) && importDeclPath.node.importKind !== "type" && importDeclPath.node.importKind !== "typeof";
+}
+
+// src/Entrypoint/Options.ts
+var PanicThresholdOptionsSchema = z.enum([
+  /*
+   * Any errors will panic the compiler by throwing an exception, which will
+   * bubble up to the nearest exception handler above the Forget transform.
+   * If Forget is invoked through `BabelPluginReactCompiler`, this will at the least
+   * skip Forget compilation for the rest of current file.
+   */
+  "all_errors",
+  /*
+   * Panic by throwing an exception only on critical or unrecognized errors.
+   * For all other errors, skip the erroring function without inserting
+   * a Forget-compiled version (i.e. same behavior as noEmit).
+   */
+  "critical_errors",
+  // Never panic by throwing an exception.
+  "none"
+]);
+var CompilerReactTargetSchema = z.union([
+  z.literal("17"),
+  z.literal("18"),
+  z.literal("19"),
+  /**
+   * Used exclusively for Meta apps which are guaranteed to have compatible
+   * react runtime and compiler versions. Note that only the FB-internal bundles
+   * re-export useMemoCache (see
+   * https://github.com/facebook/react/blob/5b0ef217ef32333a8e56f39be04327c89efa346f/packages/react/index.fb.js#L68-L70),
+   * so this option is invalid / creates runtime errors for open-source users.
+   */
+  z.object({
+    kind: z.literal("donotuse_meta_internal"),
+    runtimeModule: z.string().default("react")
+  })
+]);
+var CompilationModeSchema = z.enum([
+  /*
+   * Compiles functions annotated with "use forget" or component/hook-like functions.
+   * This latter includes:
+   * * Components declared with component syntax.
+   * * Functions which can be inferred to be a component or hook:
+   *   - Be named like a hook or component. This logic matches the ESLint rule.
+   *   - *and* create JSX and/or call a hook. This is an additional check to help prevent
+   *     false positives, since compilation has a greater impact than linting.
+   * This is the default mode
+   */
+  "infer",
+  // Compile only components using Flow component syntax and hooks using hook syntax.
+  "syntax",
+  // Compile only functions which are explicitly annotated with "use forget"
+  "annotation",
+  // Compile all top-level functions
+  "all"
+]);
+var defaultOptions = {
+  compilationMode: "infer",
+  panicThreshold: "none",
+  environment: parseEnvironmentConfig({}).unwrap(),
+  logger: null,
+  gating: null,
+  noEmit: false,
+  eslintSuppressionRules: null,
+  flowSuppressions: true,
+  ignoreUseNoForget: false,
+  sources: (filename) => {
+    return filename.indexOf("node_modules") === -1;
+  },
+  enableReanimatedCheck: true,
+  target: "19"
+};
+function parsePluginOptions(obj) {
+  if (obj == null || typeof obj !== "object") {
+    return defaultOptions;
+  }
+  const parsedOptions = /* @__PURE__ */ Object.create(null);
+  for (let [key2, value] of Object.entries(obj)) {
+    if (typeof value === "string") {
+      value = value.toLowerCase();
+    }
+    if (isCompilerFlag(key2)) {
+      switch (key2) {
+        case "environment": {
+          const environmentResult = parseEnvironmentConfig(value);
+          if (environmentResult.isErr()) {
+            CompilerError.throwInvalidConfig({
+              reason: "Error in validating environment config. This is an advanced setting and not meant to be used directly",
+              description: environmentResult.unwrapErr().toString(),
+              suggestions: null,
+              loc: null
+            });
+          }
+          parsedOptions[key2] = environmentResult.unwrap();
+          break;
+        }
+        case "target": {
+          parsedOptions[key2] = parseTargetConfig(value);
+          break;
+        }
+        case "gating": {
+          if (value == null) {
+            parsedOptions[key2] = null;
+          } else {
+            parsedOptions[key2] = tryParseExternalFunction(value);
+          }
+          break;
+        }
+        default: {
+          parsedOptions[key2] = value;
+        }
+      }
+    }
+  }
+  return __spreadValues(__spreadValues({}, defaultOptions), parsedOptions);
+}
+function parseTargetConfig(value) {
+  const parsed = CompilerReactTargetSchema.safeParse(value);
+  if (parsed.success) {
+    return parsed.data;
+  } else {
+    CompilerError.throwInvalidConfig({
+      reason: "Not a valid target",
+      description: `${fromZodError(parsed.error)}`,
+      suggestions: null,
+      loc: null
+    });
+  }
+}
+function isCompilerFlag(s) {
+  return hasOwnProperty2(defaultOptions, s);
 }
 
 // src/Entrypoint/Reanimated.ts
@@ -143538,6 +144115,7 @@ var index_default = BabelPluginReactCompiler;
   ErrorSeverity,
   OPT_IN_DIRECTIVES,
   OPT_OUT_DIRECTIVES,
+  ProgramContext,
   ValueKind,
   compile,
   compileProgram,