babel-plugin-react-compiler 0.0.0-experimental-fe484b5-20240911 → 0.0.0-experimental-de2cfda-20240912

package/dist/index.js

@@ -135625,6 +135625,31 @@ function getOrInsertDefault(m, key, defaultValue) {
     return defaultValue;
   }
 }
+function Set_union(a, b) {
+  const union = new Set(a);
+  for (const item of b) {
+    union.add(item);
+  }
+  return union;
+}
+function Set_intersect(sets) {
+  if (sets.length === 0 || sets.some(s => s.size === 0)) {
+    return new Set();
+  } else if (sets.length === 1) {
+    return new Set(sets[0]);
+  }
+  const result = new Set();
+  const first = sets[0];
+  outer: for (const e of first) {
+    for (let i = 1; i < sets.length; i++) {
+      if (!sets[i].has(e)) {
+        continue outer;
+      }
+    }
+    result.add(e);
+  }
+  return result;
+}
 function Iterable_some(iter, pred) {
   for (const item of iter) {
     if (pred(item)) {
@@ -140998,6 +141023,7 @@ function getFunctionName$1(instrValue, defaultValue) {
       return defaultValue;
   }
 }
+var _ScopeBlockTraversal_activeScopes;
 function* eachInstructionLValue(instr) {
   if (instr.lvalue !== null) {
     yield instr.lvalue;
@@ -142052,6 +142078,93 @@ function* eachTerminalOperand(terminal) {
     }
   }
 }
+class ScopeBlockTraversal {
+  constructor() {
+    _ScopeBlockTraversal_activeScopes.set(this, []);
+    this.blockInfos = new Map();
+  }
+  recordScopes(block) {
+    var _a, _b;
+    const blockInfo = this.blockInfos.get(block.id);
+    if (
+      (blockInfo === null || blockInfo === void 0 ? void 0 : blockInfo.kind) ===
+      'begin'
+    ) {
+      __classPrivateFieldGet(this, _ScopeBlockTraversal_activeScopes, 'f').push(
+        blockInfo.scope.id
+      );
+    } else if (
+      (blockInfo === null || blockInfo === void 0 ? void 0 : blockInfo.kind) ===
+      'end'
+    ) {
+      const top = __classPrivateFieldGet(
+        this,
+        _ScopeBlockTraversal_activeScopes,
+        'f'
+      ).at(-1);
+      CompilerError.invariant(blockInfo.scope.id === top, {
+        reason:
+          'Expected traversed block fallthrough to match top-most active scope',
+        loc:
+          (_b =
+            (_a = block.instructions[0]) === null || _a === void 0
+              ? void 0
+              : _a.loc) !== null && _b !== void 0
+            ? _b
+            : block.terminal.id,
+      });
+      __classPrivateFieldGet(
+        this,
+        _ScopeBlockTraversal_activeScopes,
+        'f'
+      ).pop();
+    }
+    if (
+      block.terminal.kind === 'scope' ||
+      block.terminal.kind === 'pruned-scope'
+    ) {
+      CompilerError.invariant(
+        !this.blockInfos.has(block.terminal.block) &&
+          !this.blockInfos.has(block.terminal.fallthrough),
+        {
+          reason: 'Expected unique scope blocks and fallthroughs',
+          loc: block.terminal.loc,
+        }
+      );
+      this.blockInfos.set(block.terminal.block, {
+        kind: 'begin',
+        scope: block.terminal.scope,
+        pruned: block.terminal.kind === 'pruned-scope',
+        fallthrough: block.terminal.fallthrough,
+      });
+      this.blockInfos.set(block.terminal.fallthrough, {
+        kind: 'end',
+        scope: block.terminal.scope,
+        pruned: block.terminal.kind === 'pruned-scope',
+      });
+    }
+  }
+  isScopeActive(scopeId) {
+    return (
+      __classPrivateFieldGet(
+        this,
+        _ScopeBlockTraversal_activeScopes,
+        'f'
+      ).indexOf(scopeId) !== -1
+    );
+  }
+  get currentScope() {
+    var _a;
+    return (_a = __classPrivateFieldGet(
+      this,
+      _ScopeBlockTraversal_activeScopes,
+      'f'
+    ).at(-1)) !== null && _a !== void 0
+      ? _a
+      : null;
+  }
+}
+_ScopeBlockTraversal_activeScopes = new WeakMap();
 function assertConsistentIdentifiers(fn) {
   const identifiers = new Map();
   const assignments = new Set();
@@ -150485,7 +150598,7 @@ const EnvironmentConfigSchema = z.object({
   enablePreserveExistingManualUseMemo: z.boolean().default(false),
   enableForest: z.boolean().default(false),
   enableUseTypeAnnotations: z.boolean().default(false),
-  enablePropagateDepsInHIR: z.boolean().default(true),
+  enablePropagateDepsInHIR: z.boolean().default(false),
   enableOptionalDependencies: z.boolean().default(true),
   validateHooksUsage: z.boolean().default(true),
   validateRefAccessDuringRender: z.boolean().default(true),
@@ -153014,8 +153127,10 @@ function mergeLocation(l, r) {
     };
   }
 }
-function isMutable({id: id}, place) {
-  const range = place.identifier.mutableRange;
+function isMutable(instr, place) {
+  return inRange(instr, place.identifier.mutableRange);
+}
+function inRange({id: id}, range) {
   return id >= range.start && id < range.end;
 }
 function mayAllocate(env, instruction) {
@@ -155630,7 +155745,7 @@ var _Context_nextScheduleId,
   _Context_catchHandlers,
   _Context_controlFlowStack;
 function buildReactiveFunction(fn) {
-  const cx = new Context$2(fn.body);
+  const cx = new Context$3(fn.body);
   const driver = new Driver(cx);
   const body = driver.traverseBlock(cx.block(fn.body.entry));
   return {
@@ -156678,7 +156793,7 @@ class Driver {
     };
   }
 }
-let Context$2 = class Context {
+let Context$3 = class Context {
   constructor(ir) {
     _Context_nextScheduleId.set(this, 0);
     this.emitted = new Set();
@@ -157058,7 +157173,7 @@ function expandFbtScopeRange(fbtRange, extendWith) {
     );
   }
 }
-var _Context_nextCacheIndex, _Context_declarations$1;
+var _Context_nextCacheIndex, _Context_declarations$2;
 const MEMO_CACHE_SENTINEL = 'react.memo_cache_sentinel';
 const EARLY_RETURN_SENTINEL = 'react.early_return_sentinel';
 function codegenFunction(
@@ -157066,7 +157181,7 @@ function codegenFunction(
   {uniqueIdentifiers: uniqueIdentifiers, fbtOperands: fbtOperands}
 ) {
   var _a, _b, _c;
-  const cx = new Context$1(
+  const cx = new Context$2(
     fn.env,
     (_a = fn.id) !== null && _a !== void 0 ? _a : '[[ anonymous ]]',
     uniqueIdentifiers,
@@ -157231,7 +157346,7 @@ function codegenFunction(
     pruneHoistedContexts(reactiveFunction);
     const identifiers = renameVariables(reactiveFunction);
     const codegen = codegenReactiveFunction(
-      new Context$1(
+      new Context$2(
         cx.env,
         (_c = reactiveFunction.id) !== null && _c !== void 0
           ? _c
@@ -157318,10 +157433,10 @@ function convertParameter(param) {
     return t__namespace.restElement(convertIdentifier(param.place.identifier));
   }
 }
-let Context$1 = class Context {
+let Context$2 = class Context {
   constructor(env, fnName, uniqueIdentifiers, fbtOperands, temporaries = null) {
     _Context_nextCacheIndex.set(this, 0);
-    _Context_declarations$1.set(this, new Set());
+    _Context_declarations$2.set(this, new Set());
     this.errors = new CompilerError();
     this.objectMethods = new Map();
     this.synthesizedNames = new Map();
@@ -157346,12 +157461,12 @@ let Context$1 = class Context {
     );
   }
   declare(identifier) {
-    __classPrivateFieldGet(this, _Context_declarations$1, 'f').add(
+    __classPrivateFieldGet(this, _Context_declarations$2, 'f').add(
       identifier.declarationId
     );
   }
   hasDeclared(identifier) {
-    return __classPrivateFieldGet(this, _Context_declarations$1, 'f').has(
+    return __classPrivateFieldGet(this, _Context_declarations$2, 'f').has(
       identifier.declarationId
     );
   }
@@ -157371,7 +157486,7 @@ let Context$1 = class Context {
   }
 };
 (_Context_nextCacheIndex = new WeakMap()),
-  (_Context_declarations$1 = new WeakMap());
+  (_Context_declarations$2 = new WeakMap());
 function codegenBlock(cx, block) {
   const temp = new Map(cx.temp);
   const result = codegenBlockNoReset(cx, block);
@@ -158648,7 +158763,7 @@ function codegenInstructionValue(cx, instrValue) {
               pruneUnusedLabels(reactiveFunction);
               pruneUnusedLValues(reactiveFunction);
               const fn = codegenReactiveFunction(
-                new Context$1(
+                new Context$2(
                   cx.env,
                   (_e = reactiveFunction.id) !== null && _e !== void 0
                     ? _e
@@ -158847,7 +158962,7 @@ function codegenInstructionValue(cx, instrValue) {
       pruneUnusedLValues(reactiveFunction);
       pruneHoistedContexts(reactiveFunction);
       const fn = codegenReactiveFunction(
-        new Context$1(
+        new Context$2(
           cx.env,
           (_g = reactiveFunction.id) !== null && _g !== void 0
             ? _g
@@ -160398,21 +160513,21 @@ class ReactiveScopeDependencyTree {
       _ReactiveScopeDependencyTree_getOrCreateRoot
     ).call(this, dep.identifier);
     for (const item of path) {
-      let currChild = getOrMakeProperty(currNode, item.property);
+      let currChild = getOrMakeProperty$1(currNode, item.property);
       const accessType = inConditional
-        ? PropertyAccessType.ConditionalAccess
+        ? PropertyAccessType$1.ConditionalAccess
         : item.optional
-          ? PropertyAccessType.OptionalAccess
-          : PropertyAccessType.UnconditionalAccess;
-      currChild.accessType = merge(currChild.accessType, accessType);
+          ? PropertyAccessType$1.OptionalAccess
+          : PropertyAccessType$1.UnconditionalAccess;
+      currChild.accessType = merge$1(currChild.accessType, accessType);
       currNode = currChild;
     }
     const depType = inConditional
-      ? PropertyAccessType.ConditionalDependency
+      ? PropertyAccessType$1.ConditionalDependency
       : isOptional(currNode.accessType)
-        ? PropertyAccessType.OptionalDependency
-        : PropertyAccessType.UnconditionalDependency;
-    currNode.accessType = merge(currNode.accessType, depType);
+        ? PropertyAccessType$1.OptionalDependency
+        : PropertyAccessType$1.UnconditionalDependency;
+    currNode.accessType = merge$1(currNode.accessType, depType);
   }
   deriveMinimalDependencies() {
     const results = new Set();
@@ -160421,12 +160536,12 @@ class ReactiveScopeDependencyTree {
       _ReactiveScopeDependencyTree_roots,
       'f'
     ).entries()) {
-      const deps = deriveMinimalDependenciesInSubtree(rootNode, null);
+      const deps = deriveMinimalDependenciesInSubtree$1(rootNode, null);
       CompilerError.invariant(
         deps.every(
           dep =>
-            dep.accessType === PropertyAccessType.UnconditionalDependency ||
-            dep.accessType == PropertyAccessType.OptionalDependency
+            dep.accessType === PropertyAccessType$1.UnconditionalDependency ||
+            dep.accessType == PropertyAccessType$1.OptionalDependency
         ),
         {
           reason:
@@ -160463,9 +160578,9 @@ class ReactiveScopeDependencyTree {
       ).call(this, id);
       addSubtree(currRoot, otherRoot, innerScopeInConditionalWithinParent);
       if (!isUnconditional(currRoot.accessType)) {
-        currRoot.accessType = isDependency(currRoot.accessType)
-          ? PropertyAccessType.UnconditionalDependency
-          : PropertyAccessType.UnconditionalAccess;
+        currRoot.accessType = isDependency$1(currRoot.accessType)
+          ? PropertyAccessType$1.UnconditionalDependency
+          : PropertyAccessType$1.UnconditionalAccess;
       }
     }
   }
@@ -160508,7 +160623,7 @@ class ReactiveScopeDependencyTree {
       _ReactiveScopeDependencyTree_roots,
       'f'
     ).entries()) {
-      const rootResults = printSubtree(rootNode, includeAccesses).map(
+      const rootResults = printSubtree$1(rootNode, includeAccesses).map(
         result => `${printIdentifier(rootId)}.${result}`
       );
       res.push(rootResults);
@@ -160546,7 +160661,7 @@ class ReactiveScopeDependencyTree {
       if (rootNode === undefined) {
         rootNode = {
           properties: new Map(),
-          accessType: PropertyAccessType.UnconditionalAccess,
+          accessType: PropertyAccessType$1.UnconditionalAccess,
         };
         __classPrivateFieldGet(
           this,
@@ -160570,7 +160685,7 @@ class ReactiveScopeDependencyTree {
         ).call(this, buf, childNode, depth + 1);
       }
     });
-var PropertyAccessType;
+var PropertyAccessType$1;
 (function (PropertyAccessType) {
   PropertyAccessType['ConditionalAccess'] = 'ConditionalAccess';
   PropertyAccessType['OptionalAccess'] = 'OptionalAccess';
@@ -160578,49 +160693,49 @@ var PropertyAccessType;
   PropertyAccessType['ConditionalDependency'] = 'ConditionalDependency';
   PropertyAccessType['OptionalDependency'] = 'OptionalDependency';
   PropertyAccessType['UnconditionalDependency'] = 'UnconditionalDependency';
-})(PropertyAccessType || (PropertyAccessType = {}));
-const MIN_ACCESS_TYPE = PropertyAccessType.ConditionalAccess;
+})(PropertyAccessType$1 || (PropertyAccessType$1 = {}));
+const MIN_ACCESS_TYPE$1 = PropertyAccessType$1.ConditionalAccess;
 function isUnconditional(access) {
   return (
-    access === PropertyAccessType.UnconditionalAccess ||
-    access === PropertyAccessType.UnconditionalDependency
+    access === PropertyAccessType$1.UnconditionalAccess ||
+    access === PropertyAccessType$1.UnconditionalDependency
   );
 }
-function isDependency(access) {
+function isDependency$1(access) {
   return (
-    access === PropertyAccessType.ConditionalDependency ||
-    access === PropertyAccessType.OptionalDependency ||
-    access === PropertyAccessType.UnconditionalDependency
+    access === PropertyAccessType$1.ConditionalDependency ||
+    access === PropertyAccessType$1.OptionalDependency ||
+    access === PropertyAccessType$1.UnconditionalDependency
   );
 }
 function isOptional(access) {
   return (
-    access === PropertyAccessType.OptionalAccess ||
-    access === PropertyAccessType.OptionalDependency
+    access === PropertyAccessType$1.OptionalAccess ||
+    access === PropertyAccessType$1.OptionalDependency
   );
 }
-function merge(access1, access2) {
+function merge$1(access1, access2) {
   const resultIsUnconditional =
     isUnconditional(access1) || isUnconditional(access2);
-  const resultIsDependency = isDependency(access1) || isDependency(access2);
+  const resultIsDependency = isDependency$1(access1) || isDependency$1(access2);
   const resultIsOptional = isOptional(access1) || isOptional(access2);
   if (resultIsUnconditional) {
     if (resultIsDependency) {
-      return PropertyAccessType.UnconditionalDependency;
+      return PropertyAccessType$1.UnconditionalDependency;
     } else {
-      return PropertyAccessType.UnconditionalAccess;
+      return PropertyAccessType$1.UnconditionalAccess;
     }
   } else if (resultIsOptional) {
     if (resultIsDependency) {
-      return PropertyAccessType.OptionalDependency;
+      return PropertyAccessType$1.OptionalDependency;
     } else {
-      return PropertyAccessType.OptionalAccess;
+      return PropertyAccessType$1.OptionalAccess;
     }
   } else {
     if (resultIsDependency) {
-      return PropertyAccessType.ConditionalDependency;
+      return PropertyAccessType$1.ConditionalDependency;
     } else {
-      return PropertyAccessType.ConditionalAccess;
+      return PropertyAccessType$1.ConditionalAccess;
     }
   }
 }
@@ -160640,28 +160755,28 @@ function prependPath(results, path) {
     relativePath: [path, ...result.relativePath],
   }));
 }
-function deriveMinimalDependenciesInSubtree(dep, property) {
+function deriveMinimalDependenciesInSubtree$1(dep, property) {
   const results = [];
   for (const [childName, childNode] of dep.properties) {
-    const childResult = deriveMinimalDependenciesInSubtree(
+    const childResult = deriveMinimalDependenciesInSubtree$1(
       childNode,
       childName
     );
     results.push(...childResult);
   }
   switch (dep.accessType) {
-    case PropertyAccessType.UnconditionalDependency: {
+    case PropertyAccessType$1.UnconditionalDependency: {
       return promoteResult(
-        PropertyAccessType.UnconditionalDependency,
+        PropertyAccessType$1.UnconditionalDependency,
         property !== null ? {property: property, optional: false} : null
       );
     }
-    case PropertyAccessType.UnconditionalAccess: {
+    case PropertyAccessType$1.UnconditionalAccess: {
       if (
         results.every(
           ({accessType: accessType}) =>
-            accessType === PropertyAccessType.UnconditionalDependency ||
-            accessType === PropertyAccessType.OptionalDependency
+            accessType === PropertyAccessType$1.UnconditionalDependency ||
+            accessType === PropertyAccessType$1.OptionalDependency
         )
       ) {
         return prependPath(
@@ -160670,23 +160785,23 @@ function deriveMinimalDependenciesInSubtree(dep, property) {
         );
       } else {
         return promoteResult(
-          PropertyAccessType.UnconditionalDependency,
+          PropertyAccessType$1.UnconditionalDependency,
           property !== null ? {property: property, optional: false} : null
         );
       }
     }
-    case PropertyAccessType.OptionalDependency: {
+    case PropertyAccessType$1.OptionalDependency: {
       return promoteResult(
-        PropertyAccessType.OptionalDependency,
+        PropertyAccessType$1.OptionalDependency,
         property !== null ? {property: property, optional: true} : null
       );
     }
-    case PropertyAccessType.OptionalAccess: {
+    case PropertyAccessType$1.OptionalAccess: {
       if (
         results.every(
           ({accessType: accessType}) =>
-            accessType === PropertyAccessType.UnconditionalDependency ||
-            accessType === PropertyAccessType.OptionalDependency
+            accessType === PropertyAccessType$1.UnconditionalDependency ||
+            accessType === PropertyAccessType$1.OptionalDependency
         )
       ) {
         return prependPath(
@@ -160695,26 +160810,26 @@ function deriveMinimalDependenciesInSubtree(dep, property) {
         );
       } else {
         return promoteResult(
-          PropertyAccessType.OptionalDependency,
+          PropertyAccessType$1.OptionalDependency,
           property !== null ? {property: property, optional: true} : null
         );
       }
     }
-    case PropertyAccessType.ConditionalAccess:
-    case PropertyAccessType.ConditionalDependency: {
+    case PropertyAccessType$1.ConditionalAccess:
+    case PropertyAccessType$1.ConditionalDependency: {
       if (
         results.every(
           ({accessType: accessType}) =>
-            accessType === PropertyAccessType.ConditionalDependency
+            accessType === PropertyAccessType$1.ConditionalDependency
         )
       ) {
         return promoteResult(
-          PropertyAccessType.ConditionalDependency,
+          PropertyAccessType$1.ConditionalDependency,
           property !== null ? {property: property, optional: true} : null
         );
       } else {
         return promoteResult(
-          PropertyAccessType.UnconditionalDependency,
+          PropertyAccessType$1.UnconditionalDependency,
           property !== null ? {property: property, optional: true} : null
         );
       }
@@ -160735,9 +160850,9 @@ function demoteSubtreeToConditional(subtree) {
     if (!isUnconditional(accessType)) {
       continue;
     }
-    node.accessType = isDependency(accessType)
-      ? PropertyAccessType.ConditionalDependency
-      : PropertyAccessType.ConditionalAccess;
+    node.accessType = isDependency$1(accessType)
+      ? PropertyAccessType$1.ConditionalDependency
+      : PropertyAccessType$1.ConditionalAccess;
     for (const childNode of properties.values()) {
       if (isUnconditional(accessType)) {
         stack.push(childNode);
@@ -160748,11 +160863,11 @@ function demoteSubtreeToConditional(subtree) {
 function addSubtree(currNode, otherNode, demoteOtherNode) {
   let otherType = otherNode.accessType;
   if (demoteOtherNode) {
-    otherType = isDependency(otherType)
-      ? PropertyAccessType.ConditionalDependency
-      : PropertyAccessType.ConditionalAccess;
+    otherType = isDependency$1(otherType)
+      ? PropertyAccessType$1.ConditionalDependency
+      : PropertyAccessType$1.ConditionalAccess;
   }
-  currNode.accessType = merge(currNode.accessType, otherType);
+  currNode.accessType = merge$1(currNode.accessType, otherType);
   for (const [propertyName, otherChild] of otherNode.properties) {
     const currChild = currNode.properties.get(propertyName);
     if (currChild) {
@@ -160787,29 +160902,29 @@ function addSubtreeIntersection(currProperties, otherProperties) {
         currNode.properties,
         otherNodes.map(node => node.properties)
       );
-      const isDep = otherNodes.some(tree => isDependency(tree.accessType));
+      const isDep = otherNodes.some(tree => isDependency$1(tree.accessType));
       const externalAccessType = isDep
-        ? PropertyAccessType.UnconditionalDependency
-        : PropertyAccessType.UnconditionalAccess;
-      currNode.accessType = merge(externalAccessType, currNode.accessType);
+        ? PropertyAccessType$1.UnconditionalDependency
+        : PropertyAccessType$1.UnconditionalAccess;
+      currNode.accessType = merge$1(externalAccessType, currNode.accessType);
     }
   }
 }
-function printSubtree(node, includeAccesses) {
+function printSubtree$1(node, includeAccesses) {
   const results = [];
   for (const [propertyName, propertyNode] of node.properties) {
-    if (includeAccesses || isDependency(propertyNode.accessType)) {
+    if (includeAccesses || isDependency$1(propertyNode.accessType)) {
       results.push(`${propertyName} (${propertyNode.accessType})`);
     }
-    const propertyResults = printSubtree(propertyNode, includeAccesses);
+    const propertyResults = printSubtree$1(propertyNode, includeAccesses);
     results.push(...propertyResults.map(result => `${propertyName}.${result}`));
   }
   return results;
 }
-function getOrMakeProperty(node, property) {
+function getOrMakeProperty$1(node, property) {
   let child = node.properties.get(property);
   if (child == null) {
-    child = {properties: new Map(), accessType: MIN_ACCESS_TYPE};
+    child = {properties: new Map(), accessType: MIN_ACCESS_TYPE$1};
     node.properties.set(property, child);
   }
   return child;
@@ -160828,26 +160943,26 @@ function mapNonNull(arr, fn) {
 }
 var _PoisonState_instances,
   _PoisonState_invalidate,
-  _Context_instances,
-  _Context_temporariesUsedOutsideScope,
-  _Context_declarations,
-  _Context_reassignments,
-  _Context_dependencies,
+  _Context_instances$1,
+  _Context_temporariesUsedOutsideScope$1,
+  _Context_declarations$1,
+  _Context_reassignments$1,
+  _Context_dependencies$1,
   _Context_properties,
-  _Context_temporaries,
+  _Context_temporaries$1,
   _Context_inConditionalWithinScope,
   _Context_depsInCurrentConditional,
-  _Context_scopes,
+  _Context_scopes$1,
   _Context_getProperty,
-  _Context_checkValidDependency,
-  _Context_isScopeActive;
+  _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(escapingTemporaries.usedOutsideDeclaringScope);
+  const context = new Context$1(escapingTemporaries.usedOutsideDeclaringScope);
   for (const param of fn.params) {
     if (param.kind === 'Identifier') {
       context.declare(param.identifier, {
@@ -161015,25 +161130,25 @@ class PoisonState {
     }
     this.isPoisoned = false;
   });
-class Context {
+let Context$1 = class Context {
   constructor(temporariesUsedOutsideScope) {
-    _Context_instances.add(this);
-    _Context_temporariesUsedOutsideScope.set(this, void 0);
-    _Context_declarations.set(this, new Map());
-    _Context_reassignments.set(this, new Map());
-    _Context_dependencies.set(this, new ReactiveScopeDependencyTree());
+    _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.set(this, new Map());
+    _Context_temporaries$1.set(this, new Map());
     _Context_inConditionalWithinScope.set(this, false);
     _Context_depsInCurrentConditional.set(
       this,
       new ReactiveScopeDependencyTree()
     );
-    _Context_scopes.set(this, empty());
+    _Context_scopes$1.set(this, empty());
     this.poisonState = new PoisonState(new Set(), new Set(), false);
     __classPrivateFieldSet(
       this,
-      _Context_temporariesUsedOutsideScope,
+      _Context_temporariesUsedOutsideScope$1,
       temporariesUsedOutsideScope,
       'f'
     );
@@ -161046,7 +161161,7 @@ class Context {
     );
     const previousDependencies = __classPrivateFieldGet(
       this,
-      _Context_dependencies,
+      _Context_dependencies$1,
       'f'
     );
     const prevDepsInConditional = this.isPoisoned
@@ -161064,14 +161179,14 @@ class Context {
     __classPrivateFieldSet(this, _Context_inConditionalWithinScope, false, 'f');
     __classPrivateFieldSet(
       this,
-      _Context_dependencies,
+      _Context_dependencies$1,
       scopedDependencies,
       'f'
     );
     __classPrivateFieldSet(
       this,
-      _Context_scopes,
-      __classPrivateFieldGet(this, _Context_scopes, 'f').push({
+      _Context_scopes$1,
+      __classPrivateFieldGet(this, _Context_scopes$1, 'f').push({
         value: scope,
         ownBlocks: empty(),
       }),
@@ -161081,17 +161196,17 @@ class Context {
     fn();
     __classPrivateFieldSet(
       this,
-      _Context_scopes,
-      __classPrivateFieldGet(this, _Context_scopes, 'f').pop(),
+      _Context_scopes$1,
+      __classPrivateFieldGet(this, _Context_scopes$1, 'f').pop(),
       'f'
     );
     this.poisonState.removeMaybePoisonedScope(
       scope.id,
-      __classPrivateFieldGet(this, _Context_scopes, 'f').value
+      __classPrivateFieldGet(this, _Context_scopes$1, 'f').value
     );
     __classPrivateFieldSet(
       this,
-      _Context_dependencies,
+      _Context_dependencies$1,
       previousDependencies,
       'f'
     );
@@ -161105,7 +161220,7 @@ class Context {
       scopedDependencies.deriveMinimalDependencies();
     __classPrivateFieldGet(
       this,
-      _Context_dependencies,
+      _Context_dependencies$1,
       'f'
     ).addDepsFromInnerScope(
       scopedDependencies,
@@ -161113,9 +161228,9 @@ class Context {
         this.isPoisoned,
       __classPrivateFieldGet(
         this,
-        _Context_instances,
+        _Context_instances$1,
         'm',
-        _Context_checkValidDependency
+        _Context_checkValidDependency$1
       ).bind(this)
     );
     if (prevDepsInConditional != null) {
@@ -161124,9 +161239,9 @@ class Context {
         true,
         __classPrivateFieldGet(
           this,
-          _Context_instances,
+          _Context_instances$1,
           'm',
-          _Context_checkValidDependency
+          _Context_checkValidDependency$1
         ).bind(this)
       );
       __classPrivateFieldSet(
@@ -161141,12 +161256,12 @@ class Context {
   isUsedOutsideDeclaringScope(place) {
     return __classPrivateFieldGet(
       this,
-      _Context_temporariesUsedOutsideScope,
+      _Context_temporariesUsedOutsideScope$1,
       'f'
     ).has(place.identifier.declarationId);
   }
   printDeps(includeAccesses = false) {
-    return __classPrivateFieldGet(this, _Context_dependencies, 'f').printDeps(
+    return __classPrivateFieldGet(this, _Context_dependencies$1, 'f').printDeps(
       includeAccesses
     );
   }
@@ -161191,7 +161306,7 @@ class Context {
   promoteDepsFromExhaustiveConditionals(depsInConditionals) {
     __classPrivateFieldGet(
       this,
-      _Context_dependencies,
+      _Context_dependencies$1,
       'f'
     ).promoteDepsFromExhaustiveConditionals(depsInConditionals);
     __classPrivateFieldGet(
@@ -161202,29 +161317,29 @@ class Context {
   }
   declare(identifier, decl) {
     if (
-      !__classPrivateFieldGet(this, _Context_declarations, 'f').has(
+      !__classPrivateFieldGet(this, _Context_declarations$1, 'f').has(
         identifier.declarationId
       )
     ) {
-      __classPrivateFieldGet(this, _Context_declarations, 'f').set(
+      __classPrivateFieldGet(this, _Context_declarations$1, 'f').set(
         identifier.declarationId,
         decl
       );
     }
-    __classPrivateFieldGet(this, _Context_reassignments, 'f').set(
+    __classPrivateFieldGet(this, _Context_reassignments$1, 'f').set(
       identifier,
       decl
     );
   }
   declareTemporary(lvalue, place) {
-    __classPrivateFieldGet(this, _Context_temporaries, 'f').set(
+    __classPrivateFieldGet(this, _Context_temporaries$1, 'f').set(
       lvalue.identifier,
       place
     );
   }
   resolveTemporary(place) {
     var _a;
-    return (_a = __classPrivateFieldGet(this, _Context_temporaries, 'f').get(
+    return (_a = __classPrivateFieldGet(this, _Context_temporaries$1, 'f').get(
       place.identifier
     )) !== null && _a !== void 0
       ? _a
@@ -161233,7 +161348,7 @@ class Context {
   declareProperty(lvalue, object, property, optional) {
     const nextDependency = __classPrivateFieldGet(
       this,
-      _Context_instances,
+      _Context_instances$1,
       'm',
       _Context_getProperty
     ).call(this, object, property, optional);
@@ -161243,7 +161358,7 @@ class Context {
     );
   }
   get currentScope() {
-    return __classPrivateFieldGet(this, _Context_scopes, 'f');
+    return __classPrivateFieldGet(this, _Context_scopes$1, 'f');
   }
   get isPoisoned() {
     return this.poisonState.isPoisoned;
@@ -161266,7 +161381,7 @@ class Context {
   visitProperty(object, property, optional) {
     const nextDependency = __classPrivateFieldGet(
       this,
-      _Context_instances,
+      _Context_instances$1,
       'm',
       _Context_getProperty
     ).call(this, object, property, optional);
@@ -161275,7 +161390,7 @@ class Context {
   visitDependency(maybeDependency) {
     const originalDeclaration = __classPrivateFieldGet(
       this,
-      _Context_declarations,
+      _Context_declarations$1,
       'f'
     ).get(maybeDependency.identifier.declarationId);
     if (
@@ -161286,9 +161401,9 @@ class Context {
         if (
           !__classPrivateFieldGet(
             this,
-            _Context_instances,
+            _Context_instances$1,
             'm',
-            _Context_isScopeActive
+            _Context_isScopeActive$1
           ).call(this, scope.value) &&
           !Iterable_some(
             scope.value.declarations.values(),
@@ -161307,9 +161422,9 @@ class Context {
     if (
       __classPrivateFieldGet(
         this,
-        _Context_instances,
+        _Context_instances$1,
         'm',
-        _Context_checkValidDependency
+        _Context_checkValidDependency$1
       ).call(this, maybeDependency)
     ) {
       const isPoisoned = this.isPoisoned;
@@ -161317,7 +161432,7 @@ class Context {
         maybeDependency,
         isPoisoned
       );
-      __classPrivateFieldGet(this, _Context_dependencies, 'f').add(
+      __classPrivateFieldGet(this, _Context_dependencies$1, 'f').add(
         maybeDependency,
         __classPrivateFieldGet(this, _Context_inConditionalWithinScope, 'f') ||
           isPoisoned
@@ -161339,9 +161454,9 @@ class Context {
       ) &&
       __classPrivateFieldGet(
         this,
-        _Context_instances,
+        _Context_instances$1,
         'm',
-        _Context_checkValidDependency
+        _Context_checkValidDependency$1
       ).call(this, {identifier: place.identifier, path: []})
     ) {
       currentScope.reassignments.add(place.identifier);
@@ -161350,7 +161465,7 @@ class Context {
   pushLabeledBlock(id) {
     const currentScope = __classPrivateFieldGet(
       this,
-      _Context_scopes,
+      _Context_scopes$1,
       'f'
     ).value;
     if (currentScope != null) {
@@ -161360,7 +161475,7 @@ class Context {
   popLabeledBlock(id) {
     const currentScope = __classPrivateFieldGet(
       this,
-      _Context_scopes,
+      _Context_scopes$1,
       'f'
     ).value;
     if (currentScope != null) {
@@ -161373,17 +161488,17 @@ class Context {
     }
     this.poisonState.removeMaybePoisonedBlock(id, currentScope);
   }
-}
-(_Context_temporariesUsedOutsideScope = new WeakMap()),
-  (_Context_declarations = new WeakMap()),
-  (_Context_reassignments = new WeakMap()),
-  (_Context_dependencies = new WeakMap()),
+};
+(_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 = new WeakMap()),
+  (_Context_temporaries$1 = new WeakMap()),
   (_Context_inConditionalWithinScope = new WeakMap()),
   (_Context_depsInCurrentConditional = new WeakMap()),
-  (_Context_scopes = new WeakMap()),
-  (_Context_instances = new WeakSet()),
+  (_Context_scopes$1 = new WeakMap()),
+  (_Context_instances$1 = new WeakSet()),
   (_Context_getProperty = function _Context_getProperty(
     object,
     property,
@@ -161407,7 +161522,7 @@ class Context {
     objectDependency.path.push({property: property, optional: optional});
     return objectDependency;
   }),
-  (_Context_checkValidDependency = function _Context_checkValidDependency(
+  (_Context_checkValidDependency$1 = function _Context_checkValidDependency(
     maybeDependency
   ) {
     var _a, _b, _c, _d;
@@ -161427,11 +161542,11 @@ class Context {
     }
     const identifier = maybeDependency.identifier;
     const currentDeclaration =
-      (_b = __classPrivateFieldGet(this, _Context_reassignments, 'f').get(
+      (_b = __classPrivateFieldGet(this, _Context_reassignments$1, 'f').get(
         identifier
       )) !== null && _b !== void 0
         ? _b
-        : __classPrivateFieldGet(this, _Context_declarations, 'f').get(
+        : __classPrivateFieldGet(this, _Context_declarations$1, 'f').get(
             identifier.declarationId
           );
     const currentScope =
@@ -161448,11 +161563,11 @@ class Context {
           : _d.value) !== currentScope)
     );
   }),
-  (_Context_isScopeActive = function _Context_isScopeActive(scope) {
-    if (__classPrivateFieldGet(this, _Context_scopes, 'f') === null) {
+  (_Context_isScopeActive$1 = function _Context_isScopeActive(scope) {
+    if (__classPrivateFieldGet(this, _Context_scopes$1, 'f') === null) {
       return false;
     }
-    return __classPrivateFieldGet(this, _Context_scopes, 'f').find(
+    return __classPrivateFieldGet(this, _Context_scopes$1, 'f').find(
       state => state.value === scope
     );
   });
@@ -169445,6 +169560,917 @@ function validateNoJSXInTryStatement(fn) {
     throw errors;
   }
 }
+var _Tree_instances, _a, _Tree_getOrCreateRoot, _Tree_getOrCreateProperty;
+function collectHoistablePropertyLoads(fn, temporaries) {
+  const nodes = collectPropertyLoadsInBlocks(fn, temporaries);
+  propagateNonNull(fn, nodes);
+  const nodesKeyedByScopeId = new Map();
+  for (const [_, block] of fn.body.blocks) {
+    if (block.terminal.kind === 'scope') {
+      nodesKeyedByScopeId.set(
+        block.terminal.scope.id,
+        nodes.get(block.terminal.block)
+      );
+    }
+  }
+  return nodesKeyedByScopeId;
+}
+function getProperty(object, propertyName, temporaries) {
+  const resolvedDependency = temporaries.get(object.identifier.id);
+  let property;
+  if (resolvedDependency == null) {
+    property = {
+      identifier: object.identifier,
+      path: [{property: propertyName, optional: false}],
+    };
+  } else {
+    property = {
+      identifier: resolvedDependency.identifier,
+      path: [
+        ...resolvedDependency.path,
+        {property: propertyName, optional: false},
+      ],
+    };
+  }
+  return property;
+}
+class Tree {
+  constructor() {
+    _Tree_instances.add(this);
+    this.roots = new Map();
+  }
+  getPropertyLoadNode(n) {
+    CompilerError.invariant(n.path.length > 0, {
+      reason:
+        '[CollectHoistablePropertyLoads] Expected property node, found root node',
+      loc: GeneratedSource,
+    });
+    let currNode = __classPrivateFieldGet(
+      this,
+      _Tree_instances,
+      'm',
+      _Tree_getOrCreateRoot
+    ).call(this, n.identifier);
+    for (let i = 0; i < n.path.length - 1; i++) {
+      currNode = assertNonNull(currNode.properties.get(n.path[i].property));
+    }
+    return __classPrivateFieldGet(_a, _a, 'm', _Tree_getOrCreateProperty).call(
+      _a,
+      currNode,
+      n.path.at(-1).property
+    );
+  }
+}
+(_a = Tree),
+  (_Tree_instances = new WeakSet()),
+  (_Tree_getOrCreateRoot = function _Tree_getOrCreateRoot(identifier) {
+    let rootNode = this.roots.get(identifier);
+    if (rootNode === undefined) {
+      rootNode = {
+        root: identifier,
+        properties: new Map(),
+        fullPath: {identifier: identifier, path: []},
+        parent: null,
+      };
+      this.roots.set(identifier, rootNode);
+    }
+    return rootNode;
+  }),
+  (_Tree_getOrCreateProperty = function _Tree_getOrCreateProperty(
+    node,
+    property
+  ) {
+    let child = node.properties.get(property);
+    if (child == null) {
+      child = {
+        properties: new Map(),
+        parent: node,
+        fullPath: {
+          identifier: node.fullPath.identifier,
+          path: node.fullPath.path.concat([
+            {property: property, optional: false},
+          ]),
+        },
+      };
+      node.properties.set(property, child);
+    }
+    return child;
+  });
+function collectPropertyLoadsInBlocks(fn, temporaries) {
+  const knownImmutableIdentifiers = new Set();
+  if (fn.fnType === 'Component' || fn.fnType === 'Hook') {
+    for (const p of fn.params) {
+      if (p.kind === 'Identifier') {
+        knownImmutableIdentifiers.add(p.identifier);
+      }
+    }
+  }
+  const tree = new Tree();
+  const nodes = new Map();
+  for (const [_, block] of fn.body.blocks) {
+    const assumedNonNullObjects = new Set();
+    for (const instr of block.instructions) {
+      if (instr.value.kind === 'PropertyLoad') {
+        const property = getProperty(
+          instr.value.object,
+          instr.value.property,
+          temporaries
+        );
+        const propertyNode = tree.getPropertyLoadNode(property);
+        const object = instr.value.object.identifier;
+        const isMutableAtInstr =
+          object.mutableRange.end > object.mutableRange.start + 1 &&
+          object.scope != null &&
+          inRange(instr, object.scope.range);
+        if (
+          !isMutableAtInstr ||
+          knownImmutableIdentifiers.has(propertyNode.fullPath.identifier)
+        ) {
+          let curr = propertyNode.parent;
+          while (curr != null) {
+            assumedNonNullObjects.add(curr);
+            curr = curr.parent;
+          }
+        }
+      }
+    }
+    nodes.set(block.id, {
+      block: block,
+      assumedNonNullObjects: assumedNonNullObjects,
+    });
+  }
+  return nodes;
+}
+function propagateNonNull(fn, nodes) {
+  const blockSuccessors = new Map();
+  const terminalPreds = new Set();
+  for (const [blockId, block] of fn.body.blocks) {
+    for (const pred of block.preds) {
+      getOrInsertDefault(blockSuccessors, pred, new Set()).add(blockId);
+    }
+    if (block.terminal.kind === 'throw' || block.terminal.kind === 'return') {
+      terminalPreds.add(blockId);
+    }
+  }
+  function recursivelyPropagateNonNull(
+    nodeId,
+    direction,
+    traversalState,
+    nonNullObjectsByBlock
+  ) {
+    var _b;
+    if (traversalState.has(nodeId)) {
+      return false;
+    }
+    traversalState.set(nodeId, 'active');
+    const node = nodes.get(nodeId);
+    if (node == null) {
+      CompilerError.invariant(false, {
+        reason: `Bad node ${nodeId}, kind: ${direction}`,
+        loc: GeneratedSource,
+      });
+    }
+    const neighbors = Array.from(
+      direction === 'backward'
+        ? (_b = blockSuccessors.get(nodeId)) !== null && _b !== void 0
+          ? _b
+          : []
+        : node.block.preds
+    );
+    let changed = false;
+    for (const pred of neighbors) {
+      if (!traversalState.has(pred)) {
+        const neighborChanged = recursivelyPropagateNonNull(
+          pred,
+          direction,
+          traversalState,
+          nonNullObjectsByBlock
+        );
+        changed || (changed = neighborChanged);
+      }
+    }
+    const neighborAccesses = Set_intersect(
+      Array.from(neighbors)
+        .filter(n => traversalState.get(n) === 'done')
+        .map(n => assertNonNull(nonNullObjectsByBlock.get(n)))
+    );
+    const prevObjects = assertNonNull(nonNullObjectsByBlock.get(nodeId));
+    const newObjects = Set_union(prevObjects, neighborAccesses);
+    nonNullObjectsByBlock.set(nodeId, newObjects);
+    traversalState.set(nodeId, 'done');
+    changed || (changed = prevObjects.size !== newObjects.size);
+    return changed;
+  }
+  const fromEntry = new Map();
+  const fromExit = new Map();
+  for (const [blockId, blockInfo] of nodes) {
+    fromEntry.set(blockId, blockInfo.assumedNonNullObjects);
+    fromExit.set(blockId, blockInfo.assumedNonNullObjects);
+  }
+  const traversalState = new Map();
+  const reversedBlocks = [...fn.body.blocks];
+  reversedBlocks.reverse();
+  let i = 0;
+  let changed;
+  do {
+    i++;
+    changed = false;
+    for (const [blockId] of fn.body.blocks) {
+      const forwardChanged = recursivelyPropagateNonNull(
+        blockId,
+        'forward',
+        traversalState,
+        fromEntry
+      );
+      changed || (changed = forwardChanged);
+    }
+    traversalState.clear();
+    for (const [blockId] of reversedBlocks) {
+      const backwardChanged = recursivelyPropagateNonNull(
+        blockId,
+        'backward',
+        traversalState,
+        fromExit
+      );
+      changed || (changed = backwardChanged);
+    }
+    traversalState.clear();
+  } while (changed);
+  CompilerError.invariant(i <= 2, {
+    reason: 'require fixed-point iteration',
+    description: `#iterations = ${i}`,
+    loc: GeneratedSource,
+  });
+  CompilerError.invariant(
+    fromEntry.size === fromExit.size && fromEntry.size === nodes.size,
+    {
+      reason:
+        'bad sizes after calculating fromEntry + fromExit ' +
+        `${fromEntry.size} ${fromExit.size} ${nodes.size}`,
+      loc: GeneratedSource,
+    }
+  );
+  for (const [id, node] of nodes) {
+    node.assumedNonNullObjects = Set_union(
+      assertNonNull(fromEntry.get(id)),
+      assertNonNull(fromExit.get(id))
+    );
+  }
+}
+function assertNonNull(value, source) {
+  CompilerError.invariant(value != null, {
+    reason: 'Unexpected null',
+    description: source != null ? `(from ${source})` : null,
+    loc: GeneratedSource,
+  });
+  return value;
+}
+var _ReactiveScopeDependencyTreeHIR_instances,
+  _ReactiveScopeDependencyTreeHIR_roots,
+  _ReactiveScopeDependencyTreeHIR_getOrCreateRoot;
+class ReactiveScopeDependencyTreeHIR {
+  constructor() {
+    _ReactiveScopeDependencyTreeHIR_instances.add(this);
+    _ReactiveScopeDependencyTreeHIR_roots.set(this, new Map());
+  }
+  addDependency(dep) {
+    const {path: path} = dep;
+    let currNode = __classPrivateFieldGet(
+      this,
+      _ReactiveScopeDependencyTreeHIR_instances,
+      'm',
+      _ReactiveScopeDependencyTreeHIR_getOrCreateRoot
+    ).call(this, dep.identifier, false);
+    const accessType = PropertyAccessType.Access;
+    currNode.accessType = merge(currNode.accessType, accessType);
+    for (const property of path) {
+      let currChild = getOrMakeProperty(currNode, property.property);
+      currChild.accessType = merge(currChild.accessType, accessType);
+      currNode = currChild;
+    }
+    currNode.accessType = merge(
+      currNode.accessType,
+      PropertyAccessType.Dependency
+    );
+  }
+  markNodesNonNull(dep) {
+    const accessType = PropertyAccessType.NonNullAccess;
+    let currNode = __classPrivateFieldGet(
+      this,
+      _ReactiveScopeDependencyTreeHIR_roots,
+      'f'
+    ).get(dep.identifier);
+    let cursor = 0;
+    while (currNode != null && cursor < dep.path.length) {
+      currNode.accessType = merge(currNode.accessType, accessType);
+      currNode = currNode.properties.get(dep.path[cursor++].property);
+    }
+    if (currNode != null) {
+      currNode.accessType = merge(currNode.accessType, accessType);
+    }
+  }
+  deriveMinimalDependencies() {
+    const results = new Set();
+    for (const [rootId, rootNode] of __classPrivateFieldGet(
+      this,
+      _ReactiveScopeDependencyTreeHIR_roots,
+      'f'
+    ).entries()) {
+      {
+        assertWellFormedTree(rootNode);
+      }
+      const deps = deriveMinimalDependenciesInSubtree(rootNode, []);
+      for (const dep of deps) {
+        results.add({
+          identifier: rootId,
+          path: dep.path.map(s => ({property: s, optional: false})),
+        });
+      }
+    }
+    return results;
+  }
+  printDeps(includeAccesses) {
+    let res = [];
+    for (const [rootId, rootNode] of __classPrivateFieldGet(
+      this,
+      _ReactiveScopeDependencyTreeHIR_roots,
+      'f'
+    ).entries()) {
+      const rootResults = printSubtree(rootNode, includeAccesses).map(
+        result => `${printIdentifier(rootId)}.${result}`
+      );
+      res.push(rootResults);
+    }
+    return res.flat().join('\n');
+  }
+}
+(_ReactiveScopeDependencyTreeHIR_roots = new WeakMap()),
+  (_ReactiveScopeDependencyTreeHIR_instances = new WeakSet()),
+  (_ReactiveScopeDependencyTreeHIR_getOrCreateRoot =
+    function _ReactiveScopeDependencyTreeHIR_getOrCreateRoot(
+      identifier,
+      isNonNull
+    ) {
+      let rootNode = __classPrivateFieldGet(
+        this,
+        _ReactiveScopeDependencyTreeHIR_roots,
+        'f'
+      ).get(identifier);
+      if (rootNode === undefined) {
+        rootNode = {
+          properties: new Map(),
+          accessType: isNonNull
+            ? PropertyAccessType.NonNullAccess
+            : PropertyAccessType.Access,
+        };
+        __classPrivateFieldGet(
+          this,
+          _ReactiveScopeDependencyTreeHIR_roots,
+          'f'
+        ).set(identifier, rootNode);
+      }
+      return rootNode;
+    });
+var PropertyAccessType;
+(function (PropertyAccessType) {
+  PropertyAccessType['Access'] = 'Access';
+  PropertyAccessType['NonNullAccess'] = 'NonNullAccess';
+  PropertyAccessType['Dependency'] = 'Dependency';
+  PropertyAccessType['NonNullDependency'] = 'NonNullDependency';
+})(PropertyAccessType || (PropertyAccessType = {}));
+const MIN_ACCESS_TYPE = PropertyAccessType.Access;
+function isNonNull(access) {
+  return (
+    access === PropertyAccessType.NonNullAccess ||
+    access === PropertyAccessType.NonNullDependency
+  );
+}
+function isDependency(access) {
+  return (
+    access === PropertyAccessType.Dependency ||
+    access === PropertyAccessType.NonNullDependency
+  );
+}
+function merge(access1, access2) {
+  const resultisNonNull = isNonNull(access1) || isNonNull(access2);
+  const resultIsDependency = isDependency(access1) || isDependency(access2);
+  if (resultisNonNull) {
+    if (resultIsDependency) {
+      return PropertyAccessType.NonNullDependency;
+    } else {
+      return PropertyAccessType.NonNullAccess;
+    }
+  } else {
+    if (resultIsDependency) {
+      return PropertyAccessType.Dependency;
+    } else {
+      return PropertyAccessType.Access;
+    }
+  }
+}
+function assertWellFormedTree(node) {
+  let nonNullInChildren = false;
+  for (const childNode of node.properties.values()) {
+    assertWellFormedTree(childNode);
+    nonNullInChildren || (nonNullInChildren = isNonNull(childNode.accessType));
+  }
+  if (nonNullInChildren) {
+    CompilerError.invariant(isNonNull(node.accessType), {
+      reason:
+        '[DeriveMinimialDependencies] Not well formed tree, unexpected non-null node',
+      description: node.accessType,
+      loc: GeneratedSource,
+    });
+  }
+}
+function deriveMinimalDependenciesInSubtree(node, path) {
+  if (isDependency(node.accessType)) {
+    return [{path: path}];
+  } else {
+    if (isNonNull(node.accessType)) {
+      const result = [];
+      for (const [childName, childNode] of node.properties) {
+        result.push(
+          ...deriveMinimalDependenciesInSubtree(childNode, [...path, childName])
+        );
+      }
+      return result;
+    } else {
+      return [{path: path}];
+    }
+  }
+}
+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 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;
+}
+var _Context_instances,
+  _Context_declarations,
+  _Context_reassignments,
+  _Context_scopes,
+  _Context_dependencies,
+  _Context_temporaries,
+  _Context_temporariesUsedOutsideScope,
+  _Context_checkValidDependency,
+  _Context_isScopeActive;
+function propagateScopeDependenciesHIR(fn) {
+  const usedOutsideDeclaringScope =
+    findTemporariesUsedOutsideDeclaringScope(fn);
+  const temporaries = collectTemporariesSidemap(fn, usedOutsideDeclaringScope);
+  const hoistablePropertyLoads = collectHoistablePropertyLoads(fn, temporaries);
+  const scopeDeps = collectDependencies(
+    fn,
+    usedOutsideDeclaringScope,
+    temporaries
+  );
+  for (const [scope, deps] of scopeDeps) {
+    const tree = new ReactiveScopeDependencyTreeHIR();
+    for (const dep of deps) {
+      tree.addDependency(Object.assign({}, dep));
+    }
+    recordHoistablePropertyReads(hoistablePropertyLoads, scope.id, tree);
+    const candidates = tree.deriveMinimalDependencies();
+    for (const candidateDep of candidates) {
+      if (
+        !Iterable_some(
+          scope.dependencies,
+          existingDep =>
+            existingDep.identifier.declarationId ===
+              candidateDep.identifier.declarationId &&
+            areEqualPaths(existingDep.path, candidateDep.path)
+        )
+      )
+        scope.dependencies.add(candidateDep);
+    }
+  }
+}
+function findTemporariesUsedOutsideDeclaringScope(fn) {
+  const declarations = new Map();
+  const prunedScopes = new Set();
+  const scopeTraversal = new ScopeBlockTraversal();
+  const usedOutsideDeclaringScope = new Set();
+  function handlePlace(place) {
+    const declaringScope = declarations.get(place.identifier.declarationId);
+    if (
+      declaringScope != null &&
+      !scopeTraversal.isScopeActive(declaringScope) &&
+      !prunedScopes.has(declaringScope)
+    ) {
+      usedOutsideDeclaringScope.add(place.identifier.declarationId);
+    }
+  }
+  function handleInstruction(instr) {
+    const scope = scopeTraversal.currentScope;
+    if (scope == null || prunedScopes.has(scope)) {
+      return;
+    }
+    switch (instr.value.kind) {
+      case 'LoadLocal':
+      case 'LoadContext':
+      case 'PropertyLoad': {
+        declarations.set(instr.lvalue.identifier.declarationId, scope);
+        break;
+      }
+    }
+  }
+  for (const [blockId, block] of fn.body.blocks) {
+    scopeTraversal.recordScopes(block);
+    const scopeStartInfo = scopeTraversal.blockInfos.get(blockId);
+    if (
+      (scopeStartInfo === null || scopeStartInfo === void 0
+        ? void 0
+        : scopeStartInfo.kind) === 'begin' &&
+      scopeStartInfo.pruned
+    ) {
+      prunedScopes.add(scopeStartInfo.scope.id);
+    }
+    for (const instr of block.instructions) {
+      for (const place of eachInstructionOperand(instr)) {
+        handlePlace(place);
+      }
+      handleInstruction(instr);
+    }
+    for (const place of eachTerminalOperand(block.terminal)) {
+      handlePlace(place);
+    }
+  }
+  return usedOutsideDeclaringScope;
+}
+function collectTemporariesSidemap(fn, usedOutsideDeclaringScope) {
+  const temporaries = new Map();
+  for (const [_, block] of fn.body.blocks) {
+    for (const instr of block.instructions) {
+      const {value: value, lvalue: lvalue} = instr;
+      const usedOutside = usedOutsideDeclaringScope.has(
+        lvalue.identifier.declarationId
+      );
+      if (value.kind === 'PropertyLoad' && !usedOutside) {
+        const property = getProperty(value.object, value.property, 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: [],
+        });
+      }
+    }
+  }
+  return temporaries;
+}
+class Context {
+  constructor(temporariesUsedOutsideScope, temporaries) {
+    _Context_instances.add(this);
+    _Context_declarations.set(this, new Map());
+    _Context_reassignments.set(this, new Map());
+    _Context_scopes.set(this, empty());
+    _Context_dependencies.set(this, empty());
+    this.deps = new Map();
+    _Context_temporaries.set(this, void 0);
+    _Context_temporariesUsedOutsideScope.set(this, void 0);
+    __classPrivateFieldSet(
+      this,
+      _Context_temporariesUsedOutsideScope,
+      temporariesUsedOutsideScope,
+      'f'
+    );
+    __classPrivateFieldSet(this, _Context_temporaries, temporaries, 'f');
+  }
+  enterScope(scope) {
+    __classPrivateFieldSet(
+      this,
+      _Context_dependencies,
+      __classPrivateFieldGet(this, _Context_dependencies, 'f').push([]),
+      'f'
+    );
+    __classPrivateFieldSet(
+      this,
+      _Context_scopes,
+      __classPrivateFieldGet(this, _Context_scopes, 'f').push(scope),
+      'f'
+    );
+  }
+  exitScope(scope, pruned) {
+    var _a;
+    const scopedDependencies = __classPrivateFieldGet(
+      this,
+      _Context_dependencies,
+      'f'
+    ).value;
+    CompilerError.invariant(scopedDependencies != null, {
+      reason: '[PropagateScopeDeps]: Unexpected scope mismatch',
+      loc: scope.loc,
+    });
+    __classPrivateFieldSet(
+      this,
+      _Context_scopes,
+      __classPrivateFieldGet(this, _Context_scopes, 'f').pop(),
+      'f'
+    );
+    __classPrivateFieldSet(
+      this,
+      _Context_dependencies,
+      __classPrivateFieldGet(this, _Context_dependencies, 'f').pop(),
+      'f'
+    );
+    for (const dep of scopedDependencies) {
+      if (
+        __classPrivateFieldGet(
+          this,
+          _Context_instances,
+          'm',
+          _Context_checkValidDependency
+        ).call(this, dep)
+      ) {
+        (_a = __classPrivateFieldGet(
+          this,
+          _Context_dependencies,
+          'f'
+        ).value) === null || _a === void 0
+          ? void 0
+          : _a.push(dep);
+      }
+    }
+    if (!pruned) {
+      this.deps.set(scope, scopedDependencies);
+    }
+  }
+  isUsedOutsideDeclaringScope(place) {
+    return __classPrivateFieldGet(
+      this,
+      _Context_temporariesUsedOutsideScope,
+      'f'
+    ).has(place.identifier.declarationId);
+  }
+  declare(identifier, decl) {
+    if (
+      !__classPrivateFieldGet(this, _Context_declarations, 'f').has(
+        identifier.declarationId
+      )
+    ) {
+      __classPrivateFieldGet(this, _Context_declarations, 'f').set(
+        identifier.declarationId,
+        decl
+      );
+    }
+    __classPrivateFieldGet(this, _Context_reassignments, 'f').set(
+      identifier,
+      decl
+    );
+  }
+  get currentScope() {
+    return __classPrivateFieldGet(this, _Context_scopes, 'f');
+  }
+  visitOperand(place) {
+    var _a;
+    this.visitDependency(
+      (_a = __classPrivateFieldGet(this, _Context_temporaries, 'f').get(
+        place.identifier.id
+      )) !== null && _a !== void 0
+        ? _a
+        : {identifier: place.identifier, path: []}
+    );
+  }
+  visitProperty(object, property) {
+    const nextDependency = getProperty(
+      object,
+      property,
+      __classPrivateFieldGet(this, _Context_temporaries, 'f')
+    );
+    this.visitDependency(nextDependency);
+  }
+  visitDependency(maybeDependency) {
+    const originalDeclaration = __classPrivateFieldGet(
+      this,
+      _Context_declarations,
+      'f'
+    ).get(maybeDependency.identifier.declarationId);
+    if (
+      originalDeclaration !== undefined &&
+      originalDeclaration.scope.value !== null
+    ) {
+      originalDeclaration.scope.each(scope => {
+        if (
+          !__classPrivateFieldGet(
+            this,
+            _Context_instances,
+            'm',
+            _Context_isScopeActive
+          ).call(this, scope) &&
+          !Iterable_some(
+            scope.declarations.values(),
+            decl =>
+              decl.identifier.declarationId ===
+              maybeDependency.identifier.declarationId
+          )
+        ) {
+          scope.declarations.set(maybeDependency.identifier.id, {
+            identifier: maybeDependency.identifier,
+            scope: originalDeclaration.scope.value,
+          });
+        }
+      });
+    }
+    if (
+      __classPrivateFieldGet(
+        this,
+        _Context_instances,
+        'm',
+        _Context_checkValidDependency
+      ).call(this, maybeDependency)
+    ) {
+      __classPrivateFieldGet(this, _Context_dependencies, 'f').value.push(
+        maybeDependency
+      );
+    }
+  }
+  visitReassignment(place) {
+    const currentScope = this.currentScope.value;
+    if (
+      currentScope != null &&
+      !Iterable_some(
+        currentScope.reassignments,
+        identifier =>
+          identifier.declarationId === place.identifier.declarationId
+      ) &&
+      __classPrivateFieldGet(
+        this,
+        _Context_instances,
+        'm',
+        _Context_checkValidDependency
+      ).call(this, {identifier: place.identifier, path: []})
+    ) {
+      currentScope.reassignments.add(place.identifier);
+    }
+  }
+}
+(_Context_declarations = new WeakMap()),
+  (_Context_reassignments = new WeakMap()),
+  (_Context_scopes = new WeakMap()),
+  (_Context_dependencies = new WeakMap()),
+  (_Context_temporaries = new WeakMap()),
+  (_Context_temporariesUsedOutsideScope = new WeakMap()),
+  (_Context_instances = new WeakSet()),
+  (_Context_checkValidDependency = function _Context_checkValidDependency(
+    maybeDependency
+  ) {
+    var _a, _b;
+    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, 'f').get(
+        identifier
+      )) !== null && _b !== void 0
+        ? _b
+        : __classPrivateFieldGet(this, _Context_declarations, 'f').get(
+            identifier.declarationId
+          );
+    const currentScope = this.currentScope.value;
+    return (
+      currentScope != null &&
+      currentDeclaration !== undefined &&
+      currentDeclaration.id < currentScope.range.start
+    );
+  }),
+  (_Context_isScopeActive = function _Context_isScopeActive(scope) {
+    if (__classPrivateFieldGet(this, _Context_scopes, 'f') === null) {
+      return false;
+    }
+    return __classPrivateFieldGet(this, _Context_scopes, 'f').find(
+      state => state === scope
+    );
+  });
+function handleInstruction(instr, context) {
+  const {id: id, value: value, lvalue: lvalue} = instr;
+  if (value.kind === 'LoadLocal') {
+    if (
+      value.place.identifier.name === null ||
+      lvalue.identifier.name !== null ||
+      context.isUsedOutsideDeclaringScope(lvalue)
+    ) {
+      context.visitOperand(value.place);
+    }
+  } else if (value.kind === 'PropertyLoad') {
+    if (context.isUsedOutsideDeclaringScope(lvalue)) {
+      context.visitProperty(value.object, value.property);
+    }
+  } 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 {
+    for (const operand of eachInstructionValueOperand(value)) {
+      context.visitOperand(operand);
+    }
+  }
+  context.declare(lvalue.identifier, {id: id, scope: context.currentScope});
+}
+function collectDependencies(fn, usedOutsideDeclaringScope, temporaries) {
+  const context = new Context(usedOutsideDeclaringScope, temporaries);
+  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(),
+      });
+    }
+  }
+  const scopeTraversal = new ScopeBlockTraversal();
+  for (const [blockId, block] of fn.body.blocks) {
+    scopeTraversal.recordScopes(block);
+    const scopeBlockInfo = scopeTraversal.blockInfos.get(blockId);
+    if (
+      (scopeBlockInfo === null || scopeBlockInfo === void 0
+        ? void 0
+        : scopeBlockInfo.kind) === 'begin'
+    ) {
+      context.enterScope(scopeBlockInfo.scope);
+    } else if (
+      (scopeBlockInfo === null || scopeBlockInfo === void 0
+        ? void 0
+        : scopeBlockInfo.kind) === 'end'
+    ) {
+      context.exitScope(
+        scopeBlockInfo.scope,
+        scopeBlockInfo === null || scopeBlockInfo === void 0
+          ? void 0
+          : scopeBlockInfo.pruned
+      );
+    }
+    for (const instr of block.instructions) {
+      handleInstruction(instr, context);
+    }
+    for (const place of eachTerminalOperand(block.terminal)) {
+      context.visitOperand(place);
+    }
+  }
+  return context.deps;
+}
+function recordHoistablePropertyReads(nodes, scopeId, tree) {
+  const node = nodes.get(scopeId);
+  CompilerError.invariant(node != null, {
+    reason: '[PropagateScopeDependencies] Scope not found in tracked blocks',
+    loc: GeneratedSource,
+  });
+  for (const item of node.assumedNonNullObjects) {
+    tree.markNodesNonNull(Object.assign({}, item.fullPath));
+  }
+}
 function* run(
   func,
   config,
@@ -169596,6 +170622,10 @@ 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});
+  }
   const reactiveFunction = buildReactiveFunction(hir);
   yield log({
     kind: 'reactive',
@@ -169610,12 +170640,14 @@ function* runWithEnvironment(func, env) {
     value: reactiveFunction,
   });
   assertScopeInstructionsWithinScopes(reactiveFunction);
-  propagateScopeDependencies(reactiveFunction);
-  yield log({
-    kind: 'reactive',
-    name: 'PropagateScopeDependencies',
-    value: reactiveFunction,
-  });
+  if (!env.config.enablePropagateDepsInHIR) {
+    propagateScopeDependencies(reactiveFunction);
+    yield log({
+      kind: 'reactive',
+      name: 'PropagateScopeDependencies',
+      value: reactiveFunction,
+    });
+  }
   pruneNonEscapingScopes(reactiveFunction);
   yield log({
     kind: 'reactive',