babel-plugin-react-compiler 19.0.0-beta-63b359f-20241101 → 19.0.0-beta-a7bf2bd-20241110

package/dist/index.js

@@ -125654,6 +125654,12 @@ function makeTemporaryIdentifier(id, loc) {
     loc: loc,
   };
 }
+function forkTemporaryIdentifier(id, source) {
+  return Object.assign(Object.assign({}, source), {
+    mutableRange: {start: makeInstructionId(0), end: makeInstructionId(0)},
+    id: id,
+  });
+}
 function makeIdentifierName(name) {
   CompilerError.invariant(t__namespace.isValidIdentifier(name), {
     reason: `Expected a valid identifier name`,
@@ -136618,6 +136624,7 @@ const ReactElementSymbolSchema = z.object({
     z.literal('react.element'),
     z.literal('react.transitional.element'),
   ]),
+  globalDevVar: z.string(),
 });
 const ExternalFunctionSchema = z.object({
   source: z.string(),
@@ -136626,8 +136633,8 @@ const ExternalFunctionSchema = z.object({
 const InstrumentationSchema = z
   .object({
     fn: ExternalFunctionSchema,
-    gating: ExternalFunctionSchema.nullish(),
-    globalGating: z.string().nullish(),
+    gating: ExternalFunctionSchema.nullable(),
+    globalGating: z.string().nullable(),
   })
   .refine(
     opts => opts.gating != null || opts.globalGating != null,
@@ -136648,7 +136655,7 @@ const HookSchema = z.object({
   transitiveMixedData: z.boolean().default(false),
 });
 const EnvironmentConfigSchema = z.object({
-  customHooks: z.map(z.string(), HookSchema).optional().default(new Map()),
+  customHooks: z.map(z.string(), HookSchema).default(new Map()),
   moduleTypeProvider: z.nullable(z.function().args(z.string())).default(null),
   customMacros: z.nullable(z.array(MacroSchema)).default(null),
   enableResetCacheOnSourceFileChanges: z.boolean().default(false),
@@ -136657,9 +136664,7 @@ const EnvironmentConfigSchema = z.object({
   enablePreserveExistingManualUseMemo: z.boolean().default(false),
   enableForest: z.boolean().default(false),
   enableUseTypeAnnotations: z.boolean().default(false),
-  enablePropagateDepsInHIR: z.boolean().default(false),
-  enableOptionalDependencies: z.boolean().default(true),
-  inlineJsxTransform: ReactElementSymbolSchema.nullish(),
+  inlineJsxTransform: ReactElementSymbolSchema.nullable().default(null),
   validateHooksUsage: z.boolean().default(true),
   validateRefAccessDuringRender: z.boolean().default(true),
   validateNoSetStateInRender: z.boolean().default(true),
@@ -136670,26 +136675,60 @@ const EnvironmentConfigSchema = z.object({
   validateBlocklistedImports: z.nullable(z.array(z.string())).default(null),
   enableAssumeHooksFollowRulesOfReact: z.boolean().default(true),
   enableTransitivelyFreezeFunctionExpressions: z.boolean().default(true),
-  enableEmitFreeze: ExternalFunctionSchema.nullish(),
-  enableEmitHookGuards: ExternalFunctionSchema.nullish(),
+  enableEmitFreeze: ExternalFunctionSchema.nullable().default(null),
+  enableEmitHookGuards: ExternalFunctionSchema.nullable().default(null),
   enableInstructionReordering: z.boolean().default(false),
   enableFunctionOutlining: z.boolean().default(true),
   enableJsxOutlining: z.boolean().default(false),
-  enableEmitInstrumentForget: InstrumentationSchema.nullish(),
+  enableEmitInstrumentForget: InstrumentationSchema.nullable().default(null),
   assertValidMutableRanges: z.boolean().default(false),
   enableChangeVariableCodegen: z.boolean().default(false),
   enableMemoizationComments: z.boolean().default(false),
   throwUnknownException__testonly: z.boolean().default(false),
-  enableSharedRuntime__testonly: z.boolean().default(false),
   enableTreatFunctionDepsAsConditional: z.boolean().default(false),
   disableMemoizationForDebugging: z.boolean().default(false),
-  enableChangeDetectionForDebugging: ExternalFunctionSchema.nullish(),
+  enableChangeDetectionForDebugging:
+    ExternalFunctionSchema.nullable().default(null),
   enableCustomTypeDefinitionForReanimated: z.boolean().default(false),
   hookPattern: z.string().nullable().default(null),
-  enableTreatRefLikeIdentifiersAsRefs: z.boolean().nullable().default(false),
-  lowerContextAccess: ExternalFunctionSchema.nullish(),
+  enableTreatRefLikeIdentifiersAsRefs: z.boolean().default(false),
+  lowerContextAccess: ExternalFunctionSchema.nullable().default(null),
 });
-function parseConfigPragma(pragma) {
+const testComplexConfigDefaults = {
+  validateNoCapitalizedCalls: [],
+  enableChangeDetectionForDebugging: {
+    source: 'react-compiler-runtime',
+    importSpecifierName: '$structuralCheck',
+  },
+  enableEmitFreeze: {
+    source: 'react-compiler-runtime',
+    importSpecifierName: 'makeReadOnly',
+  },
+  enableEmitInstrumentForget: {
+    fn: {
+      source: 'react-compiler-runtime',
+      importSpecifierName: 'useRenderCounter',
+    },
+    gating: {
+      source: 'react-compiler-runtime',
+      importSpecifierName: 'shouldInstrument',
+    },
+    globalGating: '__DEV__',
+  },
+  enableEmitHookGuards: {
+    source: 'react-compiler-runtime',
+    importSpecifierName: '$dispatcherGuard',
+  },
+  inlineJsxTransform: {
+    elementSymbol: 'react.transitional.element',
+    globalDevVar: 'DEV',
+  },
+  lowerContextAccess: {
+    source: 'react-compiler-runtime',
+    importSpecifierName: 'useContext_withSelector',
+  },
+};
+function parseConfigPragmaForTests(pragma) {
   const maybeConfig = {};
   const defaultConfig = EnvironmentConfigSchema.parse({});
   for (const token of pragma.split(' ')) {
@@ -136697,19 +136736,10 @@ function parseConfigPragma(pragma) {
       continue;
     }
     const keyVal = token.slice(1);
-    let [key, val] = keyVal.split(':');
-    if (key === 'validateNoCapitalizedCalls') {
-      maybeConfig[key] = [];
-      continue;
-    }
-    if (
-      key === 'enableChangeDetectionForDebugging' &&
-      (val === undefined || val === 'true')
-    ) {
-      maybeConfig[key] = {
-        source: 'react-compiler-runtime',
-        importSpecifierName: '$structuralCheck',
-      };
+    let [key, val = undefined] = keyVal.split(':');
+    const isSet = val === undefined || val === 'true';
+    if (isSet && key in testComplexConfigDefaults) {
+      maybeConfig[key] = testComplexConfigDefaults[key];
       continue;
     }
     if (key === 'customMacros' && val) {
@@ -136723,15 +136753,6 @@ function parseConfigPragma(pragma) {
             props.push({type: 'name', name: elt});
           }
         }
-        console.log([
-          valSplit[0],
-          props
-            .map(x => {
-              var _a;
-              return (_a = x.name) !== null && _a !== void 0 ? _a : '*';
-            })
-            .join('.'),
-        ]);
         maybeConfig[key] = [[valSplit[0], props]];
       }
       continue;
@@ -136740,11 +136761,10 @@ function parseConfigPragma(pragma) {
       continue;
     }
     if (val === undefined || val === 'true') {
-      val = true;
+      maybeConfig[key] = true;
     } else {
-      val = false;
+      maybeConfig[key] = false;
     }
-    maybeConfig[key] = val;
   }
   const config = EnvironmentConfigSchema.safeParse(maybeConfig);
   if (config.success) {
@@ -139834,7 +139854,7 @@ function findContextIdentifiers(func) {
         const currentFn =
           (_a = state.currentFn.at(-1)) !== null && _a !== void 0 ? _a : null;
         if (path.isReferencedIdentifier()) {
-          handleIdentifier(currentFn, state.identifiers, path);
+          handleIdentifier$1(currentFn, state.identifiers, path);
         }
       },
     },
@@ -139850,7 +139870,7 @@ function findContextIdentifiers(func) {
   }
   return result;
 }
-function handleIdentifier(currentFn, identifiers, path) {
+function handleIdentifier$1(currentFn, identifiers, path) {
   const name = path.node.name;
   const binding = path.scope.getBinding(name);
   if (binding == null) {
@@ -141181,6 +141201,313 @@ function instructionMayThrow(instr) {
     }
   }
 }
+function inlineJsxTransform(fn, inlineJsxTransformConfig) {
+  var _a;
+  const inlinedJsxDeclarations = new Map();
+  for (const [_, currentBlock] of [...fn.body.blocks]) {
+    let fallthroughBlockInstructions = null;
+    const instructionCount = currentBlock.instructions.length;
+    for (let i = 0; i < instructionCount; i++) {
+      const instr = currentBlock.instructions[i];
+      if (currentBlock.kind === 'value') {
+        (_a = fn.env.logger) === null || _a === void 0
+          ? void 0
+          : _a.logEvent(fn.env.filename, {
+              kind: 'CompileDiagnostic',
+              fnLoc: null,
+              detail: {
+                reason: 'JSX Inlining is not supported on value blocks',
+                loc: instr.loc,
+              },
+            });
+        continue;
+      }
+      switch (instr.value.kind) {
+        case 'JsxExpression':
+        case 'JsxFragment': {
+          const currentBlockInstructions = currentBlock.instructions.slice(
+            0,
+            i
+          );
+          const thenBlockInstructions = currentBlock.instructions.slice(
+            i,
+            i + 1
+          );
+          const elseBlockInstructions = [];
+          fallthroughBlockInstructions !== null &&
+          fallthroughBlockInstructions !== void 0
+            ? fallthroughBlockInstructions
+            : (fallthroughBlockInstructions = currentBlock.instructions.slice(
+                i + 1
+              ));
+          const fallthroughBlockId = fn.env.nextBlockId;
+          const fallthroughBlock = {
+            kind: currentBlock.kind,
+            id: fallthroughBlockId,
+            instructions: fallthroughBlockInstructions,
+            terminal: currentBlock.terminal,
+            preds: new Set(),
+            phis: new Set(),
+          };
+          const varPlace = createTemporaryPlace(fn.env, instr.value.loc);
+          promoteTemporary(varPlace.identifier);
+          const varLValuePlace = createTemporaryPlace(fn.env, instr.value.loc);
+          const thenVarPlace = Object.assign(Object.assign({}, varPlace), {
+            identifier: forkTemporaryIdentifier(
+              fn.env.nextIdentifierId,
+              varPlace.identifier
+            ),
+          });
+          const elseVarPlace = Object.assign(Object.assign({}, varPlace), {
+            identifier: forkTemporaryIdentifier(
+              fn.env.nextIdentifierId,
+              varPlace.identifier
+            ),
+          });
+          const varInstruction = {
+            id: makeInstructionId(0),
+            lvalue: Object.assign({}, varLValuePlace),
+            value: {
+              kind: 'DeclareLocal',
+              lvalue: {
+                place: Object.assign({}, varPlace),
+                kind: InstructionKind.Let,
+              },
+              type: null,
+              loc: instr.value.loc,
+            },
+            loc: instr.loc,
+          };
+          currentBlockInstructions.push(varInstruction);
+          const devGlobalPlace = createTemporaryPlace(fn.env, instr.value.loc);
+          const devGlobalInstruction = {
+            id: makeInstructionId(0),
+            lvalue: Object.assign(Object.assign({}, devGlobalPlace), {
+              effect: exports.Effect.Mutate,
+            }),
+            value: {
+              kind: 'LoadGlobal',
+              binding: {
+                kind: 'Global',
+                name: inlineJsxTransformConfig.globalDevVar,
+              },
+              loc: instr.value.loc,
+            },
+            loc: instr.loc,
+          };
+          currentBlockInstructions.push(devGlobalInstruction);
+          const thenBlockId = fn.env.nextBlockId;
+          const elseBlockId = fn.env.nextBlockId;
+          const ifTerminal = {
+            kind: 'if',
+            test: Object.assign(Object.assign({}, devGlobalPlace), {
+              effect: exports.Effect.Read,
+            }),
+            consequent: thenBlockId,
+            alternate: elseBlockId,
+            fallthrough: fallthroughBlockId,
+            loc: instr.loc,
+            id: makeInstructionId(0),
+          };
+          currentBlock.instructions = currentBlockInstructions;
+          currentBlock.terminal = ifTerminal;
+          const thenBlock = {
+            id: thenBlockId,
+            instructions: thenBlockInstructions,
+            kind: 'block',
+            phis: new Set(),
+            preds: new Set(),
+            terminal: {
+              kind: 'goto',
+              block: fallthroughBlockId,
+              variant: GotoVariant.Break,
+              id: makeInstructionId(0),
+              loc: instr.loc,
+            },
+          };
+          fn.body.blocks.set(thenBlockId, thenBlock);
+          const resassignElsePlace = createTemporaryPlace(
+            fn.env,
+            instr.value.loc
+          );
+          const reassignElseInstruction = {
+            id: makeInstructionId(0),
+            lvalue: Object.assign({}, resassignElsePlace),
+            value: {
+              kind: 'StoreLocal',
+              lvalue: {place: elseVarPlace, kind: InstructionKind.Reassign},
+              value: Object.assign({}, instr.lvalue),
+              type: null,
+              loc: instr.value.loc,
+            },
+            loc: instr.loc,
+          };
+          thenBlockInstructions.push(reassignElseInstruction);
+          const elseBlockTerminal = {
+            kind: 'goto',
+            block: fallthroughBlockId,
+            variant: GotoVariant.Break,
+            id: makeInstructionId(0),
+            loc: instr.loc,
+          };
+          const elseBlock = {
+            id: elseBlockId,
+            instructions: elseBlockInstructions,
+            kind: 'block',
+            phis: new Set(),
+            preds: new Set(),
+            terminal: elseBlockTerminal,
+          };
+          fn.body.blocks.set(elseBlockId, elseBlock);
+          const {
+            refProperty: refProperty,
+            keyProperty: keyProperty,
+            propsProperty: propsProperty,
+          } = createPropsProperties(
+            fn,
+            instr,
+            elseBlockInstructions,
+            instr.value.kind === 'JsxExpression' ? instr.value.props : [],
+            instr.value.children
+          );
+          const reactElementInstructionPlace = createTemporaryPlace(
+            fn.env,
+            instr.value.loc
+          );
+          const reactElementInstruction = {
+            id: makeInstructionId(0),
+            lvalue: Object.assign(
+              Object.assign({}, reactElementInstructionPlace),
+              {effect: exports.Effect.Store}
+            ),
+            value: {
+              kind: 'ObjectExpression',
+              properties: [
+                createSymbolProperty(
+                  fn,
+                  instr,
+                  elseBlockInstructions,
+                  '$$typeof',
+                  inlineJsxTransformConfig.elementSymbol
+                ),
+                instr.value.kind === 'JsxExpression'
+                  ? createTagProperty(
+                      fn,
+                      instr,
+                      elseBlockInstructions,
+                      instr.value.tag
+                    )
+                  : createSymbolProperty(
+                      fn,
+                      instr,
+                      elseBlockInstructions,
+                      'type',
+                      'react.fragment'
+                    ),
+                refProperty,
+                keyProperty,
+                propsProperty,
+              ],
+              loc: instr.value.loc,
+            },
+            loc: instr.loc,
+          };
+          elseBlockInstructions.push(reactElementInstruction);
+          const reassignConditionalInstruction = {
+            id: makeInstructionId(0),
+            lvalue: Object.assign(
+              {},
+              createTemporaryPlace(fn.env, instr.value.loc)
+            ),
+            value: {
+              kind: 'StoreLocal',
+              lvalue: {
+                place: Object.assign({}, elseVarPlace),
+                kind: InstructionKind.Reassign,
+              },
+              value: Object.assign({}, reactElementInstruction.lvalue),
+              type: null,
+              loc: instr.value.loc,
+            },
+            loc: instr.loc,
+          };
+          elseBlockInstructions.push(reassignConditionalInstruction);
+          const operands = new Map();
+          operands.set(thenBlockId, Object.assign({}, elseVarPlace));
+          operands.set(elseBlockId, Object.assign({}, thenVarPlace));
+          const phiIdentifier = forkTemporaryIdentifier(
+            fn.env.nextIdentifierId,
+            varPlace.identifier
+          );
+          const phiPlace = Object.assign(
+            Object.assign({}, createTemporaryPlace(fn.env, instr.value.loc)),
+            {identifier: phiIdentifier}
+          );
+          const phis = new Set([
+            {kind: 'Phi', operands: operands, place: phiPlace},
+          ]);
+          fallthroughBlock.phis = phis;
+          fn.body.blocks.set(fallthroughBlockId, fallthroughBlock);
+          inlinedJsxDeclarations.set(instr.lvalue.identifier.declarationId, {
+            identifier: phiIdentifier,
+            blockIdsToIgnore: new Set([thenBlockId, elseBlockId]),
+          });
+          break;
+        }
+        case 'FunctionExpression':
+        case 'ObjectMethod': {
+          inlineJsxTransform(
+            instr.value.loweredFunc.func,
+            inlineJsxTransformConfig
+          );
+          break;
+        }
+      }
+    }
+  }
+  for (const [blockId, block] of fn.body.blocks) {
+    for (const instr of block.instructions) {
+      mapInstructionOperands(instr, place =>
+        handlePlace(place, blockId, inlinedJsxDeclarations)
+      );
+      mapInstructionLValues(instr, lvalue =>
+        handlelValue(lvalue, blockId, inlinedJsxDeclarations)
+      );
+      mapInstructionValueOperands(instr.value, place =>
+        handlePlace(place, blockId, inlinedJsxDeclarations)
+      );
+    }
+    mapTerminalOperands(block.terminal, place =>
+      handlePlace(place, blockId, inlinedJsxDeclarations)
+    );
+    if (block.terminal.kind === 'scope') {
+      const scope = block.terminal.scope;
+      for (const dep of scope.dependencies) {
+        dep.identifier = handleIdentifier(
+          dep.identifier,
+          inlinedJsxDeclarations
+        );
+      }
+      for (const [origId, decl] of [...scope.declarations]) {
+        const newDecl = handleIdentifier(
+          decl.identifier,
+          inlinedJsxDeclarations
+        );
+        if (newDecl.id !== origId) {
+          scope.declarations.delete(origId);
+          scope.declarations.set(decl.identifier.id, {
+            identifier: newDecl,
+            scope: decl.scope,
+          });
+        }
+      }
+    }
+  }
+  reversePostorderBlocks(fn.body);
+  markPredecessors(fn.body);
+  markInstructionIds(fn.body);
+  fixScopeAndIdentifierRanges(fn.body);
+}
 function createSymbolProperty(
   fn,
   instr,
@@ -141473,152 +141800,65 @@ function createPropsProperties(
     propsProperty: propsProperty,
   };
 }
-function inlineJsxTransform(fn, inlineJsxTransformConfig) {
-  for (const [, block] of fn.body.blocks) {
-    let nextInstructions = null;
-    for (let i = 0; i < block.instructions.length; i++) {
-      const instr = block.instructions[i];
-      switch (instr.value.kind) {
-        case 'JsxExpression': {
-          nextInstructions !== null && nextInstructions !== void 0
-            ? nextInstructions
-            : (nextInstructions = block.instructions.slice(0, i));
-          const {
-            refProperty: refProperty,
-            keyProperty: keyProperty,
-            propsProperty: propsProperty,
-          } = createPropsProperties(
-            fn,
-            instr,
-            nextInstructions,
-            instr.value.props,
-            instr.value.children
-          );
-          const reactElementInstruction = {
-            id: makeInstructionId(0),
-            lvalue: Object.assign(Object.assign({}, instr.lvalue), {
-              effect: exports.Effect.Store,
-            }),
-            value: {
-              kind: 'ObjectExpression',
-              properties: [
-                createSymbolProperty(
-                  fn,
-                  instr,
-                  nextInstructions,
-                  '$$typeof',
-                  inlineJsxTransformConfig.elementSymbol
-                ),
-                createTagProperty(fn, instr, nextInstructions, instr.value.tag),
-                refProperty,
-                keyProperty,
-                propsProperty,
-              ],
-              loc: instr.value.loc,
-            },
-            loc: instr.loc,
-          };
-          nextInstructions.push(reactElementInstruction);
-          break;
-        }
-        case 'JsxFragment': {
-          nextInstructions !== null && nextInstructions !== void 0
-            ? nextInstructions
-            : (nextInstructions = block.instructions.slice(0, i));
-          const {
-            refProperty: refProperty,
-            keyProperty: keyProperty,
-            propsProperty: propsProperty,
-          } = createPropsProperties(
-            fn,
-            instr,
-            nextInstructions,
-            [],
-            instr.value.children
-          );
-          const reactElementInstruction = {
-            id: makeInstructionId(0),
-            lvalue: Object.assign(Object.assign({}, instr.lvalue), {
-              effect: exports.Effect.Store,
-            }),
-            value: {
-              kind: 'ObjectExpression',
-              properties: [
-                createSymbolProperty(
-                  fn,
-                  instr,
-                  nextInstructions,
-                  '$$typeof',
-                  inlineJsxTransformConfig.elementSymbol
-                ),
-                createSymbolProperty(
-                  fn,
-                  instr,
-                  nextInstructions,
-                  'type',
-                  'react.fragment'
-                ),
-                refProperty,
-                keyProperty,
-                propsProperty,
-              ],
-              loc: instr.value.loc,
-            },
-            loc: instr.loc,
-          };
-          nextInstructions.push(reactElementInstruction);
-          break;
-        }
-        case 'FunctionExpression':
-        case 'ObjectMethod': {
-          inlineJsxTransform(
-            instr.value.loweredFunc.func,
-            inlineJsxTransformConfig
-          );
-          if (nextInstructions !== null) {
-            nextInstructions.push(instr);
-          }
-          break;
-        }
-        default: {
-          if (nextInstructions !== null) {
-            nextInstructions.push(instr);
-          }
-        }
-      }
-    }
-    if (nextInstructions !== null) {
-      block.instructions = nextInstructions;
-    }
-  }
-  reversePostorderBlocks(fn.body);
-  markPredecessors(fn.body);
-  markInstructionIds(fn.body);
-  fixScopeAndIdentifierRanges(fn.body);
-}
-function findScopesToMerge(fn) {
-  const objectMethodDecls = new Set();
-  const mergeScopesBuilder = new DisjointSet();
-  for (const [_, block] of fn.body.blocks) {
-    for (const {lvalue: lvalue, value: value} of block.instructions) {
-      if (value.kind === 'ObjectMethod') {
-        objectMethodDecls.add(lvalue.identifier);
-      } else if (value.kind === 'ObjectExpression') {
-        for (const operand of eachInstructionValueOperand(value)) {
-          if (objectMethodDecls.has(operand.identifier)) {
-            const operandScope = operand.identifier.scope;
-            const lvalueScope = lvalue.identifier.scope;
-            CompilerError.invariant(
-              operandScope != null && lvalueScope != null,
-              {
-                reason:
-                  'Internal error: Expected all ObjectExpressions and ObjectMethods to have non-null scope.',
-                suggestions: null,
-                loc: GeneratedSource,
-              }
-            );
-            mergeScopesBuilder.union([operandScope, lvalueScope]);
-          }
+function handlePlace(place, blockId, inlinedJsxDeclarations) {
+  const inlinedJsxDeclaration = inlinedJsxDeclarations.get(
+    place.identifier.declarationId
+  );
+  if (
+    inlinedJsxDeclaration == null ||
+    inlinedJsxDeclaration.blockIdsToIgnore.has(blockId)
+  ) {
+    return place;
+  }
+  return Object.assign(Object.assign({}, place), {
+    identifier: inlinedJsxDeclaration.identifier,
+  });
+}
+function handlelValue(lvalue, blockId, inlinedJsxDeclarations) {
+  const inlinedJsxDeclaration = inlinedJsxDeclarations.get(
+    lvalue.identifier.declarationId
+  );
+  if (
+    inlinedJsxDeclaration == null ||
+    inlinedJsxDeclaration.blockIdsToIgnore.has(blockId)
+  ) {
+    return lvalue;
+  }
+  return Object.assign(Object.assign({}, lvalue), {
+    identifier: inlinedJsxDeclaration.identifier,
+  });
+}
+function handleIdentifier(identifier, inlinedJsxDeclarations) {
+  const inlinedJsxDeclaration = inlinedJsxDeclarations.get(
+    identifier.declarationId
+  );
+  return inlinedJsxDeclaration == null
+    ? identifier
+    : inlinedJsxDeclaration.identifier;
+}
+function findScopesToMerge(fn) {
+  const objectMethodDecls = new Set();
+  const mergeScopesBuilder = new DisjointSet();
+  for (const [_, block] of fn.body.blocks) {
+    for (const {lvalue: lvalue, value: value} of block.instructions) {
+      if (value.kind === 'ObjectMethod') {
+        objectMethodDecls.add(lvalue.identifier);
+      } else if (value.kind === 'ObjectExpression') {
+        for (const operand of eachInstructionValueOperand(value)) {
+          if (objectMethodDecls.has(operand.identifier)) {
+            const operandScope = operand.identifier.scope;
+            const lvalueScope = lvalue.identifier.scope;
+            CompilerError.invariant(
+              operandScope != null && lvalueScope != null,
+              {
+                reason:
+                  'Internal error: Expected all ObjectExpressions and ObjectMethods to have non-null scope.',
+                suggestions: null,
+                loc: GeneratedSource,
+              }
+            );
+            mergeScopesBuilder.union([operandScope, lvalueScope]);
+          }
         }
       }
     }
@@ -142254,7 +142494,7 @@ var _Context_nextScheduleId,
   _Context_catchHandlers,
   _Context_controlFlowStack;
 function buildReactiveFunction(fn) {
-  const cx = new Context$3(fn.body);
+  const cx = new Context$2(fn.body);
   const driver = new Driver(cx);
   const body = driver.traverseBlock(cx.block(fn.body.entry));
   return {
@@ -143302,7 +143542,7 @@ class Driver {
     };
   }
 }
-let Context$3 = class Context {
+let Context$2 = class Context {
   constructor(ir) {
     _Context_nextScheduleId.set(this, 0);
     this.emitted = new Set();
@@ -143682,7 +143922,7 @@ function expandFbtScopeRange(fbtRange, extendWith) {
     );
   }
 }
-var _Context_nextCacheIndex, _Context_declarations$2;
+var _Context_nextCacheIndex, _Context_declarations$1;
 const MEMO_CACHE_SENTINEL = 'react.memo_cache_sentinel';
 const EARLY_RETURN_SENTINEL = 'react.early_return_sentinel';
 function codegenFunction(
@@ -143690,7 +143930,7 @@ function codegenFunction(
   {uniqueIdentifiers: uniqueIdentifiers, fbtOperands: fbtOperands}
 ) {
   var _a, _b, _c;
-  const cx = new Context$2(
+  const cx = new Context$1(
     fn.env,
     (_a = fn.id) !== null && _a !== void 0 ? _a : '[[ anonymous ]]',
     uniqueIdentifiers,
@@ -143855,7 +144095,7 @@ function codegenFunction(
     pruneHoistedContexts(reactiveFunction);
     const identifiers = renameVariables(reactiveFunction);
     const codegen = codegenReactiveFunction(
-      new Context$2(
+      new Context$1(
         cx.env,
         (_c = reactiveFunction.id) !== null && _c !== void 0
           ? _c
@@ -143942,10 +144182,10 @@ function convertParameter(param) {
     return t__namespace.restElement(convertIdentifier(param.place.identifier));
   }
 }
-let Context$2 = class Context {
+let Context$1 = class Context {
   constructor(env, fnName, uniqueIdentifiers, fbtOperands, temporaries = null) {
     _Context_nextCacheIndex.set(this, 0);
-    _Context_declarations$2.set(this, new Set());
+    _Context_declarations$1.set(this, new Set());
     this.errors = new CompilerError();
     this.objectMethods = new Map();
     this.synthesizedNames = new Map();
@@ -143970,12 +144210,12 @@ let Context$2 = class Context {
     );
   }
   declare(identifier) {
-    __classPrivateFieldGet(this, _Context_declarations$2, 'f').add(
+    __classPrivateFieldGet(this, _Context_declarations$1, 'f').add(
       identifier.declarationId
     );
   }
   hasDeclared(identifier) {
-    return __classPrivateFieldGet(this, _Context_declarations$2, 'f').has(
+    return __classPrivateFieldGet(this, _Context_declarations$1, 'f').has(
       identifier.declarationId
     );
   }
@@ -143995,7 +144235,7 @@ let Context$2 = class Context {
   }
 };
 (_Context_nextCacheIndex = new WeakMap()),
-  (_Context_declarations$2 = new WeakMap());
+  (_Context_declarations$1 = new WeakMap());
 function codegenBlock(cx, block) {
   const temp = new Map(cx.temp);
   const result = codegenBlockNoReset(cx, block);
@@ -144088,7 +144328,7 @@ function codegenReactiveScope(cx, statements, scope, block) {
   const changeExpressions = [];
   const changeExpressionComments = [];
   const outputComments = [];
-  for (const dep of scope.dependencies) {
+  for (const dep of [...scope.dependencies].sort(compareScopeDependency)) {
     const index = cx.nextCacheIndex;
     changeExpressionComments.push(printDependencyComment(dep));
     const comparison = t__namespace.binaryExpression(
@@ -144128,7 +144368,9 @@ function codegenReactiveScope(cx, statements, scope, block) {
     );
   }
   let firstOutputIndex = null;
-  for (const [, {identifier: identifier}] of scope.declarations) {
+  for (const [, {identifier: identifier}] of [...scope.declarations].sort(
+    ([, a], [, b]) => compareScopeDeclaration(a, b)
+  )) {
     const index = cx.nextCacheIndex;
     if (firstOutputIndex === null) {
       firstOutputIndex = index;
@@ -145271,7 +145513,7 @@ function codegenInstructionValue(cx, instrValue) {
               pruneUnusedLabels(reactiveFunction);
               pruneUnusedLValues(reactiveFunction);
               const fn = codegenReactiveFunction(
-                new Context$2(
+                new Context$1(
                   cx.env,
                   (_e = reactiveFunction.id) !== null && _e !== void 0
                     ? _e
@@ -145470,7 +145712,7 @@ function codegenInstructionValue(cx, instrValue) {
       pruneUnusedLValues(reactiveFunction);
       pruneHoistedContexts(reactiveFunction);
       const fn = codegenReactiveFunction(
-        new Context$2(
+        new Context$1(
           cx.env,
           (_g = reactiveFunction.id) !== null && _g !== void 0
             ? _g
@@ -145939,6 +146181,50 @@ function convertIdentifier(identifier) {
   );
   return t__namespace.identifier(identifier.name.value);
 }
+function compareScopeDependency(a, b) {
+  var _a, _b;
+  CompilerError.invariant(
+    ((_a = a.identifier.name) === null || _a === void 0 ? void 0 : _a.kind) ===
+      'named' &&
+      ((_b = b.identifier.name) === null || _b === void 0
+        ? void 0
+        : _b.kind) === 'named',
+    {
+      reason: '[Codegen] Expected named identifier for dependency',
+      loc: a.identifier.loc,
+    }
+  );
+  const aName = [
+    a.identifier.name.value,
+    ...a.path.map(entry => `${entry.optional ? '?' : ''}${entry.property}`),
+  ].join('.');
+  const bName = [
+    b.identifier.name.value,
+    ...b.path.map(entry => `${entry.optional ? '?' : ''}${entry.property}`),
+  ].join('.');
+  if (aName < bName) return -1;
+  else if (aName > bName) return 1;
+  else return 0;
+}
+function compareScopeDeclaration(a, b) {
+  var _a, _b;
+  CompilerError.invariant(
+    ((_a = a.identifier.name) === null || _a === void 0 ? void 0 : _a.kind) ===
+      'named' &&
+      ((_b = b.identifier.name) === null || _b === void 0
+        ? void 0
+        : _b.kind) === 'named',
+    {
+      reason: '[Codegen] Expected named identifier for declaration',
+      loc: a.identifier.loc,
+    }
+  );
+  const aName = a.identifier.name.value;
+  const bName = b.identifier.name.value;
+  if (aName < bName) return -1;
+  else if (aName > bName) return 1;
+  else return 0;
+}
 function extractScopeDeclarationsFromDestructuring(fn) {
   const state = new State$1(fn.env);
   visitReactiveFunction(fn, new Visitor$9(), state);
@@ -146935,1651 +147221,42 @@ let Transform$3 = class Transform extends ReactiveFunctionTransform {
     return {kind: 'keep'};
   }
 };
-var _Node_value, _Node_next;
-function empty() {
-  return EMPTY;
-}
-class Node {
-  constructor(value, next = EMPTY) {
-    _Node_value.set(this, void 0);
-    _Node_next.set(this, void 0);
-    __classPrivateFieldSet(this, _Node_value, value, 'f');
-    __classPrivateFieldSet(this, _Node_next, next, 'f');
-  }
-  push(value) {
-    return new Node(value, this);
-  }
-  pop() {
-    return __classPrivateFieldGet(this, _Node_next, 'f');
-  }
-  find(fn) {
-    return fn(__classPrivateFieldGet(this, _Node_value, 'f'))
-      ? true
-      : __classPrivateFieldGet(this, _Node_next, 'f').find(fn);
-  }
-  contains(value) {
-    return (
-      value === __classPrivateFieldGet(this, _Node_value, 'f') ||
-      (__classPrivateFieldGet(this, _Node_next, 'f') !== null &&
-        __classPrivateFieldGet(this, _Node_next, 'f').contains(value))
-    );
-  }
-  each(fn) {
-    fn(__classPrivateFieldGet(this, _Node_value, 'f'));
-    __classPrivateFieldGet(this, _Node_next, 'f').each(fn);
-  }
-  get value() {
-    return __classPrivateFieldGet(this, _Node_value, 'f');
-  }
-  print(fn) {
-    return (
-      fn(__classPrivateFieldGet(this, _Node_value, 'f')) +
-      __classPrivateFieldGet(this, _Node_next, 'f').print(fn)
-    );
-  }
-}
-(_Node_value = new WeakMap()), (_Node_next = new WeakMap());
-class Empty {
-  push(value) {
-    return new Node(value, this);
-  }
-  pop() {
-    return this;
-  }
-  find(_fn) {
-    return false;
-  }
-  contains(_value) {
-    return false;
-  }
-  each(_fn) {
-    return;
-  }
-  get value() {
-    return null;
-  }
-  print(_) {
-    return '';
-  }
+function pruneHoistedContexts(fn) {
+  const hoistedIdentifiers = new Map();
+  visitReactiveFunction(fn, new Visitor$8(), hoistedIdentifiers);
 }
-const EMPTY = new Empty();
-var _ReactiveScopeDependencyTree_instances,
-  _ReactiveScopeDependencyTree_roots,
-  _ReactiveScopeDependencyTree_getOrCreateRoot,
-  _ReactiveScopeDependencyTree_debugImpl;
-class ReactiveScopeDependencyTree {
-  constructor() {
-    _ReactiveScopeDependencyTree_instances.add(this);
-    _ReactiveScopeDependencyTree_roots.set(this, new Map());
-  }
-  add(dep, inConditional) {
-    const {path: path} = dep;
-    let currNode = __classPrivateFieldGet(
-      this,
-      _ReactiveScopeDependencyTree_instances,
-      'm',
-      _ReactiveScopeDependencyTree_getOrCreateRoot
-    ).call(this, dep.identifier);
-    for (const item of path) {
-      let currChild = getOrMakeProperty(currNode, item.property);
-      const accessType = inConditional
-        ? PropertyAccessType$1.ConditionalAccess
-        : item.optional
-          ? PropertyAccessType$1.OptionalAccess
-          : PropertyAccessType$1.UnconditionalAccess;
-      currChild.accessType = merge$1(currChild.accessType, accessType);
-      currNode = currChild;
-    }
-    const depType = inConditional
-      ? PropertyAccessType$1.ConditionalDependency
-      : isOptional$1(currNode.accessType)
-        ? PropertyAccessType$1.OptionalDependency
-        : PropertyAccessType$1.UnconditionalDependency;
-    currNode.accessType = merge$1(currNode.accessType, depType);
-  }
-  deriveMinimalDependencies() {
-    const results = new Set();
-    for (const [rootId, rootNode] of __classPrivateFieldGet(
-      this,
-      _ReactiveScopeDependencyTree_roots,
-      'f'
-    ).entries()) {
-      const deps = deriveMinimalDependenciesInSubtree(rootNode, null);
-      CompilerError.invariant(
-        deps.every(
-          dep =>
-            dep.accessType === PropertyAccessType$1.UnconditionalDependency ||
-            dep.accessType == PropertyAccessType$1.OptionalDependency
-        ),
-        {
-          reason:
-            '[PropagateScopeDependencies] All dependencies must be reduced to unconditional dependencies.',
-          description: null,
-          loc: null,
-          suggestions: null,
-        }
+let Visitor$8 = class Visitor extends ReactiveFunctionTransform {
+  transformInstruction(instruction, state) {
+    this.visitInstruction(instruction, state);
+    if (
+      instruction.value.kind === 'DeclareContext' &&
+      instruction.value.lvalue.kind === 'HoistedConst'
+    ) {
+      state.set(
+        instruction.value.lvalue.place.identifier.declarationId,
+        InstructionKind.Const
       );
-      for (const dep of deps) {
-        results.add({identifier: rootId, path: dep.relativePath});
-      }
-    }
-    return results;
-  }
-  addDepsFromInnerScope(
-    depsFromInnerScope,
-    innerScopeInConditionalWithinParent,
-    checkValidDepIdFn
-  ) {
-    for (const [id, otherRoot] of __classPrivateFieldGet(
-      depsFromInnerScope,
-      _ReactiveScopeDependencyTree_roots,
-      'f'
-    )) {
-      if (!checkValidDepIdFn({identifier: id, path: []})) {
-        continue;
-      }
-      let currRoot = __classPrivateFieldGet(
-        this,
-        _ReactiveScopeDependencyTree_instances,
-        'm',
-        _ReactiveScopeDependencyTree_getOrCreateRoot
-      ).call(this, id);
-      addSubtree(currRoot, otherRoot, innerScopeInConditionalWithinParent);
-      if (!isUnconditional(currRoot.accessType)) {
-        currRoot.accessType = isDependency$1(currRoot.accessType)
-          ? PropertyAccessType$1.UnconditionalDependency
-          : PropertyAccessType$1.UnconditionalAccess;
-      }
-    }
-  }
-  promoteDepsFromExhaustiveConditionals(trees) {
-    CompilerError.invariant(trees.length > 1, {
-      reason: 'Expected trees to be at least 2 elements long.',
-      description: null,
-      loc: null,
-      suggestions: null,
-    });
-    for (const [id, root] of __classPrivateFieldGet(
-      this,
-      _ReactiveScopeDependencyTree_roots,
-      'f'
-    )) {
-      const nodesForRootId = mapNonNull(trees, tree => {
-        const node = __classPrivateFieldGet(
-          tree,
-          _ReactiveScopeDependencyTree_roots,
-          'f'
-        ).get(id);
-        if (node != null && isUnconditional(node.accessType)) {
-          return node;
-        } else {
-          return null;
-        }
-      });
-      if (nodesForRootId) {
-        addSubtreeIntersection(
-          root.properties,
-          nodesForRootId.map(root => root.properties)
-        );
-      }
+      return {kind: 'remove'};
     }
-  }
-  printDeps(includeAccesses) {
-    let res = [];
-    for (const [rootId, rootNode] of __classPrivateFieldGet(
-      this,
-      _ReactiveScopeDependencyTree_roots,
-      'f'
-    ).entries()) {
-      const rootResults = printSubtree$1(rootNode, includeAccesses).map(
-        result => `${printIdentifier(rootId)}.${result}`
+    if (
+      instruction.value.kind === 'DeclareContext' &&
+      instruction.value.lvalue.kind === 'HoistedLet'
+    ) {
+      state.set(
+        instruction.value.lvalue.place.identifier.declarationId,
+        InstructionKind.Let
       );
-      res.push(rootResults);
+      return {kind: 'remove'};
     }
-    return res.flat().join('\n');
-  }
-  debug() {
-    const buf = [`tree() [`];
-    for (const [rootId, rootNode] of __classPrivateFieldGet(
-      this,
-      _ReactiveScopeDependencyTree_roots,
-      'f'
-    )) {
-      buf.push(`${printIdentifier(rootId)} (${rootNode.accessType}):`);
-      __classPrivateFieldGet(
-        this,
-        _ReactiveScopeDependencyTree_instances,
-        'm',
-        _ReactiveScopeDependencyTree_debugImpl
-      ).call(this, buf, rootNode, 1);
-    }
-    buf.push(']');
-    return buf.length > 2 ? buf.join('\n') : buf.join('');
-  }
-}
-(_ReactiveScopeDependencyTree_roots = new WeakMap()),
-  (_ReactiveScopeDependencyTree_instances = new WeakSet()),
-  (_ReactiveScopeDependencyTree_getOrCreateRoot =
-    function _ReactiveScopeDependencyTree_getOrCreateRoot(identifier) {
-      let rootNode = __classPrivateFieldGet(
-        this,
-        _ReactiveScopeDependencyTree_roots,
-        'f'
-      ).get(identifier);
-      if (rootNode === undefined) {
-        rootNode = {
-          properties: new Map(),
-          accessType: PropertyAccessType$1.UnconditionalAccess,
-        };
-        __classPrivateFieldGet(
-          this,
-          _ReactiveScopeDependencyTree_roots,
-          'f'
-        ).set(identifier, rootNode);
-      }
-      return rootNode;
-    }),
-  (_ReactiveScopeDependencyTree_debugImpl =
-    function _ReactiveScopeDependencyTree_debugImpl(buf, node, depth = 0) {
-      for (const [property, childNode] of node.properties) {
-        buf.push(
-          `${'  '.repeat(depth)}.${property} (${childNode.accessType}):`
-        );
-        __classPrivateFieldGet(
-          this,
-          _ReactiveScopeDependencyTree_instances,
-          'm',
-          _ReactiveScopeDependencyTree_debugImpl
-        ).call(this, buf, childNode, depth + 1);
-      }
-    });
-var PropertyAccessType$1;
-(function (PropertyAccessType) {
-  PropertyAccessType['ConditionalAccess'] = 'ConditionalAccess';
-  PropertyAccessType['OptionalAccess'] = 'OptionalAccess';
-  PropertyAccessType['UnconditionalAccess'] = 'UnconditionalAccess';
-  PropertyAccessType['ConditionalDependency'] = 'ConditionalDependency';
-  PropertyAccessType['OptionalDependency'] = 'OptionalDependency';
-  PropertyAccessType['UnconditionalDependency'] = 'UnconditionalDependency';
-})(PropertyAccessType$1 || (PropertyAccessType$1 = {}));
-const MIN_ACCESS_TYPE = PropertyAccessType$1.ConditionalAccess;
-function isUnconditional(access) {
-  return (
-    access === PropertyAccessType$1.UnconditionalAccess ||
-    access === PropertyAccessType$1.UnconditionalDependency
-  );
-}
-function isDependency$1(access) {
-  return (
-    access === PropertyAccessType$1.ConditionalDependency ||
-    access === PropertyAccessType$1.OptionalDependency ||
-    access === PropertyAccessType$1.UnconditionalDependency
-  );
-}
-function isOptional$1(access) {
-  return (
-    access === PropertyAccessType$1.OptionalAccess ||
-    access === PropertyAccessType$1.OptionalDependency
-  );
-}
-function merge$1(access1, access2) {
-  const resultIsUnconditional =
-    isUnconditional(access1) || isUnconditional(access2);
-  const resultIsDependency = isDependency$1(access1) || isDependency$1(access2);
-  const resultIsOptional = isOptional$1(access1) || isOptional$1(access2);
-  if (resultIsUnconditional) {
-    if (resultIsDependency) {
-      return PropertyAccessType$1.UnconditionalDependency;
-    } else {
-      return PropertyAccessType$1.UnconditionalAccess;
-    }
-  } else if (resultIsOptional) {
-    if (resultIsDependency) {
-      return PropertyAccessType$1.OptionalDependency;
-    } else {
-      return PropertyAccessType$1.OptionalAccess;
-    }
-  } else {
-    if (resultIsDependency) {
-      return PropertyAccessType$1.ConditionalDependency;
-    } else {
-      return PropertyAccessType$1.ConditionalAccess;
-    }
-  }
-}
-function promoteResult(accessType, path) {
-  const result = {relativePath: [], accessType: accessType};
-  if (path !== null) {
-    result.relativePath.push(path);
-  }
-  return [result];
-}
-function prependPath(results, path) {
-  if (path === null) {
-    return results;
-  }
-  return results.map(result => ({
-    accessType: result.accessType,
-    relativePath: [path, ...result.relativePath],
-  }));
-}
-function deriveMinimalDependenciesInSubtree(dep, property) {
-  const results = [];
-  for (const [childName, childNode] of dep.properties) {
-    const childResult = deriveMinimalDependenciesInSubtree(
-      childNode,
-      childName
-    );
-    results.push(...childResult);
-  }
-  switch (dep.accessType) {
-    case PropertyAccessType$1.UnconditionalDependency: {
-      return promoteResult(
-        PropertyAccessType$1.UnconditionalDependency,
-        property !== null ? {property: property, optional: false} : null
-      );
-    }
-    case PropertyAccessType$1.UnconditionalAccess: {
-      if (
-        results.every(
-          ({accessType: accessType}) =>
-            accessType === PropertyAccessType$1.UnconditionalDependency ||
-            accessType === PropertyAccessType$1.OptionalDependency
-        )
-      ) {
-        return prependPath(
-          results,
-          property !== null ? {property: property, optional: false} : null
-        );
-      } else {
-        return promoteResult(
-          PropertyAccessType$1.UnconditionalDependency,
-          property !== null ? {property: property, optional: false} : null
-        );
-      }
-    }
-    case PropertyAccessType$1.OptionalDependency: {
-      return promoteResult(
-        PropertyAccessType$1.OptionalDependency,
-        property !== null ? {property: property, optional: true} : null
-      );
-    }
-    case PropertyAccessType$1.OptionalAccess: {
-      if (
-        results.every(
-          ({accessType: accessType}) =>
-            accessType === PropertyAccessType$1.UnconditionalDependency ||
-            accessType === PropertyAccessType$1.OptionalDependency
-        )
-      ) {
-        return prependPath(
-          results,
-          property !== null ? {property: property, optional: true} : null
-        );
-      } else {
-        return promoteResult(
-          PropertyAccessType$1.OptionalDependency,
-          property !== null ? {property: property, optional: true} : null
-        );
-      }
-    }
-    case PropertyAccessType$1.ConditionalAccess:
-    case PropertyAccessType$1.ConditionalDependency: {
-      if (
-        results.every(
-          ({accessType: accessType}) =>
-            accessType === PropertyAccessType$1.ConditionalDependency
-        )
-      ) {
-        return promoteResult(
-          PropertyAccessType$1.ConditionalDependency,
-          property !== null ? {property: property, optional: true} : null
-        );
-      } else {
-        return promoteResult(
-          PropertyAccessType$1.UnconditionalDependency,
-          property !== null ? {property: property, optional: true} : null
-        );
-      }
-    }
-    default: {
-      assertExhaustive(
-        dep.accessType,
-        '[PropgateScopeDependencies] Unhandled access type!'
-      );
-    }
-  }
-}
-function demoteSubtreeToConditional(subtree) {
-  const stack = [subtree];
-  let node;
-  while ((node = stack.pop()) !== undefined) {
-    const {accessType: accessType, properties: properties} = node;
-    if (!isUnconditional(accessType)) {
-      continue;
-    }
-    node.accessType = isDependency$1(accessType)
-      ? PropertyAccessType$1.ConditionalDependency
-      : PropertyAccessType$1.ConditionalAccess;
-    for (const childNode of properties.values()) {
-      if (isUnconditional(accessType)) {
-        stack.push(childNode);
-      }
-    }
-  }
-}
-function addSubtree(currNode, otherNode, demoteOtherNode) {
-  let otherType = otherNode.accessType;
-  if (demoteOtherNode) {
-    otherType = isDependency$1(otherType)
-      ? PropertyAccessType$1.ConditionalDependency
-      : PropertyAccessType$1.ConditionalAccess;
-  }
-  currNode.accessType = merge$1(currNode.accessType, otherType);
-  for (const [propertyName, otherChild] of otherNode.properties) {
-    const currChild = currNode.properties.get(propertyName);
-    if (currChild) {
-      addSubtree(currChild, otherChild, demoteOtherNode);
-    } else {
-      if (demoteOtherNode) {
-        demoteSubtreeToConditional(otherChild);
-      }
-      currNode.properties.set(propertyName, otherChild);
-    }
-  }
-}
-function addSubtreeIntersection(currProperties, otherProperties) {
-  CompilerError.invariant(otherProperties.length > 1, {
-    reason:
-      '[DeriveMinimalDependencies] Expected otherProperties to be at least 2 elements long.',
-    description: null,
-    loc: null,
-    suggestions: null,
-  });
-  for (const [propertyName, currNode] of currProperties) {
-    const otherNodes = mapNonNull(otherProperties, properties => {
-      const node = properties.get(propertyName);
-      if (node != null && isUnconditional(node.accessType)) {
-        return node;
-      } else {
-        return null;
-      }
-    });
-    if (otherNodes) {
-      addSubtreeIntersection(
-        currNode.properties,
-        otherNodes.map(node => node.properties)
-      );
-      const isDep = otherNodes.some(tree => isDependency$1(tree.accessType));
-      const externalAccessType = isDep
-        ? PropertyAccessType$1.UnconditionalDependency
-        : PropertyAccessType$1.UnconditionalAccess;
-      currNode.accessType = merge$1(externalAccessType, currNode.accessType);
-    }
-  }
-}
-function printSubtree$1(node, includeAccesses) {
-  const results = [];
-  for (const [propertyName, propertyNode] of node.properties) {
-    if (includeAccesses || isDependency$1(propertyNode.accessType)) {
-      results.push(`${propertyName} (${propertyNode.accessType})`);
-    }
-    const propertyResults = printSubtree$1(propertyNode, includeAccesses);
-    results.push(...propertyResults.map(result => `${propertyName}.${result}`));
-  }
-  return results;
-}
-function getOrMakeProperty(node, property) {
-  let child = node.properties.get(property);
-  if (child == null) {
-    child = {properties: new Map(), accessType: MIN_ACCESS_TYPE};
-    node.properties.set(property, child);
-  }
-  return child;
-}
-function mapNonNull(arr, fn) {
-  const result = [];
-  for (let i = 0; i < arr.length; i++) {
-    const element = fn(arr[i]);
-    if (element) {
-      result.push(element);
-    } else {
-      return null;
-    }
-  }
-  return result;
-}
-var _PoisonState_instances,
-  _PoisonState_invalidate,
-  _Context_instances$1,
-  _Context_temporariesUsedOutsideScope$1,
-  _Context_declarations$1,
-  _Context_reassignments$1,
-  _Context_dependencies$1,
-  _Context_properties,
-  _Context_temporaries$1,
-  _Context_inConditionalWithinScope,
-  _Context_depsInCurrentConditional,
-  _Context_scopes$1,
-  _Context_getProperty,
-  _Context_checkValidDependency$1,
-  _Context_isScopeActive$1;
-function propagateScopeDependencies(fn) {
-  const escapingTemporaries = {
-    declarations: new Map(),
-    usedOutsideDeclaringScope: new Set(),
-  };
-  visitReactiveFunction(fn, new FindPromotedTemporaries(), escapingTemporaries);
-  const context = new Context$1(escapingTemporaries.usedOutsideDeclaringScope);
-  for (const param of fn.params) {
-    if (param.kind === 'Identifier') {
-      context.declare(param.identifier, {
-        id: makeInstructionId(0),
-        scope: empty(),
-      });
-    } else {
-      context.declare(param.place.identifier, {
-        id: makeInstructionId(0),
-        scope: empty(),
-      });
-    }
-  }
-  visitReactiveFunction(fn, new PropagationVisitor(fn.env), context);
-}
-class FindPromotedTemporaries extends ReactiveFunctionVisitor {
-  constructor() {
-    super(...arguments);
-    this.scopes = [];
-  }
-  visitScope(scope, state) {
-    this.scopes.push(scope.scope.id);
-    this.traverseScope(scope, state);
-    this.scopes.pop();
-  }
-  visitInstruction(instruction, state) {
-    this.traverseInstruction(instruction, state);
-    const scope = this.scopes.at(-1);
-    if (instruction.lvalue === null || scope === undefined) {
-      return;
-    }
-    switch (instruction.value.kind) {
-      case 'LoadLocal':
-      case 'LoadContext':
-      case 'PropertyLoad': {
-        state.declarations.set(
-          instruction.lvalue.identifier.declarationId,
-          scope
-        );
-        break;
-      }
-    }
-  }
-  visitPlace(_id, place, state) {
-    const declaringScope = state.declarations.get(
-      place.identifier.declarationId
-    );
-    if (declaringScope === undefined) {
-      return;
-    }
-    if (this.scopes.indexOf(declaringScope) === -1) {
-      state.usedOutsideDeclaringScope.add(place.identifier.declarationId);
-    }
-  }
-}
-class PoisonState {
-  constructor(poisonedBlocks, poisonedScopes, isPoisoned) {
-    _PoisonState_instances.add(this);
-    this.poisonedBlocks = new Set();
-    this.poisonedScopes = new Set();
-    this.isPoisoned = false;
-    this.poisonedBlocks = poisonedBlocks;
-    this.poisonedScopes = poisonedScopes;
-    this.isPoisoned = isPoisoned;
-  }
-  clone() {
-    return new PoisonState(
-      new Set(this.poisonedBlocks),
-      new Set(this.poisonedScopes),
-      this.isPoisoned
-    );
-  }
-  take(other) {
-    const copy = new PoisonState(
-      this.poisonedBlocks,
-      this.poisonedScopes,
-      this.isPoisoned
-    );
-    this.poisonedBlocks = other.poisonedBlocks;
-    this.poisonedScopes = other.poisonedScopes;
-    this.isPoisoned = other.isPoisoned;
-    return copy;
-  }
-  merge(others, currentScope) {
-    for (const other of others) {
-      for (const id of other.poisonedBlocks) {
-        this.poisonedBlocks.add(id);
-      }
-      for (const id of other.poisonedScopes) {
-        this.poisonedScopes.add(id);
-      }
-    }
-    __classPrivateFieldGet(
-      this,
-      _PoisonState_instances,
-      'm',
-      _PoisonState_invalidate
-    ).call(this, currentScope);
-  }
-  addPoisonTarget(target, activeScopes) {
-    const currentScope = activeScopes.value;
-    if (target == null && currentScope != null) {
-      let cursor = activeScopes;
-      while (true) {
-        const next = cursor.pop();
-        if (next.value == null) {
-          const poisonedScope = cursor.value.value.id;
-          this.poisonedScopes.add(poisonedScope);
-          if (
-            poisonedScope ===
-            (currentScope === null || currentScope === void 0
-              ? void 0
-              : currentScope.value.id)
-          ) {
-            this.isPoisoned = true;
-          }
-          break;
-        } else {
-          cursor = next;
-        }
-      }
-    } else if (target != null) {
-      this.poisonedBlocks.add(target);
-      if (
-        !this.isPoisoned &&
-        (currentScope === null || currentScope === void 0
-          ? void 0
-          : currentScope.ownBlocks.find(blockId => blockId === target))
-      ) {
-        this.isPoisoned = true;
-      }
-    }
-  }
-  removeMaybePoisonedScope(id, currentScope) {
-    this.poisonedScopes.delete(id);
-    __classPrivateFieldGet(
-      this,
-      _PoisonState_instances,
-      'm',
-      _PoisonState_invalidate
-    ).call(this, currentScope);
-  }
-  removeMaybePoisonedBlock(id, currentScope) {
-    this.poisonedBlocks.delete(id);
-    __classPrivateFieldGet(
-      this,
-      _PoisonState_instances,
-      'm',
-      _PoisonState_invalidate
-    ).call(this, currentScope);
-  }
-}
-(_PoisonState_instances = new WeakSet()),
-  (_PoisonState_invalidate = function _PoisonState_invalidate(currentScope) {
-    if (currentScope != null) {
-      if (this.poisonedScopes.has(currentScope.value.id)) {
-        this.isPoisoned = true;
-        return;
-      } else if (
-        currentScope.ownBlocks.find(blockId => this.poisonedBlocks.has(blockId))
-      ) {
-        this.isPoisoned = true;
-        return;
-      }
-    }
-    this.isPoisoned = false;
-  });
-let Context$1 = class Context {
-  constructor(temporariesUsedOutsideScope) {
-    _Context_instances$1.add(this);
-    _Context_temporariesUsedOutsideScope$1.set(this, void 0);
-    _Context_declarations$1.set(this, new Map());
-    _Context_reassignments$1.set(this, new Map());
-    _Context_dependencies$1.set(this, new ReactiveScopeDependencyTree());
-    _Context_properties.set(this, new Map());
-    _Context_temporaries$1.set(this, new Map());
-    _Context_inConditionalWithinScope.set(this, false);
-    _Context_depsInCurrentConditional.set(
-      this,
-      new ReactiveScopeDependencyTree()
-    );
-    _Context_scopes$1.set(this, empty());
-    this.poisonState = new PoisonState(new Set(), new Set(), false);
-    __classPrivateFieldSet(
-      this,
-      _Context_temporariesUsedOutsideScope$1,
-      temporariesUsedOutsideScope,
-      'f'
-    );
-  }
-  enter(scope, fn) {
-    const prevInConditional = __classPrivateFieldGet(
-      this,
-      _Context_inConditionalWithinScope,
-      'f'
-    );
-    const previousDependencies = __classPrivateFieldGet(
-      this,
-      _Context_dependencies$1,
-      'f'
-    );
-    const prevDepsInConditional = this.isPoisoned
-      ? __classPrivateFieldGet(this, _Context_depsInCurrentConditional, 'f')
-      : null;
-    if (prevDepsInConditional != null) {
-      __classPrivateFieldSet(
-        this,
-        _Context_depsInCurrentConditional,
-        new ReactiveScopeDependencyTree(),
-        'f'
-      );
-    }
-    const scopedDependencies = new ReactiveScopeDependencyTree();
-    __classPrivateFieldSet(this, _Context_inConditionalWithinScope, false, 'f');
-    __classPrivateFieldSet(
-      this,
-      _Context_dependencies$1,
-      scopedDependencies,
-      'f'
-    );
-    __classPrivateFieldSet(
-      this,
-      _Context_scopes$1,
-      __classPrivateFieldGet(this, _Context_scopes$1, 'f').push({
-        value: scope,
-        ownBlocks: empty(),
-      }),
-      'f'
-    );
-    this.poisonState.isPoisoned = false;
-    fn();
-    __classPrivateFieldSet(
-      this,
-      _Context_scopes$1,
-      __classPrivateFieldGet(this, _Context_scopes$1, 'f').pop(),
-      'f'
-    );
-    this.poisonState.removeMaybePoisonedScope(
-      scope.id,
-      __classPrivateFieldGet(this, _Context_scopes$1, 'f').value
-    );
-    __classPrivateFieldSet(
-      this,
-      _Context_dependencies$1,
-      previousDependencies,
-      'f'
-    );
-    __classPrivateFieldSet(
-      this,
-      _Context_inConditionalWithinScope,
-      prevInConditional,
-      'f'
-    );
-    const minInnerScopeDependencies =
-      scopedDependencies.deriveMinimalDependencies();
-    __classPrivateFieldGet(
-      this,
-      _Context_dependencies$1,
-      'f'
-    ).addDepsFromInnerScope(
-      scopedDependencies,
-      __classPrivateFieldGet(this, _Context_inConditionalWithinScope, 'f') ||
-        this.isPoisoned,
-      __classPrivateFieldGet(
-        this,
-        _Context_instances$1,
-        'm',
-        _Context_checkValidDependency$1
-      ).bind(this)
-    );
-    if (prevDepsInConditional != null) {
-      prevDepsInConditional.addDepsFromInnerScope(
-        __classPrivateFieldGet(this, _Context_depsInCurrentConditional, 'f'),
-        true,
-        __classPrivateFieldGet(
-          this,
-          _Context_instances$1,
-          'm',
-          _Context_checkValidDependency$1
-        ).bind(this)
-      );
-      __classPrivateFieldSet(
-        this,
-        _Context_depsInCurrentConditional,
-        prevDepsInConditional,
-        'f'
-      );
-    }
-    return minInnerScopeDependencies;
-  }
-  isUsedOutsideDeclaringScope(place) {
-    return __classPrivateFieldGet(
-      this,
-      _Context_temporariesUsedOutsideScope$1,
-      'f'
-    ).has(place.identifier.declarationId);
-  }
-  printDeps(includeAccesses = false) {
-    return __classPrivateFieldGet(this, _Context_dependencies$1, 'f').printDeps(
-      includeAccesses
-    );
-  }
-  enterConditional(fn) {
-    const prevInConditional = __classPrivateFieldGet(
-      this,
-      _Context_inConditionalWithinScope,
-      'f'
-    );
-    const prevUncondAccessed = __classPrivateFieldGet(
-      this,
-      _Context_depsInCurrentConditional,
-      'f'
-    );
-    __classPrivateFieldSet(this, _Context_inConditionalWithinScope, true, 'f');
-    __classPrivateFieldSet(
-      this,
-      _Context_depsInCurrentConditional,
-      new ReactiveScopeDependencyTree(),
-      'f'
-    );
-    fn();
-    const result = __classPrivateFieldGet(
-      this,
-      _Context_depsInCurrentConditional,
-      'f'
-    );
-    __classPrivateFieldSet(
-      this,
-      _Context_inConditionalWithinScope,
-      prevInConditional,
-      'f'
-    );
-    __classPrivateFieldSet(
-      this,
-      _Context_depsInCurrentConditional,
-      prevUncondAccessed,
-      'f'
-    );
-    return result;
-  }
-  promoteDepsFromExhaustiveConditionals(depsInConditionals) {
-    __classPrivateFieldGet(
-      this,
-      _Context_dependencies$1,
-      'f'
-    ).promoteDepsFromExhaustiveConditionals(depsInConditionals);
-    __classPrivateFieldGet(
-      this,
-      _Context_depsInCurrentConditional,
-      'f'
-    ).promoteDepsFromExhaustiveConditionals(depsInConditionals);
-  }
-  declare(identifier, decl) {
-    if (
-      !__classPrivateFieldGet(this, _Context_declarations$1, 'f').has(
-        identifier.declarationId
-      )
-    ) {
-      __classPrivateFieldGet(this, _Context_declarations$1, 'f').set(
-        identifier.declarationId,
-        decl
-      );
-    }
-    __classPrivateFieldGet(this, _Context_reassignments$1, 'f').set(
-      identifier,
-      decl
-    );
-  }
-  declareTemporary(lvalue, place) {
-    __classPrivateFieldGet(this, _Context_temporaries$1, 'f').set(
-      lvalue.identifier,
-      place
-    );
-  }
-  resolveTemporary(place) {
-    var _a;
-    return (_a = __classPrivateFieldGet(this, _Context_temporaries$1, 'f').get(
-      place.identifier
-    )) !== null && _a !== void 0
-      ? _a
-      : place;
-  }
-  declareProperty(lvalue, object, property, optional) {
-    const nextDependency = __classPrivateFieldGet(
-      this,
-      _Context_instances$1,
-      'm',
-      _Context_getProperty
-    ).call(this, object, property, optional);
-    __classPrivateFieldGet(this, _Context_properties, 'f').set(
-      lvalue.identifier,
-      nextDependency
-    );
-  }
-  get currentScope() {
-    return __classPrivateFieldGet(this, _Context_scopes$1, 'f');
-  }
-  get isPoisoned() {
-    return this.poisonState.isPoisoned;
-  }
-  visitOperand(place) {
-    const resolved = this.resolveTemporary(place);
-    let dependency = {identifier: resolved.identifier, path: []};
-    if (resolved.identifier.name === null) {
-      const propertyDependency = __classPrivateFieldGet(
-        this,
-        _Context_properties,
-        'f'
-      ).get(resolved.identifier);
-      if (propertyDependency !== undefined) {
-        dependency = Object.assign({}, propertyDependency);
-      }
-    }
-    this.visitDependency(dependency);
-  }
-  visitProperty(object, property, optional) {
-    const nextDependency = __classPrivateFieldGet(
-      this,
-      _Context_instances$1,
-      'm',
-      _Context_getProperty
-    ).call(this, object, property, optional);
-    this.visitDependency(nextDependency);
-  }
-  visitDependency(maybeDependency) {
-    const originalDeclaration = __classPrivateFieldGet(
-      this,
-      _Context_declarations$1,
-      'f'
-    ).get(maybeDependency.identifier.declarationId);
-    if (
-      originalDeclaration !== undefined &&
-      originalDeclaration.scope.value !== null
-    ) {
-      originalDeclaration.scope.each(scope => {
-        if (
-          !__classPrivateFieldGet(
-            this,
-            _Context_instances$1,
-            'm',
-            _Context_isScopeActive$1
-          ).call(this, scope.value) &&
-          !Iterable_some(
-            scope.value.declarations.values(),
-            decl =>
-              decl.identifier.declarationId ===
-              maybeDependency.identifier.declarationId
-          )
-        ) {
-          scope.value.declarations.set(maybeDependency.identifier.id, {
-            identifier: maybeDependency.identifier,
-            scope: originalDeclaration.scope.value.value,
-          });
-        }
-      });
-    }
-    if (
-      __classPrivateFieldGet(
-        this,
-        _Context_instances$1,
-        'm',
-        _Context_checkValidDependency$1
-      ).call(this, maybeDependency)
-    ) {
-      const isPoisoned = this.isPoisoned;
-      __classPrivateFieldGet(this, _Context_depsInCurrentConditional, 'f').add(
-        maybeDependency,
-        isPoisoned
-      );
-      __classPrivateFieldGet(this, _Context_dependencies$1, 'f').add(
-        maybeDependency,
-        __classPrivateFieldGet(this, _Context_inConditionalWithinScope, 'f') ||
-          isPoisoned
-      );
-    }
-  }
-  visitReassignment(place) {
-    var _a;
-    const currentScope =
-      (_a = this.currentScope.value) === null || _a === void 0
-        ? void 0
-        : _a.value;
-    if (
-      currentScope != null &&
-      !Iterable_some(
-        currentScope.reassignments,
-        identifier =>
-          identifier.declarationId === place.identifier.declarationId
-      ) &&
-      __classPrivateFieldGet(
-        this,
-        _Context_instances$1,
-        'm',
-        _Context_checkValidDependency$1
-      ).call(this, {identifier: place.identifier, path: []})
-    ) {
-      currentScope.reassignments.add(place.identifier);
-    }
-  }
-  pushLabeledBlock(id) {
-    const currentScope = __classPrivateFieldGet(
-      this,
-      _Context_scopes$1,
-      'f'
-    ).value;
-    if (currentScope != null) {
-      currentScope.ownBlocks = currentScope.ownBlocks.push(id);
-    }
-  }
-  popLabeledBlock(id) {
-    const currentScope = __classPrivateFieldGet(
-      this,
-      _Context_scopes$1,
-      'f'
-    ).value;
-    if (currentScope != null) {
-      const last = currentScope.ownBlocks.value;
-      currentScope.ownBlocks = currentScope.ownBlocks.pop();
-      CompilerError.invariant(last != null && last === id, {
-        reason: '[PropagateScopeDependencies] Misformed block stack',
-        loc: GeneratedSource,
-      });
-    }
-    this.poisonState.removeMaybePoisonedBlock(id, currentScope);
-  }
-};
-(_Context_temporariesUsedOutsideScope$1 = new WeakMap()),
-  (_Context_declarations$1 = new WeakMap()),
-  (_Context_reassignments$1 = new WeakMap()),
-  (_Context_dependencies$1 = new WeakMap()),
-  (_Context_properties = new WeakMap()),
-  (_Context_temporaries$1 = new WeakMap()),
-  (_Context_inConditionalWithinScope = new WeakMap()),
-  (_Context_depsInCurrentConditional = new WeakMap()),
-  (_Context_scopes$1 = new WeakMap()),
-  (_Context_instances$1 = new WeakSet()),
-  (_Context_getProperty = function _Context_getProperty(
-    object,
-    property,
-    optional
-  ) {
-    const resolvedObject = this.resolveTemporary(object);
-    const resolvedDependency = __classPrivateFieldGet(
-      this,
-      _Context_properties,
-      'f'
-    ).get(resolvedObject.identifier);
-    let objectDependency;
-    if (resolvedDependency === undefined) {
-      objectDependency = {identifier: resolvedObject.identifier, path: []};
-    } else {
-      objectDependency = {
-        identifier: resolvedDependency.identifier,
-        path: [...resolvedDependency.path],
-      };
-    }
-    objectDependency.path.push({property: property, optional: optional});
-    return objectDependency;
-  }),
-  (_Context_checkValidDependency$1 = function _Context_checkValidDependency(
-    maybeDependency
-  ) {
-    var _a, _b, _c, _d;
-    if (
-      isUseRefType(maybeDependency.identifier) &&
-      ((_a = maybeDependency.path.at(0)) === null || _a === void 0
-        ? void 0
-        : _a.property) === 'current'
-    ) {
-      return false;
-    }
-    if (isRefValueType(maybeDependency.identifier)) {
-      return false;
-    }
-    if (isObjectMethodType(maybeDependency.identifier)) {
-      return false;
-    }
-    const identifier = maybeDependency.identifier;
-    const currentDeclaration =
-      (_b = __classPrivateFieldGet(this, _Context_reassignments$1, 'f').get(
-        identifier
-      )) !== null && _b !== void 0
-        ? _b
-        : __classPrivateFieldGet(this, _Context_declarations$1, 'f').get(
-            identifier.declarationId
-          );
-    const currentScope =
-      (_c = this.currentScope.value) === null || _c === void 0
-        ? void 0
-        : _c.value;
-    return (
-      currentScope != null &&
-      currentDeclaration !== undefined &&
-      currentDeclaration.id < currentScope.range.start &&
-      (currentDeclaration.scope == null ||
-        ((_d = currentDeclaration.scope.value) === null || _d === void 0
-          ? void 0
-          : _d.value) !== currentScope)
-    );
-  }),
-  (_Context_isScopeActive$1 = function _Context_isScopeActive(scope) {
-    if (__classPrivateFieldGet(this, _Context_scopes$1, 'f') === null) {
-      return false;
-    }
-    return __classPrivateFieldGet(this, _Context_scopes$1, 'f').find(
-      state => state.value === scope
-    );
-  });
-class PropagationVisitor extends ReactiveFunctionVisitor {
-  constructor(env) {
-    super();
-    this.env = env;
-  }
-  visitScope(scope, context) {
-    const scopeDependencies = context.enter(scope.scope, () => {
-      this.visitBlock(scope.instructions, context);
-    });
-    for (const candidateDep of scopeDependencies) {
-      if (
-        !Iterable_some(
-          scope.scope.dependencies,
-          existingDep =>
-            existingDep.identifier.declarationId ===
-              candidateDep.identifier.declarationId &&
-            areEqualPaths(existingDep.path, candidateDep.path)
-        )
-      ) {
-        scope.scope.dependencies.add(candidateDep);
-      }
-    }
-  }
-  visitPrunedScope(scopeBlock, context) {
-    context.enter(scopeBlock.scope, () => {
-      this.visitBlock(scopeBlock.instructions, context);
-    });
-  }
-  visitInstruction(instruction, context) {
-    const {id: id, value: value, lvalue: lvalue} = instruction;
-    this.visitInstructionValue(context, id, value, lvalue);
-    if (lvalue == null) {
-      return;
-    }
-    context.declare(lvalue.identifier, {id: id, scope: context.currentScope});
-  }
-  extractOptionalProperty(context, optionalValue, lvalue) {
-    const sequence = optionalValue.value;
-    CompilerError.invariant(sequence.kind === 'SequenceExpression', {
-      reason: 'Expected OptionalExpression value to be a SequenceExpression',
-      description: `Found a \`${sequence.kind}\``,
-      loc: sequence.loc,
-    });
-    if (
-      sequence.instructions.length === 1 &&
-      sequence.instructions[0].lvalue !== null &&
-      sequence.instructions[0].value.kind === 'LoadLocal' &&
-      sequence.instructions[0].value.place.identifier.name !== null &&
-      !context.isUsedOutsideDeclaringScope(sequence.instructions[0].lvalue) &&
-      sequence.value.kind === 'SequenceExpression' &&
-      sequence.value.instructions.length === 1 &&
-      sequence.value.instructions[0].value.kind === 'PropertyLoad' &&
-      sequence.value.instructions[0].value.object.identifier.id ===
-        sequence.instructions[0].lvalue.identifier.id &&
-      sequence.value.instructions[0].lvalue !== null &&
-      sequence.value.value.kind === 'LoadLocal' &&
-      sequence.value.value.place.identifier.id ===
-        sequence.value.instructions[0].lvalue.identifier.id
-    ) {
-      context.declareTemporary(
-        sequence.instructions[0].lvalue,
-        sequence.instructions[0].value.place
-      );
-      const propertyLoad = sequence.value.instructions[0].value;
-      return {
-        lvalue: lvalue,
-        object: propertyLoad.object,
-        property: propertyLoad.property,
-        optional: optionalValue.optional,
-      };
-    }
-    if (
-      sequence.instructions.length === 1 &&
-      sequence.instructions[0].lvalue !== null &&
-      sequence.instructions[0].value.kind === 'SequenceExpression' &&
-      sequence.instructions[0].value.instructions.length === 1 &&
-      sequence.instructions[0].value.instructions[0].lvalue !== null &&
-      sequence.instructions[0].value.instructions[0].value.kind ===
-        'LoadLocal' &&
-      sequence.instructions[0].value.instructions[0].value.place.identifier
-        .name !== null &&
-      !context.isUsedOutsideDeclaringScope(
-        sequence.instructions[0].value.instructions[0].lvalue
-      ) &&
-      sequence.instructions[0].value.value.kind === 'PropertyLoad' &&
-      sequence.instructions[0].value.value.object.identifier.id ===
-        sequence.instructions[0].value.instructions[0].lvalue.identifier.id &&
-      sequence.value.kind === 'SequenceExpression' &&
-      sequence.value.instructions.length === 1 &&
-      sequence.value.instructions[0].lvalue !== null &&
-      sequence.value.instructions[0].value.kind === 'PropertyLoad' &&
-      sequence.value.instructions[0].value.object.identifier.id ===
-        sequence.instructions[0].lvalue.identifier.id &&
-      sequence.value.value.kind === 'LoadLocal' &&
-      sequence.value.value.place.identifier.id ===
-        sequence.value.instructions[0].lvalue.identifier.id
-    ) {
-      context.declareTemporary(
-        sequence.instructions[0].value.instructions[0].lvalue,
-        sequence.instructions[0].value.instructions[0].value.place
-      );
-      context.declareProperty(
-        sequence.instructions[0].lvalue,
-        sequence.instructions[0].value.value.object,
-        sequence.instructions[0].value.value.property,
-        false
-      );
-      const propertyLoad = sequence.value.instructions[0].value;
-      return {
-        lvalue: lvalue,
-        object: propertyLoad.object,
-        property: propertyLoad.property,
-        optional: optionalValue.optional,
-      };
-    }
-    if (
-      sequence.instructions.length === 1 &&
-      sequence.instructions[0].value.kind === 'SequenceExpression' &&
-      sequence.instructions[0].value.instructions.length === 1 &&
-      sequence.instructions[0].value.instructions[0].lvalue !== null &&
-      sequence.instructions[0].value.instructions[0].value.kind ===
-        'OptionalExpression' &&
-      sequence.instructions[0].value.value.kind === 'LoadLocal' &&
-      sequence.instructions[0].value.value.place.identifier.id ===
-        sequence.instructions[0].value.instructions[0].lvalue.identifier.id &&
-      sequence.value.kind === 'SequenceExpression' &&
-      sequence.value.instructions.length === 1 &&
-      sequence.value.instructions[0].lvalue !== null &&
-      sequence.value.instructions[0].value.kind === 'PropertyLoad' &&
-      sequence.value.instructions[0].value.object.identifier.id ===
-        sequence.instructions[0].value.value.place.identifier.id &&
-      sequence.value.value.kind === 'LoadLocal' &&
-      sequence.value.value.place.identifier.id ===
-        sequence.value.instructions[0].lvalue.identifier.id
-    ) {
-      const {lvalue: innerLvalue, value: innerOptional} =
-        sequence.instructions[0].value.instructions[0];
-      const innerProperty = this.extractOptionalProperty(
-        context,
-        innerOptional,
-        innerLvalue
-      );
-      if (innerProperty === null) {
-        return null;
-      }
-      context.declareProperty(
-        innerProperty.lvalue,
-        innerProperty.object,
-        innerProperty.property,
-        innerProperty.optional
-      );
-      const propertyLoad = sequence.value.instructions[0].value;
-      return {
-        lvalue: lvalue,
-        object: propertyLoad.object,
-        property: propertyLoad.property,
-        optional: optionalValue.optional,
-      };
-    }
-    return null;
-  }
-  visitOptionalExpression(context, id, value, lvalue) {
-    if (
-      lvalue !== null &&
-      value.optional &&
-      this.env.config.enableOptionalDependencies
-    ) {
-      const inner = this.extractOptionalProperty(context, value, lvalue);
-      if (inner !== null) {
-        context.visitProperty(inner.object, inner.property, inner.optional);
-        return;
-      }
-    }
-    const inner = value.value;
-    CompilerError.invariant(inner.kind === 'SequenceExpression', {
-      reason: 'Expected OptionalExpression value to be a SequenceExpression',
-      description: `Found a \`${value.kind}\``,
-      loc: value.loc,
-      suggestions: null,
-    });
-    for (const instr of inner.instructions) {
-      this.visitInstruction(instr, context);
-    }
-    context.enterConditional(() => {
-      this.visitReactiveValue(context, id, inner.value, null);
-    });
-  }
-  visitReactiveValue(context, id, value, lvalue) {
-    switch (value.kind) {
-      case 'OptionalExpression': {
-        this.visitOptionalExpression(context, id, value, lvalue);
-        break;
-      }
-      case 'LogicalExpression': {
-        this.visitReactiveValue(context, id, value.left, null);
-        context.enterConditional(() => {
-          this.visitReactiveValue(context, id, value.right, null);
-        });
-        break;
-      }
-      case 'ConditionalExpression': {
-        this.visitReactiveValue(context, id, value.test, null);
-        const consequentDeps = context.enterConditional(() => {
-          this.visitReactiveValue(context, id, value.consequent, null);
-        });
-        const alternateDeps = context.enterConditional(() => {
-          this.visitReactiveValue(context, id, value.alternate, null);
-        });
-        context.promoteDepsFromExhaustiveConditionals([
-          consequentDeps,
-          alternateDeps,
-        ]);
-        break;
-      }
-      case 'SequenceExpression': {
-        for (const instr of value.instructions) {
-          this.visitInstruction(instr, context);
-        }
-        this.visitInstructionValue(context, id, value.value, null);
-        break;
-      }
-      case 'FunctionExpression': {
-        if (this.env.config.enableTreatFunctionDepsAsConditional) {
-          context.enterConditional(() => {
-            for (const operand of eachInstructionValueOperand(value)) {
-              context.visitOperand(operand);
-            }
-          });
-        } else {
-          for (const operand of eachInstructionValueOperand(value)) {
-            context.visitOperand(operand);
-          }
-        }
-        break;
-      }
-      case 'ReactiveFunctionValue': {
-        CompilerError.invariant(false, {
-          reason: `Unexpected ReactiveFunctionValue`,
-          loc: value.loc,
-          description: null,
-          suggestions: null,
-        });
-      }
-      default: {
-        for (const operand of eachInstructionValueOperand(value)) {
-          context.visitOperand(operand);
-        }
-      }
-    }
-  }
-  visitInstructionValue(context, id, value, lvalue) {
-    if (value.kind === 'LoadLocal' && lvalue !== null) {
-      if (
-        value.place.identifier.name !== null &&
-        lvalue.identifier.name === null &&
-        !context.isUsedOutsideDeclaringScope(lvalue)
-      ) {
-        context.declareTemporary(lvalue, value.place);
-      } else {
-        context.visitOperand(value.place);
-      }
-    } else if (value.kind === 'PropertyLoad') {
-      if (lvalue !== null && !context.isUsedOutsideDeclaringScope(lvalue)) {
-        context.declareProperty(lvalue, value.object, value.property, false);
-      } else {
-        context.visitProperty(value.object, value.property, false);
-      }
-    } else if (value.kind === 'StoreLocal') {
-      context.visitOperand(value.value);
-      if (value.lvalue.kind === InstructionKind.Reassign) {
-        context.visitReassignment(value.lvalue.place);
-      }
-      context.declare(value.lvalue.place.identifier, {
-        id: id,
-        scope: context.currentScope,
-      });
-    } else if (
-      value.kind === 'DeclareLocal' ||
-      value.kind === 'DeclareContext'
-    ) {
-      context.declare(value.lvalue.place.identifier, {
-        id: id,
-        scope: context.currentScope,
-      });
-    } else if (value.kind === 'Destructure') {
-      context.visitOperand(value.value);
-      for (const place of eachPatternOperand(value.lvalue.pattern)) {
-        if (value.lvalue.kind === InstructionKind.Reassign) {
-          context.visitReassignment(place);
-        }
-        context.declare(place.identifier, {
-          id: id,
-          scope: context.currentScope,
-        });
-      }
-    } else {
-      this.visitReactiveValue(context, id, value, lvalue);
-    }
-  }
-  enterTerminal(stmt, context) {
-    if (stmt.label != null) {
-      context.pushLabeledBlock(stmt.label.id);
-    }
-    const terminal = stmt.terminal;
-    switch (terminal.kind) {
-      case 'continue':
-      case 'break': {
-        context.poisonState.addPoisonTarget(
-          terminal.target,
-          context.currentScope
-        );
-        break;
-      }
-      case 'throw':
-      case 'return': {
-        context.poisonState.addPoisonTarget(null, context.currentScope);
-        break;
-      }
-    }
-  }
-  exitTerminal(stmt, context) {
-    if (stmt.label != null) {
-      context.popLabeledBlock(stmt.label.id);
-    }
-  }
-  visitTerminal(stmt, context) {
-    this.enterTerminal(stmt, context);
-    const terminal = stmt.terminal;
-    switch (terminal.kind) {
-      case 'break':
-      case 'continue': {
-        break;
-      }
-      case 'return': {
-        context.visitOperand(terminal.value);
-        break;
-      }
-      case 'throw': {
-        context.visitOperand(terminal.value);
-        break;
-      }
-      case 'for': {
-        this.visitReactiveValue(context, terminal.id, terminal.init, null);
-        this.visitReactiveValue(context, terminal.id, terminal.test, null);
-        context.enterConditional(() => {
-          this.visitBlock(terminal.loop, context);
-          if (terminal.update !== null) {
-            this.visitReactiveValue(
-              context,
-              terminal.id,
-              terminal.update,
-              null
-            );
-          }
-        });
-        break;
-      }
-      case 'for-of': {
-        this.visitReactiveValue(context, terminal.id, terminal.init, null);
-        context.enterConditional(() => {
-          this.visitBlock(terminal.loop, context);
-        });
-        break;
-      }
-      case 'for-in': {
-        this.visitReactiveValue(context, terminal.id, terminal.init, null);
-        context.enterConditional(() => {
-          this.visitBlock(terminal.loop, context);
-        });
-        break;
-      }
-      case 'do-while': {
-        this.visitBlock(terminal.loop, context);
-        context.enterConditional(() => {
-          this.visitReactiveValue(context, terminal.id, terminal.test, null);
-        });
-        break;
-      }
-      case 'while': {
-        this.visitReactiveValue(context, terminal.id, terminal.test, null);
-        context.enterConditional(() => {
-          this.visitBlock(terminal.loop, context);
-        });
-        break;
-      }
-      case 'if': {
-        context.visitOperand(terminal.test);
-        const {consequent: consequent, alternate: alternate} = terminal;
-        const prevPoisonState = context.poisonState.clone();
-        const depsInIf = context.enterConditional(() => {
-          this.visitBlock(consequent, context);
-        });
-        if (alternate !== null) {
-          const ifPoisonState = context.poisonState.take(prevPoisonState);
-          const depsInElse = context.enterConditional(() => {
-            this.visitBlock(alternate, context);
-          });
-          context.poisonState.merge(
-            [ifPoisonState],
-            context.currentScope.value
-          );
-          context.promoteDepsFromExhaustiveConditionals([depsInIf, depsInElse]);
-        }
-        break;
-      }
-      case 'switch': {
-        context.visitOperand(terminal.test);
-        const isDefaultOnly =
-          terminal.cases.length === 1 && terminal.cases[0].test == null;
-        if (isDefaultOnly) {
-          const case_ = terminal.cases[0];
-          if (case_.block != null) {
-            this.visitBlock(case_.block, context);
-            break;
-          }
-        }
-        const depsInCases = [];
-        let foundDefault = false;
-        const prevPoisonState = context.poisonState.clone();
-        const mutExPoisonStates = [];
-        for (const {test: test, block: block} of terminal.cases) {
-          if (test !== null) {
-            context.visitOperand(test);
-          } else {
-            foundDefault = true;
-          }
-          if (block !== undefined) {
-            mutExPoisonStates.push(
-              context.poisonState.take(prevPoisonState.clone())
-            );
-            depsInCases.push(
-              context.enterConditional(() => {
-                this.visitBlock(block, context);
-              })
-            );
-          }
-        }
-        if (foundDefault) {
-          context.promoteDepsFromExhaustiveConditionals(depsInCases);
-        }
-        context.poisonState.merge(
-          mutExPoisonStates,
-          context.currentScope.value
-        );
-        break;
-      }
-      case 'label': {
-        this.visitBlock(terminal.block, context);
-        break;
-      }
-      case 'try': {
-        this.visitBlock(terminal.block, context);
-        this.visitBlock(terminal.handler, context);
-        break;
-      }
-      default: {
-        assertExhaustive(
-          terminal,
-          `Unexpected terminal kind \`${terminal.kind}\``
-        );
-      }
-    }
-    this.exitTerminal(stmt, context);
-  }
-}
-function pruneHoistedContexts(fn) {
-  const hoistedIdentifiers = new Map();
-  visitReactiveFunction(fn, new Visitor$8(), hoistedIdentifiers);
-}
-let Visitor$8 = class Visitor extends ReactiveFunctionTransform {
-  transformInstruction(instruction, state) {
-    this.visitInstruction(instruction, state);
-    if (
-      instruction.value.kind === 'DeclareContext' &&
-      instruction.value.lvalue.kind === 'HoistedConst'
-    ) {
-      state.set(
-        instruction.value.lvalue.place.identifier.declarationId,
-        InstructionKind.Const
-      );
-      return {kind: 'remove'};
-    }
-    if (
-      instruction.value.kind === 'DeclareContext' &&
-      instruction.value.lvalue.kind === 'HoistedLet'
-    ) {
-      state.set(
-        instruction.value.lvalue.place.identifier.declarationId,
-        InstructionKind.Let
-      );
-      return {kind: 'remove'};
-    }
-    if (
-      instruction.value.kind === 'DeclareContext' &&
-      instruction.value.lvalue.kind === 'HoistedFunction'
-    ) {
-      state.set(
-        instruction.value.lvalue.place.identifier.declarationId,
-        InstructionKind.Function
-      );
-      return {kind: 'remove'};
+    if (
+      instruction.value.kind === 'DeclareContext' &&
+      instruction.value.lvalue.kind === 'HoistedFunction'
+    ) {
+      state.set(
+        instruction.value.lvalue.place.identifier.declarationId,
+        InstructionKind.Function
+      );
+      return {kind: 'remove'};
     }
     if (
       instruction.value.kind === 'StoreContext' &&
@@ -156459,203 +155136,12 @@ function validateNoJSXInTryStatement(fn) {
     throw errors;
   }
 }
-function collectOptionalChainSidemap(fn) {
-  const context = {
-    blocks: fn.body.blocks,
-    seenOptionals: new Set(),
-    processedInstrsInOptional: new Set(),
-    temporariesReadInOptional: new Map(),
-    hoistableObjects: new Map(),
-  };
-  for (const [_, block] of fn.body.blocks) {
-    if (
-      block.terminal.kind === 'optional' &&
-      !context.seenOptionals.has(block.id)
-    ) {
-      traverseOptionalBlock(block, context, null);
-    }
-  }
-  return {
-    temporariesReadInOptional: context.temporariesReadInOptional,
-    processedInstrsInOptional: context.processedInstrsInOptional,
-    hoistableObjects: context.hoistableObjects,
-  };
-}
-function matchOptionalTestBlock(terminal, blocks) {
-  const consequentBlock = assertNonNull(blocks.get(terminal.consequent));
-  if (
-    consequentBlock.instructions.length === 2 &&
-    consequentBlock.instructions[0].value.kind === 'PropertyLoad' &&
-    consequentBlock.instructions[1].value.kind === 'StoreLocal'
-  ) {
-    const propertyLoad = consequentBlock.instructions[0];
-    const storeLocal = consequentBlock.instructions[1].value;
-    const storeLocalInstrId = consequentBlock.instructions[1].id;
-    CompilerError.invariant(
-      propertyLoad.value.object.identifier.id === terminal.test.identifier.id,
-      {
-        reason:
-          '[OptionalChainDeps] Inconsistent optional chaining property load',
-        description: `Test=${printIdentifier(terminal.test.identifier)} PropertyLoad base=${printIdentifier(propertyLoad.value.object.identifier)}`,
-        loc: propertyLoad.loc,
-      }
-    );
-    CompilerError.invariant(
-      storeLocal.value.identifier.id === propertyLoad.lvalue.identifier.id,
-      {
-        reason: '[OptionalChainDeps] Unexpected storeLocal',
-        loc: propertyLoad.loc,
-      }
-    );
-    if (
-      consequentBlock.terminal.kind !== 'goto' ||
-      consequentBlock.terminal.variant !== GotoVariant.Break
-    ) {
-      return null;
-    }
-    const alternate = assertNonNull(blocks.get(terminal.alternate));
-    CompilerError.invariant(
-      alternate.instructions.length === 2 &&
-        alternate.instructions[0].value.kind === 'Primitive' &&
-        alternate.instructions[1].value.kind === 'StoreLocal',
-      {reason: 'Unexpected alternate structure', loc: terminal.loc}
-    );
-    return {
-      consequentId: storeLocal.lvalue.place.identifier.id,
-      property: propertyLoad.value.property,
-      propertyId: propertyLoad.lvalue.identifier.id,
-      storeLocalInstrId: storeLocalInstrId,
-      consequentGoto: consequentBlock.terminal.block,
-    };
-  }
-  return null;
-}
-function traverseOptionalBlock(optional, context, outerAlternate) {
-  context.seenOptionals.add(optional.id);
-  const maybeTest = context.blocks.get(optional.terminal.test);
-  let test;
-  let baseObject;
-  if (maybeTest.terminal.kind === 'branch') {
-    CompilerError.invariant(optional.terminal.optional, {
-      reason: '[OptionalChainDeps] Expect base case to be always optional',
-      loc: optional.terminal.loc,
-    });
-    if (
-      maybeTest.instructions.length === 0 ||
-      maybeTest.instructions[0].value.kind !== 'LoadLocal'
-    ) {
-      return null;
-    }
-    const path = [];
-    for (let i = 1; i < maybeTest.instructions.length; i++) {
-      const instrVal = maybeTest.instructions[i].value;
-      const prevInstr = maybeTest.instructions[i - 1];
-      if (
-        instrVal.kind === 'PropertyLoad' &&
-        instrVal.object.identifier.id === prevInstr.lvalue.identifier.id
-      ) {
-        path.push({property: instrVal.property, optional: false});
-      } else {
-        return null;
-      }
-    }
-    CompilerError.invariant(
-      maybeTest.terminal.test.identifier.id ===
-        maybeTest.instructions.at(-1).lvalue.identifier.id,
-      {
-        reason: '[OptionalChainDeps] Unexpected test expression',
-        loc: maybeTest.terminal.loc,
-      }
-    );
-    baseObject = {
-      identifier: maybeTest.instructions[0].value.place.identifier,
-      path: path,
-    };
-    test = maybeTest.terminal;
-  } else if (maybeTest.terminal.kind === 'optional') {
-    const testBlock = context.blocks.get(maybeTest.terminal.fallthrough);
-    if (testBlock.terminal.kind !== 'branch') {
-      CompilerError.throwTodo({
-        reason: `Unexpected terminal kind \`${testBlock.terminal.kind}\` for optional fallthrough block`,
-        loc: maybeTest.terminal.loc,
-      });
-    }
-    const innerOptional = traverseOptionalBlock(
-      maybeTest,
-      context,
-      testBlock.terminal.alternate
-    );
-    if (innerOptional == null) {
-      return null;
-    }
-    if (testBlock.terminal.test.identifier.id !== innerOptional) {
-      return null;
-    }
-    if (!optional.terminal.optional) {
-      context.hoistableObjects.set(
-        optional.id,
-        assertNonNull(context.temporariesReadInOptional.get(innerOptional))
-      );
-    }
-    baseObject = assertNonNull(
-      context.temporariesReadInOptional.get(innerOptional)
-    );
-    test = testBlock.terminal;
-  } else {
-    return null;
-  }
-  if (test.alternate === outerAlternate) {
-    CompilerError.invariant(optional.instructions.length === 0, {
-      reason:
-        '[OptionalChainDeps] Unexpected instructions an inner optional block. ' +
-        'This indicates that the compiler may be incorrectly concatenating two unrelated optional chains',
-      loc: optional.terminal.loc,
-    });
-  }
-  const matchConsequentResult = matchOptionalTestBlock(test, context.blocks);
-  if (!matchConsequentResult) {
-    return null;
-  }
-  CompilerError.invariant(
-    matchConsequentResult.consequentGoto === optional.terminal.fallthrough,
-    {
-      reason: '[OptionalChainDeps] Unexpected optional goto-fallthrough',
-      description: `${matchConsequentResult.consequentGoto} != ${optional.terminal.fallthrough}`,
-      loc: optional.terminal.loc,
-    }
-  );
-  const load = {
-    identifier: baseObject.identifier,
-    path: [
-      ...baseObject.path,
-      {
-        property: matchConsequentResult.property,
-        optional: optional.terminal.optional,
-      },
-    ],
-  };
-  context.processedInstrsInOptional.add(
-    matchConsequentResult.storeLocalInstrId
-  );
-  context.processedInstrsInOptional.add(test.id);
-  context.temporariesReadInOptional.set(
-    matchConsequentResult.consequentId,
-    load
-  );
-  context.temporariesReadInOptional.set(matchConsequentResult.propertyId, load);
-  return matchConsequentResult.consequentId;
-}
 function collectHoistablePropertyLoads(
   fn,
   temporaries,
-  hoistableFromOptionals,
-  nestedFnImmutableContext
+  hoistableFromOptionals
 ) {
   const registry = new PropertyPathRegistry();
-  const functionExpressionLoads = collectFunctionExpressionFakeLoads(fn);
-  const actuallyEvaluatedTemporaries = new Map(
-    [...temporaries].filter(([id]) => !functionExpressionLoads.has(id))
-  );
   const knownImmutableIdentifiers = new Set();
   if (fn.fnType === 'Component' || fn.fnType === 'Hook') {
     for (const p of fn.params) {
@@ -156664,14 +155150,26 @@ function collectHoistablePropertyLoads(
       }
     }
   }
-  const nodes = collectNonNullsInBlocks(fn, {
-    temporaries: actuallyEvaluatedTemporaries,
+  return collectHoistablePropertyLoadsImpl(fn, {
+    temporaries: temporaries,
     knownImmutableIdentifiers: knownImmutableIdentifiers,
     hoistableFromOptionals: hoistableFromOptionals,
     registry: registry,
-    nestedFnImmutableContext: nestedFnImmutableContext,
+    nestedFnImmutableContext: null,
   });
-  propagateNonNull(fn, nodes, registry);
+}
+function collectHoistablePropertyLoadsImpl(fn, context) {
+  const functionExpressionLoads = collectFunctionExpressionFakeLoads(fn);
+  const actuallyEvaluatedTemporaries = new Map(
+    [...context.temporaries].filter(([id]) => !functionExpressionLoads.has(id))
+  );
+  const nodes = collectNonNullsInBlocks(
+    fn,
+    Object.assign(Object.assign({}, context), {
+      temporaries: actuallyEvaluatedTemporaries,
+    })
+  );
+  propagateNonNull(fn, nodes, context.registry);
   return nodes;
 }
 function keyByScopeId(fn, source) {
@@ -156808,28 +155306,25 @@ function collectNonNullsInBlocks(fn, context) {
         assumedNonNullObjects.add(maybeNonNull);
       }
       if (
-        instr.value.kind === 'FunctionExpression' &&
+        (instr.value.kind === 'FunctionExpression' ||
+          instr.value.kind === 'ObjectMethod') &&
         !fn.env.config.enableTreatFunctionDepsAsConditional
       ) {
         const innerFn = instr.value.loweredFunc;
-        const innerTemporaries = collectTemporariesSidemap(
-          innerFn.func,
-          new Set()
-        );
-        const innerOptionals = collectOptionalChainSidemap(innerFn.func);
-        const innerHoistableMap = collectHoistablePropertyLoads(
+        const innerHoistableMap = collectHoistablePropertyLoadsImpl(
           innerFn.func,
-          innerTemporaries,
-          innerOptionals.hoistableObjects,
-          (_a = context.nestedFnImmutableContext) !== null && _a !== void 0
-            ? _a
-            : new Set(
-                innerFn.func.context
-                  .filter(place =>
-                    isImmutableAtInstr(place.identifier, instr.id, context)
-                  )
-                  .map(place => place.identifier.id)
-              )
+          Object.assign(Object.assign({}, context), {
+            nestedFnImmutableContext:
+              (_a = context.nestedFnImmutableContext) !== null && _a !== void 0
+                ? _a
+                : new Set(
+                    innerFn.func.context
+                      .filter(place =>
+                        isImmutableAtInstr(place.identifier, instr.id, context)
+                      )
+                      .map(place => place.identifier.id)
+                  ),
+          })
         );
         const innerHoistables = assertNonNull(
           innerHoistableMap.get(innerFn.func.body.entry)
@@ -156978,7 +155473,10 @@ function collectFunctionExpressionFakeLoads(fn) {
   const functionExpressionReferences = new Set();
   for (const [_, block] of fn.body.blocks) {
     for (const {lvalue: lvalue, value: value} of block.instructions) {
-      if (value.kind === 'FunctionExpression') {
+      if (
+        value.kind === 'FunctionExpression' ||
+        value.kind === 'ObjectMethod'
+      ) {
         for (const reference of value.loweredFunc.dependencies) {
           let curr = reference.identifier.id;
           while (curr != null) {
@@ -156993,6 +155491,74 @@ function collectFunctionExpressionFakeLoads(fn) {
   }
   return functionExpressionReferences;
 }
+var _Node_value, _Node_next;
+function empty() {
+  return EMPTY;
+}
+class Node {
+  constructor(value, next = EMPTY) {
+    _Node_value.set(this, void 0);
+    _Node_next.set(this, void 0);
+    __classPrivateFieldSet(this, _Node_value, value, 'f');
+    __classPrivateFieldSet(this, _Node_next, next, 'f');
+  }
+  push(value) {
+    return new Node(value, this);
+  }
+  pop() {
+    return __classPrivateFieldGet(this, _Node_next, 'f');
+  }
+  find(fn) {
+    return fn(__classPrivateFieldGet(this, _Node_value, 'f'))
+      ? true
+      : __classPrivateFieldGet(this, _Node_next, 'f').find(fn);
+  }
+  contains(value) {
+    return (
+      value === __classPrivateFieldGet(this, _Node_value, 'f') ||
+      (__classPrivateFieldGet(this, _Node_next, 'f') !== null &&
+        __classPrivateFieldGet(this, _Node_next, 'f').contains(value))
+    );
+  }
+  each(fn) {
+    fn(__classPrivateFieldGet(this, _Node_value, 'f'));
+    __classPrivateFieldGet(this, _Node_next, 'f').each(fn);
+  }
+  get value() {
+    return __classPrivateFieldGet(this, _Node_value, 'f');
+  }
+  print(fn) {
+    return (
+      fn(__classPrivateFieldGet(this, _Node_value, 'f')) +
+      __classPrivateFieldGet(this, _Node_next, 'f').print(fn)
+    );
+  }
+}
+(_Node_value = new WeakMap()), (_Node_next = new WeakMap());
+class Empty {
+  push(value) {
+    return new Node(value, this);
+  }
+  pop() {
+    return this;
+  }
+  find(_fn) {
+    return false;
+  }
+  contains(_value) {
+    return false;
+  }
+  each(_fn) {
+    return;
+  }
+  get value() {
+    return null;
+  }
+  print(_) {
+    return '';
+  }
+}
+const EMPTY = new Empty();
 var _a,
   _ReactiveScopeDependencyTreeHIR_hoistableObjects,
   _ReactiveScopeDependencyTreeHIR_deps,
@@ -157152,105 +155718,307 @@ class ReactiveScopeDependencyTreeHIR {
       roots,
       defaultAccessType
     ) {
-      let rootNode = roots.get(identifier);
-      if (rootNode === undefined) {
-        rootNode = {properties: new Map(), accessType: defaultAccessType};
-        roots.set(identifier, rootNode);
+      let rootNode = roots.get(identifier);
+      if (rootNode === undefined) {
+        rootNode = {properties: new Map(), accessType: defaultAccessType};
+        roots.set(identifier, rootNode);
+      }
+      return rootNode;
+    }),
+  (_ReactiveScopeDependencyTreeHIR_debugImpl =
+    function _ReactiveScopeDependencyTreeHIR_debugImpl(buf, node, depth = 0) {
+      for (const [property, childNode] of node.properties) {
+        buf.push(
+          `${'  '.repeat(depth)}.${property} (${childNode.accessType}):`
+        );
+        __classPrivateFieldGet(
+          this,
+          _a,
+          'm',
+          _ReactiveScopeDependencyTreeHIR_debugImpl
+        ).call(this, buf, childNode, depth + 1);
+      }
+    });
+var PropertyAccessType;
+(function (PropertyAccessType) {
+  PropertyAccessType['OptionalAccess'] = 'OptionalAccess';
+  PropertyAccessType['UnconditionalAccess'] = 'UnconditionalAccess';
+  PropertyAccessType['OptionalDependency'] = 'OptionalDependency';
+  PropertyAccessType['UnconditionalDependency'] = 'UnconditionalDependency';
+})(PropertyAccessType || (PropertyAccessType = {}));
+function isOptional(access) {
+  return (
+    access === PropertyAccessType.OptionalAccess ||
+    access === PropertyAccessType.OptionalDependency
+  );
+}
+function isDependency(access) {
+  return (
+    access === PropertyAccessType.OptionalDependency ||
+    access === PropertyAccessType.UnconditionalDependency
+  );
+}
+function merge(access1, access2) {
+  const resultIsUnconditional = !(isOptional(access1) && isOptional(access2));
+  const resultIsDependency = isDependency(access1) || isDependency(access2);
+  if (resultIsUnconditional) {
+    if (resultIsDependency) {
+      return PropertyAccessType.UnconditionalDependency;
+    } else {
+      return PropertyAccessType.UnconditionalAccess;
+    }
+  } else {
+    if (resultIsDependency) {
+      return PropertyAccessType.OptionalDependency;
+    } else {
+      return PropertyAccessType.OptionalAccess;
+    }
+  }
+}
+function collectMinimalDependenciesInSubtree(
+  node,
+  rootIdentifier,
+  path,
+  results
+) {
+  if (isDependency(node.accessType)) {
+    results.add({identifier: rootIdentifier, path: path});
+  } else {
+    for (const [childName, childNode] of node.properties) {
+      collectMinimalDependenciesInSubtree(
+        childNode,
+        rootIdentifier,
+        [
+          ...path,
+          {property: childName, optional: isOptional(childNode.accessType)},
+        ],
+        results
+      );
+    }
+  }
+}
+function printSubtree(node, includeAccesses) {
+  const results = [];
+  for (const [propertyName, propertyNode] of node.properties) {
+    if (includeAccesses || isDependency(propertyNode.accessType)) {
+      results.push(`${propertyName} (${propertyNode.accessType})`);
+    }
+    const propertyResults = printSubtree(propertyNode, includeAccesses);
+    results.push(...propertyResults.map(result => `${propertyName}.${result}`));
+  }
+  return results;
+}
+function makeOrMergeProperty(node, property, accessType) {
+  let child = node.properties.get(property);
+  if (child == null) {
+    child = {properties: new Map(), accessType: accessType};
+    node.properties.set(property, child);
+  } else {
+    child.accessType = merge(child.accessType, accessType);
+  }
+  return child;
+}
+function collectOptionalChainSidemap(fn) {
+  const context = {
+    currFn: fn,
+    blocks: fn.body.blocks,
+    seenOptionals: new Set(),
+    processedInstrsInOptional: new Set(),
+    temporariesReadInOptional: new Map(),
+    hoistableObjects: new Map(),
+  };
+  traverseFunction(fn, context);
+  return {
+    temporariesReadInOptional: context.temporariesReadInOptional,
+    processedInstrsInOptional: context.processedInstrsInOptional,
+    hoistableObjects: context.hoistableObjects,
+  };
+}
+function traverseFunction(fn, context) {
+  for (const [_, block] of fn.body.blocks) {
+    for (const instr of block.instructions) {
+      if (
+        instr.value.kind === 'FunctionExpression' ||
+        instr.value.kind === 'ObjectMethod'
+      ) {
+        traverseFunction(
+          instr.value.loweredFunc.func,
+          Object.assign(Object.assign({}, context), {
+            currFn: instr.value.loweredFunc.func,
+            blocks: instr.value.loweredFunc.func.body.blocks,
+          })
+        );
+      }
+    }
+    if (
+      block.terminal.kind === 'optional' &&
+      !context.seenOptionals.has(block.id)
+    ) {
+      traverseOptionalBlock(block, context, null);
+    }
+  }
+}
+function matchOptionalTestBlock(terminal, blocks) {
+  const consequentBlock = assertNonNull(blocks.get(terminal.consequent));
+  if (
+    consequentBlock.instructions.length === 2 &&
+    consequentBlock.instructions[0].value.kind === 'PropertyLoad' &&
+    consequentBlock.instructions[1].value.kind === 'StoreLocal'
+  ) {
+    const propertyLoad = consequentBlock.instructions[0];
+    const storeLocal = consequentBlock.instructions[1].value;
+    const storeLocalInstr = consequentBlock.instructions[1];
+    CompilerError.invariant(
+      propertyLoad.value.object.identifier.id === terminal.test.identifier.id,
+      {
+        reason:
+          '[OptionalChainDeps] Inconsistent optional chaining property load',
+        description: `Test=${printIdentifier(terminal.test.identifier)} PropertyLoad base=${printIdentifier(propertyLoad.value.object.identifier)}`,
+        loc: propertyLoad.loc,
+      }
+    );
+    CompilerError.invariant(
+      storeLocal.value.identifier.id === propertyLoad.lvalue.identifier.id,
+      {
+        reason: '[OptionalChainDeps] Unexpected storeLocal',
+        loc: propertyLoad.loc,
+      }
+    );
+    if (
+      consequentBlock.terminal.kind !== 'goto' ||
+      consequentBlock.terminal.variant !== GotoVariant.Break
+    ) {
+      return null;
+    }
+    const alternate = assertNonNull(blocks.get(terminal.alternate));
+    CompilerError.invariant(
+      alternate.instructions.length === 2 &&
+        alternate.instructions[0].value.kind === 'Primitive' &&
+        alternate.instructions[1].value.kind === 'StoreLocal',
+      {reason: 'Unexpected alternate structure', loc: terminal.loc}
+    );
+    return {
+      consequentId: storeLocal.lvalue.place.identifier.id,
+      property: propertyLoad.value.property,
+      propertyId: propertyLoad.lvalue.identifier.id,
+      storeLocalInstr: storeLocalInstr,
+      consequentGoto: consequentBlock.terminal.block,
+    };
+  }
+  return null;
+}
+function traverseOptionalBlock(optional, context, outerAlternate) {
+  context.seenOptionals.add(optional.id);
+  const maybeTest = context.blocks.get(optional.terminal.test);
+  let test;
+  let baseObject;
+  if (maybeTest.terminal.kind === 'branch') {
+    CompilerError.invariant(optional.terminal.optional, {
+      reason: '[OptionalChainDeps] Expect base case to be always optional',
+      loc: optional.terminal.loc,
+    });
+    if (
+      maybeTest.instructions.length === 0 ||
+      maybeTest.instructions[0].value.kind !== 'LoadLocal'
+    ) {
+      return null;
+    }
+    const path = [];
+    for (let i = 1; i < maybeTest.instructions.length; i++) {
+      const instrVal = maybeTest.instructions[i].value;
+      const prevInstr = maybeTest.instructions[i - 1];
+      if (
+        instrVal.kind === 'PropertyLoad' &&
+        instrVal.object.identifier.id === prevInstr.lvalue.identifier.id
+      ) {
+        path.push({property: instrVal.property, optional: false});
+      } else {
+        return null;
       }
-      return rootNode;
-    }),
-  (_ReactiveScopeDependencyTreeHIR_debugImpl =
-    function _ReactiveScopeDependencyTreeHIR_debugImpl(buf, node, depth = 0) {
-      for (const [property, childNode] of node.properties) {
-        buf.push(
-          `${'  '.repeat(depth)}.${property} (${childNode.accessType}):`
-        );
-        __classPrivateFieldGet(
-          this,
-          _a,
-          'm',
-          _ReactiveScopeDependencyTreeHIR_debugImpl
-        ).call(this, buf, childNode, depth + 1);
+    }
+    CompilerError.invariant(
+      maybeTest.terminal.test.identifier.id ===
+        maybeTest.instructions.at(-1).lvalue.identifier.id,
+      {
+        reason: '[OptionalChainDeps] Unexpected test expression',
+        loc: maybeTest.terminal.loc,
       }
-    });
-var PropertyAccessType;
-(function (PropertyAccessType) {
-  PropertyAccessType['OptionalAccess'] = 'OptionalAccess';
-  PropertyAccessType['UnconditionalAccess'] = 'UnconditionalAccess';
-  PropertyAccessType['OptionalDependency'] = 'OptionalDependency';
-  PropertyAccessType['UnconditionalDependency'] = 'UnconditionalDependency';
-})(PropertyAccessType || (PropertyAccessType = {}));
-function isOptional(access) {
-  return (
-    access === PropertyAccessType.OptionalAccess ||
-    access === PropertyAccessType.OptionalDependency
-  );
-}
-function isDependency(access) {
-  return (
-    access === PropertyAccessType.OptionalDependency ||
-    access === PropertyAccessType.UnconditionalDependency
-  );
-}
-function merge(access1, access2) {
-  const resultIsUnconditional = !(isOptional(access1) && isOptional(access2));
-  const resultIsDependency = isDependency(access1) || isDependency(access2);
-  if (resultIsUnconditional) {
-    if (resultIsDependency) {
-      return PropertyAccessType.UnconditionalDependency;
-    } else {
-      return PropertyAccessType.UnconditionalAccess;
+    );
+    baseObject = {
+      identifier: maybeTest.instructions[0].value.place.identifier,
+      path: path,
+    };
+    test = maybeTest.terminal;
+  } else if (maybeTest.terminal.kind === 'optional') {
+    const testBlock = context.blocks.get(maybeTest.terminal.fallthrough);
+    if (testBlock.terminal.kind !== 'branch') {
+      CompilerError.throwTodo({
+        reason: `Unexpected terminal kind \`${testBlock.terminal.kind}\` for optional fallthrough block`,
+        loc: maybeTest.terminal.loc,
+      });
     }
-  } else {
-    if (resultIsDependency) {
-      return PropertyAccessType.OptionalDependency;
-    } else {
-      return PropertyAccessType.OptionalAccess;
+    const innerOptional = traverseOptionalBlock(
+      maybeTest,
+      context,
+      testBlock.terminal.alternate
+    );
+    if (innerOptional == null) {
+      return null;
     }
-  }
-}
-function collectMinimalDependenciesInSubtree(
-  node,
-  rootIdentifier,
-  path,
-  results
-) {
-  if (isDependency(node.accessType)) {
-    results.add({identifier: rootIdentifier, path: path});
-  } else {
-    for (const [childName, childNode] of node.properties) {
-      collectMinimalDependenciesInSubtree(
-        childNode,
-        rootIdentifier,
-        [
-          ...path,
-          {property: childName, optional: isOptional(childNode.accessType)},
-        ],
-        results
+    if (testBlock.terminal.test.identifier.id !== innerOptional) {
+      return null;
+    }
+    if (!optional.terminal.optional) {
+      context.hoistableObjects.set(
+        optional.id,
+        assertNonNull(context.temporariesReadInOptional.get(innerOptional))
       );
     }
+    baseObject = assertNonNull(
+      context.temporariesReadInOptional.get(innerOptional)
+    );
+    test = testBlock.terminal;
+  } else {
+    return null;
   }
-}
-function printSubtree(node, includeAccesses) {
-  const results = [];
-  for (const [propertyName, propertyNode] of node.properties) {
-    if (includeAccesses || isDependency(propertyNode.accessType)) {
-      results.push(`${propertyName} (${propertyNode.accessType})`);
-    }
-    const propertyResults = printSubtree(propertyNode, includeAccesses);
-    results.push(...propertyResults.map(result => `${propertyName}.${result}`));
+  if (test.alternate === outerAlternate) {
+    CompilerError.invariant(optional.instructions.length === 0, {
+      reason:
+        '[OptionalChainDeps] Unexpected instructions an inner optional block. ' +
+        'This indicates that the compiler may be incorrectly concatenating two unrelated optional chains',
+      loc: optional.terminal.loc,
+    });
   }
-  return results;
-}
-function makeOrMergeProperty(node, property, accessType) {
-  let child = node.properties.get(property);
-  if (child == null) {
-    child = {properties: new Map(), accessType: accessType};
-    node.properties.set(property, child);
-  } else {
-    child.accessType = merge(child.accessType, accessType);
+  const matchConsequentResult = matchOptionalTestBlock(test, context.blocks);
+  if (!matchConsequentResult) {
+    return null;
   }
-  return child;
+  CompilerError.invariant(
+    matchConsequentResult.consequentGoto === optional.terminal.fallthrough,
+    {
+      reason: '[OptionalChainDeps] Unexpected optional goto-fallthrough',
+      description: `${matchConsequentResult.consequentGoto} != ${optional.terminal.fallthrough}`,
+      loc: optional.terminal.loc,
+    }
+  );
+  const load = {
+    identifier: baseObject.identifier,
+    path: [
+      ...baseObject.path,
+      {
+        property: matchConsequentResult.property,
+        optional: optional.terminal.optional,
+      },
+    ],
+  };
+  context.processedInstrsInOptional.add(matchConsequentResult.storeLocalInstr);
+  context.processedInstrsInOptional.add(test);
+  context.temporariesReadInOptional.set(
+    matchConsequentResult.consequentId,
+    load
+  );
+  context.temporariesReadInOptional.set(matchConsequentResult.propertyId, load);
+  return matchConsequentResult.consequentId;
 }
 var _Context_instances,
   _Context_declarations,
@@ -157272,7 +156040,7 @@ function propagateScopeDependenciesHIR(fn) {
   } = collectOptionalChainSidemap(fn);
   const hoistablePropertyLoads = keyByScopeId(
     fn,
-    collectHoistablePropertyLoads(fn, temporaries, hoistableObjects, null)
+    collectHoistablePropertyLoads(fn, temporaries, hoistableObjects)
   );
   const scopeDeps = collectDependencies(
     fn,
@@ -157364,6 +156132,20 @@ function findTemporariesUsedOutsideDeclaringScope(fn) {
 }
 function collectTemporariesSidemap(fn, usedOutsideDeclaringScope) {
   const temporaries = new Map();
+  collectTemporariesSidemapImpl(
+    fn,
+    usedOutsideDeclaringScope,
+    temporaries,
+    false
+  );
+  return temporaries;
+}
+function collectTemporariesSidemapImpl(
+  fn,
+  usedOutsideDeclaringScope,
+  temporaries,
+  isInnerFn
+) {
   for (const [_, block] of fn.body.blocks) {
     for (const instr of block.instructions) {
       const {value: value, lvalue: lvalue} = instr;
@@ -157371,27 +156153,45 @@ function collectTemporariesSidemap(fn, usedOutsideDeclaringScope) {
         lvalue.identifier.declarationId
       );
       if (value.kind === 'PropertyLoad' && !usedOutside) {
-        const property = getProperty(
-          value.object,
-          value.property,
-          false,
-          temporaries
-        );
-        temporaries.set(lvalue.identifier.id, property);
+        if (!isInnerFn || temporaries.has(value.object.identifier.id)) {
+          const property = getProperty(
+            value.object,
+            value.property,
+            false,
+            temporaries
+          );
+          temporaries.set(lvalue.identifier.id, property);
+        }
       } else if (
         value.kind === 'LoadLocal' &&
         lvalue.identifier.name == null &&
         value.place.identifier.name !== null &&
         !usedOutside
       ) {
-        temporaries.set(lvalue.identifier.id, {
-          identifier: value.place.identifier,
-          path: [],
-        });
+        if (
+          !isInnerFn ||
+          fn.context.some(
+            context => context.identifier.id === value.place.identifier.id
+          )
+        ) {
+          temporaries.set(lvalue.identifier.id, {
+            identifier: value.place.identifier,
+            path: [],
+          });
+        }
+      } else if (
+        value.kind === 'FunctionExpression' ||
+        value.kind === 'ObjectMethod'
+      ) {
+        collectTemporariesSidemapImpl(
+          value.loweredFunc.func,
+          usedOutsideDeclaringScope,
+          temporaries,
+          true
+        );
       }
     }
   }
-  return temporaries;
 }
 function getProperty(object, propertyName, optional, temporaries) {
   const resolvedDependency = temporaries.get(object.identifier.id);
@@ -157422,6 +156222,7 @@ class Context {
     this.deps = new Map();
     _Context_temporaries.set(this, void 0);
     _Context_temporariesUsedOutsideScope.set(this, void 0);
+    this.inInnerFn = false;
     __classPrivateFieldSet(
       this,
       _Context_temporariesUsedOutsideScope,
@@ -157497,6 +156298,7 @@ class Context {
     ).has(place.identifier.declarationId);
   }
   declare(identifier, decl) {
+    if (this.inInnerFn) return;
     if (
       !__classPrivateFieldGet(this, _Context_declarations, 'f').has(
         identifier.declarationId
@@ -157742,11 +156544,11 @@ function collectDependencies(
       }
     }
     for (const instr of block.instructions) {
-      if (!processedInstrsInOptional.has(instr.id)) {
+      if (!processedInstrsInOptional.has(instr)) {
         handleInstruction(instr, context);
       }
     }
-    if (!processedInstrsInOptional.has(block.terminal.id)) {
+    if (!processedInstrsInOptional.has(block.terminal)) {
       for (const place of eachTerminalOperand(block.terminal)) {
         context.visitOperand(place);
       }
@@ -157884,6 +156686,15 @@ function process$1(fn, jsx, globals) {
   return {instrs: newInstrs, fn: outlinedFn};
 }
 function collectProps(instructions) {
+  let id = 1;
+  function generateName(oldName) {
+    let newName = oldName;
+    while (seen.has(newName)) {
+      newName = `${oldName}${id++}`;
+    }
+    seen.add(newName);
+    return newName;
+  }
   const attributes = [];
   const jsxIds = new Set(instructions.map(i => i.lvalue.identifier.id));
   const seen = new Set();
@@ -157893,24 +156704,38 @@ function collectProps(instructions) {
       if (at.kind === 'JsxSpreadAttribute') {
         return null;
       }
-      if (seen.has(at.name)) {
-        return null;
-      }
       if (at.kind === 'JsxAttribute') {
-        seen.add(at.name);
-        attributes.push(at);
+        const newName = generateName(at.name);
+        attributes.push({
+          originalName: at.name,
+          newName: newName,
+          place: at.place,
+        });
       }
     }
-    if (
-      value.children &&
-      value.children.some(child => !jsxIds.has(child.identifier.id))
-    ) {
-      return null;
+    if (value.children) {
+      for (const child of value.children) {
+        if (jsxIds.has(child.identifier.id)) {
+          continue;
+        }
+        promoteTemporary(child.identifier);
+        const newName = generateName('t');
+        attributes.push({
+          originalName: child.identifier.name.value,
+          newName: newName,
+          place: child,
+        });
+      }
     }
   }
   return attributes;
 }
-function emitOutlinedJsx(env, instructions, props, outlinedTag) {
+function emitOutlinedJsx(env, instructions, outlinedProps, outlinedTag) {
+  const props = outlinedProps.map(p => ({
+    kind: 'JsxAttribute',
+    name: p.newName,
+    place: p.place,
+  }));
   const loadJsx = {
     id: makeInstructionId(0),
     loc: GeneratedSource,
@@ -157943,9 +156768,11 @@ function emitOutlinedFn(env, jsx, oldProps, globals) {
   const oldToNewProps = createOldToNewPropsMapping(env, oldProps);
   const propsObj = createTemporaryPlace(env, GeneratedSource);
   promoteTemporary(propsObj.identifier);
-  const destructurePropsInstr = emitDestructureProps(env, propsObj, [
-    ...oldToNewProps.values(),
-  ]);
+  const destructurePropsInstr = emitDestructureProps(
+    env,
+    propsObj,
+    oldToNewProps
+  );
   instructions.push(destructurePropsInstr);
   const updatedJsxInstructions = emitUpdatedJsx(jsx, oldToNewProps);
   const loadGlobalInstrs = emitLoadGlobals(jsx, globals);
@@ -157999,6 +156826,7 @@ function emitLoadGlobals(jsx, globals) {
 }
 function emitUpdatedJsx(jsx, oldToNewProps) {
   const newInstrs = [];
+  const jsxIds = new Set(jsx.map(i => i.lvalue.identifier.id));
   for (const instr of jsx) {
     const {value: value} = instr;
     const newProps = [];
@@ -158015,13 +156843,34 @@ function emitUpdatedJsx(jsx, oldToNewProps) {
         newProp !== undefined,
         `Expected a new property for ${printIdentifier(prop.place.identifier)}`
       );
-      newProps.push(
-        Object.assign(Object.assign({}, prop), {place: newProp.place})
-      );
+      newProps.push({
+        kind: 'JsxAttribute',
+        name: newProp.originalName,
+        place: newProp.place,
+      });
+    }
+    let newChildren = null;
+    if (value.children) {
+      newChildren = [];
+      for (const child of value.children) {
+        if (jsxIds.has(child.identifier.id)) {
+          newChildren.push(Object.assign({}, child));
+          continue;
+        }
+        const newChild = oldToNewProps.get(child.identifier.id);
+        invariant$1(
+          newChild !== undefined,
+          `Expected a new prop for ${printIdentifier(child.identifier)}`
+        );
+        newChildren.push(Object.assign({}, newChild.place));
+      }
     }
     newInstrs.push(
       Object.assign(Object.assign({}, instr), {
-        value: Object.assign(Object.assign({}, value), {props: newProps}),
+        value: Object.assign(Object.assign({}, value), {
+          props: newProps,
+          children: newChildren,
+        }),
       })
     );
   }
@@ -158030,25 +156879,27 @@ function emitUpdatedJsx(jsx, oldToNewProps) {
 function createOldToNewPropsMapping(env, oldProps) {
   const oldToNewProps = new Map();
   for (const oldProp of oldProps) {
-    invariant$1(
-      oldProp.kind === 'JsxAttribute',
-      `Expected only attributes but found ${oldProp.kind}`
-    );
-    if (oldProp.name === 'key') {
+    if (oldProp.originalName === 'key') {
       continue;
     }
-    const newProp = {
-      kind: 'ObjectProperty',
-      key: {kind: 'string', name: oldProp.name},
-      type: 'property',
+    const newProp = Object.assign(Object.assign({}, oldProp), {
       place: createTemporaryPlace(env, GeneratedSource),
-    };
-    newProp.place.identifier.name = makeIdentifierName(oldProp.name);
+    });
+    newProp.place.identifier.name = makeIdentifierName(oldProp.newName);
     oldToNewProps.set(oldProp.place.identifier.id, newProp);
   }
   return oldToNewProps;
 }
-function emitDestructureProps(env, propsObj, properties) {
+function emitDestructureProps(env, propsObj, oldToNewProps) {
+  const properties = [];
+  for (const [_, prop] of oldToNewProps) {
+    properties.push({
+      kind: 'ObjectProperty',
+      key: {kind: 'string', name: prop.newName},
+      type: 'property',
+      place: prop.place,
+    });
+  }
   const destructurePropsInstr = {
     id: makeInstructionId(0),
     lvalue: createTemporaryPlace(env, GeneratedSource),
@@ -158219,10 +157070,8 @@ function* runWithEnvironment(func, env) {
   yield log({kind: 'hir', name: 'FlattenScopesWithHooksOrUseHIR', value: hir});
   assertTerminalSuccessorsExist(hir);
   assertTerminalPredsExist(hir);
-  if (env.config.enablePropagateDepsInHIR) {
-    propagateScopeDependenciesHIR(hir);
-    yield log({kind: 'hir', name: 'PropagateScopeDependenciesHIR', value: hir});
-  }
+  propagateScopeDependenciesHIR(hir);
+  yield log({kind: 'hir', name: 'PropagateScopeDependenciesHIR', value: hir});
   if (env.config.inlineJsxTransform) {
     inlineJsxTransform(hir, env.config.inlineJsxTransform);
     yield log({kind: 'hir', name: 'inlineJsxTransform', value: hir});
@@ -158241,14 +157090,6 @@ function* runWithEnvironment(func, env) {
     value: reactiveFunction,
   });
   assertScopeInstructionsWithinScopes(reactiveFunction);
-  if (!env.config.enablePropagateDepsInHIR) {
-    propagateScopeDependencies(reactiveFunction);
-    yield log({
-      kind: 'reactive',
-      name: 'PropagateScopeDependencies',
-      value: reactiveFunction,
-    });
-  }
   pruneNonEscapingScopes(reactiveFunction);
   yield log({
     kind: 'reactive',
@@ -159479,7 +158320,7 @@ exports.OPT_OUT_DIRECTIVES = OPT_OUT_DIRECTIVES;
 exports.compile = compileFn;
 exports.compileProgram = compileProgram;
 exports.default = BabelPluginReactCompiler;
-exports.parseConfigPragma = parseConfigPragma;
+exports.parseConfigPragmaForTests = parseConfigPragmaForTests;
 exports.parsePluginOptions = parsePluginOptions;
 exports.printHIR = printHIR;
 exports.printReactiveFunction = printReactiveFunction;