babel-plugin-react-compiler 19.0.0-beta-aeaed83-20250323 → 19.0.0-beta-e993439-20250405

package/dist/index.js

@@ -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,
@@ -110433,8 +110434,10 @@ __export(index_exports, {
   findDirectiveEnablingMemoization: () => findDirectiveEnablingMemoization,
   parseConfigPragmaForTests: () => parseConfigPragmaForTests,
   parsePluginOptions: () => parsePluginOptions,
+  printFunctionWithOutlined: () => printFunctionWithOutlined,
   printHIR: () => printHIR,
   printReactiveFunction: () => printReactiveFunction,
+  printReactiveFunctionWithOutlined: () => printReactiveFunctionWithOutlined,
   runBabelPluginReactCompiler: () => runBabelPluginReactCompiler,
   validateEnvironmentConfig: () => validateEnvironmentConfig
 });
@@ -110829,7 +110832,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;
@@ -110842,14 +110845,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);
@@ -110892,24 +110895,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)
     );
@@ -110955,7 +110964,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"));
@@ -114952,6 +114961,14 @@ function getHookKindForType(env, type) {
 var import_generator = __toESM(require_lib26());
 
 // src/ReactiveScopes/PrintReactiveFunction.ts
+function printReactiveFunctionWithOutlined(fn) {
+  const writer = new Writer();
+  writeReactiveFunction(fn, writer);
+  for (const outlined of fn.env.getOutlinedFunctions()) {
+    writer.writeLine("\nfunction " + printFunction(outlined.fn));
+  }
+  return writer.complete();
+}
 function printReactiveFunction(fn) {
   const writer = new Writer();
   writeReactiveFunction(fn, writer);
@@ -115319,6 +115336,15 @@ _line = new WeakMap();
 _depth = new WeakMap();
 
 // src/HIR/PrintHIR.ts
+function printFunctionWithOutlined(fn) {
+  const output = [printFunction(fn)];
+  for (const outlined of fn.env.getOutlinedFunctions()) {
+    output.push(`
+function ${outlined.fn.id}:
+${printHIR(outlined.fn.body)}`);
+  }
+  return output.join("\n");
+}
 function printFunction(fn) {
   const output = [];
   let definition = "";
@@ -117570,6 +117596,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) {
@@ -120990,6 +121017,19 @@ function lowerExpression(builder, exprPath) {
         kind: "TypeCastExpression",
         value: lowerExpressionToTemporary(builder, expr.get("expression")),
         typeAnnotation: typeAnnotation2.node,
+        typeAnnotationKind: "cast",
+        type: lowerType(typeAnnotation2.node),
+        loc: exprLoc
+      };
+    }
+    case "TSSatisfiesExpression": {
+      let expr = exprPath;
+      const typeAnnotation2 = expr.get("typeAnnotation");
+      return {
+        kind: "TypeCastExpression",
+        value: lowerExpressionToTemporary(builder, expr.get("expression")),
+        typeAnnotation: typeAnnotation2.node,
+        typeAnnotationKind: "satisfies",
         type: lowerType(typeAnnotation2.node),
         loc: exprLoc
       };
@@ -121001,6 +121041,7 @@ function lowerExpression(builder, exprPath) {
         kind: "TypeCastExpression",
         value: lowerExpressionToTemporary(builder, expr.get("expression")),
         typeAnnotation: typeAnnotation2.node,
+        typeAnnotationKind: "as",
         type: lowerType(typeAnnotation2.node),
         loc: exprLoc
       };
@@ -123818,6 +123859,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() })
@@ -124407,6 +124450,7 @@ function parseConfigPragmaForTests(pragma, defaults) {
   const environment = parseConfigPragmaEnvironmentForTest(pragma);
   let compilationMode = defaults.compilationMode;
   let panicThreshold = "all_errors";
+  let noEmit = defaultOptions.noEmit;
   for (const token2 of pragma.split(" ")) {
     if (!token2.startsWith("@")) {
       continue;
@@ -124432,17 +124476,22 @@ function parseConfigPragmaForTests(pragma, defaults) {
         panicThreshold = "none";
         break;
       }
+      case "@noEmit": {
+        noEmit = true;
+        break;
+      }
     }
   }
   return parsePluginOptions({
     environment,
     compilationMode,
-    panicThreshold
+    panicThreshold,
+    noEmit
   });
 }
 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);
@@ -124452,6 +124501,7 @@ var Environment = class {
     __privateAdd(this, _nextScope, 0);
     __privateAdd(this, _scope);
     __privateAdd(this, _outlinedFunctions, []);
+    this.inferredEffectLocations = /* @__PURE__ */ new Set();
     __privateAdd(this, _contextIdentifiers);
     __privateAdd(this, _hoistedIdentifiers);
     __privateSet(this, _scope, scope);
@@ -124461,11 +124511,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`,
@@ -124513,6 +124563,9 @@ 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;
@@ -125401,260 +125454,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
@@ -129463,7 +129270,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
@@ -129629,9 +129436,10 @@ function codegenFunction(fn, {
   const compiled = compileResult.unwrap();
   const hookGuard = fn.env.config.enableEmitHookGuards;
   if (hookGuard != null && fn.env.isInferredMemoEnabled) {
-    compiled.body = t4.blockStatement([
+    compiled.body = t3.blockStatement([
       createHookGuard(
         hookGuard,
+        fn.env.programContext,
         compiled.body.body,
         0 /* PushHookGuard */,
         1 /* PopHookGuard */
@@ -129641,12 +129449,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)
           ])
         )
       ])
@@ -129654,60 +129463,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)
               )
             )
           ])
@@ -129718,30 +129527,43 @@ function codegenFunction(fn, {
   }
   const emitInstrumentForget = fn.env.config.enableEmitInstrumentForget;
   if (emitInstrumentForget != null && fn.id != null && fn.env.isInferredMemoEnabled) {
-    let gating;
-    if (emitInstrumentForget.gating != null && emitInstrumentForget.globalGating != null) {
-      gating = t4.logicalExpression(
-        "&&",
-        t4.identifier(emitInstrumentForget.globalGating),
-        t4.identifier(emitInstrumentForget.gating.importSpecifierName)
+    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);
@@ -129780,7 +129602,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];
@@ -129796,7 +129618,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,
@@ -129807,8 +129629,9 @@ 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,
+    inferredEffectLocations: fn.env.inferredEffectLocations
   });
 }
 var CountMemoBlockVisitor = class extends ReactiveFunctionVisitor {
@@ -129835,7 +129658,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;
@@ -129929,8 +129752,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
             )
           );
@@ -129949,16 +129772,20 @@ function codegenBlockNoReset(cx, block) {
       }
     }
   }
-  return t4.blockStatement(statements);
+  return t3.blockStatement(statements);
 }
 function wrapCacheDep(cx, value) {
   if (cx.env.config.enableEmitFreeze != null && cx.env.isInferredMemoEnabled) {
-    return t4.conditionalExpression(
-      t4.identifier("__DEV__"),
-      t4.callExpression(
-        t4.identifier(cx.env.config.enableEmitFreeze.importSpecifierName),
-        [value, t4.stringLiteral(cx.fnName)]
-      ),
+    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 {
@@ -129975,20 +129802,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);
@@ -129996,12 +129823,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)
@@ -130029,7 +129856,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) });
@@ -130049,7 +129876,7 @@ function codegenReactiveScope(cx, statements, scope, block) {
       if (acc == null) {
         return ident;
       }
-      return t4.logicalExpression("||", acc, ident);
+      return t3.logicalExpression("||", acc, ident);
     },
     null
   );
@@ -130060,16 +129887,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)]
       )
     );
   }
@@ -130082,81 +129909,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
         ])
@@ -130165,12 +129993,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
@@ -130178,13 +130006,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
             )
           )
@@ -130192,15 +130020,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(
@@ -130209,20 +130037,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")}:`,
@@ -130230,7 +130058,7 @@ function codegenReactiveScope(cx, statements, scope, block) {
       );
     }
     if (computationBlock.body.length > 0) {
-      t4.addComment(
+      t3.addComment(
         computationBlock.body[0],
         "leading",
         ` Inputs changed, recompute`,
@@ -130238,7 +130066,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`,
@@ -130260,16 +130088,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))])
       )
     );
   }
@@ -130280,20 +130108,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,
@@ -130367,13 +130195,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)
@@ -130449,13 +130277,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)
@@ -130471,35 +130299,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);
@@ -130510,9 +130338,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: {
@@ -130575,7 +130403,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 */: {
@@ -130615,7 +130443,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 */: {
@@ -130625,7 +130453,7 @@ function codegenInstructionNullable(cx, instr) {
           loc: instr.value.loc,
           suggestions: null
         });
-        const expr = t4.assignmentExpression(
+        const expr = t3.assignmentExpression(
           "=",
           codegenLValue(cx, lvalue),
           value
@@ -130646,7 +130474,7 @@ function codegenInstructionNullable(cx, instr) {
         }
       }
       case "Catch" /* Catch */: {
-        return t4.emptyStatement();
+        return t3.emptyStatement();
       }
       case "HoistedLet" /* HoistedLet */:
       case "HoistedConst" /* HoistedConst */:
@@ -130665,7 +130493,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",
@@ -130721,7 +130549,7 @@ function codegenForInit(cx, init) {
       description: null,
       suggestions: null
     });
-    return t4.variableDeclaration(kind, declarators);
+    return t3.variableDeclaration(kind, declarators);
   } else {
     return codegenInstructionValueToExpression(cx, init);
   }
@@ -130760,17 +130588,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);
       }
     }
   }
@@ -130785,60 +130613,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(env, callee, args, loc, isHook2) {
-  const callExpr = t4.callExpression(callee, args);
+  const callExpr = t3.callExpression(callee, args);
   if (loc != null && loc != GeneratedSource) {
     callExpr.loc = loc;
   }
   const hookGuard = env.config.enableEmitHookGuards;
   if (hookGuard != null && isHook2 && env.isInferredMemoEnabled) {
-    const iife = t4.functionExpression(
+    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;
   }
@@ -130847,21 +130675,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
@@ -130869,7 +130697,7 @@ function codegenInstruction(cx, instr, value) {
       );
     } else {
       return createVariableDeclaration(instr.loc, "const", [
-        t4.variableDeclarator(
+        t3.variableDeclarator(
           convertIdentifier(instr.lvalue.identifier),
           expressionValue
         )
@@ -130896,12 +130724,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": {
@@ -130916,7 +130744,7 @@ function codegenInstructionValue(cx, instrValue) {
       break;
     }
     case "UnaryExpression": {
-      value = t4.unaryExpression(
+      value = t3.unaryExpression(
         instrValue.operator,
         // todo
         codegenPlaceToExpression(cx, instrValue.value)
@@ -130931,9 +130759,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
           );
         }
@@ -130959,13 +130787,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
@@ -130975,13 +130803,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,
@@ -131004,7 +130832,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,
@@ -131013,7 +130841,7 @@ function codegenInstructionValue(cx, instrValue) {
         }
       );
       CompilerError.invariant(
-        t4.isNodesEquivalent(
+        t3.isNodesEquivalent(
           memberExpr.object,
           codegenPlaceToExpression(cx, instrValue.receiver)
         ),
@@ -131037,7 +130865,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": {
@@ -131049,7 +130877,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",
@@ -131079,7 +130907,7 @@ function codegenInstructionValue(cx, instrValue) {
                 ),
                 reactiveFunction
               ).unwrap();
-              const babelNode = t4.objectMethod(
+              const babelNode = t3.objectMethod(
                 "method",
                 key2,
                 fn.params,
@@ -131099,11 +130927,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": {
@@ -131115,7 +130943,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);
@@ -131168,16 +130996,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;
@@ -131188,19 +131016,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)
@@ -131208,14 +131036,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
@@ -131227,13 +131055,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
@@ -131270,10 +131098,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,
@@ -131286,20 +131114,27 @@ 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(
-          codegenPlaceToExpression(cx, instrValue.value),
-          instrValue.typeAnnotation
-        );
+      if (t3.isTSType(instrValue.typeAnnotation)) {
+        if (instrValue.typeAnnotationKind === "satisfies") {
+          value = t3.tsSatisfiesExpression(
+            codegenPlaceToExpression(cx, instrValue.value),
+            instrValue.typeAnnotation
+          );
+        } else {
+          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;
@@ -131335,7 +131170,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}'`,
@@ -131343,7 +131178,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`,
@@ -131351,7 +131186,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}`);
           }
         }
       });
@@ -131368,28 +131203,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": {
@@ -131405,7 +131240,7 @@ function codegenInstructionValue(cx, instrValue) {
       break;
     }
     case "PostfixUpdate": {
-      value = t4.updateExpression(
+      value = t3.updateExpression(
         instrValue.operation,
         codegenPlaceToExpression(cx, instrValue.lvalue),
         false
@@ -131413,7 +131248,7 @@ function codegenInstructionValue(cx, instrValue) {
       break;
     }
     case "PrefixUpdate": {
-      value = t4.updateExpression(
+      value = t3.updateExpression(
         instrValue.operation,
         codegenPlaceToExpression(cx, instrValue.lvalue),
         true
@@ -131430,7 +131265,7 @@ function codegenInstructionValue(cx, instrValue) {
           suggestions: null
         }
       );
-      value = t4.assignmentExpression(
+      value = t3.assignmentExpression(
         "=",
         codegenLValue(cx, instrValue.lvalue.place),
         codegenPlaceToExpression(cx, instrValue.value)
@@ -131438,9 +131273,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;
@@ -131502,7 +131337,7 @@ function codegenJsxAttribute(cx, attribute) {
       return createJsxAttribute(attribute.place.loc, propName, value);
     }
     case "JsxSpreadAttribute": {
-      return t4.jsxSpreadAttribute(
+      return t3.jsxSpreadAttribute(
         codegenPlaceToExpression(cx, attribute.argument)
       );
     }
@@ -131557,9 +131392,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",
@@ -131568,20 +131403,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,
@@ -131590,14 +131425,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);
@@ -131607,7 +131442,7 @@ function codegenArrayPattern(cx, pattern) {
     }
     return result;
   } else {
-    return t4.arrayPattern(
+    return t3.arrayPattern(
       pattern.items.map((item) => {
         if (item.kind === "Hole") {
           return null;
@@ -131623,25 +131458,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);
@@ -131656,15 +131491,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");
   }
@@ -131673,7 +131508,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) {
@@ -131707,7 +131542,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;
@@ -132657,6 +132492,10 @@ function pruneHoistedContexts(fn) {
   const hoistedIdentifiers = /* @__PURE__ */ new Map();
   visitReactiveFunction(fn, new Visitor3(), hoistedIdentifiers);
 }
+var REWRITTEN_HOISTED_CONST = Symbol(
+  "REWRITTEN_HOISTED_CONST"
+);
+var REWRITTEN_HOISTED_LET = Symbol("REWRITTEN_HOISTED_LET");
 var Visitor3 = class extends ReactiveFunctionTransform {
   transformInstruction(instruction, state) {
     this.visitInstruction(instruction, state);
@@ -132681,25 +132520,64 @@ var Visitor3 = class extends ReactiveFunctionTransform {
       );
       return { kind: "remove" };
     }
-    if (instruction.value.kind === "StoreContext" && state.has(instruction.value.lvalue.place.identifier.declarationId)) {
+    if (instruction.value.kind === "StoreContext") {
       const kind = state.get(
         instruction.value.lvalue.place.identifier.declarationId
       );
-      return {
-        kind: "replace",
-        value: {
-          kind: "instruction",
-          instruction: __spreadProps(__spreadValues({}, instruction), {
-            value: __spreadProps(__spreadValues({}, instruction.value), {
-              lvalue: __spreadProps(__spreadValues({}, instruction.value.lvalue), {
-                kind
-              }),
-              type: null,
-              kind: "StoreLocal"
-            })
-          })
+      if (kind != null) {
+        CompilerError.invariant(kind !== REWRITTEN_HOISTED_CONST, {
+          reason: "Expected exactly one store to a hoisted const variable",
+          loc: instruction.loc
+        });
+        if (kind === "Const" /* Const */ || kind === "Function" /* Function */) {
+          state.set(
+            instruction.value.lvalue.place.identifier.declarationId,
+            REWRITTEN_HOISTED_CONST
+          );
+          return {
+            kind: "replace",
+            value: {
+              kind: "instruction",
+              instruction: __spreadProps(__spreadValues({}, instruction), {
+                value: __spreadProps(__spreadValues({}, instruction.value), {
+                  lvalue: __spreadProps(__spreadValues({}, instruction.value.lvalue), {
+                    kind
+                  }),
+                  type: null,
+                  kind: "StoreLocal"
+                })
+              })
+            }
+          };
+        } else if (kind !== REWRITTEN_HOISTED_LET) {
+          state.set(
+            instruction.value.lvalue.place.identifier.declarationId,
+            REWRITTEN_HOISTED_LET
+          );
+          return {
+            kind: "replace-many",
+            value: [
+              {
+                kind: "instruction",
+                instruction: {
+                  id: instruction.id,
+                  lvalue: null,
+                  value: {
+                    kind: "DeclareContext",
+                    lvalue: {
+                      kind: "Let" /* Let */,
+                      place: __spreadValues({}, instruction.value.lvalue.place)
+                    },
+                    loc: instruction.value.loc
+                  },
+                  loc: instruction.loc
+                }
+              },
+              { kind: "instruction", instruction }
+            ]
+          };
         }
-      };
+      }
     }
     return { kind: "keep" };
   }
@@ -135353,7 +135231,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]);
 }
@@ -135403,15 +135281,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;
@@ -135439,6 +135319,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);
@@ -135461,6 +135342,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--) {
@@ -136624,6 +136506,7 @@ function inferEffectDependencies(fn) {
             });
             value.args.push(__spreadProps(__spreadValues({}, depsPlace), { effect: "freeze" /* Freeze */ }));
             rewriteInstrs.set(instr.id, newInstructions);
+            fn.env.inferredEffectLocations.add(callee.loc);
           } else if (loadGlobals.has(value.args[0].identifier.id)) {
             newInstructions.push({
               id: makeInstructionId(0),
@@ -136633,6 +136516,7 @@ function inferEffectDependencies(fn) {
             });
             value.args.push(__spreadProps(__spreadValues({}, depsPlace), { effect: "freeze" /* Freeze */ }));
             rewriteInstrs.set(instr.id, newInstructions);
+            fn.env.inferredEffectLocations.add(callee.loc);
           }
         }
       }
@@ -136654,6 +136538,7 @@ function inferEffectDependencies(fn) {
   if (hasRewrite) {
     markInstructionIds(fn.body);
     fixScopeAndIdentifierRanges(fn.body);
+    fn.env.hasInferredEffect = true;
   }
 }
 function writeDependencyToInstructions(dep, reactive, env, loc) {
@@ -139861,7 +139746,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) {
@@ -139889,6 +139774,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;
@@ -139896,9 +139782,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);
@@ -139922,17 +139811,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 {
@@ -141639,7 +141523,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);
@@ -141649,7 +141533,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;
@@ -141657,6 +141541,7 @@ function collectProps(instructions) {
       newName = `${oldName}${id++}`;
     }
     seen.add(newName);
+    env.programContext.addNewReference(newName);
     return newName;
   }
   const attributes = [];
@@ -141919,6 +141804,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();
@@ -141942,7 +141828,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
@@ -142162,18 +142055,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 {
@@ -142506,7 +142394,7 @@ function validateStaticComponents(fn) {
 }
 
 // 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(
@@ -142518,7 +142406,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",
@@ -142834,29 +142722,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 = [];
@@ -143159,7 +143037,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,
@@ -143196,6 +143078,7 @@ function compileProgram(program, pass) {
     })
   );
   const retryErrors = [];
+  const inferredEffectLocations = /* @__PURE__ */ new Set();
   const processFn = (fn, fnType) => {
     var _a2, _b2, _c, _d, _e, _f, _g, _h, _i;
     let optInDirectives = [];
@@ -143227,7 +143110,7 @@ function compileProgram(program, pass) {
             environment,
             fnType,
             "all_features",
-            useMemoCacheIdentifier.name,
+            programContext,
             pass.opts.logger,
             pass.filename,
             pass.code
@@ -143254,13 +143137,13 @@ 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.hasLoweredContextAccess) {
+        if (!compileResult.compiledFn.hasFireRewrite && !compileResult.compiledFn.hasInferredEffect) {
           return null;
         }
       } catch (err) {
@@ -143299,6 +143182,9 @@ function compileProgram(program, pass) {
     if (!pass.opts.noEmit) {
       return compileResult.compiledFn;
     }
+    for (const loc of compileResult.compiledFn.inferredEffectLocations) {
+      if (loc !== GeneratedSource) inferredEffectLocations.add(loc);
+    }
     return null;
   };
   while (queue.length !== 0) {
@@ -143339,84 +143225,30 @@ 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 };
+  return { retryErrors, inferredEffectLocations };
 }
 function shouldSkipCompilation(program, pass) {
   if (pass.opts.sources) {
@@ -143439,7 +143271,7 @@ function shouldSkipCompilation(program, pass) {
   }
   if (hasMemoCacheFunctionImport(
     program,
-    getReactCompilerRuntimeModule(pass.opts)
+    getReactCompilerRuntimeModule(pass.opts.target)
   )) {
     return true;
   }
@@ -143733,14 +143565,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,
@@ -143748,10 +143580,315 @@ 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
 function hasModule(name) {
   if (typeof require === "undefined") {
@@ -143805,7 +143942,9 @@ function assertValidEffectImportReference(numArgs, paths, context) {
     const parent = path.parentPath;
     if (parent != null && parent.isCallExpression()) {
       const args = parent.get("arguments");
-      if (args.length === numArgs) {
+      const maybeCalleeLoc = path.node.loc;
+      const hasInferredEffect = maybeCalleeLoc != null && context.inferredEffectLocations.has(maybeCalleeLoc);
+      if (args.length === numArgs && !hasInferredEffect) {
         const maybeErrorDiagnostic = matchCompilerDiagnostic(
           path,
           context.transformErrors
@@ -143839,7 +143978,7 @@ function assertValidFireImportReference(paths, context) {
     );
   }
 }
-function validateNoUntransformedReferences(path, filename, logger, env, transformErrors) {
+function validateNoUntransformedReferences(path, filename, logger, env, compileResult) {
   const moduleLoadChecks = /* @__PURE__ */ new Map();
   if (env.enableFire) {
     for (const module2 of Environment.knownReactModules) {
@@ -143860,7 +143999,7 @@ function validateNoUntransformedReferences(path, filename, logger, env, transfor
     }
   }
   if (moduleLoadChecks.size > 0) {
-    transformProgram(path, moduleLoadChecks, filename, logger, transformErrors);
+    transformProgram(path, moduleLoadChecks, filename, logger, compileResult);
   }
 }
 function validateImportSpecifier(specifier, importSpecifierChecks, state) {
@@ -143918,13 +144057,15 @@ function validateNamespacedImport(specifier, importSpecifierChecks, state) {
     checkFn(references, state);
   }
 }
-function transformProgram(path, moduleLoadChecks, filename, logger, transformErrors) {
+function transformProgram(path, moduleLoadChecks, filename, logger, compileResult) {
+  var _a, _b;
   const traversalState = {
     shouldInvalidateScopes: true,
     program: path,
     filename,
     logger,
-    transformErrors
+    transformErrors: (_a = compileResult == null ? void 0 : compileResult.retryErrors) != null ? _a : [],
+    inferredEffectLocations: (_b = compileResult == null ? void 0 : compileResult.inferredEffectLocations) != null ? _b : /* @__PURE__ */ new Set()
   };
   path.traverse({
     ImportDeclaration(path2) {
@@ -143975,7 +144116,7 @@ function BabelPluginReactCompiler(_babel) {
        */
       Program: {
         enter(prog, pass) {
-          var _a, _b, _c, _d, _e;
+          var _a, _b, _c, _d;
           const filename = (_a = pass.filename) != null ? _a : "unknown";
           if (ENABLE_REACT_COMPILER_TIMINGS === true) {
             performance.mark(`${filename}:start`, {
@@ -144005,7 +144146,7 @@ function BabelPluginReactCompiler(_babel) {
             (_d = pass.filename) != null ? _d : null,
             opts.logger,
             opts.environment,
-            (_e = result == null ? void 0 : result.retryErrors) != null ? _e : []
+            result
           );
           if (ENABLE_REACT_COMPILER_TIMINGS === true) {
             performance.mark(`${filename}:end`, {
@@ -144075,6 +144216,7 @@ var index_default = BabelPluginReactCompiler;
   ErrorSeverity,
   OPT_IN_DIRECTIVES,
   OPT_OUT_DIRECTIVES,
+  ProgramContext,
   ValueKind,
   compile,
   compileProgram,
@@ -144082,8 +144224,10 @@ var index_default = BabelPluginReactCompiler;
   findDirectiveEnablingMemoization,
   parseConfigPragmaForTests,
   parsePluginOptions,
+  printFunctionWithOutlined,
   printHIR,
   printReactiveFunction,
+  printReactiveFunctionWithOutlined,
   runBabelPluginReactCompiler,
   validateEnvironmentConfig
 });