marko 6.0.98 → 6.0.100

package/dist/translator/index.js

@@ -719,6 +719,20 @@ function getFnRoot(path5) {
   }
   return fnPath;
 }
+function getFnParent(path5) {
+  let curPath = path5;
+  while (!isMarko(curPath)) {
+    if (isFunction(curPath)) {
+      return curPath;
+    }
+    const parentPath = curPath.parentPath;
+    if (parentPath) {
+      curPath = parentPath;
+    } else {
+      break;
+    }
+  }
+}
 function getDeclarationRoot(path5) {
   let curPath = path5;
   let declPath;
@@ -3130,45 +3144,6 @@ function getDeclaredBindingExpression(binding) {
 
 // src/translator/util/scope-read.ts
 var import_compiler19 = require("@marko/compiler");
-function createScopeReadPattern(section, referencedBindings) {
-  const rootDepth = section.depth;
-  const rootPattern = import_compiler19.types.objectPattern([]);
-  let nestedPatterns;
-  forEach(referencedBindings, (ref) => {
-    const propertyValue = ref.name;
-    if (!isValidPropertyIdentifier(propertyValue)) return;
-    const propertyKey = getScopeAccessor(ref);
-    const isShorthand = propertyKey === propertyValue;
-    let pattern = rootPattern;
-    if (ref.section !== section && ref.type !== 4 /* local */) {
-      if (!nestedPatterns) nestedPatterns = [rootPattern];
-      const relativeDepth = rootDepth - ref.section.depth;
-      let i = nestedPatterns.length;
-      let prev = nestedPatterns[i - 1];
-      for (; i <= relativeDepth; i++) {
-        const nestedPattern = import_compiler19.types.objectPattern([]);
-        prev.properties.push(
-          import_compiler19.types.objectProperty(
-            import_compiler19.types.identifier(getAccessorProp().Owner),
-            nestedPattern
-          )
-        );
-        nestedPatterns.push(nestedPattern);
-        prev = nestedPattern;
-      }
-      pattern = nestedPatterns[relativeDepth];
-    }
-    pattern.properties.push(
-      import_compiler19.types.objectProperty(
-        toPropertyName(propertyKey),
-        import_compiler19.types.identifier(propertyValue),
-        false,
-        isShorthand
-      )
-    );
-  });
-  return rootPattern;
-}
 function getScopeExpression(section, targetSection) {
   let scope = scopeIdentifier ?? import_compiler19.types.identifier("undefined");
   const diff = section.depth - targetSection.depth;
@@ -3183,7 +3158,7 @@ function getScopeExpression(section, targetSection) {
 function createScopeReadExpression(section, reference) {
   const propName = toPropertyName(getScopeAccessor(reference));
   return import_compiler19.types.memberExpression(
-    getScopeExpression(section, reference.section),
+    reference.type === 4 /* local */ ? scopeIdentifier : getScopeExpression(section, reference.section),
     propName,
     propName.type !== "Identifier"
   );
@@ -3393,20 +3368,10 @@ function signalHasStatements(signal) {
 function getSignalFn(signal) {
   const section = signal.section;
   const binding = signal.referencedBindings;
-  const params = [scopeIdentifier];
   const isIntersection = Array.isArray(binding);
   const isBinding = binding && !isIntersection;
   const isValue = isBinding && binding.section === section;
   const assertsHoists = isValue && binding.hoists.size && !isOptimize();
-  if (isBinding && (signal.renderReferencedBindings || assertsHoists || binding.aliases.size || binding.propertyAliases.size)) {
-    const valueParam = import_compiler22.types.identifier(binding.name);
-    if (binding.loc) {
-      valueParam.loc = binding.loc;
-      valueParam.start = binding.loc.start.index;
-      valueParam.end = binding.loc.end.index;
-    }
-    params.push(valueParam);
-  }
   if (isValue) {
     for (const alias of binding.aliases) {
       const aliasSignal = getSignal(alias.section, alias);
@@ -3438,7 +3403,7 @@ function getSignalFn(signal) {
                     ...getTranslatedExtraArgs(aliasSignal)
                   ])
                 ),
-                [import_compiler22.types.identifier(binding.name)]
+                [createScopeReadExpression(binding.section, binding)]
               )
             )
           );
@@ -3447,7 +3412,7 @@ function getSignalFn(signal) {
             import_compiler22.types.expressionStatement(
               import_compiler22.types.callExpression(aliasSignal.identifier, [
                 scopeIdentifier,
-                import_compiler22.types.identifier(binding.name),
+                createScopeReadExpression(binding.section, binding),
                 ...getTranslatedExtraArgs(aliasSignal)
               ])
             )
@@ -3462,7 +3427,7 @@ function getSignalFn(signal) {
           import_compiler22.types.callExpression(aliasSignal.identifier, [
             scopeIdentifier,
             toMemberExpression(
-              import_compiler22.types.identifier(binding.name),
+              createScopeReadExpression(binding.section, binding),
               key,
               binding.nullable
             ),
@@ -3474,7 +3439,10 @@ function getSignalFn(signal) {
     if (assertsHoists) {
       signal.render.push(
         import_compiler22.types.expressionStatement(
-          callRuntime("_assert_hoist", import_compiler22.types.identifier(binding.name))
+          callRuntime(
+            "_assert_hoist",
+            createScopeReadExpression(binding.section, binding)
+          )
         )
       );
     }
@@ -3556,42 +3524,25 @@ function getSignalFn(signal) {
       )
     );
   }
-  if (isIntersection && signal.renderReferencedBindings) {
-    signal.render.unshift(
-      import_compiler22.types.variableDeclaration("let", [
-        import_compiler22.types.variableDeclarator(
-          createScopeReadPattern(section, signal.renderReferencedBindings),
-          scopeIdentifier
-        )
-      ])
-    );
-  }
   if (signal.render.length === 1) {
     const render = signal.render[0];
     if (render.type === "ExpressionStatement") {
       const { expression } = render;
       if (expression.type === "CallExpression") {
         const args = expression.arguments;
-        if (params.length >= args.length) {
-          let i = args.length;
-          for (; i--; ) {
-            const param = params[i];
-            const arg = args[i];
-            if (arg.type !== "Identifier" || param.type !== "Identifier" || param.name !== arg.name) {
-              break;
-            }
-          }
-          if (i === -1) {
-            if (expression.callee.type === "MemberExpression" && expression.callee.property.type === "Identifier" && expression.callee.property.name === "_") {
-              return expression.callee.object;
-            }
-            return expression.callee;
+        if (args.length === 1 && args[0].type === "Identifier" && args[0].name === scopeIdentifier.name) {
+          if (expression.callee.type === "MemberExpression" && expression.callee.property.type === "Identifier" && expression.callee.property.name === "_") {
+            return expression.callee.object;
           }
+          return expression.callee;
         }
       }
     }
   }
-  return import_compiler22.types.arrowFunctionExpression(params, import_compiler22.types.blockStatement(signal.render));
+  return import_compiler22.types.arrowFunctionExpression(
+    [scopeIdentifier],
+    import_compiler22.types.blockStatement(signal.render)
+  );
 }
 var hasTranslatedExtraArgs = /* @__PURE__ */ new WeakSet();
 var emptyExtraArgs = [];
@@ -3758,11 +3709,11 @@ function writeSignals(section) {
     writeSignal(signal);
   }
   function writeSignal(signal) {
-    if (!signal.build || seen.has(signal)) return;
+    if (seen.has(signal)) return;
     seen.add(signal);
-    for (const value2 of signal.values) {
-      writeSignal(value2.signal);
-      traverseReplace(value2, "value", replaceRenderNode);
+    for (const value of signal.values) {
+      writeSignal(value.signal);
+      traverseReplace(value, "value", replaceRenderNode);
     }
     forEach(signal.intersection, writeSignal);
     traverseReplace(signal, "render", replaceRenderNode);
@@ -3772,11 +3723,6 @@ function writeSignals(section) {
       const effectIdentifier = import_compiler22.types.identifier(
         `${signal.identifier.name}__script`
       );
-      const referencedBindings = signal.effectReferencedBindings;
-      const referencesScope = traverseContains(
-        signal.effect,
-        isScopeIdentifier
-      );
       effectDeclarator = import_compiler22.types.variableDeclarator(
         effectIdentifier,
         callRuntime(
@@ -3785,45 +3731,47 @@ function writeSignals(section) {
             getResumeRegisterId(section, signal.referencedBindings)
           ),
           import_compiler22.types.arrowFunctionExpression(
-            referencedBindings ? referencesScope ? [
-              scopeIdentifier,
-              createScopeReadPattern(section, referencedBindings)
-            ] : [createScopeReadPattern(section, referencedBindings)] : referencesScope ? [scopeIdentifier] : [],
+            [scopeIdentifier],
             toFirstExpressionOrBlock(signal.effect)
           )
         )
       );
     }
-    let value = signal.build();
-    if (!value || !signal.register && import_compiler22.types.isFunction(value) && import_compiler22.types.isBlockStatement(value.body) && !value.body.body.length) {
-      return;
-    }
-    if (import_compiler22.types.isCallExpression(value)) {
-      replaceNullishAndEmptyFunctionsWith0(value.arguments);
-    }
-    if (signal.register) {
-      value = callRuntime(
-        "_var_resume",
-        import_compiler22.types.stringLiteral(
-          getResumeRegisterId(section, signal.referencedBindings, "var")
-        ),
-        value
-      );
-    }
-    const signalDeclarator = import_compiler22.types.variableDeclarator(signal.identifier, value);
-    let signalDeclaration = !section.parent && !signal.referencedBindings && (import_compiler22.types.isFunctionExpression(value) || import_compiler22.types.isArrowFunctionExpression(value)) ? import_compiler22.types.functionDeclaration(
-      signal.identifier,
-      value.params,
-      import_compiler22.types.isExpression(value.body) ? import_compiler22.types.blockStatement([import_compiler22.types.expressionStatement(value.body)]) : value.body
-    ) : import_compiler22.types.variableDeclaration("const", [signalDeclarator]);
-    if (signal.export) {
-      signalDeclaration = import_compiler22.types.exportNamedDeclaration(signalDeclaration);
+    let signalDeclaration;
+    if (signal.build) {
+      let value = signal.build();
+      if (!value || !signal.register && import_compiler22.types.isFunction(value) && import_compiler22.types.isBlockStatement(value.body) && !value.body.body.length) {
+        return;
+      }
+      if (import_compiler22.types.isCallExpression(value)) {
+        replaceNullishAndEmptyFunctionsWith0(value.arguments);
+      }
+      if (signal.register) {
+        value = callRuntime(
+          "_var_resume",
+          import_compiler22.types.stringLiteral(
+            getResumeRegisterId(section, signal.referencedBindings, "var")
+          ),
+          value
+        );
+      }
+      const signalDeclarator = import_compiler22.types.variableDeclarator(signal.identifier, value);
+      signalDeclaration = !section.parent && !signal.referencedBindings && (import_compiler22.types.isFunctionExpression(value) || import_compiler22.types.isArrowFunctionExpression(value)) ? import_compiler22.types.functionDeclaration(
+        signal.identifier,
+        value.params,
+        import_compiler22.types.isExpression(value.body) ? import_compiler22.types.blockStatement([import_compiler22.types.expressionStatement(value.body)]) : value.body
+      ) : import_compiler22.types.variableDeclaration("const", [signalDeclarator]);
+      if (signal.export) {
+        signalDeclaration = import_compiler22.types.exportNamedDeclaration(signalDeclaration);
+      }
     }
     const signalStatements = signal.prependStatements || [];
     if (effectDeclarator) {
       signalStatements.push(import_compiler22.types.variableDeclaration("const", [effectDeclarator]));
     }
-    signalStatements.push(signalDeclaration);
+    if (signalDeclaration) {
+      signalStatements.push(signalDeclaration);
+    }
     (0, import_babel_utils15.getProgram)().node.body.push(...signalStatements);
   }
 }
@@ -3898,25 +3846,10 @@ function writeRegisteredFns() {
   if (registeredFns) {
     for (const registeredFn of registeredFns) {
       let fn;
-      const params = registeredFn.referencedBindings ? registeredFn.referencesScope ? [
-        scopeIdentifier,
-        import_compiler22.types.assignmentPattern(
-          createScopeReadPattern(
-            registeredFn.section,
-            registeredFn.referencedBindings
-          ),
-          scopeIdentifier
-        )
-      ] : [
-        createScopeReadPattern(
-          registeredFn.section,
-          registeredFn.referencedBindings
-        )
-      ] : registeredFn.referencesScope ? [scopeIdentifier] : void 0;
-      if (params) {
+      if (registeredFn.referencedBindings || registeredFn.referencesScope) {
         fn = import_compiler22.types.functionDeclaration(
           import_compiler22.types.identifier(registeredFn.id),
-          params,
+          [scopeIdentifier],
           import_compiler22.types.blockStatement(toReturnedFunction(registeredFn.node))
         );
       } else if (registeredFn.node.type === "FunctionDeclaration" && registeredFn.node.id?.name === registeredFn.id) {
@@ -4168,32 +4101,34 @@ var updateExpressions = /* @__PURE__ */ new WeakSet();
 function replaceAssignedNode(node) {
   switch (node.type) {
     case "ExpressionStatement": {
-      if (node.expression.type === "SequenceExpression" && updateExpressions.delete(node.expression)) {
-        node.expression = node.expression.expressions[0];
-        return node;
+      if (node.expression.type === "BinaryExpression" && updateExpressions.delete(node.expression)) {
+        node.expression = node.expression.left;
+      }
+      if (node.expression.type === "CallExpression" && updateExpressions.delete(node.expression)) {
+        node.expression.callee = node.expression.arguments[0];
+        node.expression.arguments = [node.expression.arguments[1]];
       }
       break;
     }
     case "UpdateExpression": {
       const { extra } = node.argument;
       if (isAssignedBindingExtra(extra)) {
-        const builtAssignment = getBuildAssignment(extra)?.(
+        let builtAssignment = getBuildAssignment(extra)?.(
           extra.section,
-          node
+          import_compiler22.types.binaryExpression(
+            node.operator === "++" ? "+" : "-",
+            createScopeReadExpression(extra.section, extra.assignment),
+            import_compiler22.types.numericLiteral(1)
+          )
         );
         if (builtAssignment) {
           if (!node.prefix) {
-            node.prefix = true;
-            const replacement = import_compiler22.types.sequenceExpression([
+            builtAssignment = import_compiler22.types.binaryExpression(
+              node.operator === "++" ? "-" : "+",
               builtAssignment,
-              import_compiler22.types.binaryExpression(
-                node.operator === "++" ? "-" : "+",
-                node.argument,
-                import_compiler22.types.numericLiteral(1)
-              )
-            ]);
-            updateExpressions.add(replacement);
-            return replacement;
+              import_compiler22.types.numericLiteral(1)
+            );
+            updateExpressions.add(builtAssignment);
           }
           return builtAssignment;
         }
@@ -4207,15 +4142,15 @@ function replaceAssignedNode(node) {
           if (isAssignedBindingExtra(extra)) {
             return getBuildAssignment(extra)?.(
               extra.section,
-              bindingUtil.has(
-                extra.assignmentFunction.referencedBindingsInFunction,
-                extra.assignment
-              ) ? node : node.operator === "=" ? node.right : import_compiler22.types.binaryExpression(
+              node.operator === "=" ? node.right : import_compiler22.types.binaryExpression(
                 node.operator.slice(
                   0,
                   -1
                 ),
-                node.left,
+                createScopeReadExpression(
+                  extra.section,
+                  extra.assignment
+                ),
                 node.right
               )
             ) || extra?.assignment && withLeadingComment(node.right, getDebugName(extra.assignment));
@@ -4237,12 +4172,7 @@ function replaceAssignedNode(node) {
                   import_compiler22.types.identifier(uid)
                 );
                 if (builtAssignment) {
-                  if (!bindingUtil.has(
-                    extra.assignmentFunction.referencedBindingsInFunction,
-                    extra.assignment
-                  )) {
-                    id.name = uid;
-                  }
+                  id.name = uid;
                   (params ||= []).push(import_compiler22.types.identifier(uid));
                   (assignments ||= []).push(builtAssignment);
                   return;
@@ -4280,8 +4210,14 @@ function replaceAssignedNode(node) {
 function getBuildAssignment(extra) {
   const { assignmentTo, assignment } = extra;
   if (assignmentTo) {
-    return (_section, value) => {
-      return import_compiler22.types.callExpression(import_compiler22.types.identifier(assignmentTo.name), [value]);
+    return (section, value) => {
+      const replacement = callRuntime(
+        "_call",
+        createScopeReadExpression(section, assignmentTo),
+        value
+      );
+      updateExpressions.add(replacement);
+      return replacement;
     };
   }
   return getSignal(assignment.section, assignment).buildAssignment;
@@ -6389,10 +6325,9 @@ var for_default = {
         const tagExtra = node.extra;
         const { referencedBindings } = tagExtra;
         const nodeRef = getOptimizedOnlyChildNodeBinding(tag, tagSection);
-        setClosureSignalBuilder(tag, (closure, render) => {
+        setClosureSignalBuilder(tag, (_closure, render) => {
           return callRuntime(
             "_for_closure",
-            getScopeAccessorLiteral(closure),
             getScopeAccessorLiteral(nodeRef),
             render
           );
@@ -7998,25 +7933,28 @@ function trackReferencesForBinding(babelBinding, binding) {
   }
 }
 function trackAssignment(assignment, binding) {
-  const fnRoot = getFnRoot(assignment);
+  const fnParent = getFnParent(assignment);
+  if (!fnParent) {
+    throw assignment.buildCodeFrameError(
+      `Assignments to a tag ${binding.type === 3 /* param */ ? "parameter" : "variable"} must be within a script or function.`
+    );
+  }
+  const fnRoot = getFnRoot(fnParent);
+  const fnExtra = fnRoot && (fnRoot.node.extra ??= {});
   const section = getOrCreateSection(assignment);
   setReferencesScope(assignment);
   forEachIdentifierPath(assignment, (id) => {
     if (id.node.name === binding.name) {
-      if (!fnRoot) {
-        throw id.buildCodeFrameError(
-          `Assignments to a tag ${binding.type === 3 /* param */ ? "parameter" : "variable"} must be within a script or function.`
-        );
-      }
-      const fnExtra = fnRoot && (fnRoot.node.extra ??= {});
       const idExtra = id.node.extra ??= {};
       idExtra.assignment = binding;
-      idExtra.assignmentFunction = fnExtra;
-      fnExtra.section = idExtra.section = section;
       binding.assignmentSections = sectionUtil.add(
         binding.assignmentSections,
         section
       );
+      if (fnExtra) {
+        idExtra.assignmentFunction = fnExtra;
+        fnExtra.section = idExtra.section = section;
+      }
       if (binding.upstreamAlias && binding.property !== void 0) {
         const changePropName = binding.property + "Change";
         const changeBinding = binding.upstreamAlias.propertyAliases.get(changePropName) || createBinding(
@@ -8546,6 +8484,8 @@ function resolveBindingSources(binding) {
         binding.sources = aliasRoot2.sources;
       } else if (binding.assignmentSections) {
         binding.sources = createSources(binding, void 0);
+      } else {
+        resolveDerivedSources(binding);
       }
       return;
     }
@@ -8780,78 +8720,74 @@ function getSectionInstancesAccessorLiteral(section) {
 }
 function getReadReplacement(node) {
   const { extra } = node;
-  if (!extra) return;
-  let { binding, read } = extra;
-  let replacement;
+  if (!extra || extra.assignment) return;
+  const { read, binding } = extra;
   if (read) {
+    const readBinding = read.binding;
+    let replacement;
     if (read.props === void 0) {
-      binding = read.binding;
-      read = void 0;
-    } else {
-      binding = void 0;
-    }
-  }
-  if (binding) {
-    if (node.type === "Identifier") {
-      if (binding.type === 0 /* dom */) {
-        if (binding.section.domGetterBindings.has(binding) && isOutputDOM()) {
-          replacement = import_compiler35.types.callExpression(getBindingGetterIdentifier(binding), [
-            getScopeExpression(node.extra.section, binding.section)
-          ]);
-        }
-      } else if (binding.type === 6 /* hoist */) {
-        if (node.extra?.[kIsInvoked]) {
-          if (isOutputDOM()) {
+      if (isOutputDOM()) {
+        if (readBinding.type === 0 /* dom */) {
+          if (!extra[kIsInvoked] && readBinding.section.domGetterBindings.has(readBinding)) {
             replacement = import_compiler35.types.callExpression(
-              getBindingGetterIdentifier(binding),
-              [getScopeExpression(node.extra.section, binding.section)]
+              getBindingGetterIdentifier(readBinding),
+              [getScopeExpression(extra.section, readBinding.section)]
             );
           }
+        } else if (readBinding.type === 6 /* hoist */ && extra[kIsInvoked]) {
+          replacement = import_compiler35.types.callExpression(
+            getBindingGetterIdentifier(readBinding),
+            [getScopeExpression(extra.section, readBinding.section)]
+          );
         } else {
-          replacement = import_compiler35.types.identifier(binding.name);
+          replacement = createScopeReadExpression(extra.section, readBinding);
+        }
+      } else {
+        if (node.type !== "Identifier") {
+          replacement = import_compiler35.types.identifier(readBinding.name);
+        } else if (readBinding.name !== node.name && readBinding.type !== 0 /* dom */ && (readBinding.type !== 6 /* hoist */ || !extra[kIsInvoked])) {
+          node.name = readBinding.name;
         }
-      } else if (binding.name !== node.name) {
-        node.name = binding.name;
       }
     } else {
-      replacement = import_compiler35.types.identifier(binding.name);
-    }
-  } else if (read) {
-    const props = read.props ? Array.isArray(read.props) ? read.props.slice() : [read.props] : [];
-    let curNode = node;
-    let curBinding = read.binding;
-    let replaceMember;
-    replacement = import_compiler35.types.identifier(read.binding.name);
-    while (props.length && (curNode.type === "MemberExpression" || curNode.type === "OptionalMemberExpression")) {
-      const prop = props.pop();
-      const memberProp = getMemberExpressionPropString(curNode);
-      if (memberProp !== prop) break;
-      replaceMember = curNode;
-      curNode = curNode.object;
-    }
-    for (const prop of props) {
-      if (curBinding) {
-        curBinding = curBinding.propertyAliases.get(prop);
-      }
-      replacement = toMemberExpression(
-        replacement,
-        prop,
-        !!curBinding?.nullable
-      );
-    }
-    if (replaceMember) {
-      if (read.binding.nullable && replaceMember.object.type !== replacement.type) {
-        replaceMember.type = "OptionalMemberExpression";
-        replaceMember.optional = true;
+      const props = read.props ? Array.isArray(read.props) ? read.props.slice() : [read.props] : [];
+      let curNode = node;
+      let curBinding = read.binding;
+      let replaceMember;
+      replacement = isOutputDOM() ? createScopeReadExpression(extra.section, read.binding) : import_compiler35.types.identifier(read.binding.name);
+      while (props.length && (curNode.type === "MemberExpression" || curNode.type === "OptionalMemberExpression")) {
+        const prop = props.pop();
+        const memberProp = getMemberExpressionPropString(curNode);
+        if (memberProp !== prop) break;
+        replaceMember = curNode;
+        curNode = curNode.object;
+      }
+      for (const prop of props) {
+        if (curBinding) {
+          curBinding = curBinding.propertyAliases.get(prop);
+        }
+        replacement = toMemberExpression(
+          replacement,
+          prop,
+          !!curBinding?.nullable
+        );
+      }
+      if (replaceMember) {
+        if (read.binding.nullable && replaceMember.object.type !== replacement.type) {
+          replaceMember.type = "OptionalMemberExpression";
+          replaceMember.optional = true;
+        }
+        replaceMember.object = withPreviousLocation(
+          replacement,
+          replaceMember.object
+        );
+        replacement = void 0;
       }
-      replaceMember.object = withPreviousLocation(
-        replacement,
-        replaceMember.object
-      );
-      replacement = void 0;
     }
+    return replacement && withPreviousLocation(replacement, node);
+  } else if (binding && node.type == "Identifier" && node.name !== binding.name) {
+    node.name = binding.name;
   }
-  return replacement && withPreviousLocation(replacement, node);
 }
 function pruneBinding(bindings, binding) {
   let shouldPrune = !binding.downstreamExpressions.size;
@@ -8939,14 +8875,23 @@ function resolveReferencedBindings(expr, reads, intersectionsBySection) {
     const rootBindings = getRootBindings(reads);
     for (const read of reads) {
       let { binding } = read;
-      if (read.node && read.node.extra?.assignmentTo !== binding) {
-        ({ binding } = (read.node.extra ??= {}).read ??= resolveExpressionReference(rootBindings, binding));
+      if (read.node) {
+        const readExtra = read.node.extra ??= {};
+        if (readExtra.assignmentTo !== binding) {
+          readExtra.section = expr.section;
+          ({ binding } = readExtra.read ??= resolveExpressionReference(
+            rootBindings,
+            binding
+          ));
+        }
       }
       referencedBindings = bindingUtil.add(referencedBindings, binding);
     }
   } else if (reads) {
     if (reads.node) {
-      (reads.node.extra ??= {}).read = createRead(reads.binding, void 0);
+      const readExtra = reads.node.extra ??= {};
+      readExtra.section = expr.section;
+      readExtra.read = createRead(reads.binding, void 0);
     }
     referencedBindings = reads.binding;
   }
@@ -9284,7 +9229,7 @@ var const_default = {
         }
       }
       if (!valueExtra.nullable) binding.nullable = false;
-      setBindingDownstream(binding, valueExtra);
+      if (!upstreamAlias) setBindingDownstream(binding, valueExtra);
     }
   },
   translate: {
@@ -10658,10 +10603,9 @@ var IfTag = {
             const consequent = import_compiler48.types.numericLiteral(branchBodySection ? i : -1);
             if (branchBodySection) {
               rendererIdentifiers.push(import_compiler48.types.identifier(branchBodySection.name));
-              setClosureSignalBuilder(branchTag, (closure, render) => {
+              setClosureSignalBuilder(branchTag, (_closure, render) => {
                 return callRuntime(
                   "_if_closure",
-                  getScopeAccessorLiteral(closure),
                   getScopeAccessorLiteral(nodeRef),
                   import_compiler48.types.numericLiteral(i),
                   render
@@ -10888,17 +10832,20 @@ var let_default = {
     }
     const tagSection = getOrCreateSection(tag);
     const binding = trackVarReferences(tag, 1 /* let */);
-    mergeReferences(tagSection, tag.node, [
+    const tagExtra = mergeReferences(tagSection, tag.node, [
       valueAttr?.value,
       valueChangeAttr?.value
     ]);
     if (valueChangeAttr) {
+      setBindingDownstream(binding, tagExtra);
       addSerializeReason(
         tagSection,
         true,
         binding,
         getAccessorPrefix().TagVariableChange
       );
+    } else {
+      setBindingDownstream(binding, false);
     }
   },
   translate: {