marko 6.0.0-next.3.85 → 6.0.0

package/dist/translator/index.js

@@ -110,7 +110,7 @@ var attrs_default = {
 
 // src/translator/core/await.ts
 var import_compiler25 = require("@marko/compiler");
-var import_babel_utils17 = require("@marko/compiler/babel-utils");
+var import_babel_utils18 = require("@marko/compiler/babel-utils");
 
 // src/common/accessor.debug.ts
 var AccessorPrefix = /* @__PURE__ */ ((AccessorPrefix4) => {
@@ -132,6 +132,7 @@ var AccessorPrefix = /* @__PURE__ */ ((AccessorPrefix4) => {
   return AccessorPrefix4;
 })(AccessorPrefix || {});
 var AccessorProp = /* @__PURE__ */ ((AccessorProp4) => {
+  AccessorProp4["Owner"] = "_";
   AccessorProp4["BranchAccessor"] = "#BranchAccessor";
   AccessorProp4["CatchContent"] = "#CatchContent";
   AccessorProp4["PlaceholderBranch"] = "#PlaceholderBranch";
@@ -154,16 +155,85 @@ function evaluate(value) {
     if (computed) {
       extra.computed = computed.value;
       extra.confident = true;
+      extra.nullable = computed.value == null;
     } else {
       extra.computed = void 0;
       extra.confident = false;
+      extra.nullable = isNullableExpr(value);
     }
   }
   return extra;
 }
+function isNullableExpr(expr) {
+  switch (expr.type) {
+    case "ArrayExpression":
+    case "ArrowFunctionExpression":
+    case "BigIntLiteral":
+    case "BinaryExpression":
+    case "BooleanLiteral":
+    case "ClassExpression":
+    case "FunctionExpression":
+    case "NewExpression":
+    case "NumericLiteral":
+    case "ObjectExpression":
+    case "RegExpLiteral":
+    case "StringLiteral":
+    case "TemplateLiteral":
+    case "UpdateExpression":
+      return false;
+    case "AssignmentExpression":
+      switch (expr.operator) {
+        case "=":
+          return isNullableExpr(expr.right);
+        case "*=":
+        case "/=":
+        case "%=":
+        case "+=":
+        case "-=":
+        case "<<=":
+        case ">>=":
+        case ">>>=":
+        case "&=":
+        case "^=":
+        case "|=":
+        case "**=":
+          return false;
+        case "||=":
+        case "??=":
+          return isNullableExpr(expr.right) || isNullableExpr(expr.left);
+        case "&&=":
+          return isNullableExpr(expr.left) && isNullableExpr(expr.right);
+        default:
+          return true;
+      }
+    case "AwaitExpression":
+      return isNullableExpr(expr.argument);
+    case "ConditionalExpression":
+      return isNullableExpr(expr.consequent) && isNullableExpr(expr.alternate);
+    case "LogicalExpression":
+      switch (expr.operator) {
+        case "||":
+        case "??":
+          return isNullableExpr(expr.right) || isNullableExpr(expr.left);
+        case "&&":
+          return isNullableExpr(expr.left) && isNullableExpr(expr.right);
+        default:
+          return true;
+      }
+    case "ParenthesizedExpression":
+      return isNullableExpr(expr.expression);
+    case "SequenceExpression":
+      return isNullableExpr(expr.expressions[expr.expressions.length - 1]);
+    case "UnaryExpression":
+      return expr.operator === "void";
+    default:
+      return true;
+  }
+}
 
 // src/translator/util/references.ts
 var import_compiler24 = require("@marko/compiler");
+var import_babel_utils17 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/for-each-identifier.ts
 function forEachIdentifier(node, cb) {
@@ -310,6 +380,37 @@ function generateUid(name2 = "") {
 function generateUidIdentifier(name2) {
   return import_compiler3.types.identifier(generateUid(name2));
 }
+var sharedUIDsForFile = /* @__PURE__ */ new WeakMap();
+function getSharedUid(name2) {
+  const file = (0, import_babel_utils4.getFile)();
+  let sharedUIDs = sharedUIDsForFile.get(file);
+  if (!sharedUIDs) {
+    const { cache } = file.markoOpts;
+    const { filename } = file.opts;
+    const cacheKey = `uid-shared:${filename}`;
+    sharedUIDs = cache.get(cacheKey);
+    if (sharedUIDs) {
+      if (isTranslate()) {
+        sharedUIDs = new Map(sharedUIDs);
+      }
+    } else {
+      sharedUIDs = /* @__PURE__ */ new Map();
+      if (!isTranslate()) {
+        cache.set(cacheKey, sharedUIDs);
+      }
+    }
+    sharedUIDsForFile.set(file, sharedUIDs);
+  }
+  let uniqueName = sharedUIDs.get(name2);
+  if (!uniqueName) {
+    uniqueName = generateUid(name2);
+    sharedUIDs.set(name2, uniqueName);
+  }
+  return uniqueName;
+}
+function usedSharedUid(name2) {
+  return !!sharedUIDsForFile.get((0, import_babel_utils4.getFile)())?.has(name2);
+}
 function getInitialCounts(file) {
   const counts = /* @__PURE__ */ new Map();
   const program = file.path;
@@ -352,6 +453,7 @@ var AccessorPrefix2 = /* @__PURE__ */ ((AccessorPrefix4) => {
   return AccessorPrefix4;
 })(AccessorPrefix2 || {});
 var AccessorProp2 = /* @__PURE__ */ ((AccessorProp4) => {
+  AccessorProp4["Owner"] = "_";
   AccessorProp4["BranchAccessor"] = "a";
   AccessorProp4["CatchContent"] = "b";
   AccessorProp4["PlaceholderBranch"] = "c";
@@ -506,18 +608,8 @@ var Sorted = class {
   findIndex(data, item) {
     if (data) {
       if (Array.isArray(data)) {
-        let max = data.length;
-        let pos = 0;
-        while (pos < max) {
-          const mid = pos + max >>> 1;
-          const compareResult = this.compare(data[mid], item);
-          if (compareResult === 0) return mid;
-          if (compareResult > 0) max = mid;
-          else pos = mid + 1;
-        }
-        return -1;
-      }
-      if (this.compare(data, item) === 0) {
+        return findIndexSorted(this.compare, data, item);
+      } else if (this.compare(data, item) === 0) {
         return 0;
       }
     }
@@ -640,9 +732,41 @@ function find(data, cb) {
     }
   }
 }
-function map(data, cb) {
+function toArray(data, cb) {
   return data ? Array.isArray(data) ? data.map(cb) : [cb(data, 0)] : [];
 }
+function filterMap(data, cb) {
+  if (data) {
+    if (Array.isArray(data)) {
+      const len = data.length;
+      let result;
+      let i = 0;
+      while (i < len) {
+        let item = cb(data[i++]);
+        if (item) {
+          result = item;
+          while (i < len) {
+            item = cb(data[i++]);
+            if (item) {
+              result = [result, item];
+              while (i < len) {
+                item = cb(data[i++]);
+                if (item) {
+                  result.push(item);
+                }
+              }
+              return result;
+            }
+          }
+          return result;
+        }
+      }
+      return result;
+    } else {
+      return cb(data);
+    }
+  }
+}
 function findSorted(compare, data, item) {
   let max = data.length;
   let pos = 0;
@@ -655,6 +779,18 @@ function findSorted(compare, data, item) {
     else pos = mid + 1;
   }
 }
+function findIndexSorted(compare, data, item) {
+  let max = data.length;
+  let pos = 0;
+  while (pos < max) {
+    const mid = pos + max >>> 1;
+    const compareResult = compare(data[mid], item);
+    if (compareResult === 0) return mid;
+    if (compareResult > 0) max = mid;
+    else pos = mid + 1;
+  }
+  return -1;
+}
 function addSorted(compare, data, item) {
   const len = data.length;
   let max = len;
@@ -783,9 +919,81 @@ var entry_builder_default = {
   }
 };
 
+// src/translator/util/get-known-attr-values.ts
+function getKnownAttrValues(tag) {
+  const attrs2 = {};
+  for (const attr2 of tag.attributes) {
+    if (attr2.type === "MarkoAttribute") {
+      attrs2[attr2.name] = attr2.value;
+    }
+  }
+  return attrs2;
+}
+
+// src/translator/util/is-core-tag.ts
+var import_babel_utils7 = require("@marko/compiler/babel-utils");
+
+// src/translator/util/get-tag-name.ts
+function getTagName(tag) {
+  return tag.node.name.value;
+}
+
+// src/translator/util/is-core-tag.ts
+var { taglibId } = runtime_info_default;
+var htmlTaglibId = "marko-html";
+var interopTaglibId = "@marko/translator-interop-class-tags";
+function isCoreTag(tag) {
+  if (tag.isMarkoTag()) {
+    const tagDef = (0, import_babel_utils7.getTagDef)(tag);
+    if (tagDef) {
+      switch (tagDef.taglibId) {
+        case taglibId:
+        case interopTaglibId:
+          return true;
+        case htmlTaglibId:
+          switch (tagDef.name) {
+            case "script":
+            case "style":
+              return true;
+          }
+          break;
+      }
+    }
+  }
+  return false;
+}
+function isCoreTagName(tag, name2) {
+  return isCoreTag(tag) && getTagName(tag) === name2;
+}
+function isConditionTag(tag) {
+  if (isCoreTag(tag)) {
+    switch (getTagName(tag)) {
+      case "if":
+      case "else-if":
+      case "else":
+        return true;
+    }
+  }
+  return false;
+}
+function isControlFlowTag(tag) {
+  if (isCoreTag(tag)) {
+    switch (getTagName(tag)) {
+      case "if":
+      case "else-if":
+      case "else":
+      case "for":
+      case "await":
+      case "try":
+        return true;
+    }
+  }
+  return false;
+}
+
 // src/translator/util/runtime.ts
 var import_compiler7 = require("@marko/compiler");
-var import_babel_utils7 = require("@marko/compiler/babel-utils");
+var import_babel_utils8 = require("@marko/compiler/babel-utils");
 
 // src/common/attr-tag.ts
 var rest = false ? Symbol("Attribute Tag") : Symbol();
@@ -1251,7 +1459,7 @@ var pureDOMFunctions = /* @__PURE__ */ new Set([
 function importRuntime(name2) {
   const { output } = getMarkoOpts();
   return toMemberExpression(
-    (0, import_babel_utils7.importStar)((0, import_babel_utils7.getFile)(), getRuntimePath(output), "$"),
+    (0, import_babel_utils8.importStar)((0, import_babel_utils8.getFile)(), getRuntimePath(output), "$"),
     name2
   );
 }
@@ -1304,82 +1512,27 @@ function getCompatRuntimeFile() {
 var import_compiler10 = require("@marko/compiler");
 var import_babel_utils11 = require("@marko/compiler/babel-utils");
 
-// src/translator/util/is-core-tag.ts
-var import_babel_utils8 = require("@marko/compiler/babel-utils");
-
-// src/translator/util/get-tag-name.ts
-function getTagName(tag) {
-  return tag.node.name.value;
-}
-
-// src/translator/util/is-core-tag.ts
-var { taglibId } = runtime_info_default;
-var htmlTaglibId = "marko-html";
-var interopTaglibId = "@marko/translator-interop-class-tags";
-function isCoreTag(tag) {
-  if (tag.isMarkoTag()) {
-    const tagDef = (0, import_babel_utils8.getTagDef)(tag);
-    if (tagDef) {
-      switch (tagDef.taglibId) {
-        case taglibId:
-        case interopTaglibId:
-          return true;
-        case htmlTaglibId:
-          switch (tagDef.name) {
-            case "script":
-            case "style":
-              return true;
-          }
-          break;
-      }
-    }
-  }
-  return false;
-}
-function isCoreTagName(tag, name2) {
-  return isCoreTag(tag) && getTagName(tag) === name2;
-}
-function isConditionTag(tag) {
-  if (isCoreTag(tag)) {
-    switch (getTagName(tag)) {
-      case "if":
-      case "else-if":
-      case "else":
-        return true;
-    }
-  }
-  return false;
-}
-function isControlFlowTag(tag) {
-  if (isCoreTag(tag)) {
-    switch (getTagName(tag)) {
-      case "if":
-      case "else-if":
-      case "else":
-      case "for":
-      case "await":
-      case "try":
-        return true;
-    }
-  }
-  return false;
-}
-
 // src/translator/util/serialize-reasons.ts
 var import_compiler8 = require("@marko/compiler");
-var serializeReasonExprs = /* @__PURE__ */ new WeakMap();
+var reasonExprs = /* @__PURE__ */ new WeakMap();
+var keyedReasonExprs = /* @__PURE__ */ new WeakMap();
 var serializeKeysByBinding = /* @__PURE__ */ new WeakMap();
 var serializeKeyBySourceModifier = {};
-function forcePropSerialize(section, extra, prop) {
-  forceSerialize(section, getPropSerializeReasonKey(extra, prop));
+function forceSectionSerialize(section, prop) {
+  if (prop) {
+    forceSerializeKey(section, getSectionPropSerializeReasonKey(section, prop));
+  } else if (section.serializeReason !== true) {
+    reasonExprs.delete(section);
+    section.serializeReason = true;
+  }
 }
 function forceBindingSerialize(section, binding, prefix2) {
-  forceSerialize(section, getBindingSerializeReasonKey(binding, prefix2));
+  forceSerializeKey(section, getBindingSerializeReasonKey(binding, prefix2));
 }
-function forceSerialize(section, key) {
+function forceSerializeKey(section, key) {
   if (section.serializeReasons.get(key) !== true) {
     section.serializeReasons.set(key, true);
-    serializeReasonExprs.get(section)?.delete(key);
+    keyedReasonExprs.get(section)?.delete(key);
   }
 }
 function isBindingForceSerialized(section, binding, prefix2) {
@@ -1387,73 +1540,85 @@ function isBindingForceSerialized(section, binding, prefix2) {
     getBindingSerializeReasonKey(binding, prefix2)
   ) === true;
 }
-function addPropSerializeReasonExpr(section, extra, prop, expr) {
-  return addSerializeReasonExpr(
-    section,
-    getPropSerializeReasonKey(extra, prop),
-    expr
-  );
+function addSectionSerializeReasonExpr(section, expr, prop) {
+  if (expr) {
+    if (prop) {
+      addKeyedSerializeReasonExpr(
+        section,
+        getSectionPropSerializeReasonKey(section, prop),
+        expr
+      );
+    } else if (section.serializeReason !== true) {
+      if (expr === true) {
+        forceSectionSerialize(section);
+      } else {
+        const existingExpr = reasonExprs.get(section);
+        reasonExprs.set(
+          section,
+          existingExpr ? concat(existingExpr, expr) : expr
+        );
+      }
+    }
+  }
 }
 function addBindingSerializeReasonExpr(section, binding, expr, prefix2) {
-  return addSerializeReasonExpr(
-    section,
-    getBindingSerializeReasonKey(binding, prefix2),
-    expr
-  );
-}
-function addSerializeReasonExpr(section, key, expr) {
+  const key = getBindingSerializeReasonKey(binding, prefix2);
   if (expr && section.serializeReasons.get(key) !== true) {
-    if (expr === true) {
-      forceSerialize(section, key);
+    addKeyedSerializeReasonExpr(section, key, expr);
+  }
+}
+function addKeyedSerializeReasonExpr(section, key, expr) {
+  if (expr === true) {
+    forceSerializeKey(section, key);
+  } else {
+    let existingExpr;
+    let keyedExprs = keyedReasonExprs.get(section);
+    if (keyedExprs) {
+      existingExpr = keyedExprs.get(key);
     } else {
-      let existingExpr;
-      let exprsByKey = serializeReasonExprs.get(section);
-      if (exprsByKey) {
-        existingExpr = exprsByKey.get(key);
-      } else {
-        exprsByKey = /* @__PURE__ */ new Map();
-        serializeReasonExprs.set(section, exprsByKey);
-      }
-      exprsByKey.set(key, existingExpr ? concat(existingExpr, expr) : expr);
+      keyedExprs = /* @__PURE__ */ new Map();
+      keyedReasonExprs.set(section, keyedExprs);
     }
+    keyedExprs.set(key, existingExpr ? concat(existingExpr, expr) : expr);
   }
 }
-function addPropSerializeReasonRef(section, extra, prop, ref) {
-  addSerializeReasonRef(section, getPropSerializeReasonKey(extra, prop), ref);
-}
-function addSerializeReasonRef(section, key, ref) {
+function addSectionSerializeReasonRef(section, ref, prop) {
   if (ref) {
-    const existingReason = section.serializeReasons.get(key);
-    if (existingReason !== true) {
-      if (ref === true) {
-        forceSerialize(section, key);
-      } else {
-        const reason = getSerializeSourcesForRef(ref);
-        if (reason === true) {
-          forceSerialize(section, key);
+    if (prop) {
+      addKeyedSerializeReasonRef(
+        section,
+        getSectionPropSerializeReasonKey(section, prop),
+        ref
+      );
+    } else {
+      const existingReason = section.serializeReason;
+      if (existingReason !== true) {
+        if (ref === true) {
+          forceSectionSerialize(section);
         } else {
-          section.serializeReasons.set(
-            key,
-            mergeSerializeReasons(existingReason, reason)
-          );
+          const reason = getSerializeSourcesForRef(ref);
+          if (reason === true) {
+            forceSectionSerialize(section);
+          } else {
+            section.serializeReason = mergeSerializeReasons(
+              existingReason,
+              reason
+            );
+          }
         }
       }
     }
   }
 }
-function addBindingSerializeReason(section, binding, reason, prefix2) {
-  addSerializeReason(
-    section,
-    getBindingSerializeReasonKey(binding, prefix2),
-    reason
-  );
-}
-function addSerializeReason(section, key, reason) {
-  if (reason) {
-    const existingReason = section.serializeReasons.get(key);
-    if (existingReason !== true) {
+function addKeyedSerializeReasonRef(section, key, ref) {
+  const existingReason = section.serializeReasons.get(key);
+  if (existingReason !== true) {
+    if (ref === true) {
+      forceSerializeKey(section, key);
+    } else {
+      const reason = getSerializeSourcesForRef(ref);
       if (reason === true) {
-        forceSerialize(section, key);
+        forceSerializeKey(section, key);
       } else {
         section.serializeReasons.set(
           key,
@@ -1463,31 +1628,119 @@ function addSerializeReason(section, key, reason) {
     }
   }
 }
-function getPropSerializeReason(section, extra, prop) {
-  return section.serializeReasons.get(getPropSerializeReasonKey(extra, prop));
+function addSectionSerializeReason(section, reason, prop) {
+  if (reason) {
+    if (prop) {
+      addKeyedSerializeReason(
+        section,
+        getSectionPropSerializeReasonKey(section, prop),
+        reason
+      );
+    } else {
+      const existingReason = section.serializeReason;
+      if (existingReason !== true) {
+        if (reason === true) {
+          forceSectionSerialize(section);
+        } else {
+          section.serializeReason = mergeSerializeReasons(
+            existingReason,
+            reason
+          );
+        }
+      }
+    }
+  }
+}
+function addBindingSerializeReason(section, binding, reason, prefix2) {
+  if (reason) {
+    addKeyedSerializeReason(
+      section,
+      getBindingSerializeReasonKey(binding, prefix2),
+      reason
+    );
+  }
+}
+function addKeyedSerializeReason(section, key, reason) {
+  const existingReason = section.serializeReasons.get(key);
+  if (existingReason !== true) {
+    if (reason === true) {
+      forceSerializeKey(section, key);
+    } else {
+      section.serializeReasons.set(
+        key,
+        mergeSerializeReasons(existingReason, reason)
+      );
+    }
+  }
+}
+function getSectionSerializeReason(section, prop) {
+  return prop ? section.serializeReasons.get(
+    getSectionPropSerializeReasonKey(section, prop)
+  ) : section.serializeReason;
 }
 function getBindingSerializeReason(section, binding, prefix2) {
   return section.serializeReasons.get(
     getBindingSerializeReasonKey(binding, prefix2)
   );
 }
-function getPropSerializeReasonKey(extra, prop) {
-  return extra[prop] ||= Symbol(
-    typeof prop === "symbol" ? prop.description : prop
-  );
+function getSectionPropSerializeReasonKey(section, prop) {
+  const keys = serializeKeyBySourceModifier[prop] ||= /* @__PURE__ */ new WeakMap();
+  let key = keys.get(section);
+  if (!key) {
+    keys.set(
+      section,
+      key = Symbol(
+        typeof prop === "symbol" ? `Symbol(${prop.description})` : prop
+      )
+    );
+  }
+  return key;
 }
 function getBindingSerializeReasonKey(binding, prefix2) {
   const keys = prefix2 ? serializeKeyBySourceModifier[prefix2] ||= /* @__PURE__ */ new WeakMap() : serializeKeysByBinding;
   let key = keys.get(binding);
   if (!key) {
-    keys.set(binding, key = Symbol((prefix2 || "") + binding.name));
+    keys.set(
+      binding,
+      key = Symbol(
+        (prefix2 ? typeof prefix2 === "symbol" ? `Symbol(${prefix2.description})` : prefix2 : "") + binding.name
+      )
+    );
   }
   return key;
 }
-function consumeSerializeReasonExprs(section) {
-  const exprs = serializeReasonExprs.get(section);
-  serializeReasonExprs.delete(section);
-  return exprs;
+function applySerializeReasonExprs(section) {
+  const keyedExprs = keyedReasonExprs.get(section);
+  if (keyedExprs) {
+    keyedReasonExprs.delete(section);
+    for (const [key, exprs] of keyedExprs) {
+      const reason = getSerializeSourcesForExprs(exprs);
+      if (reason) {
+        section.serializeReasons.set(
+          key,
+          mergeSerializeReasons(section.serializeReasons.get(key), reason)
+        );
+      }
+    }
+  }
+  section.serializeReason = mergeSerializeReasons(
+    section.serializeReason,
+    getSerializeSourcesForExprs(reasonExprs.get(section))
+  );
+  reasonExprs.delete(section);
+}
+function finalizeSectionSerializeReasons(section) {
+  let reason = section.serializeReason;
+  if (reason !== true) {
+    for (const [, keyedReason] of section.serializeReasons) {
+      if (keyedReason === true) {
+        reason = true;
+        break;
+      }
+      reason = mergeSerializeReasons(reason, keyedReason);
+    }
+    section.serializeReason = reason;
+  }
 }
 function getSerializeSourcesForExpr(expr) {
   if (isReferencedExtra(expr)) {
@@ -1534,17 +1787,17 @@ function mergeSerializeReasons(a, b) {
 // src/translator/util/state.ts
 var import_babel_utils9 = require("@marko/compiler/babel-utils");
 var createProgramState = (init) => {
-  const map2 = /* @__PURE__ */ new WeakMap();
+  const map = /* @__PURE__ */ new WeakMap();
   return [
     () => {
-      let state = map2.get((0, import_babel_utils9.getProgram)());
+      let state = map.get((0, import_babel_utils9.getProgram)());
       if (!state) {
-        map2.set((0, import_babel_utils9.getProgram)(), state = init());
+        map.set((0, import_babel_utils9.getProgram)(), state = init());
       }
       return state;
     },
     (value) => {
-      map2.set((0, import_babel_utils9.getProgram)(), value);
+      map.set((0, import_babel_utils9.getProgram)(), value);
     }
   ];
 };
@@ -1681,7 +1934,6 @@ function analyzeExpressionTagName(name2, extra) {
 }
 
 // src/translator/util/sections.ts
-var kBranchSerializeReason = Symbol("serialize branch reason");
 var sectionUtil = new Sorted(function compareSections(a, b) {
   return a.id - b.id;
 });
@@ -1710,6 +1962,7 @@ function startSection(path5) {
       hoisted: void 0,
       isHoistThrough: void 0,
       assignments: void 0,
+      serializeReason: void 0,
       serializeReasons: /* @__PURE__ */ new Map(),
       content: getContentInfo(path5),
       upstreamExpression: void 0,
@@ -1923,8 +2176,8 @@ function isNativeNode(tag) {
 }
 
 // src/translator/visitors/program/dom.ts
-var import_compiler20 = require("@marko/compiler");
-var import_babel_utils14 = require("@marko/compiler/babel-utils");
+var import_compiler21 = require("@marko/compiler");
+var import_babel_utils15 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/get-style-file.ts
 var import_path = __toESM(require("path"));
@@ -1963,23 +2216,12 @@ function escapeRegExp(str) {
 }
 
 // src/translator/util/signals.ts
-var import_compiler19 = require("@marko/compiler");
-var import_babel_utils13 = require("@marko/compiler/babel-utils");
+var import_compiler20 = require("@marko/compiler");
+var import_babel_utils14 = require("@marko/compiler/babel-utils");
 
 // src/translator/core/return.ts
-var import_compiler15 = require("@marko/compiler");
-var import_babel_utils12 = require("@marko/compiler/babel-utils");
-
-// src/translator/util/get-known-attr-values.ts
-function getKnownAttrValues(tag) {
-  const attrs2 = {};
-  for (const attr2 of tag.attributes) {
-    if (attr2.type === "MarkoAttribute") {
-      attrs2[attr2.name] = attr2.value;
-    }
-  }
-  return attrs2;
-}
+var import_compiler17 = require("@marko/compiler");
+var import_babel_utils13 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/get-parent-tag.ts
 function getParentTag(tag) {
@@ -2055,10 +2297,201 @@ function translateByTarget({
 }
 
 // src/translator/util/writer.ts
-var import_compiler14 = require("@marko/compiler");
+var import_compiler16 = require("@marko/compiler");
 
-// src/translator/util/normalize-string-expression.ts
+// src/translator/visitors/program/html.ts
+var import_compiler13 = require("@marko/compiler");
+var import_babel_utils12 = require("@marko/compiler/babel-utils");
+
+// src/translator/util/is-static.ts
+function isStatic(path5) {
+  return path5.isImportDeclaration() || path5.isExportDeclaration() || path5.isMarkoScriptlet({ static: true });
+}
+
+// src/translator/util/simplify-fn.ts
 var import_compiler12 = require("@marko/compiler");
+function simplifyFunction(fn) {
+  switch (fn.type) {
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+    case "ArrowFunctionExpression":
+      return fn;
+    default:
+      return import_compiler12.types.functionExpression(
+        null,
+        fn.params,
+        fn.body,
+        fn.async,
+        fn.generator
+      );
+  }
+}
+
+// src/translator/visitors/program/html.ts
+function getTemplateContentName() {
+  return getSharedUid("content");
+}
+function getExprIfSerialized(reason, expr) {
+  return reason ? reason === true ? expr : import_compiler13.types.logicalExpression(
+    "&&",
+    callRuntime(
+      "serializeIf",
+      import_compiler13.types.identifier(getSharedUid("serialize")),
+      import_compiler13.types.numericLiteral(
+        resolveSerializeReasonId(
+          (0, import_babel_utils12.getProgram)().node.extra.inputSerializeReasons,
+          reason
+        )
+      )
+    ),
+    expr
+  ) : void 0;
+}
+function getSerializeGuard(reason) {
+  return reason ? reason === true ? import_compiler13.types.numericLiteral(1) : callRuntime(
+    "serializeGuard",
+    import_compiler13.types.identifier(getSharedUid("serialize")),
+    import_compiler13.types.numericLiteral(
+      resolveSerializeReasonId(
+        (0, import_babel_utils12.getProgram)().node.extra.inputSerializeReasons,
+        reason
+      )
+    )
+  ) : void 0;
+}
+var html_default = {
+  translate: {
+    exit(program) {
+      flushInto(program);
+      writeHTMLResumeStatements(program);
+      traverseReplace(program.node, "body", replaceNode);
+      const renderContent = [];
+      for (const child of program.get("body")) {
+        if (!isStatic(child)) {
+          renderContent.push(child.node);
+          child.remove();
+        } else if (child.isMarkoScriptlet()) {
+          if (child.node.target && child.node.target !== "server") {
+            child.remove();
+          } else {
+            child.replaceWithMultiple(child.node.body);
+          }
+        }
+      }
+      const serializeId = usedSharedUid("serialize") && getSharedUid("serialize");
+      const contentId = usedSharedUid("content") && getTemplateContentName();
+      const contentFn = import_compiler13.types.arrowFunctionExpression(
+        serializeId ? [import_compiler13.types.identifier("input"), import_compiler13.types.identifier(serializeId)] : [import_compiler13.types.identifier("input")],
+        import_compiler13.types.blockStatement(renderContent)
+      );
+      const exportDefault = import_compiler13.types.exportDefaultDeclaration(
+        callRuntime(
+          "createTemplate",
+          import_compiler13.types.stringLiteral(program.hub.file.metadata.marko.id),
+          contentId ? import_compiler13.types.identifier(contentId) : contentFn
+        )
+      );
+      if (contentId) {
+        program.node.body.push(
+          import_compiler13.types.variableDeclaration("const", [
+            import_compiler13.types.variableDeclarator(import_compiler13.types.identifier(contentId), contentFn)
+          ]),
+          exportDefault
+        );
+      } else {
+        program.node.body.push(exportDefault);
+      }
+    }
+  }
+};
+function replaceNode(node, container) {
+  return replaceBindingReadNode(node) || replaceRegisteredFunctionNode(node, container);
+}
+function replaceBindingReadNode(node) {
+  switch (node.type) {
+    case "Identifier":
+    case "MemberExpression": {
+      const { extra } = node;
+      if (extra && !(extra.read && !extra.read.binding.declared || extra.binding && !extra.binding.declared)) {
+        return getReadReplacement(node);
+      }
+    }
+  }
+}
+function replaceRegisteredFunctionNode(node, container) {
+  switch (node.type) {
+    case "ClassMethod": {
+      const replacement = getRegisteredFnExpression(node);
+      return replacement && import_compiler13.types.classProperty(node.key, replacement);
+    }
+    case "ClassPrivateMethod": {
+      const replacement = getRegisteredFnExpression(node);
+      return replacement && import_compiler13.types.classPrivateProperty(node.key, replacement);
+    }
+    case "ObjectMethod": {
+      const replacement = getRegisteredFnExpression(node);
+      return replacement && import_compiler13.types.objectProperty(node.key, replacement);
+    }
+    case "FunctionDeclaration": {
+      const { extra } = node;
+      if (isRegisteredFnExtra(extra)) {
+        let registeredFnDeclarations = registeredFnDeclarationsByBody.get(
+          container
+        );
+        if (!registeredFnDeclarations) {
+          registeredFnDeclarationsByBody.set(
+            container,
+            registeredFnDeclarations = []
+          );
+        }
+        registeredFnDeclarations.push({
+          id: node.id.name,
+          registerId: extra.registerId
+        });
+      }
+      break;
+    }
+    case "ArrowFunctionExpression":
+    case "FunctionExpression": {
+      return getRegisteredFnExpression(node);
+    }
+    case "BlockStatement":
+    case "MarkoScriptlet":
+      addRegisteredDeclarations(node.body);
+      break;
+  }
+}
+var registeredFnDeclarationsByBody = /* @__PURE__ */ new WeakMap();
+function addRegisteredDeclarations(body) {
+  const registeredFnDeclarations = registeredFnDeclarationsByBody.get(body);
+  if (registeredFnDeclarations) {
+    for (const { id, registerId } of registeredFnDeclarations) {
+      body.push(
+        import_compiler13.types.expressionStatement(
+          callRuntime(
+            "register",
+            import_compiler13.types.identifier(id),
+            import_compiler13.types.stringLiteral(registerId)
+          )
+        )
+      );
+    }
+  }
+}
+function getRegisteredFnExpression(node) {
+  const { extra } = node;
+  if (isRegisteredFnExtra(extra)) {
+    return callRuntime(
+      "register",
+      simplifyFunction(node),
+      import_compiler13.types.stringLiteral(extra.registerId),
+      (extra.referencedBindingsInFunction || extra.referencesScope) && getScopeIdIdentifier(extra.section)
+    );
+  }
+}
+
+// src/translator/util/normalize-string-expression.ts
+var import_compiler14 = require("@marko/compiler");
 function normalizeStringExpression(parts) {
   const strs = [];
   const exprs = [];
@@ -2066,9 +2499,9 @@ function normalizeStringExpression(parts) {
   for (let i = 1; i < parts.length; i++) {
     let content = parts[i];
     if (typeof content === "object") {
-      if (import_compiler12.types.isStringLiteral(content)) {
+      if (import_compiler14.types.isStringLiteral(content)) {
         content = content.value;
-      } else if (import_compiler12.types.isTemplateLiteral(content)) {
+      } else if (import_compiler14.types.isTemplateLiteral(content)) {
         let nextIndex = i + 1;
         const exprLen = content.expressions.length;
         shiftItems(parts, nextIndex, content.quasis.length + exprLen);
@@ -2092,12 +2525,12 @@ function normalizeStringExpression(parts) {
       return exprs[0];
     }
     strs.push(curStr);
-    return import_compiler12.types.templateLiteral(
-      strs.map((raw) => import_compiler12.types.templateElement({ raw })),
+    return import_compiler14.types.templateLiteral(
+      strs.map((raw) => import_compiler14.types.templateElement({ raw })),
       exprs
     );
   } else if (curStr) {
-    return import_compiler12.types.stringLiteral(curStr);
+    return import_compiler14.types.stringLiteral(curStr);
   }
 }
 function appendLiteral(arr, str) {
@@ -2110,7 +2543,7 @@ function shiftItems(list, start, offset) {
 }
 
 // src/translator/util/walks.ts
-var import_compiler13 = require("@marko/compiler");
+var import_compiler15 = require("@marko/compiler");
 var [getWalks] = createSectionState(
   "walks",
   () => [""]
@@ -2289,16 +2722,16 @@ function consumeHTML(path5) {
   trailers.length = 0;
   trailers[0] = "";
   if (writeResult && trailerResult) {
-    return import_compiler14.types.expressionStatement(
-      import_compiler14.types.sequenceExpression([
+    return import_compiler16.types.expressionStatement(
+      import_compiler16.types.sequenceExpression([
         callRuntime("write", writeResult),
         callRuntime("writeTrailers", trailerResult)
       ])
     );
   } else if (writeResult) {
-    return import_compiler14.types.expressionStatement(callRuntime("write", writeResult));
+    return import_compiler16.types.expressionStatement(callRuntime("write", writeResult));
   } else if (trailerResult) {
-    return import_compiler14.types.expressionStatement(callRuntime("writeTrailers", trailerResult));
+    return import_compiler16.types.expressionStatement(callRuntime("writeTrailers", trailerResult));
   }
 }
 function flushBefore(path5) {
@@ -2324,19 +2757,22 @@ function getSectionMeta(section) {
     writes: normalizeStringExpression([writePrefix, ...writes, writePostfix])
   };
 }
-function markNode(path5, binding) {
-  const section = getSection(path5);
-  if (binding.type !== 0 /* dom */) {
+function markNode(path5, nodeBinding, reason) {
+  if (nodeBinding.type !== 0 /* dom */) {
     throw path5.buildCodeFrameError(
       "Tried to mark a node that was not determined to need a mark during analyze."
     );
   }
   if (isOutputHTML()) {
-    writeTo(path5)`${callRuntime(
-      "markResumeNode",
-      getScopeIdIdentifier(section),
-      getScopeAccessorLiteral(binding)
-    )}`;
+    if (reason) {
+      const section = getSection(path5);
+      writeTo(path5)`${callRuntime(
+        "markResumeNode",
+        getScopeIdIdentifier(section),
+        getScopeAccessorLiteral(nodeBinding),
+        reason === true ? void 0 : getSerializeGuard(reason)
+      )}`;
+    }
   }
 }
 
@@ -2345,14 +2781,14 @@ var tagsWithReturn = /* @__PURE__ */ new WeakSet();
 var [getSectionReturnValueIdentifier, setReturnValueIdentifier] = createSectionState("returnValue");
 var return_default = {
   analyze(tag) {
-    (0, import_babel_utils12.assertNoArgs)(tag);
-    (0, import_babel_utils12.assertNoVar)(tag);
-    (0, import_babel_utils12.assertNoParams)(tag);
+    (0, import_babel_utils13.assertNoArgs)(tag);
+    (0, import_babel_utils13.assertNoVar)(tag);
+    (0, import_babel_utils13.assertNoParams)(tag);
     assertNoBodyContent(tag);
-    (0, import_babel_utils12.assertAllowedAttributes)(tag, ["value", "valueChange"]);
+    (0, import_babel_utils13.assertAllowedAttributes)(tag, ["value", "valueChange"]);
     const parentTag = getParentTag(tag);
     if (parentTag) {
-      if ((0, import_babel_utils12.isNativeTag)(parentTag)) {
+      if ((0, import_babel_utils13.isNativeTag)(parentTag)) {
         throw tag.get("name").buildCodeFrameError(
           "The `return` tag can not be used in a native tag."
         );
@@ -2369,9 +2805,16 @@ var return_default = {
     } else {
       tagsWithReturn.add(tag.parentPath);
     }
-    if (!getKnownAttrValues(tag.node).value) {
+    const attrs2 = getKnownAttrValues(tag.node);
+    if (!attrs2.value) {
       throw tag.get("name").buildCodeFrameError("The `return` tag requires a value.");
     }
+    if (attrs2.valueChange) {
+      forceSectionSerialize(
+        getSection(tag),
+        getAccessorProp().TagVariableChange
+      );
+    }
   },
   translate: translateByTarget({
     html: {
@@ -2380,7 +2823,7 @@ var return_default = {
         const attrs2 = getKnownAttrValues(tag.node);
         flushBefore(tag);
         if (attrs2.valueChange) {
-          setSerializedValue(
+          setSectionSerializedValue(
             section,
             getAccessorProp().TagVariableChange,
             attrs2.valueChange
@@ -2390,8 +2833,8 @@ var return_default = {
           const returnId = generateUidIdentifier("return");
           setReturnValueIdentifier(section, returnId);
           tag.replaceWith(
-            import_compiler15.types.variableDeclaration("const", [
-              import_compiler15.types.variableDeclarator(returnId, attrs2.value)
+            import_compiler17.types.variableDeclaration("const", [
+              import_compiler17.types.variableDeclarator(returnId, attrs2.value)
             ])
           )[0].skip();
         }
@@ -2441,44 +2884,25 @@ var return_default = {
 };
 
 // src/translator/util/get-defined-binding-expression.ts
-var import_compiler16 = require("@marko/compiler");
+var import_compiler18 = require("@marko/compiler");
 function getDeclaredBindingExpression(binding) {
   if (binding.declared || !binding.upstreamAlias) {
-    return import_compiler16.types.identifier(binding.name);
-  } else if (binding.property !== void 0) {
-    return toMemberExpression(
-      getDeclaredBindingExpression(binding.upstreamAlias),
-      binding.property,
-      binding.upstreamAlias.nullable
-    );
-  } else {
-    return getDeclaredBindingExpression(binding.upstreamAlias);
-  }
-}
-
-// src/translator/util/simplify-fn.ts
-var import_compiler17 = require("@marko/compiler");
-function simplifyFunction(fn) {
-  switch (fn.type) {
-    case "FunctionDeclaration":
-    case "FunctionExpression":
-    case "ArrowFunctionExpression":
-      return fn;
-    default:
-      return import_compiler17.types.functionExpression(
-        null,
-        fn.params,
-        fn.body,
-        fn.async,
-        fn.generator
-      );
+    return import_compiler18.types.identifier(binding.name);
+  } else if (binding.property !== void 0) {
+    return toMemberExpression(
+      getDeclaredBindingExpression(binding.upstreamAlias),
+      binding.property,
+      binding.upstreamAlias.nullable
+    );
+  } else {
+    return getDeclaredBindingExpression(binding.upstreamAlias);
   }
 }
 
 // src/translator/util/to-first-expression-or-block.ts
-var import_compiler18 = require("@marko/compiler");
+var import_compiler19 = require("@marko/compiler");
 function toFirstExpressionOrBlock(stmts) {
-  if (stmts.length === 1 && import_compiler18.types.isExpressionStatement(stmts[0])) {
+  if (stmts.length === 1 && import_compiler19.types.isExpressionStatement(stmts[0])) {
     const { expression } = stmts[0];
     switch (expression.type) {
       case "ObjectExpression":
@@ -2488,13 +2912,13 @@ function toFirstExpressionOrBlock(stmts) {
         return expression;
     }
   }
-  return import_compiler18.types.blockStatement(stmts);
+  return import_compiler19.types.blockStatement(stmts);
 }
 function toParenthesizedExpressionIfNeeded(expr) {
   switch (expr.type) {
     case "ObjectExpression":
     case "AssignmentExpression":
-      return import_compiler18.types.parenthesizedExpression(expr);
+      return import_compiler19.types.parenthesizedExpression(expr);
     default:
       return expr;
   }
@@ -2509,22 +2933,13 @@ var [getClosureSignalBuilder, _setClosureSignalBuilder] = createSectionState("qu
 function setClosureSignalBuilder(tag, builder) {
   _setClosureSignalBuilder(getSectionForBody(tag.get("body")), builder);
 }
-var [serializeSectionReason, setSerializeSectionReason] = createSectionState("serializeSectionSources");
-function serializeSectionIfNeeded(section, reason) {
+var [getSerializedAccessors] = createSectionState("serializedScopeProperties", () => /* @__PURE__ */ new Map());
+function setSectionSerializedValue(section, prop, expression) {
+  const reason = getSectionSerializeReason(section, prop);
   if (reason) {
-    const existingReason = serializeSectionReason(section);
-    if (existingReason === true) return;
-    if (!existingReason || reason === true) {
-      setSerializeSectionReason(section, reason);
-    } else {
-      setSerializeSectionReason(
-        section,
-        bindingUtil.union(existingReason, reason)
-      );
-    }
+    getSerializedAccessors(section).set(prop, { expression, reason });
   }
 }
-var [getSerializedAccessors] = createSectionState("serializedScopeProperties", () => /* @__PURE__ */ new Map());
 function setBindingSerializedValue(section, binding, expression, prefix2) {
   const reason = getBindingSerializeReason(section, binding, prefix2);
   if (reason) {
@@ -2534,7 +2949,9 @@ function setBindingSerializedValue(section, binding, expression, prefix2) {
     );
   }
 }
+var nonAnalyzedForceSerializedSection = /* @__PURE__ */ new WeakSet();
 function setSerializedValue(section, key, expression) {
+  nonAnalyzedForceSerializedSection.add(section);
   getSerializedAccessors(section).set(key, { expression, reason: true });
 }
 var [getSectionWriteScopeBuilder, setSectionWriteScopeBuilder] = createSectionState(
@@ -2565,17 +2982,17 @@ function getHoistFunctionIdentifier(hoistedBinding) {
   return identifier;
 }
 var unimplementedBuild = () => {
-  return import_compiler19.types.stringLiteral("SIGNAL NOT INITIALIZED");
+  return import_compiler20.types.stringLiteral("SIGNAL NOT INITIALIZED");
 };
 function getSignal(section, referencedBindings, name2 = generateSignalName(referencedBindings)) {
   const signals = getSignals(section);
   let signal = signals.get(referencedBindings);
   if (!signal) {
-    const exportName = referencedBindings ? !Array.isArray(referencedBindings) && referencedBindings.section === section && referencedBindings.export : !section.parent && (0, import_babel_utils13.getProgram)().node.extra.domExports?.setup;
+    const exportName = referencedBindings ? !Array.isArray(referencedBindings) && referencedBindings.section === section && referencedBindings.export : !section.parent && (0, import_babel_utils14.getProgram)().node.extra.domExports?.setup;
     signals.set(
       referencedBindings,
       signal = {
-        identifier: exportName ? import_compiler19.types.identifier(exportName) : generateUidIdentifier(name2 + section.name.replace("_", "$")),
+        identifier: exportName ? import_compiler20.types.identifier(exportName) : generateUidIdentifier(name2 + section.name.replace("_", "$")),
         referencedBindings,
         section,
         values: [],
@@ -2630,9 +3047,9 @@ function getSignal(section, referencedBindings, name2 = generateSignalName(refer
         const { id, scopeOffset } = intersectionMeta.get(referencedBindings);
         return callRuntime(
           "intersection",
-          import_compiler19.types.numericLiteral(id),
+          import_compiler20.types.numericLiteral(id),
           getSignalFn(signal),
-          scopeOffset || referencedBindings.length > 2 ? import_compiler19.types.numericLiteral(referencedBindings.length - 1) : void 0,
+          scopeOffset || referencedBindings.length > 2 ? import_compiler20.types.numericLiteral(referencedBindings.length - 1) : void 0,
           scopeOffset && getScopeAccessorLiteral(scopeOffset)
         );
       };
@@ -2644,7 +3061,7 @@ function getSignal(section, referencedBindings, name2 = generateSignalName(refer
           "dynamicClosureRead",
           getScopeAccessorLiteral(referencedBindings),
           render,
-          isImmediateOwner(section, referencedBindings) ? void 0 : import_compiler19.types.arrowFunctionExpression(
+          isImmediateOwner(section, referencedBindings) ? void 0 : import_compiler20.types.arrowFunctionExpression(
             [scopeIdentifier],
             getScopeExpression(section, referencedBindings.section)
           )
@@ -2692,7 +3109,7 @@ function getSignalFn(signal) {
   const isValue = isBinding && binding.section === section;
   let canUseCalleeDirectly = !signal.render.length;
   if (isBinding && (signal.renderReferencedBindings || binding.aliases.size || binding.propertyAliases.size)) {
-    const valueParam = import_compiler19.types.identifier(binding.name);
+    const valueParam = import_compiler20.types.identifier(binding.name);
     if (binding.loc) {
       valueParam.loc = binding.loc;
       valueParam.start = binding.loc.start.index;
@@ -2704,10 +3121,10 @@ function getSignalFn(signal) {
     for (const alias of binding.aliases) {
       const aliasSignal = getSignal(alias.section, alias);
       signal.render.push(
-        import_compiler19.types.expressionStatement(
-          import_compiler19.types.callExpression(aliasSignal.identifier, [
+        import_compiler20.types.expressionStatement(
+          import_compiler20.types.callExpression(aliasSignal.identifier, [
             scopeIdentifier,
-            import_compiler19.types.identifier(binding.name),
+            import_compiler20.types.identifier(binding.name),
             ...getTranslatedExtraArgs(aliasSignal)
           ])
         )
@@ -2716,11 +3133,11 @@ function getSignalFn(signal) {
     for (const [key, alias] of binding.propertyAliases) {
       const aliasSignal = getSignal(alias.section, alias);
       signal.render.push(
-        import_compiler19.types.expressionStatement(
-          import_compiler19.types.callExpression(aliasSignal.identifier, [
+        import_compiler20.types.expressionStatement(
+          import_compiler20.types.callExpression(aliasSignal.identifier, [
             scopeIdentifier,
             toMemberExpression(
-              import_compiler19.types.identifier(binding.name),
+              import_compiler20.types.identifier(binding.name),
               key,
               binding.nullable
             ),
@@ -2732,8 +3149,8 @@ function getSignalFn(signal) {
   }
   for (const value of signal.values) {
     signal.render.push(
-      import_compiler19.types.expressionStatement(
-        import_compiler19.types.callExpression(value.signal.identifier, [
+      import_compiler20.types.expressionStatement(
+        import_compiler20.types.callExpression(value.signal.identifier, [
           value.scope,
           value.value,
           ...getTranslatedExtraArgs(value.signal)
@@ -2743,7 +3160,7 @@ function getSignalFn(signal) {
   }
   forEach(signal.intersection, (intersection) => {
     signal.render.push(
-      import_compiler19.types.expressionStatement(import_compiler19.types.callExpression(intersection, [scopeIdentifier]))
+      import_compiler20.types.expressionStatement(import_compiler20.types.callExpression(intersection, [scopeIdentifier]))
     );
   });
   if (isValue) {
@@ -2758,8 +3175,8 @@ function getSignalFn(signal) {
               signal.identifier.name + "_closure"
             );
             signal.render.push(
-              import_compiler19.types.expressionStatement(
-                import_compiler19.types.callExpression(dynamicClosureSignalIdentifier, [
+              import_compiler20.types.expressionStatement(
+                import_compiler20.types.callExpression(dynamicClosureSignalIdentifier, [
                   scopeIdentifier
                 ])
               )
@@ -2770,8 +3187,8 @@ function getSignalFn(signal) {
           );
         } else {
           signal.render.push(
-            import_compiler19.types.expressionStatement(
-              import_compiler19.types.callExpression(getSignal(closureSection, binding).identifier, [
+            import_compiler20.types.expressionStatement(
+              import_compiler20.types.callExpression(getSignal(closureSection, binding).identifier, [
                 scopeIdentifier
               ])
             )
@@ -2781,8 +3198,8 @@ function getSignalFn(signal) {
     });
     if (dynamicClosureSignalIdentifier) {
       (signal.prependStatements ||= []).push(
-        import_compiler19.types.variableDeclaration("const", [
-          import_compiler19.types.variableDeclarator(
+        import_compiler20.types.variableDeclaration("const", [
+          import_compiler20.types.variableDeclarator(
             dynamicClosureSignalIdentifier,
             callRuntime("dynamicClosure", ...dynamicClosureArgs)
           )
@@ -2791,17 +3208,17 @@ function getSignalFn(signal) {
     }
   }
   if (signal.effect.length) {
-    const effectIdentifier = import_compiler19.types.identifier(`${signal.identifier.name}_effect`);
+    const effectIdentifier = import_compiler20.types.identifier(`${signal.identifier.name}_effect`);
     signal.render.push(
-      import_compiler19.types.expressionStatement(
-        import_compiler19.types.callExpression(effectIdentifier, [scopeIdentifier])
+      import_compiler20.types.expressionStatement(
+        import_compiler20.types.callExpression(effectIdentifier, [scopeIdentifier])
       )
     );
   }
   if (isIntersection && signal.renderReferencedBindings) {
     signal.render.unshift(
-      import_compiler19.types.variableDeclaration("const", [
-        import_compiler19.types.variableDeclarator(
+      import_compiler20.types.variableDeclaration("const", [
+        import_compiler20.types.variableDeclarator(
           createScopeReadPattern(section, signal.renderReferencedBindings),
           scopeIdentifier
         )
@@ -2830,7 +3247,7 @@ function getSignalFn(signal) {
       }
     }
   }
-  return import_compiler19.types.arrowFunctionExpression(params, import_compiler19.types.blockStatement(signal.render));
+  return import_compiler20.types.arrowFunctionExpression(params, import_compiler20.types.blockStatement(signal.render));
 }
 var hasTranslatedExtraArgs = /* @__PURE__ */ new WeakSet();
 var emptyExtraArgs = [];
@@ -2875,19 +3292,19 @@ function replaceNullishAndEmptyFunctionsWith0(args) {
   for (let i = args.length; i--; ) {
     const arg = args[i];
     if (!arg) {
-      args[i] = import_compiler19.types.numericLiteral(0);
-    } else if (import_compiler19.types.isArrowFunctionExpression(arg) && import_compiler19.types.isBlockStatement(arg.body)) {
+      args[i] = import_compiler20.types.numericLiteral(0);
+    } else if (import_compiler20.types.isArrowFunctionExpression(arg) && import_compiler20.types.isBlockStatement(arg.body)) {
       const body = arg.body.body;
       if (body.length === 0) {
-        args[i] = import_compiler19.types.numericLiteral(0);
-      } else if (body.length === 1 && import_compiler19.types.isExpressionStatement(body[0])) {
+        args[i] = import_compiler20.types.numericLiteral(0);
+      } else if (body.length === 1 && import_compiler20.types.isExpressionStatement(body[0])) {
         arg.body = toParenthesizedExpressionIfNeeded(body[0].expression);
       }
-    } else if (import_compiler19.types.isNullLiteral(arg) || import_compiler19.types.isUnaryExpression(arg) && arg.operator === "void") {
-      args[i] = import_compiler19.types.numericLiteral(0);
+    } else if (import_compiler20.types.isNullLiteral(arg) || import_compiler20.types.isUnaryExpression(arg) && arg.operator === "void") {
+      args[i] = import_compiler20.types.numericLiteral(0);
     }
   }
-  for (let i = args.length - 1; import_compiler19.types.isNumericLiteral(args[i]) && args[i].value === 0; ) {
+  for (let i = args.length - 1; import_compiler20.types.isNumericLiteral(args[i]) && args[i].value === 0; ) {
     args.length = i--;
   }
   return args;
@@ -2936,7 +3353,7 @@ function getResumeRegisterId(section, referencedBindings, type) {
   const {
     markoOpts,
     opts: { filename }
-  } = (0, import_babel_utils13.getFile)();
+  } = (0, import_babel_utils14.getFile)();
   let name2 = "";
   if (referencedBindings) {
     if (typeof referencedBindings === "string") {
@@ -2949,7 +3366,7 @@ function getResumeRegisterId(section, referencedBindings, type) {
       name2 += `_${referencedBindings.name}`;
     }
   }
-  return (0, import_babel_utils13.getTemplateId)(
+  return (0, import_babel_utils14.getTemplateId)(
     markoOpts,
     filename,
     `${section.id}${name2}${type ? "/" + type : ""}`
@@ -2960,10 +3377,10 @@ function getRegisterUID(section, name2) {
   const {
     markoOpts,
     opts: { filename }
-  } = (0, import_babel_utils13.getFile)();
+  } = (0, import_babel_utils14.getFile)();
   let used = usedRegisterIdsBySection.get(section);
   if (!used) usedRegisterIdsBySection.set(section, used = /* @__PURE__ */ new Set());
-  const baseId = (0, import_babel_utils13.getTemplateId)(
+  const baseId = (0, import_babel_utils14.getTemplateId)(
     markoOpts,
     filename,
     `${section.id}/${name2}`
@@ -2980,7 +3397,7 @@ function writeSignals(section) {
   forEach(section.hoisted, (binding) => {
     for (const hoistedBinding of binding.hoists.values()) {
       const accessors = [
-        binding.type === 0 /* dom */ ? import_compiler19.types.stringLiteral(
+        binding.type === 0 /* dom */ ? import_compiler20.types.stringLiteral(
           getAccessorPrefix().Getter + getScopeAccessor(binding)
         ) : getScopeAccessorLiteral(binding)
       ];
@@ -2993,13 +3410,13 @@ function writeSignals(section) {
         currentSection = parentSection;
       }
       const hoistIdentifier = getHoistFunctionIdentifier(hoistedBinding);
-      (0, import_babel_utils13.getProgram)().node.body.push(
-        import_compiler19.types.variableDeclaration("const", [
-          import_compiler19.types.variableDeclarator(
+      (0, import_babel_utils14.getProgram)().node.body.push(
+        import_compiler20.types.variableDeclaration("const", [
+          import_compiler20.types.variableDeclarator(
             hoistIdentifier,
             hoistedBinding.downstreamExpressions.size ? callRuntime(
               "register",
-              import_compiler19.types.stringLiteral(
+              import_compiler20.types.stringLiteral(
                 getResumeRegisterId(
                   hoistedBinding.section,
                   hoistedBinding,
@@ -3016,7 +3433,7 @@ function writeSignals(section) {
           hoistedBinding.section,
           void 0,
           initValue(hoistedBinding),
-          import_compiler19.types.callExpression(hoistIdentifier, [scopeIdentifier])
+          import_compiler20.types.callExpression(hoistIdentifier, [scopeIdentifier])
         );
       }
     }
@@ -3030,20 +3447,20 @@ function writeSignals(section) {
     let effectDeclarator;
     if (signal.effect.length) {
       traverseReplace(signal, "effect", replaceEffectNode);
-      const effectIdentifier = import_compiler19.types.identifier(`${signal.identifier.name}_effect`);
+      const effectIdentifier = import_compiler20.types.identifier(`${signal.identifier.name}_effect`);
       const referencedBindings = signal.effectReferencedBindings;
       const referencesScope = traverseContains(
         signal.effect,
         isScopeIdentifier
       );
-      effectDeclarator = import_compiler19.types.variableDeclarator(
+      effectDeclarator = import_compiler20.types.variableDeclarator(
         effectIdentifier,
         callRuntime(
           "effect",
-          import_compiler19.types.stringLiteral(
+          import_compiler20.types.stringLiteral(
             getResumeRegisterId(section, signal.referencedBindings)
           ),
-          import_compiler19.types.arrowFunctionExpression(
+          import_compiler20.types.arrowFunctionExpression(
             referencedBindings ? referencesScope ? [
               scopeIdentifier,
               createScopeReadPattern(section, referencedBindings)
@@ -3054,44 +3471,44 @@ function writeSignals(section) {
       );
     }
     let value = signal.build();
-    if (import_compiler19.types.isCallExpression(value)) {
+    if (import_compiler20.types.isCallExpression(value)) {
       replaceNullishAndEmptyFunctionsWith0(value.arguments);
     }
     if (signal.register) {
       value = callRuntime(
         "registerBoundSignal",
-        import_compiler19.types.stringLiteral(
+        import_compiler20.types.stringLiteral(
           getResumeRegisterId(section, signal.referencedBindings, "var")
         ),
         value
       );
     }
-    const signalDeclarator = import_compiler19.types.variableDeclarator(signal.identifier, value);
-    let signalDeclaration = !section.parent && !signal.referencedBindings && (import_compiler19.types.isFunctionExpression(value) || import_compiler19.types.isArrowFunctionExpression(value)) ? import_compiler19.types.functionDeclaration(
+    const signalDeclarator = import_compiler20.types.variableDeclarator(signal.identifier, value);
+    let signalDeclaration = !section.parent && !signal.referencedBindings && (import_compiler20.types.isFunctionExpression(value) || import_compiler20.types.isArrowFunctionExpression(value)) ? import_compiler20.types.functionDeclaration(
       signal.identifier,
       value.params,
-      import_compiler19.types.isExpression(value.body) ? import_compiler19.types.blockStatement([import_compiler19.types.expressionStatement(value.body)]) : value.body
-    ) : import_compiler19.types.variableDeclaration("const", [signalDeclarator]);
+      import_compiler20.types.isExpression(value.body) ? import_compiler20.types.blockStatement([import_compiler20.types.expressionStatement(value.body)]) : value.body
+    ) : import_compiler20.types.variableDeclaration("const", [signalDeclarator]);
     if (signal.export) {
-      signalDeclaration = import_compiler19.types.exportNamedDeclaration(signalDeclaration);
+      signalDeclaration = import_compiler20.types.exportNamedDeclaration(signalDeclaration);
     }
     const signalStatements = signal.prependStatements || [];
     if (effectDeclarator) {
-      signalStatements.push(import_compiler19.types.variableDeclaration("const", [effectDeclarator]));
+      signalStatements.push(import_compiler20.types.variableDeclaration("const", [effectDeclarator]));
     }
     signalStatements.push(signalDeclaration);
-    (0, import_babel_utils13.getProgram)().node.body.push(...signalStatements);
+    (0, import_babel_utils14.getProgram)().node.body.push(...signalStatements);
   }
 }
 function writeRegisteredFns() {
-  const registeredFns = registeredFnsForProgram.get((0, import_babel_utils13.getProgram)().node);
+  const registeredFns = registeredFnsForProgram.get((0, import_babel_utils14.getProgram)().node);
   const statements = [];
   if (registeredFns) {
     for (const registeredFn of registeredFns) {
       let fn;
       const params = registeredFn.referencedBindings ? registeredFn.referencesScope ? [
         scopeIdentifier,
-        import_compiler19.types.assignmentPattern(
+        import_compiler20.types.assignmentPattern(
           createScopeReadPattern(
             registeredFn.section,
             registeredFn.referencedBindings
@@ -3105,18 +3522,18 @@ function writeRegisteredFns() {
         )
       ] : registeredFn.referencesScope ? [scopeIdentifier] : void 0;
       if (params) {
-        fn = import_compiler19.types.functionDeclaration(
-          import_compiler19.types.identifier(registeredFn.id),
+        fn = import_compiler20.types.functionDeclaration(
+          import_compiler20.types.identifier(registeredFn.id),
           params,
-          import_compiler19.types.blockStatement(toReturnedFunction(registeredFn.node))
+          import_compiler20.types.blockStatement(toReturnedFunction(registeredFn.node))
         );
       } else if (registeredFn.node.type === "FunctionDeclaration" && registeredFn.node.id?.name === registeredFn.id) {
         fn = registeredFn.node;
       } else {
-        fn = import_compiler19.types.functionDeclaration(
-          import_compiler19.types.identifier(registeredFn.id),
+        fn = import_compiler20.types.functionDeclaration(
+          import_compiler20.types.identifier(registeredFn.id),
           registeredFn.node.params,
-          registeredFn.node.body.type === "BlockStatement" ? registeredFn.node.body : import_compiler19.types.blockStatement([import_compiler19.types.returnStatement(registeredFn.node.body)]),
+          registeredFn.node.body.type === "BlockStatement" ? registeredFn.node.body : import_compiler20.types.blockStatement([import_compiler20.types.returnStatement(registeredFn.node.body)]),
           registeredFn.node.generator,
           registeredFn.node.async
         );
@@ -3125,21 +3542,21 @@ function writeRegisteredFns() {
     }
     for (const registeredFn of registeredFns) {
       statements.push(
-        import_compiler19.types.expressionStatement(
+        import_compiler20.types.expressionStatement(
           callRuntime(
             "register",
-            import_compiler19.types.stringLiteral(registeredFn.registerId),
-            import_compiler19.types.identifier(registeredFn.id)
+            import_compiler20.types.stringLiteral(registeredFn.registerId),
+            import_compiler20.types.identifier(registeredFn.id)
           )
         )
       );
     }
-    (0, import_babel_utils13.getProgram)().node.body.push(...statements);
+    (0, import_babel_utils14.getProgram)().node.body.push(...statements);
   }
 }
 function toReturnedFunction(rawFn) {
   const fn = simplifyFunction(rawFn);
-  return fn.type === "FunctionDeclaration" ? [fn, import_compiler19.types.returnStatement(fn.id)] : [import_compiler19.types.returnStatement(fn)];
+  return fn.type === "FunctionDeclaration" ? [fn, import_compiler20.types.returnStatement(fn.id)] : [import_compiler20.types.returnStatement(fn)];
 }
 function sortSignals(a, b) {
   const aReferencedBindings = getReferencedBindings(a);
@@ -3176,12 +3593,7 @@ function writeHTMLResumeStatements(path5) {
   forEach(section.referencedHoists, serializeOwnersUntilBinding);
   forEach(section.referencedClosures, (closure) => {
     if (closure.sources) {
-      const serializeReason = getBindingSerializeReason(
-        closure.section,
-        closure
-      );
       serializeOwnersUntilBinding(closure);
-      serializeSectionIfNeeded(closure.section, serializeReason);
       if (isDynamicClosure(section, closure)) {
         const closureSignal = getSignal(closure.section, closure);
         let identifier = htmlDynamicClosureInstancesIdentifier.get(closureSignal);
@@ -3193,10 +3605,10 @@ function writeHTMLResumeStatements(path5) {
             )
           );
           getHTMLSectionStatements(closure.section).push(
-            import_compiler19.types.variableDeclaration("const", [
-              import_compiler19.types.variableDeclarator(
+            import_compiler20.types.variableDeclaration("const", [
+              import_compiler20.types.variableDeclarator(
                 identifier,
-                import_compiler19.types.newExpression(import_compiler19.types.identifier("Set"), [])
+                import_compiler20.types.newExpression(import_compiler20.types.identifier("Set"), [])
               )
             ])
           );
@@ -3210,7 +3622,7 @@ function writeHTMLResumeStatements(path5) {
         setBindingSerializedValue(
           section,
           closure,
-          import_compiler19.types.numericLiteral(getDynamicClosureIndex(closure, section)),
+          import_compiler20.types.numericLiteral(getDynamicClosureIndex(closure, section)),
           getAccessorPrefix().ClosureSignalIndex
         );
         addWriteScopeBuilder(
@@ -3225,13 +3637,13 @@ function writeHTMLResumeStatements(path5) {
     for (const hoistedBinding of binding.hoists.values()) {
       if (hoistedBinding.downstreamExpressions.size) {
         getHTMLSectionStatements(hoistedBinding.section).push(
-          import_compiler19.types.variableDeclaration("const", [
-            import_compiler19.types.variableDeclarator(
-              import_compiler19.types.identifier(hoistedBinding.name),
+          import_compiler20.types.variableDeclaration("const", [
+            import_compiler20.types.variableDeclarator(
+              import_compiler20.types.identifier(hoistedBinding.name),
               callRuntime(
                 "hoist",
                 getScopeIdIdentifier(hoistedBinding.section),
-                import_compiler19.types.stringLiteral(
+                import_compiler20.types.stringLiteral(
                   getResumeRegisterId(
                     hoistedBinding.section,
                     hoistedBinding,
@@ -3252,10 +3664,10 @@ function writeHTMLResumeStatements(path5) {
           );
           sectionDynamicSubscribers.add(currentSection);
           getHTMLSectionStatements(parentSection).push(
-            import_compiler19.types.variableDeclaration("const", [
-              import_compiler19.types.variableDeclarator(
+            import_compiler20.types.variableDeclaration("const", [
+              import_compiler20.types.variableDeclarator(
                 subscribersIdentifier,
-                import_compiler19.types.newExpression(import_compiler19.types.identifier("Set"), [])
+                import_compiler20.types.newExpression(import_compiler20.types.identifier("Set"), [])
               )
             ])
           );
@@ -3284,11 +3696,11 @@ function writeHTMLResumeStatements(path5) {
     if (allSignals[i].effect.length) {
       const signalRefs = allSignals[i].referencedBindings;
       body.push(
-        import_compiler19.types.expressionStatement(
+        import_compiler20.types.expressionStatement(
           callRuntime(
             "writeEffect",
             scopeIdIdentifier,
-            import_compiler19.types.stringLiteral(getResumeRegisterId(section, signalRefs))
+            import_compiler20.types.stringLiteral(getResumeRegisterId(section, signalRefs))
           )
         )
       );
@@ -3296,22 +3708,27 @@ function writeHTMLResumeStatements(path5) {
   }
   const serializedLookup = getSerializedAccessors(section);
   const serializedProperties = [];
+  const sectionSerializeReason = nonAnalyzedForceSerializedSection.has(section) ? true : section.serializeReason;
   forEach(section.bindings, (binding) => {
     if (binding.type === 0 /* dom */) return;
-    const serializeReason = getBindingSerializeReason(section, binding);
-    if (!serializeReason) return;
+    const reason = getBindingSerializeReason(section, binding);
+    if (!reason) return;
     const accessor = getScopeAccessor(binding);
     serializedLookup.delete(accessor);
     serializedProperties.push(
-      toObjectProperty(accessor, getDeclaredBindingExpression(binding))
+      toObjectProperty(
+        accessor,
+        sectionSerializeReason && (sectionSerializeReason === reason || sectionSerializeReason !== true && reason !== true && compareSerializeReasons(sectionSerializeReason, reason) === 0) ? getDeclaredBindingExpression(binding) : getExprIfSerialized(reason, getDeclaredBindingExpression(binding))
+      )
     );
   });
-  for (const [key, { expression }] of serializedLookup) {
-    serializedProperties.push(toObjectProperty(key, expression));
+  for (const [key, { expression, reason }] of serializedLookup) {
+    serializedProperties.push(
+      toObjectProperty(key, getExprIfSerialized(reason, expression))
+    );
   }
   const writeScopeBuilder = getSectionWriteScopeBuilder(section);
-  const forceSerializeReason = serializeSectionReason(section);
-  if (writeScopeBuilder || serializedProperties.length || forceSerializeReason) {
+  if (sectionSerializeReason) {
     for (const prop of serializedProperties) {
       if (prop.key.type === "Identifier" && prop.value.type === "Identifier" && prop.key.name === prop.value.name) {
         prop.shorthand = true;
@@ -3319,7 +3736,7 @@ function writeHTMLResumeStatements(path5) {
     }
     const writeScopeArgs = [
       scopeIdIdentifier,
-      import_compiler19.types.objectExpression(serializedProperties)
+      import_compiler20.types.objectExpression(serializedProperties)
     ];
     if (!isOptimize()) {
       let debugVars;
@@ -3335,38 +3752,42 @@ function writeHTMLResumeStatements(path5) {
           }
           root = root.upstreamAlias;
         }
-        const locExpr = root.loc && import_compiler19.types.stringLiteral(
+        const locExpr = root.loc && import_compiler20.types.stringLiteral(
           `${root.loc.start.line}:${root.loc.start.column + 1}`
         );
         (debugVars ||= []).push(
           toObjectProperty(
             getScopeAccessor(binding),
-            root !== binding ? import_compiler19.types.arrayExpression(
-              locExpr ? [import_compiler19.types.stringLiteral(root.name + access), locExpr] : [import_compiler19.types.stringLiteral(root.name + access)]
-            ) : locExpr || import_compiler19.types.numericLiteral(0)
+            root !== binding ? import_compiler20.types.arrayExpression(
+              locExpr ? [import_compiler20.types.stringLiteral(root.name + access), locExpr] : [import_compiler20.types.stringLiteral(root.name + access)]
+            ) : locExpr || import_compiler20.types.numericLiteral(0)
           )
         );
       });
       writeScopeArgs.push(
-        import_compiler19.types.stringLiteral(path5.hub.file.opts.filenameRelative),
-        section.loc && section.loc.start.line != null ? import_compiler19.types.stringLiteral(
+        import_compiler20.types.stringLiteral(path5.hub.file.opts.filenameRelative),
+        section.loc && section.loc.start.line != null ? import_compiler20.types.stringLiteral(
           `${section.loc.start.line}:${section.loc.start.column + 1}`
-        ) : import_compiler19.types.numericLiteral(0)
+        ) : import_compiler20.types.numericLiteral(0)
       );
       if (debugVars) {
-        writeScopeArgs.push(import_compiler19.types.objectExpression(debugVars));
+        writeScopeArgs.push(import_compiler20.types.objectExpression(debugVars));
       }
     }
-    body.push(
-      import_compiler19.types.expressionStatement(
-        writeScopeBuilder ? writeScopeBuilder(callRuntime("writeScope", ...writeScopeArgs)) : callRuntime("writeScope", ...writeScopeArgs)
-      )
-    );
+    let writeScopeCall = writeScopeBuilder ? writeScopeBuilder(callRuntime("writeScope", ...writeScopeArgs)) : callRuntime("writeScope", ...writeScopeArgs);
+    if (sectionSerializeReason !== true) {
+      writeScopeCall = import_compiler20.types.logicalExpression(
+        "&&",
+        getSerializeGuard(sectionSerializeReason),
+        writeScopeCall
+      );
+    }
+    body.push(import_compiler20.types.expressionStatement(writeScopeCall));
   }
   const resumeClosestBranch2 = !section.isBranch && (section.hasAbortSignal || !!section.referencedClosures || !!find(section.bindings, (binding) => binding.type === 1 /* let */));
   if (resumeClosestBranch2) {
     body.push(
-      import_compiler19.types.expressionStatement(
+      import_compiler20.types.expressionStatement(
         callRuntime("resumeClosestBranch", scopeIdIdentifier)
       )
     );
@@ -3374,26 +3795,28 @@ function writeHTMLResumeStatements(path5) {
   const additionalStatements = getHTMLSectionStatements(section);
   if (body.length || additionalStatements.length) {
     body.unshift(
-      import_compiler19.types.variableDeclaration("const", [
-        import_compiler19.types.variableDeclarator(scopeIdIdentifier, callRuntime("nextScopeId"))
+      import_compiler20.types.variableDeclaration("const", [
+        import_compiler20.types.variableDeclarator(scopeIdIdentifier, callRuntime("nextScopeId"))
       ]),
       ...additionalStatements
     );
   }
   const returnIdentifier = getSectionReturnValueIdentifier(section);
   if (returnIdentifier !== void 0) {
-    body.push(import_compiler19.types.returnStatement(returnIdentifier));
+    body.push(import_compiler20.types.returnStatement(returnIdentifier));
   }
 }
 function serializeOwners(from, to) {
+  const ownerProp = getAccessorProp().Owner;
   let cur = from;
   while (cur !== to) {
     const parent = cur.parent;
     if (!parent) break;
     const serialized = getSerializedAccessors(cur);
+    nonAnalyzedForceSerializedSection.add(cur);
     cur = parent;
-    if (!serialized.has("_")) {
-      serialized.set("_", {
+    if (!serialized.has(ownerProp)) {
+      serialized.set(ownerProp, {
         expression: callRuntime("ensureScopeWithId", getScopeIdIdentifier(cur)),
         reason: true
       });
@@ -3404,12 +3827,12 @@ function getSetup(section) {
   return getSignals(section).get(void 0)?.identifier;
 }
 function replaceRenderNode(node) {
-  return replaceAssignedNode(node) || replaceBindingReadNode(node) || replaceRegisteredFunctionNode(node);
+  return replaceAssignedNode(node) || replaceBindingReadNode2(node) || replaceRegisteredFunctionNode2(node);
 }
 function replaceEffectNode(node) {
-  return replaceAssignedNode(node) || replaceBindingReadNode(node);
+  return replaceAssignedNode(node) || replaceBindingReadNode2(node);
 }
-function replaceBindingReadNode(node) {
+function replaceBindingReadNode2(node) {
   switch (node.type) {
     case "Identifier":
     case "MemberExpression": {
@@ -3429,14 +3852,14 @@ function replaceAssignedNode(node) {
         if (buildAssignment) {
           const replacement = buildAssignment(
             extra.section,
-            import_compiler19.types.binaryExpression(
+            import_compiler20.types.binaryExpression(
               node.operator === "++" ? "+" : "-",
               node.argument,
-              import_compiler19.types.numericLiteral(1)
+              import_compiler20.types.numericLiteral(1)
             )
           );
           if (!node.prefix) {
-            return import_compiler19.types.sequenceExpression([replacement, node.argument]);
+            return import_compiler20.types.sequenceExpression([replacement, node.argument]);
           }
           return replacement;
         }
@@ -3455,7 +3878,7 @@ function replaceAssignedNode(node) {
             if (buildAssignment) {
               return buildAssignment(
                 extra.section,
-                node.operator === "=" ? node.right : import_compiler19.types.binaryExpression(
+                node.operator === "=" ? node.right : import_compiler20.types.binaryExpression(
                   node.operator.slice(
                     0,
                     -1
@@ -3481,26 +3904,26 @@ function replaceAssignedNode(node) {
               );
               if (signal?.buildAssignment) {
                 id.name = generateUid(id.name);
-                (params ||= []).push(import_compiler19.types.identifier(id.name));
+                (params ||= []).push(import_compiler20.types.identifier(id.name));
                 (assignments ||= []).push(
-                  signal.buildAssignment(extra.section, import_compiler19.types.identifier(id.name))
+                  signal.buildAssignment(extra.section, import_compiler20.types.identifier(id.name))
                 );
               }
             }
           });
           if (params && assignments) {
             const resultId = generateUid("result");
-            return import_compiler19.types.callExpression(
-              import_compiler19.types.arrowFunctionExpression(
-                [import_compiler19.types.identifier(resultId), ...params],
-                import_compiler19.types.sequenceExpression([
-                  import_compiler19.types.assignmentExpression(
+            return import_compiler20.types.callExpression(
+              import_compiler20.types.arrowFunctionExpression(
+                [import_compiler20.types.identifier(resultId), ...params],
+                import_compiler20.types.sequenceExpression([
+                  import_compiler20.types.assignmentExpression(
                     "=",
                     node.left,
-                    import_compiler19.types.identifier(resultId)
+                    import_compiler20.types.identifier(resultId)
                   ),
                   ...assignments,
-                  import_compiler19.types.identifier(resultId)
+                  import_compiler20.types.identifier(resultId)
                 ])
               ),
               [node.right]
@@ -3513,44 +3936,44 @@ function replaceAssignedNode(node) {
   }
 }
 var registeredFnsForProgram = /* @__PURE__ */ new WeakMap();
-function replaceRegisteredFunctionNode(node) {
+function replaceRegisteredFunctionNode2(node) {
   switch (node.type) {
     case "ClassMethod": {
-      const replacement = getRegisteredFnExpression(node);
-      return replacement && import_compiler19.types.classProperty(node.key, replacement);
+      const replacement = getRegisteredFnExpression2(node);
+      return replacement && import_compiler20.types.classProperty(node.key, replacement);
     }
     case "ClassPrivateMethod": {
-      const replacement = getRegisteredFnExpression(node);
-      return replacement && import_compiler19.types.classPrivateProperty(node.key, replacement);
+      const replacement = getRegisteredFnExpression2(node);
+      return replacement && import_compiler20.types.classPrivateProperty(node.key, replacement);
     }
     case "ObjectMethod": {
-      const replacement = getRegisteredFnExpression(node);
-      return replacement && import_compiler19.types.objectProperty(node.key, replacement);
+      const replacement = getRegisteredFnExpression2(node);
+      return replacement && import_compiler20.types.objectProperty(node.key, replacement);
     }
     case "ArrowFunctionExpression":
     case "FunctionExpression": {
-      return getRegisteredFnExpression(node);
+      return getRegisteredFnExpression2(node);
     }
     case "FunctionDeclaration": {
-      const replacement = getRegisteredFnExpression(node);
+      const replacement = getRegisteredFnExpression2(node);
       if (replacement) {
-        return import_compiler19.types.variableDeclaration("const", [
-          import_compiler19.types.variableDeclarator(node.id, replacement)
+        return import_compiler20.types.variableDeclaration("const", [
+          import_compiler20.types.variableDeclarator(node.id, replacement)
         ]);
       }
       break;
     }
   }
 }
-function getRegisteredFnExpression(node) {
+function getRegisteredFnExpression2(node) {
   const { extra } = node;
   if (isRegisteredFnExtra(extra)) {
     const id = extra.name;
     const referencesScope = extra.referencesScope;
     const referencedBindings = extra.referencedBindingsInFunction;
-    let registedFns = registeredFnsForProgram.get((0, import_babel_utils13.getProgram)().node);
+    let registedFns = registeredFnsForProgram.get((0, import_babel_utils14.getProgram)().node);
     if (!registedFns) {
-      registeredFnsForProgram.set((0, import_babel_utils13.getProgram)().node, registedFns = []);
+      registeredFnsForProgram.set((0, import_babel_utils14.getProgram)().node, registedFns = []);
     }
     registedFns.push({
       id,
@@ -3561,9 +3984,9 @@ function getRegisteredFnExpression(node) {
       referencedBindings
     });
     if (referencesScope || referencedBindings) {
-      return import_compiler19.types.callExpression(import_compiler19.types.identifier(id), [scopeIdentifier]);
+      return import_compiler20.types.callExpression(import_compiler20.types.identifier(id), [scopeIdentifier]);
     } else {
-      return import_compiler19.types.identifier(id);
+      return import_compiler20.types.identifier(id);
     }
   }
 }
@@ -3576,30 +3999,30 @@ var dom_default = {
       const section = getSectionForBody(program);
       const { walks, writes, setup } = getSectionMeta(section);
       const domExports = program.node.extra.domExports;
-      const templateIdentifier = import_compiler20.types.identifier(domExports.template);
-      const walksIdentifier = import_compiler20.types.identifier(domExports.walks);
-      const setupIdentifier = import_compiler20.types.identifier(domExports.setup);
+      const templateIdentifier = import_compiler21.types.identifier(domExports.template);
+      const walksIdentifier = import_compiler21.types.identifier(domExports.walks);
+      const setupIdentifier = import_compiler21.types.identifier(domExports.setup);
       const inputBinding = program.node.params[0].extra?.binding;
       const programInputSignal = inputBinding && bindingHasDownstreamExpressions(inputBinding) ? initValue(inputBinding) : void 0;
       const styleFile = getStyleFile(program.hub.file);
       if (styleFile) {
-        (0, import_babel_utils14.importDefault)(program.hub.file, styleFile);
+        (0, import_babel_utils15.importDefault)(program.hub.file, styleFile);
       }
       forEachSectionReverse((childSection) => {
         if (childSection !== section) {
           const tagParamsSignal = childSection.params && initValue(childSection.params);
           const { walks: walks2, writes: writes2, setup: setup2 } = getSectionMeta(childSection);
-          const identifier = import_compiler20.types.identifier(childSection.name);
-          const referencedClosures = childSection.referencedClosures ? import_compiler20.types.arrowFunctionExpression(
+          const identifier = import_compiler21.types.identifier(childSection.name);
+          const referencedClosures = childSection.referencedClosures ? import_compiler21.types.arrowFunctionExpression(
             [scopeIdentifier],
             toFirstExpressionOrBlock(
-              map(childSection.referencedClosures, (closure) => {
+              toArray(childSection.referencedClosures, (closure) => {
                 const closureSignal = getSignal(childSection, closure);
-                return import_compiler20.types.expressionStatement(
-                  import_compiler20.types.callExpression(
-                    isDynamicClosure(childSection, closure) ? closureSignal.identifier : import_compiler20.types.memberExpression(
+                return import_compiler21.types.expressionStatement(
+                  import_compiler21.types.callExpression(
+                    isDynamicClosure(childSection, closure) ? closureSignal.identifier : import_compiler21.types.memberExpression(
                       closureSignal.identifier,
-                      import_compiler20.types.identifier("_")
+                      import_compiler21.types.identifier(getAccessorProp().Owner)
                     ),
                     [scopeIdentifier]
                   )
@@ -3618,7 +4041,7 @@ var dom_default = {
             ])
           ) : callRuntime(
             isSerializedSection(childSection) ? "registerContent" : "createContent",
-            import_compiler20.types.stringLiteral(getResumeRegisterId(childSection, "renderer")),
+            import_compiler21.types.stringLiteral(getResumeRegisterId(childSection, "renderer")),
             ...replaceNullishAndEmptyFunctionsWith0([
               writes2,
               walks2,
@@ -3630,8 +4053,8 @@ var dom_default = {
           );
           writeSignals(childSection);
           program.node.body.push(
-            import_compiler20.types.variableDeclaration("const", [
-              import_compiler20.types.variableDeclarator(identifier, renderer)
+            import_compiler21.types.variableDeclaration("const", [
+              import_compiler21.types.variableDeclarator(identifier, renderer)
             ])
           );
         }
@@ -3640,36 +4063,36 @@ var dom_default = {
       writeRegisteredFns();
       if (!setup) {
         program.node.body.unshift(
-          import_compiler20.types.exportNamedDeclaration(
-            import_compiler20.types.variableDeclaration("const", [
-              import_compiler20.types.variableDeclarator(
+          import_compiler21.types.exportNamedDeclaration(
+            import_compiler21.types.variableDeclaration("const", [
+              import_compiler21.types.variableDeclarator(
                 setupIdentifier,
-                import_compiler20.types.arrowFunctionExpression([], import_compiler20.types.blockStatement([]))
+                import_compiler21.types.arrowFunctionExpression([], import_compiler21.types.blockStatement([]))
               )
             ])
           )
         );
       }
       program.node.body.unshift(
-        import_compiler20.types.exportNamedDeclaration(
-          import_compiler20.types.variableDeclaration("const", [
-            import_compiler20.types.variableDeclarator(
+        import_compiler21.types.exportNamedDeclaration(
+          import_compiler21.types.variableDeclaration("const", [
+            import_compiler21.types.variableDeclarator(
               templateIdentifier,
-              writes || import_compiler20.types.stringLiteral("")
+              writes || import_compiler21.types.stringLiteral("")
             )
           ])
         ),
-        import_compiler20.types.exportNamedDeclaration(
-          import_compiler20.types.variableDeclaration("const", [
-            import_compiler20.types.variableDeclarator(walksIdentifier, walks || import_compiler20.types.stringLiteral(""))
+        import_compiler21.types.exportNamedDeclaration(
+          import_compiler21.types.variableDeclaration("const", [
+            import_compiler21.types.variableDeclarator(walksIdentifier, walks || import_compiler21.types.stringLiteral(""))
           ])
         )
       );
       program.node.body.push(
-        import_compiler20.types.exportDefaultDeclaration(
+        import_compiler21.types.exportDefaultDeclaration(
           callRuntime(
             "createTemplate",
-            import_compiler20.types.stringLiteral(program.hub.file.metadata.marko.id),
+            import_compiler21.types.stringLiteral(program.hub.file.metadata.marko.id),
             templateIdentifier,
             walksIdentifier,
             setupIdentifier,
@@ -3681,157 +4104,6 @@ var dom_default = {
   }
 };
 
-// src/translator/visitors/program/html.ts
-var import_compiler21 = require("@marko/compiler");
-var import_babel_utils15 = require("@marko/compiler/babel-utils");
-
-// src/translator/util/is-static.ts
-function isStatic(path5) {
-  return path5.isImportDeclaration() || path5.isExportDeclaration() || path5.isMarkoScriptlet({ static: true });
-}
-
-// src/translator/visitors/program/html.ts
-var templateContentIdentifierForProgram = /* @__PURE__ */ new WeakMap();
-function getTemplateContentName() {
-  let name2 = templateContentIdentifierForProgram.get((0, import_babel_utils15.getProgram)());
-  if (!name2) {
-    templateContentIdentifierForProgram.set(
-      (0, import_babel_utils15.getProgram)(),
-      name2 = generateUid("content")
-    );
-  }
-  return name2;
-}
-var html_default = {
-  translate: {
-    exit(program) {
-      flushInto(program);
-      writeHTMLResumeStatements(program);
-      traverseReplace(program.node, "body", replaceNode);
-      const renderContent = [];
-      for (const child of program.get("body")) {
-        if (!isStatic(child)) {
-          renderContent.push(child.node);
-          child.remove();
-        } else if (child.isMarkoScriptlet()) {
-          if (child.node.target && child.node.target !== "server") {
-            child.remove();
-          } else {
-            child.replaceWithMultiple(child.node.body);
-          }
-        }
-      }
-      const contentId = templateContentIdentifierForProgram.get(program);
-      const contentFn = import_compiler21.types.arrowFunctionExpression(
-        [import_compiler21.types.identifier("input")],
-        import_compiler21.types.blockStatement(renderContent)
-      );
-      const exportDefault = import_compiler21.types.exportDefaultDeclaration(
-        callRuntime(
-          "createTemplate",
-          import_compiler21.types.stringLiteral(program.hub.file.metadata.marko.id),
-          contentId ? import_compiler21.types.identifier(contentId) : contentFn
-        )
-      );
-      if (contentId) {
-        program.node.body.push(
-          import_compiler21.types.variableDeclaration("const", [
-            import_compiler21.types.variableDeclarator(import_compiler21.types.identifier(contentId), contentFn)
-          ]),
-          exportDefault
-        );
-      } else {
-        program.node.body.push(exportDefault);
-      }
-    }
-  }
-};
-function replaceNode(node, container) {
-  return replaceBindingReadNode2(node) || replaceRegisteredFunctionNode2(node, container);
-}
-function replaceBindingReadNode2(node) {
-  switch (node.type) {
-    case "Identifier":
-    case "MemberExpression": {
-      const { extra } = node;
-      if (extra && !(extra.read && !extra.read.binding.declared || extra.binding && !extra.binding.declared)) {
-        return getReadReplacement(node);
-      }
-    }
-  }
-}
-function replaceRegisteredFunctionNode2(node, container) {
-  switch (node.type) {
-    case "ClassMethod": {
-      const replacement = getRegisteredFnExpression2(node);
-      return replacement && import_compiler21.types.classProperty(node.key, replacement);
-    }
-    case "ClassPrivateMethod": {
-      const replacement = getRegisteredFnExpression2(node);
-      return replacement && import_compiler21.types.classPrivateProperty(node.key, replacement);
-    }
-    case "ObjectMethod": {
-      const replacement = getRegisteredFnExpression2(node);
-      return replacement && import_compiler21.types.objectProperty(node.key, replacement);
-    }
-    case "FunctionDeclaration": {
-      const { extra } = node;
-      if (isRegisteredFnExtra(extra)) {
-        let registeredFnDeclarations = registeredFnDeclarationsByBody.get(
-          container
-        );
-        if (!registeredFnDeclarations) {
-          registeredFnDeclarationsByBody.set(
-            container,
-            registeredFnDeclarations = []
-          );
-        }
-        registeredFnDeclarations.push({
-          id: node.id.name,
-          registerId: extra.registerId
-        });
-      }
-      break;
-    }
-    case "ArrowFunctionExpression":
-    case "FunctionExpression": {
-      return getRegisteredFnExpression2(node);
-    }
-    case "BlockStatement":
-    case "MarkoScriptlet":
-      addRegisteredDeclarations(node.body);
-      break;
-  }
-}
-var registeredFnDeclarationsByBody = /* @__PURE__ */ new WeakMap();
-function addRegisteredDeclarations(body) {
-  const registeredFnDeclarations = registeredFnDeclarationsByBody.get(body);
-  if (registeredFnDeclarations) {
-    for (const { id, registerId } of registeredFnDeclarations) {
-      body.push(
-        import_compiler21.types.expressionStatement(
-          callRuntime(
-            "register",
-            import_compiler21.types.identifier(id),
-            import_compiler21.types.stringLiteral(registerId)
-          )
-        )
-      );
-    }
-  }
-}
-function getRegisteredFnExpression2(node) {
-  const { extra } = node;
-  if (isRegisteredFnExtra(extra)) {
-    return callRuntime(
-      "register",
-      simplifyFunction(node),
-      import_compiler21.types.stringLiteral(extra.registerId),
-      (extra.referencedBindingsInFunction || extra.referencesScope) && getScopeIdIdentifier(extra.section)
-    );
-  }
-}
-
 // src/translator/visitors/program/index.ts
 var cleanIdentifier;
 var scopeIdentifier;
@@ -3851,18 +4123,27 @@ var program_default = {
     enter(program) {
       startSection(program);
       trackParamsReferences(program, 2 /* input */);
+      const programExtra = program.node.extra ??= {};
       const inputBinding = program.node.params[0].extra?.binding;
       if (inputBinding) {
         inputBinding.nullable = false;
       }
-      (program.node.extra ??= {}).domExports = {
+      programExtra.domExports = {
         template: generateUid("template"),
         walks: generateUid("walks"),
         setup: generateUid("setup"),
-        input: void 0,
+        input: void 0
         // TODO look into recursive components with fine grained params.
-        closures: generateUid("closures")
       };
+      for (const child of program.get("body")) {
+        if (isCoreTagName(child, "return")) {
+          const { value } = getKnownAttrValues(child.node);
+          if (value) {
+            programExtra.returnValueExpr = value.extra ??= {};
+          }
+          break;
+        }
+      }
     },
     exit(program) {
       finalizeReferences();
@@ -3925,6 +4206,17 @@ var program_default = {
     }
   }
 };
+function resolveSerializeReasonId(inputSerializeReasons, reason) {
+  const id = findIndexSorted(
+    compareSerializeReasons,
+    inputSerializeReasons,
+    reason
+  );
+  if (id === -1) {
+    throw new Error("Unable to resolve serialize reason against input");
+  }
+  return id;
+}
 function resolveRelativeToEntry(entryFile, file, req) {
   return file === entryFile ? (0, import_babel_utils16.resolveRelativePath)(file, req) : (0, import_babel_utils16.resolveRelativePath)(
     entryFile,
@@ -3965,7 +4257,10 @@ function createScopeReadPattern(section, referencedBindings) {
       for (; i <= relativeDepth; i++) {
         const nestedPattern = import_compiler23.types.objectPattern([]);
         prev.properties.push(
-          import_compiler23.types.objectProperty(import_compiler23.types.identifier("_"), nestedPattern)
+          import_compiler23.types.objectProperty(
+            import_compiler23.types.identifier(getAccessorProp().Owner),
+            nestedPattern
+          )
         );
         nestedPatterns.push(nestedPattern);
         prev = nestedPattern;
@@ -3987,7 +4282,7 @@ function getScopeExpression(section, targetSection) {
   let scope = scopeIdentifier ?? import_compiler23.types.identifier("undefined");
   const diff = section.depth - targetSection.depth;
   for (let i = 0; i < diff; i++) {
-    scope = import_compiler23.types.memberExpression(scope, import_compiler23.types.identifier("_"));
+    scope = import_compiler23.types.memberExpression(scope, import_compiler23.types.identifier(getAccessorProp().Owner));
   }
   if (diff < 0) {
     throw new Error("Unable to find scope for reference.");
@@ -4015,7 +4310,7 @@ function withPreviousLocation(newNode, originalNode) {
 var kIsInvoked = Symbol("hoist is invoked");
 var [getBindings] = createProgramState(() => /* @__PURE__ */ new Set());
 var [getNextBindingId, setNextBindingId] = createProgramState(() => 0);
-function createBinding(name2, type, section, upstreamAlias, upstreamExpression, property, loc = null, declared = false) {
+function createBinding(name2, type, section, upstreamAlias, property, loc = null, declared = false) {
   const id = getNextBindingId();
   const binding = {
     id,
@@ -4033,11 +4328,10 @@ function createBinding(name2, type, section, upstreamAlias, upstreamExpression,
     hoists: /* @__PURE__ */ new Map(),
     propertyAliases: /* @__PURE__ */ new Map(),
     upstreamAlias,
-    upstreamExpression,
     downstreamExpressions: /* @__PURE__ */ new Set(),
     scopeOffset: void 0,
     export: void 0,
-    nullable: !upstreamExpression?.confident || upstreamExpression.computed == null
+    nullable: true
   };
   if (property) {
     if (declared) upstreamAlias.nullable = false;
@@ -4056,27 +4350,25 @@ function createBinding(name2, type, section, upstreamAlias, upstreamExpression,
   getBindings().add(binding);
   return binding;
 }
-function trackVarReferences(tag, type, upstreamAlias, upstreamExpression) {
+function trackVarReferences(tag, type, upstreamAlias) {
   const tagVar = tag.node.var;
   if (tagVar) {
     const section = getOrCreateSection(tag);
     const canonicalUpstreamAlias = getCanonicalBinding(upstreamAlias);
-    if (upstreamAlias && upstreamExpression) upstreamExpression.pruned = true;
     createBindingsAndTrackReferences(
       tagVar,
-      type,
+      upstreamAlias ? upstreamAlias.type : type,
       tag.scope,
       section,
       canonicalUpstreamAlias,
-      upstreamExpression,
       void 0
     );
+    return tagVar.extra?.binding;
   }
 }
-function trackParamsReferences(body, type, upstreamAlias, upstreamExpression) {
+function trackParamsReferences(body, type, upstreamAlias) {
   const params = body.node.params;
   if (body.node.body.length && params.length) {
-    if (upstreamAlias && upstreamExpression) upstreamExpression.pruned = true;
     const section = getOrCreateSection(body);
     const canonicalUpstreamAlias = getCanonicalBinding(upstreamAlias);
     const paramsBinding = canonicalUpstreamAlias || ((body.node.extra ??= {}).binding = createBinding(
@@ -4084,7 +4376,6 @@ function trackParamsReferences(body, type, upstreamAlias, upstreamExpression) {
       type,
       section,
       canonicalUpstreamAlias,
-      upstreamExpression,
       void 0
     ));
     section.params = paramsBinding;
@@ -4095,10 +4386,10 @@ function trackParamsReferences(body, type, upstreamAlias, upstreamExpression) {
         body.scope,
         section,
         paramsBinding,
-        upstreamExpression,
         i + ""
       );
     }
+    return paramsBinding;
   }
 }
 function trackHoistedReference(referencePath, binding) {
@@ -4116,7 +4407,6 @@ function trackHoistedReference(referencePath, binding) {
         hoistSection,
         void 0,
         void 0,
-        void 0,
         binding.loc,
         true
       )
@@ -4141,9 +4431,8 @@ function trackHoistedReference(referencePath, binding) {
     hoistedBinding
   );
 }
-function trackReferencesForBinding(babelBinding) {
-  const { identifier, referencePaths, constantViolations } = babelBinding;
-  const binding = identifier.extra.binding;
+function trackReferencesForBinding(babelBinding, binding) {
+  const { referencePaths, constantViolations } = babelBinding;
   for (const referencePath of referencePaths) {
     const referenceSection = getOrCreateSection(referencePath);
     if (isSameOrChildSection(binding.section, referenceSection)) {
@@ -4184,20 +4473,21 @@ function setReferencesScope(path5) {
     (fnRoot.node.extra ??= {}).referencesScope = true;
   }
 }
-function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAlias, upstreamExpression, property) {
+function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAlias, property) {
   switch (lVal.type) {
     case "Identifier":
-      (lVal.extra ??= {}).binding = createBinding(
-        lVal.name,
-        type,
-        section,
-        upstreamAlias,
-        upstreamExpression,
-        property,
-        lVal.loc,
-        true
+      trackReferencesForBinding(
+        scope.getBinding(lVal.name),
+        (lVal.extra ??= {}).binding = createBinding(
+          lVal.name,
+          type,
+          section,
+          upstreamAlias,
+          property,
+          lVal.loc,
+          true
+        )
       );
-      trackReferencesForBinding(scope.getBinding(lVal.name));
       break;
     case "ObjectPattern": {
       const patternBinding = (property ? upstreamAlias.propertyAliases.get(property) : upstreamAlias) || ((lVal.extra ??= {}).binding = createBinding(
@@ -4205,7 +4495,6 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAl
         type,
         section,
         upstreamAlias,
-        void 0,
         property,
         lVal.loc
       ));
@@ -4217,7 +4506,6 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAl
             scope,
             section,
             patternBinding,
-            void 0,
             property
           );
         } else {
@@ -4235,7 +4523,6 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAl
             scope,
             section,
             patternBinding,
-            void 0,
             key
           );
         }
@@ -4248,7 +4535,6 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAl
         type,
         section,
         upstreamAlias,
-        void 0,
         property,
         lVal.loc
       ));
@@ -4263,7 +4549,6 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAl
               scope,
               section,
               patternBinding,
-              void 0,
               property
             );
           } else {
@@ -4273,7 +4558,6 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAl
               scope,
               section,
               patternBinding,
-              void 0,
               `${i}`
             );
           }
@@ -4288,7 +4572,6 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAl
         scope,
         section,
         upstreamAlias,
-        void 0,
         property
       );
       break;
@@ -4318,7 +4601,6 @@ function trackReference(referencePath, binding) {
       reference.type,
       reference.section,
       reference,
-      void 0,
       prop
     );
   }
@@ -4342,8 +4624,13 @@ var [getMergedReferences] = createProgramState(
   () => /* @__PURE__ */ new Map()
 );
 function mergeReferences(section, target, nodes) {
-  (target.extra ??= {}).section = section;
+  const targetExtra = target.extra ??= {};
+  targetExtra.section = section;
   getMergedReferences().set(target, nodes);
+  return targetExtra;
+}
+function compareSerializeReasons(a, b) {
+  return Array.isArray(a) ? Array.isArray(b) ? compareIntersections(a, b) : -1 : Array.isArray(b) ? 1 : bindingUtil.compare(a, b);
 }
 function compareIntersections(a, b) {
   const len = a.length;
@@ -4449,29 +4736,20 @@ function finalizeReferences() {
     }
   }
   forEachSection((section) => {
+    if (isSectionWithHoists(section)) {
+      forceSectionSerialize(section);
+    }
     if (section.parent && section.isBranch && section.sectionAccessor && section.upstreamExpression) {
-      const tagSection = section.parent;
-      const tagExtra = section.upstreamExpression;
-      const nodeBinding = section.sectionAccessor.binding;
-      if (isSectionWithHoists(section)) {
-        forcePropSerialize(tagSection, tagExtra, kBranchSerializeReason);
-      } else {
-        addPropSerializeReasonRef(
-          tagSection,
-          tagExtra,
-          kBranchSerializeReason,
-          getDirectClosures(section)
-        );
-      }
-      addPropSerializeReasonExpr(
-        tagSection,
-        tagExtra,
-        kBranchSerializeReason,
-        tagExtra
+      addSectionSerializeReasonRef(section, getDirectClosures(section));
+      addSectionSerializeReasonExpr(section, section.upstreamExpression);
+      addBindingSerializeReasonExpr(
+        section.parent,
+        section.sectionAccessor.binding,
+        section.upstreamExpression
       );
-      addBindingSerializeReasonExpr(tagSection, nodeBinding, tagExtra);
     }
   });
+  forEachSection(applySerializeReasonExprs);
   forEachSection((section) => {
     const intersections = intersectionsBySection.get(section);
     if (intersections) {
@@ -4518,6 +4796,12 @@ function finalizeReferences() {
         }
         addBindingSerializeReason(closure.section, closure, serializeReason);
       }
+      if (closure.sources) {
+        addSectionSerializeReason(
+          closure.section,
+          getBindingSerializeReason(closure.section, closure)
+        );
+      }
       if (closure.serializeSources && isDynamicClosure(section, closure)) {
         addBindingSerializeReason(
           closure.section,
@@ -4534,19 +4818,26 @@ function finalizeReferences() {
       }
     });
   });
+  let inputSerializeReasons;
   forEachSection((section) => {
-    const serializeReasonExprs2 = consumeSerializeReasonExprs(section);
-    if (serializeReasonExprs2) {
-      for (const [key, exprs] of serializeReasonExprs2) {
-        const reason = getSerializeSourcesForExprs(exprs);
-        if (reason) {
-          section.serializeReasons.set(
-            key,
-            mergeSerializeReasons(section.serializeReasons.get(key), reason)
-          );
-        }
+    finalizeSectionSerializeReasons(section);
+    if (section.serializeReason && section.serializeReason !== true) {
+      inputSerializeReasons = inputSerializeReasons ? addSorted(
+        compareSerializeReasons,
+        inputSerializeReasons,
+        section.serializeReason
+      ) : [section.serializeReason];
+    }
+    for (const [, reason] of section.serializeReasons) {
+      if (reason !== true) {
+        inputSerializeReasons = inputSerializeReasons ? addSorted(compareSerializeReasons, inputSerializeReasons, reason) : [reason];
       }
     }
+  });
+  const programExtra = (0, import_babel_utils17.getProgram)().node.extra;
+  programExtra.returnSerializeReason = programExtra.returnValueExpr && getSerializeSourcesForExpr(programExtra.returnValueExpr);
+  programExtra.inputSerializeReasons = inputSerializeReasons;
+  forEachSection((section) => {
     let intersectionIndex = 0;
     const intersections = intersectionsBySection.get(section) || [];
     const { id, bindings: bindings2 } = section;
@@ -4588,33 +4879,65 @@ function getMaxOwnSourceOffset(intersection, section) {
   return scopeOffset;
 }
 var intersectionMeta = /* @__PURE__ */ new WeakMap();
+function setBindingValueExpr(binding, valueExpr) {
+  bindingValueExprs.set(binding, valueExpr || false);
+}
+var resolvedSources = /* @__PURE__ */ new WeakSet();
+var bindingValueExprs = /* @__PURE__ */ new WeakMap();
 function resolveBindingSources(binding) {
-  const derived = /* @__PURE__ */ new Set();
-  let onlyInputSources = true;
-  let sources;
-  crawl(binding);
-  binding.sources = sources;
-  binding.serializeSources = sources ? onlyInputSources ? sources : true : void 0;
-  function crawl(binding2) {
-    if (binding2.type === 4 /* derived */ || binding2.type === 3 /* param */) {
-      let alias;
-      let curBinding = binding2;
-      while (alias = curBinding.upstreamAlias) {
-        curBinding = alias;
-      }
-      if (curBinding.upstreamExpression) {
-        if (derived.has(curBinding)) return;
-        derived.add(curBinding);
-        forEach(curBinding.upstreamExpression.referencedBindings, crawl);
-      } else if (curBinding.type === 2 /* input */) {
-        sources = bindingUtil.add(sources, binding2);
-      } else {
-        onlyInputSources = false;
-        sources = bindingUtil.add(sources, curBinding);
+  if (resolvedSources.has(binding)) return;
+  resolvedSources.add(binding);
+  switch (binding.type) {
+    case 1 /* let */:
+      binding.sources = binding;
+      binding.serializeSources = true;
+      return;
+    case 2 /* input */:
+      binding.sources = binding;
+      binding.serializeSources = binding;
+      return;
+  }
+  let alias;
+  let source = binding;
+  while (alias = source.upstreamAlias) {
+    source = alias;
+  }
+  if (source === binding) {
+    resolveDerivedSources(binding);
+    return;
+  }
+  if (!resolvedSources.has(source)) {
+    resolvedSources.add(source);
+    resolveDerivedSources(source);
+  }
+  binding.sources = source.sources;
+  binding.serializeSources = source.serializeSources;
+}
+function resolveDerivedSources(binding) {
+  const exprs = bindingValueExprs.get(binding);
+  bindingValueExprs.delete(binding);
+  if (exprs === void 0 || exprs === true) {
+    binding.serializeSources = true;
+    binding.sources = binding;
+  } else if (exprs) {
+    const seen = /* @__PURE__ */ new Set();
+    let onlyInputSources = true;
+    let sources;
+    forEach(exprs, (expr) => {
+      if (isReferencedExtra(expr)) {
+        forEach(expr.referencedBindings, (ref) => {
+          if (!seen.has(ref)) {
+            seen.add(ref);
+            resolveBindingSources(ref);
+            sources = bindingUtil.union(sources, ref.sources);
+            onlyInputSources &&= ref.serializeSources !== true;
+          }
+        });
       }
-    } else {
-      onlyInputSources = false;
-      sources = bindingUtil.add(sources, binding2);
+    });
+    if (sources) {
+      binding.sources = sources;
+      binding.serializeSources = onlyInputSources ? sources : true;
     }
   }
 }
@@ -4843,22 +5166,16 @@ function isRegisteredFnExtra(extra) {
 var kDOMBinding = Symbol("await tag dom binding");
 var await_default = {
   analyze(tag) {
-    (0, import_babel_utils17.assertNoVar)(tag);
-    (0, import_babel_utils17.assertNoArgs)(tag);
+    (0, import_babel_utils18.assertNoVar)(tag);
+    (0, import_babel_utils18.assertNoArgs)(tag);
     assertNoSpreadAttrs(tag);
-    (0, import_babel_utils17.assertNoAttributeTags)(tag);
+    (0, import_babel_utils18.assertNoAttributeTags)(tag);
     const { node } = tag;
     const tagBody = tag.get("body");
     const section = getOrCreateSection(tag);
     const [valueAttr] = node.attributes;
     const tagExtra = tag.node.extra ??= {};
-    tagExtra[kDOMBinding] = createBinding(
-      "#text",
-      0 /* dom */,
-      section,
-      void 0,
-      tagExtra
-    );
+    tagExtra[kDOMBinding] = createBinding("#text", 0 /* dom */, section);
     if (!valueAttr) {
       throw tag.get("name").buildCodeFrameError("The `await` tag requires a value.");
     }
@@ -4876,13 +5193,12 @@ var await_default = {
       );
     }
     const bodySection = startSection(tagBody);
+    const valueExtra = evaluate(valueAttr.value);
     getOrCreateSection(tag);
-    trackParamsReferences(
-      tagBody,
-      3 /* param */,
-      void 0,
-      evaluate(valueAttr.value)
-    );
+    const paramsBinding = trackParamsReferences(tagBody, 3 /* param */);
+    if (paramsBinding) {
+      setBindingValueExpr(paramsBinding, valueExtra);
+    }
     bodySection.upstreamExpression = valueAttr.value.extra;
   },
   translate: translateByTarget({
@@ -4970,7 +5286,7 @@ var await_default = {
 
 // src/translator/core/client.ts
 var import_compiler26 = require("@marko/compiler");
-var import_babel_utils18 = require("@marko/compiler/babel-utils");
+var import_babel_utils19 = require("@marko/compiler/babel-utils");
 var client_default = {
   parse(tag) {
     const {
@@ -4980,7 +5296,7 @@ var client_default = {
     const rawValue = node.rawValue;
     const code = rawValue.replace(/^client\s*/, "").trim();
     const start = node.name.start + (rawValue.length - code.length);
-    let body = (0, import_babel_utils18.parseStatements)(file, code, start, start + code.length);
+    let body = (0, import_babel_utils19.parseStatements)(file, code, start, start + code.length);
     if (body.length === 1 && import_compiler26.types.isBlockStatement(body[0])) {
       body = body[0].body;
     }
@@ -5001,7 +5317,7 @@ var client_default = {
 
 // src/translator/core/const.ts
 var import_compiler28 = require("@marko/compiler");
-var import_babel_utils19 = require("@marko/compiler/babel-utils");
+var import_babel_utils20 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/translate-var.ts
 var import_compiler27 = require("@marko/compiler");
@@ -5020,8 +5336,8 @@ function translateVar(tag, initialValue, kind = "const") {
 // src/translator/core/const.ts
 var const_default = {
   analyze(tag) {
-    (0, import_babel_utils19.assertNoArgs)(tag);
-    (0, import_babel_utils19.assertNoParams)(tag);
+    (0, import_babel_utils20.assertNoArgs)(tag);
+    (0, import_babel_utils20.assertNoParams)(tag);
     assertNoBodyContent(tag);
     const { node } = tag;
     const [valueAttr] = node.attributes;
@@ -5036,14 +5352,16 @@ var const_default = {
         "The `const` tag only supports the `value` attribute."
       );
     }
+    const valueExtra = evaluate(valueAttr.value);
     const upstreamAlias = import_compiler28.types.isIdentifier(valueAttr.value) ? tag.scope.getBinding(valueAttr.value.name)?.identifier.extra?.binding : void 0;
-    trackVarReferences(
-      tag,
-      4 /* derived */,
-      upstreamAlias,
-      evaluate(valueAttr.value)
-      // TODO could perform a more extensive "nullable" check.
-    );
+    if (upstreamAlias) {
+      valueExtra.pruned = true;
+    }
+    const binding = trackVarReferences(tag, 4 /* derived */, upstreamAlias);
+    if (binding) {
+      if (!valueExtra.nullable) binding.nullable = false;
+      setBindingValueExpr(binding, valueExtra);
+    }
   },
   translate: {
     exit(tag) {
@@ -5078,13 +5396,13 @@ var const_default = {
 
 // src/translator/core/debug.ts
 var import_compiler29 = require("@marko/compiler");
-var import_babel_utils20 = require("@marko/compiler/babel-utils");
+var import_babel_utils21 = require("@marko/compiler/babel-utils");
 var debug_default = {
   analyze(tag) {
     const [valueAttr] = tag.node.attributes;
-    (0, import_babel_utils20.assertNoVar)(tag);
-    (0, import_babel_utils20.assertNoArgs)(tag);
-    (0, import_babel_utils20.assertNoParams)(tag);
+    (0, import_babel_utils21.assertNoVar)(tag);
+    (0, import_babel_utils21.assertNoArgs)(tag);
+    (0, import_babel_utils21.assertNoParams)(tag);
     assertNoBodyContent(tag);
     if (tag.node.attributes.length > 1 || tag.node.attributes.length === 1 && (!import_compiler29.types.isMarkoAttribute(valueAttr) || !valueAttr.default && valueAttr.name !== "value")) {
       throw tag.get("name").buildCodeFrameError(
@@ -5121,11 +5439,11 @@ var debug_default = {
 
 // src/translator/core/define.ts
 var import_compiler35 = require("@marko/compiler");
-var import_babel_utils26 = require("@marko/compiler/babel-utils");
+var import_babel_utils27 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/nested-attribute-tags.ts
 var import_compiler30 = require("@marko/compiler");
-var import_babel_utils21 = require("@marko/compiler/babel-utils");
+var import_babel_utils22 = require("@marko/compiler/babel-utils");
 var attrTagToIdentifierLookup = /* @__PURE__ */ new WeakMap();
 function getAttrTagIdentifier(meta) {
   let name2 = attrTagToIdentifierLookup.get(meta);
@@ -5145,13 +5463,13 @@ function analyzeAttributeTags(tag) {
   const sampleAttrTagsForControlFlow = /* @__PURE__ */ new Map();
   for (const child of attrTags2) {
     if (child.isMarkoTag()) {
-      if ((0, import_babel_utils21.isAttributeTag)(child)) {
+      if ((0, import_babel_utils22.isAttributeTag)(child)) {
         const name2 = getTagName(child);
         lookup[name2] ||= createAttrTagMeta(name2, [name2]);
         (attrTagNodesByName[name2] ||= []).push(child);
         analyzeAttributeTags(child);
       } else {
-        const isRepeated = (0, import_babel_utils21.isLoopTag)(child);
+        const isRepeated = (0, import_babel_utils22.isLoopTag)(child);
         let curGroup;
         for (const name2 of crawlAttrTags(child, attrTagNodesByName)) {
           const oldMeta = lookup[name2];
@@ -5206,7 +5524,7 @@ function crawlAttrTags(tag, attrTagNodesByName, attrTagNames = /* @__PURE__ */ n
   const attrTags2 = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
   for (const child of attrTags2) {
     if (child.isMarkoTag()) {
-      if ((0, import_babel_utils21.isAttributeTag)(child)) {
+      if ((0, import_babel_utils22.isAttributeTag)(child)) {
         const tagName = getTagName(child);
         attrTagNames.add(tagName);
         (attrTagNodesByName[tagName] ||= []).push(child);
@@ -5247,19 +5565,19 @@ function getConditionRoot(tag) {
 
 // src/translator/util/translate-attrs.ts
 var import_compiler34 = require("@marko/compiler");
-var import_babel_utils25 = require("@marko/compiler/babel-utils");
+var import_babel_utils26 = require("@marko/compiler/babel-utils");
 
 // src/translator/core/for.ts
 var import_compiler33 = require("@marko/compiler");
-var import_babel_utils24 = require("@marko/compiler/babel-utils");
+var import_babel_utils25 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/is-only-child-in-parent.ts
 var import_compiler32 = require("@marko/compiler");
-var import_babel_utils23 = require("@marko/compiler/babel-utils");
+var import_babel_utils24 = require("@marko/compiler/babel-utils");
 
 // src/translator/visitors/tag/native-tag.ts
 var import_compiler31 = require("@marko/compiler");
-var import_babel_utils22 = require("@marko/compiler/babel-utils");
+var import_babel_utils23 = require("@marko/compiler/babel-utils");
 var kNativeTagBinding = Symbol("native tag binding");
 var kSkipMark = Symbol("skip native tag mark");
 var kGetterId = Symbol("node getter id");
@@ -5361,9 +5679,9 @@ var native_tag_default = {
   },
   analyze: {
     enter(tag) {
-      (0, import_babel_utils22.assertNoArgs)(tag);
-      (0, import_babel_utils22.assertNoParams)(tag);
-      (0, import_babel_utils22.assertNoAttributeTags)(tag);
+      (0, import_babel_utils23.assertNoArgs)(tag);
+      (0, import_babel_utils23.assertNoParams)(tag);
+      (0, import_babel_utils23.assertNoAttributeTags)(tag);
       const { node } = tag;
       if (node.var && !import_compiler31.types.isIdentifier(node.var)) {
         throw tag.get("var").buildCodeFrameError(
@@ -5416,7 +5734,7 @@ var native_tag_default = {
           0 /* dom */,
           tagSection
         );
-        (0, import_babel_utils22.getProgram)().node.extra.isInteractive ||= hasEventHandlers;
+        (0, import_babel_utils23.getProgram)().node.extra.isInteractive ||= hasEventHandlers;
         if (spreadReferenceNodes) {
           if (relatedControllable && !relatedControllable.attrs.every(Boolean)) {
             for (const attr2 of relatedControllable.attrs) {
@@ -5438,6 +5756,7 @@ var native_tag_default = {
           );
         }
         if (node.var) {
+          forceSectionSerialize(tagSection);
           forceBindingSerialize(tagSection, nodeBinding);
           const varBinding = tag.scope.getBinding(node.var.name);
           for (const referencePath of varBinding.referencePaths) {
@@ -5474,7 +5793,7 @@ var native_tag_default = {
       const nodeBinding = tagExtra[kNativeTagBinding];
       const isHTML = isOutputHTML();
       const name2 = tag.get("name");
-      const tagDef = (0, import_babel_utils22.getTagDef)(tag);
+      const tagDef = (0, import_babel_utils23.getTagDef)(tag);
       const write2 = writeTo(tag);
       const tagSection = getSection(tag);
       if (isHTML && tagExtra.tagNameNullable) {
@@ -5491,7 +5810,6 @@ var native_tag_default = {
               serializeOwners(referenceSection, tagSection);
             }
           }
-          serializeSectionIfNeeded(tagSection, true);
           translateVar(
             tag,
             callRuntime(
@@ -5504,7 +5822,7 @@ var native_tag_default = {
           let getterFnIdentifier;
           if (getterId) {
             getterFnIdentifier = generateUidIdentifier(`get_${varName}`);
-            (0, import_babel_utils22.getProgram)().node.body.push(
+            (0, import_babel_utils23.getProgram)().node.body.push(
               import_compiler31.types.variableDeclaration("const", [
                 import_compiler31.types.variableDeclarator(
                   getterFnIdentifier,
@@ -5794,7 +6112,7 @@ var native_tag_default = {
       const tagExtra = tag.node.extra;
       const nodeBinding = tagExtra[kNativeTagBinding];
       const isHTML = isOutputHTML();
-      const openTagOnly = (0, import_babel_utils22.getTagDef)(tag)?.parseOptions?.openTagOnly;
+      const openTagOnly = (0, import_babel_utils23.getTagDef)(tag)?.parseOptions?.openTagOnly;
       const selectArgs = isHTML && htmlSelectArgs.get(tag.node);
       const tagName = getTagName(tag);
       const tagSection = getSection(tag);
@@ -5822,12 +6140,11 @@ var native_tag_default = {
       } else {
         tag.insertBefore(tag.node.body.body).forEach((child) => child.skip());
       }
-      const serializeMarkerReason = nodeBinding && !tagExtra[kSkipMark] && getBindingSerializeReason(tagSection, nodeBinding);
-      const shouldMark = !!serializeMarkerReason;
+      const markerSerializeReason = nodeBinding && !tagExtra[kSkipMark] && getBindingSerializeReason(tagSection, nodeBinding);
       if (!openTagOnly && !selectArgs) {
         writeTo(
           tag,
-          isHTML && !shouldMark && (tagName === "html" || tagName === "body")
+          isHTML && !markerSerializeReason && (tagName === "html" || tagName === "body")
         )`</${tag.node.name}>`;
       }
       if (isHTML && tagExtra.tagNameNullable) {
@@ -5835,8 +6152,8 @@ var native_tag_default = {
           import_compiler31.types.ifStatement(tag.node.name, consumeHTML(tag))
         )[0].skip();
       }
-      if (shouldMark) {
-        markNode(tag, nodeBinding);
+      if (markerSerializeReason) {
+        markNode(tag, nodeBinding, markerSerializeReason);
       }
       exit2(tag);
       tag.remove();
@@ -5935,7 +6252,7 @@ function isOnlyChildInParent(tag, branchSize = 1) {
     return extra[kOnlyChildInParent];
   }
   const parentTag = getParentTag(tag);
-  if (parentTag && (0, import_babel_utils23.getTagDef)(parentTag)?.html) {
+  if (parentTag && (0, import_babel_utils24.getTagDef)(parentTag)?.html) {
     return extra[kOnlyChildInParent] = tag.parent.body.length === branchSize;
   }
   return extra[kOnlyChildInParent] = false;
@@ -5961,11 +6278,10 @@ function getOptimizedOnlyChildNodeBinding(tag, section, branchSize = 1) {
 // src/translator/core/for.ts
 var for_default = {
   analyze(tag) {
-    const tagExtra = tag.node.extra ??= {};
     const isAttrTag = tag.node.body.attributeTags;
     let allowAttrs;
-    (0, import_babel_utils24.assertNoVar)(tag);
-    (0, import_babel_utils24.assertNoArgs)(tag);
+    (0, import_babel_utils25.assertNoVar)(tag);
+    (0, import_babel_utils25.assertNoArgs)(tag);
     assertNoSpreadAttrs(tag);
     switch (getForType(tag.node)) {
       case "of":
@@ -5985,7 +6301,7 @@ var for_default = {
     if (!isAttrTag) {
       allowAttrs.push("by");
     }
-    (0, import_babel_utils24.assertAllowedAttributes)(tag, allowAttrs);
+    (0, import_babel_utils25.assertAllowedAttributes)(tag, allowAttrs);
     if (isAttrTag) return;
     const tagBody = tag.get("body");
     const bodySection = startSection(tagBody);
@@ -5995,8 +6311,15 @@ var for_default = {
     }
     const tagSection = getOrCreateSection(tag);
     const nodeBinding = getOptimizedOnlyChildNodeBinding(tag, tagSection);
-    trackParamsReferences(tagBody, 3 /* param */, void 0, tagExtra);
-    mergeReferences(tagSection, tag.node, getAllTagReferenceNodes(tag.node));
+    const paramsBinding = trackParamsReferences(tagBody, 3 /* param */);
+    const tagExtra = mergeReferences(
+      tagSection,
+      tag.node,
+      getAllTagReferenceNodes(tag.node)
+    );
+    if (paramsBinding) {
+      setBindingValueExpr(paramsBinding, tagExtra);
+    }
     bodySection.sectionAccessor = {
       binding: nodeBinding,
       prefix: getAccessorPrefix().LoopScopeMap
@@ -6027,7 +6350,6 @@ var for_default = {
         const tagSection = getSection(tag);
         const bodySection = getSectionForBody(tagBody);
         const { node } = tag;
-        const tagExtra = node.extra;
         const onlyChildInParentOptimization = isOnlyChildInParent(tag);
         const nodeBinding = getOptimizedOnlyChildNodeBinding(tag, tagSection);
         const forAttrs = getKnownAttrValues(node);
@@ -6036,31 +6358,34 @@ var for_default = {
         const statements = [];
         const bodyStatements = node.body.body;
         const singleNodeOptimization = bodySection.content === null || bodySection.content.singleChild && bodySection.content.startType !== 4 /* Text */;
-        const branchSerializeReason = getPropSerializeReason(
-          tagSection,
-          tagExtra,
-          kBranchSerializeReason
-        );
+        const branchSerializeReason = getSectionSerializeReason(bodySection);
         const markerSerializeReason = getBindingSerializeReason(
           tagSection,
           nodeBinding
         );
-        const serializeReason = branchSerializeReason || markerSerializeReason;
         if (markerSerializeReason && onlyChildInParentOptimization) {
           getParentTag(tag).node.extra[kSkipMark] = true;
         }
         flushInto(tag);
         writeHTMLResumeStatements(tagBody);
         const forTagArgs = getBaseArgsInForTag(forType, forAttrs);
-        const forTagHTMLRuntime = serializeReason ? forTypeToHTMLResumeRuntime(forType, singleNodeOptimization) : forTypeToRuntime(forType);
+        const forTagHTMLRuntime = branchSerializeReason ? forTypeToHTMLResumeRuntime(forType, singleNodeOptimization) : forTypeToRuntime(forType);
         forTagArgs.push(
           import_compiler33.types.arrowFunctionExpression(params, import_compiler33.types.blockStatement(bodyStatements))
         );
-        if (serializeReason) {
+        if (branchSerializeReason) {
           forTagArgs.push(
             forAttrs.by || import_compiler33.types.numericLiteral(0),
             getScopeIdIdentifier(tagSection),
-            getScopeAccessorLiteral(nodeBinding)
+            getScopeAccessorLiteral(nodeBinding),
+            branchSerializeReason !== true && markerSerializeReason && markerSerializeReason !== true && !bindingUtil.isSuperset(
+              branchSerializeReason,
+              markerSerializeReason
+            ) ? import_compiler33.types.logicalExpression(
+              "||",
+              getSerializeGuard(branchSerializeReason),
+              getSerializeGuard(markerSerializeReason)
+            ) : getSerializeGuard(branchSerializeReason)
           );
           if (onlyChildInParentOptimization) {
             forTagArgs.push(import_compiler33.types.numericLiteral(1));
@@ -6315,7 +6640,7 @@ function translateAttrs(tag, templateExports, statements = [], contentKey = "con
     for (let i = 0; i < attrTags2.length; i++) {
       const child = attrTags2[i];
       if (child.isMarkoTag()) {
-        if ((0, import_babel_utils25.isAttributeTag)(child)) {
+        if ((0, import_babel_utils26.isAttributeTag)(child)) {
           const attrTagMeta = attrTagLookup[getTagName(child)];
           if (attrTagMeta.dynamic) {
             i = addDynamicAttrTagStatements(
@@ -6413,7 +6738,7 @@ function getTranslatedBodyContentProperty(props) {
 function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements, templateExports, contentKey = "content") {
   const tag = attrTags2[index];
   if (tag.isMarkoTag()) {
-    if ((0, import_babel_utils25.isAttributeTag)(tag)) {
+    if ((0, import_babel_utils26.isAttributeTag)(tag)) {
       const attrTagMeta = attrTagLookup[getTagName(tag)];
       if (usesExport(templateExports, attrTagMeta.name) && attrTagMeta.dynamic) {
         const translatedAttrTag = translateAttrs(
@@ -6618,7 +6943,7 @@ function buildContent(body) {
 }
 function getNonAttributeTagParent(tag) {
   let cur = tag;
-  while ((0, import_babel_utils25.isAttributeTag)(cur) || (0, import_babel_utils25.isTransparentTag)(cur)) {
+  while ((0, import_babel_utils26.isAttributeTag)(cur) || (0, import_babel_utils26.isTransparentTag)(cur)) {
     cur = getParentTag(cur);
   }
   return cur;
@@ -6627,7 +6952,7 @@ function getNonAttributeTagParent(tag) {
 // src/translator/core/define.ts
 var define_default = {
   analyze(tag) {
-    (0, import_babel_utils26.assertNoArgs)(tag);
+    (0, import_babel_utils27.assertNoArgs)(tag);
     if (!tag.node.var) {
       throw tag.get("name").buildCodeFrameError("The `define` tag requires a tag variable.");
     }
@@ -6696,17 +7021,17 @@ var define_default = {
 
 // src/translator/core/effect.ts
 var import_compiler36 = require("@marko/compiler");
-var import_babel_utils27 = require("@marko/compiler/babel-utils");
+var import_babel_utils28 = require("@marko/compiler/babel-utils");
 var effect_default = {
   migrate: [
     (tag) => {
-      (0, import_babel_utils27.assertNoArgs)(tag);
-      (0, import_babel_utils27.assertNoParams)(tag);
+      (0, import_babel_utils28.assertNoArgs)(tag);
+      (0, import_babel_utils28.assertNoParams)(tag);
       assertNoBodyContent(tag);
-      (0, import_babel_utils27.assertNoAttributeTags)(tag);
+      (0, import_babel_utils28.assertNoAttributeTags)(tag);
       assertNoSpreadAttrs(tag);
-      (0, import_babel_utils27.assertAllowedAttributes)(tag, ["value"]);
-      (0, import_babel_utils27.diagnosticDeprecate)(tag, {
+      (0, import_babel_utils28.assertAllowedAttributes)(tag, ["value"]);
+      (0, import_babel_utils28.diagnosticDeprecate)(tag, {
         label: "The 'effect' tag has been replaced by the 'script' tag.",
         fix() {
           const { node } = tag;
@@ -6729,12 +7054,12 @@ var effect_default = {
 };
 
 // src/translator/core/export.ts
-var import_babel_utils28 = require("@marko/compiler/babel-utils");
+var import_babel_utils29 = require("@marko/compiler/babel-utils");
 var export_default = {
   parse(tag) {
     const { node } = tag;
     tag.replaceWith(
-      (0, import_babel_utils28.parseStatements)(tag.hub.file, node.rawValue, node.start, node.end)[0]
+      (0, import_babel_utils29.parseStatements)(tag.hub.file, node.rawValue, node.start, node.end)[0]
     );
   },
   parseOptions: {
@@ -6750,14 +7075,14 @@ var export_default = {
 
 // src/translator/core/html-comment.ts
 var import_compiler37 = require("@marko/compiler");
-var import_babel_utils29 = require("@marko/compiler/babel-utils");
+var import_babel_utils30 = require("@marko/compiler/babel-utils");
 var kNodeBinding = Symbol("comment tag binding");
 var kGetterId2 = Symbol("node getter id");
 var html_comment_default = {
   analyze(tag) {
-    (0, import_babel_utils29.assertNoArgs)(tag);
-    (0, import_babel_utils29.assertNoParams)(tag);
-    (0, import_babel_utils29.assertNoAttributes)(tag);
+    (0, import_babel_utils30.assertNoArgs)(tag);
+    (0, import_babel_utils30.assertNoParams)(tag);
+    (0, import_babel_utils30.assertNoAttributes)(tag);
     const tagVar = tag.node.var;
     let needsBinding = false;
     let needsGetter = false;
@@ -6787,8 +7112,8 @@ var html_comment_default = {
       }
     }
     if (needsBinding) {
-      const tagExtra = tag.node.extra ??= {};
       const tagSection = getOrCreateSection(tag);
+      const tagExtra = mergeReferences(tagSection, tag.node, referenceNodes);
       const nodeBinding = tagExtra[kNodeBinding] = createBinding(
         "#comment",
         0 /* dom */,
@@ -6797,7 +7122,6 @@ var html_comment_default = {
       if (needsGetter) {
         tagExtra[kGetterId2] = getRegisterUID(tagSection, "comment");
       }
-      mergeReferences(tagSection, tag.node, referenceNodes);
       if (tagVar) {
         forceBindingSerialize(tagSection, nodeBinding);
       } else {
@@ -6828,7 +7152,7 @@ var html_comment_default = {
           let getterFnIdentifier;
           if (getterId) {
             getterFnIdentifier = generateUidIdentifier(`get_${varName}`);
-            (0, import_babel_utils29.getProgram)().node.body.push(
+            (0, import_babel_utils30.getProgram)().node.body.push(
               import_compiler37.types.variableDeclaration("const", [
                 import_compiler37.types.variableDeclarator(
                   getterFnIdentifier,
@@ -6915,9 +7239,12 @@ var html_comment_default = {
       }
       exit2(tag);
       write2`-->`;
-      const serializeMarkerReason = nodeBinding && getBindingSerializeReason(tagSection, nodeBinding);
-      if (serializeMarkerReason) {
-        markNode(tag, nodeBinding);
+      if (nodeBinding) {
+        markNode(
+          tag,
+          nodeBinding,
+          getBindingSerializeReason(tagSection, nodeBinding)
+        );
       }
       tag.remove();
     }
@@ -6936,13 +7263,13 @@ var html_comment_default = {
 
 // src/translator/core/html-script.ts
 var import_compiler38 = require("@marko/compiler");
-var import_babel_utils30 = require("@marko/compiler/babel-utils");
+var import_babel_utils31 = require("@marko/compiler/babel-utils");
 var kNodeBinding2 = Symbol("script tag node binding");
 var kGetterId3 = Symbol("node getter id");
 var html_script_default = {
   analyze(tag) {
-    (0, import_babel_utils30.assertNoArgs)(tag);
-    (0, import_babel_utils30.assertNoParams)(tag);
+    (0, import_babel_utils31.assertNoArgs)(tag);
+    (0, import_babel_utils31.assertNoParams)(tag);
     const { node } = tag;
     if (node.var && !import_compiler38.types.isIdentifier(node.var)) {
       throw tag.get("var").buildCodeFrameError(
@@ -7004,7 +7331,7 @@ var html_script_default = {
         0 /* dom */,
         tagSection
       );
-      (0, import_babel_utils30.getProgram)().node.extra.isInteractive ||= hasEventHandlers;
+      (0, import_babel_utils31.getProgram)().node.extra.isInteractive ||= hasEventHandlers;
       if (spreadReferenceNodes) {
         mergeReferences(tagSection, tag.node, spreadReferenceNodes);
       }
@@ -7064,7 +7391,7 @@ var html_script_default = {
           let getterFnIdentifier;
           if (getterId) {
             getterFnIdentifier = generateUidIdentifier(`get_${varName}`);
-            (0, import_babel_utils30.getProgram)().node.body.push(
+            (0, import_babel_utils31.getProgram)().node.body.push(
               import_compiler38.types.variableDeclaration("const", [
                 import_compiler38.types.variableDeclarator(
                   getterFnIdentifier,
@@ -7272,12 +7599,12 @@ var html_script_default = {
         }
       }
       write2`</script>`;
-      const serializeMarkerReason = getBindingSerializeReason(
-        tagSection,
-        nodeBinding
-      );
-      if (serializeMarkerReason) {
-        markNode(tag, nodeBinding);
+      if (nodeBinding) {
+        markNode(
+          tag,
+          nodeBinding,
+          getBindingSerializeReason(tagSection, nodeBinding)
+        );
       }
       exit2(tag);
       tag.remove();
@@ -7343,13 +7670,13 @@ function getUsedAttrs2(tag) {
 
 // src/translator/core/html-style.ts
 var import_compiler39 = require("@marko/compiler");
-var import_babel_utils31 = require("@marko/compiler/babel-utils");
+var import_babel_utils32 = require("@marko/compiler/babel-utils");
 var kNodeBinding3 = Symbol("style tag node binding");
 var kGetterId4 = Symbol("node getter id");
 var html_style_default = {
   analyze(tag) {
-    (0, import_babel_utils31.assertNoArgs)(tag);
-    (0, import_babel_utils31.assertNoParams)(tag);
+    (0, import_babel_utils32.assertNoArgs)(tag);
+    (0, import_babel_utils32.assertNoParams)(tag);
     const { node } = tag;
     if (node.var && !import_compiler39.types.isIdentifier(node.var)) {
       throw tag.get("var").buildCodeFrameError(
@@ -7411,7 +7738,7 @@ var html_style_default = {
         0 /* dom */,
         tagSection
       );
-      (0, import_babel_utils31.getProgram)().node.extra.isInteractive ||= hasEventHandlers;
+      (0, import_babel_utils32.getProgram)().node.extra.isInteractive ||= hasEventHandlers;
       if (spreadReferenceNodes) {
         mergeReferences(tagSection, tag.node, spreadReferenceNodes);
       }
@@ -7471,7 +7798,7 @@ var html_style_default = {
           let getterFnIdentifier;
           if (getterId) {
             getterFnIdentifier = generateUidIdentifier(`get_${varName}`);
-            (0, import_babel_utils31.getProgram)().node.body.push(
+            (0, import_babel_utils32.getProgram)().node.body.push(
               import_compiler39.types.variableDeclaration("const", [
                 import_compiler39.types.variableDeclarator(
                   getterFnIdentifier,
@@ -7679,12 +8006,12 @@ var html_style_default = {
         }
       }
       write2`</style>`;
-      const serializeMarkerReason = getBindingSerializeReason(
-        tagSection,
-        nodeBinding
-      );
-      if (serializeMarkerReason) {
-        markNode(tag, nodeBinding);
+      if (nodeBinding) {
+        markNode(
+          tag,
+          nodeBinding,
+          getBindingSerializeReason(tagSection, nodeBinding)
+        );
       }
       exit2(tag);
       tag.remove();
@@ -7745,14 +8072,14 @@ function getUsedAttrs3(tag) {
 
 // src/translator/core/id.ts
 var import_compiler40 = require("@marko/compiler");
-var import_babel_utils32 = require("@marko/compiler/babel-utils");
+var import_babel_utils33 = require("@marko/compiler/babel-utils");
 var id_default = {
   analyze(tag) {
-    (0, import_babel_utils32.assertNoArgs)(tag);
-    (0, import_babel_utils32.assertNoParams)(tag);
-    (0, import_babel_utils32.assertNoAttributes)(tag);
+    (0, import_babel_utils33.assertNoArgs)(tag);
+    (0, import_babel_utils33.assertNoParams)(tag);
+    (0, import_babel_utils33.assertNoAttributes)(tag);
     assertNoBodyContent(tag);
-    (0, import_babel_utils32.assertNoAttributeTags)(tag);
+    (0, import_babel_utils33.assertNoAttributeTags)(tag);
     const { node } = tag;
     if (!node.var) {
       throw tag.get("name").buildCodeFrameError("The `id` tag requires a tag variable.");
@@ -7760,7 +8087,10 @@ var id_default = {
     if (!import_compiler40.types.isIdentifier(node.var)) {
       throw tag.get("var").buildCodeFrameError("The `id` tag cannot be destructured");
     }
-    trackVarReferences(tag, 4 /* derived */);
+    const binding = trackVarReferences(tag, 4 /* derived */);
+    if (binding) {
+      setBindingValueExpr(binding, false);
+    }
   },
   translate: {
     exit(tag) {
@@ -7794,7 +8124,7 @@ var id_default = {
 
 // src/translator/core/if.ts
 var import_compiler42 = require("@marko/compiler");
-var import_babel_utils33 = require("@marko/compiler/babel-utils");
+var import_babel_utils34 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/to-first-statement-or-block.ts
 var import_compiler41 = require("@marko/compiler");
@@ -7879,27 +8209,39 @@ var IfTag = {
             ifTagSection
           );
           const onlyChildInParentOptimization = isOnlyChildInParent(ifTag);
-          const branchSerializeReason = getPropSerializeReason(
-            ifTagSection,
-            ifTagExtra,
-            kBranchSerializeReason
-          );
           const markerSerializeReason = getBindingSerializeReason(
             ifTagSection,
             nodeBinding
           );
           const nextTag = tag.getNextSibling();
+          let branchSerializeReasons;
           let statement;
           if (markerSerializeReason && onlyChildInParentOptimization) {
             getParentTag(ifTag).node.extra[kSkipMark] = true;
           }
           for (let i = branches.length; i--; ) {
-            const [branchTag] = branches[i];
+            const [branchTag, branchBody] = branches[i];
             const bodyStatements = branchTag.node.body.body;
-            if (branchSerializeReason) {
-              bodyStatements.push(
-                import_compiler42.types.returnStatement(import_compiler42.types.numericLiteral(i))
-              );
+            if (branchBody) {
+              const branchSerializeReason = getSectionSerializeReason(branchBody);
+              if (branchSerializeReason) {
+                if (branchSerializeReasons !== true) {
+                  if (branchSerializeReason === true) {
+                    branchSerializeReasons = true;
+                  } else if (branchSerializeReasons) {
+                    branchSerializeReasons = addSorted(
+                      compareSerializeReasons,
+                      branchSerializeReasons,
+                      branchSerializeReason
+                    );
+                  } else {
+                    branchSerializeReasons = [branchSerializeReason];
+                  }
+                }
+                bodyStatements.push(
+                  import_compiler42.types.returnStatement(import_compiler42.types.numericLiteral(i))
+                );
+              }
             }
             const [testAttr] = branchTag.node.attributes;
             const curStatement = toFirstStatementOrBlock(bodyStatements);
@@ -7914,7 +8256,8 @@ var IfTag = {
             }
             branchTag.remove();
           }
-          if (branchSerializeReason) {
+          if (branchSerializeReasons) {
+            const branchSerializeExpr = branchSerializeReasons === true ? !onlyChildInParentOptimization && !markerSerializeReason ? void 0 : getSerializeGuard(branchSerializeReasons) : getSerializeGuardForAny(branchSerializeReasons);
             const cbNode = import_compiler42.types.arrowFunctionExpression(
               [],
               import_compiler42.types.blockStatement([statement])
@@ -7925,14 +8268,16 @@ var IfTag = {
                 cbNode,
                 getScopeIdIdentifier(ifTagSection),
                 getScopeAccessorLiteral(nodeBinding),
-                markerSerializeReason ? import_compiler42.types.numericLiteral(1) : onlyChildInParentOptimization ? import_compiler42.types.numericLiteral(0) : void 0,
+                branchSerializeExpr,
+                markerSerializeReason ? getSerializeGuard(markerSerializeReason) : onlyChildInParentOptimization ? import_compiler42.types.numericLiteral(0) : void 0,
                 onlyChildInParentOptimization && import_compiler42.types.numericLiteral(1)
               ) : callRuntime(
                 "resumeConditional",
                 cbNode,
                 getScopeIdIdentifier(ifTagSection),
                 getScopeAccessorLiteral(nodeBinding),
-                markerSerializeReason ? import_compiler42.types.numericLiteral(1) : void 0
+                branchSerializeExpr,
+                getSerializeGuard(markerSerializeReason)
               )
             );
           }
@@ -8024,9 +8369,9 @@ var ElseTag = {
   ]
 };
 function assertValidCondition(tag) {
-  (0, import_babel_utils33.assertNoVar)(tag);
-  (0, import_babel_utils33.assertNoArgs)(tag);
-  (0, import_babel_utils33.assertNoParams)(tag);
+  (0, import_babel_utils34.assertNoVar)(tag);
+  (0, import_babel_utils34.assertNoArgs)(tag);
+  (0, import_babel_utils34.assertNoParams)(tag);
   assertHasBody(tag);
   assertNoSpreadAttrs(tag);
   switch (getTagName(tag)) {
@@ -8114,6 +8459,13 @@ function getBranches(tag) {
   }
   return branches;
 }
+function getSerializeGuardForAny(reasons) {
+  let expr = getSerializeGuard(reasons[0]);
+  for (let i = 1; i < reasons.length; i++) {
+    expr = import_compiler42.types.logicalExpression("||", expr, getSerializeGuard(reasons[i]));
+  }
+  return expr;
+}
 function isLastBranch(tag) {
   const branches = getBranches(tag);
   return branches[branches.length - 1][0] === tag;
@@ -8123,12 +8475,12 @@ function isRoot(tag) {
 }
 
 // src/translator/core/import.ts
-var import_babel_utils34 = require("@marko/compiler/babel-utils");
+var import_babel_utils35 = require("@marko/compiler/babel-utils");
 var import_default = {
   parse(tag) {
     const { node } = tag;
     tag.replaceWith(
-      (0, import_babel_utils34.parseStatements)(tag.hub.file, node.rawValue, node.start, node.end)[0]
+      (0, import_babel_utils35.parseStatements)(tag.hub.file, node.rawValue, node.start, node.end)[0]
     );
   },
   parseOptions: {
@@ -8147,7 +8499,7 @@ var import_default = {
 
 // src/translator/core/let.ts
 var import_compiler43 = require("@marko/compiler");
-var import_babel_utils35 = require("@marko/compiler/babel-utils");
+var import_babel_utils36 = require("@marko/compiler/babel-utils");
 var let_default = {
   analyze(tag) {
     const { node } = tag;
@@ -8176,8 +8528,8 @@ var let_default = {
         }
       }
     }
-    (0, import_babel_utils35.assertNoArgs)(tag);
-    (0, import_babel_utils35.assertNoParams)(tag);
+    (0, import_babel_utils36.assertNoArgs)(tag);
+    (0, import_babel_utils36.assertNoParams)(tag);
     assertNoBodyContent(tag);
     assertNoSpreadAttrs(tag);
     if (!tagVar) {
@@ -8186,16 +8538,26 @@ var let_default = {
     if (!import_compiler43.types.isIdentifier(tagVar)) {
       throw tag.get("var").buildCodeFrameError("The `let` tag variable cannot be destructured.");
     }
-    if (valueChangeAttr && (0, import_babel_utils35.computeNode)(valueChangeAttr.value)) {
+    if (valueChangeAttr && (0, import_babel_utils36.computeNode)(valueChangeAttr.value)) {
       throw tag.get("attributes").find((attr2) => attr2.node === valueChangeAttr).get("value").buildCodeFrameError(
         "The `let` tag `valueChange` attribute must be a function."
       );
     }
-    mergeReferences(getOrCreateSection(tag), tag.node, [
-      valueAttr?.value,
-      valueChangeAttr?.value
-    ]);
-    trackVarReferences(tag, 1 /* let */, void 0, tag.node.extra);
+    const binding = trackVarReferences(tag, 1 /* let */);
+    setBindingValueExpr(
+      binding,
+      mergeReferences(getOrCreateSection(tag), tag.node, [
+        valueAttr?.value,
+        valueChangeAttr?.value
+      ])
+    );
+    if (valueChangeAttr) {
+      forceBindingSerialize(
+        getSection(tag),
+        binding,
+        getAccessorPrefix().TagVariableChange
+      );
+    }
   },
   translate: {
     exit(tag) {
@@ -8223,10 +8585,11 @@ var let_default = {
       } else {
         translateVar(tag, valueAttr.value, "let");
         if (valueChangeAttr) {
-          setSerializedValue(
+          setBindingSerializedValue(
             section,
-            getAccessorPrefix().TagVariableChange + getScopeAccessor(binding),
-            valueChangeAttr.value
+            binding,
+            valueChangeAttr.value,
+            getAccessorPrefix().TagVariableChange
           );
         }
       }
@@ -8248,23 +8611,25 @@ var let_default = {
 
 // src/translator/core/lifecycle.ts
 var import_compiler44 = require("@marko/compiler");
-var import_babel_utils36 = require("@marko/compiler/babel-utils");
+var import_babel_utils37 = require("@marko/compiler/babel-utils");
 var kRef = Symbol("lifecycle attrs reference");
 var lifecycle_default = {
   analyze(tag) {
-    (0, import_babel_utils36.assertNoArgs)(tag);
-    (0, import_babel_utils36.assertNoVar)(tag);
-    (0, import_babel_utils36.assertNoParams)(tag);
+    (0, import_babel_utils37.assertNoArgs)(tag);
+    (0, import_babel_utils37.assertNoVar)(tag);
+    (0, import_babel_utils37.assertNoParams)(tag);
     assertNoBodyContent(tag);
     const { node } = tag;
-    const tagExtra = node.extra ??= {};
     const section = getOrCreateSection(tag);
+    const tagExtra = mergeReferences(
+      section,
+      tag.node,
+      getAllTagReferenceNodes(tag.node)
+    );
     tagExtra[kRef] = createBinding(
       generateUid("lifecycle"),
       4 /* derived */,
-      section,
-      void 0,
-      tagExtra
+      section
     );
     if (node.attributes.length === 0) {
       throw tag.get("name").buildCodeFrameError(
@@ -8279,8 +8644,7 @@ var lifecycle_default = {
       }
       (attr2.value.extra ??= {}).isEffect = true;
     }
-    ((0, import_babel_utils36.getProgram)().node.extra ??= {}).isInteractive = true;
-    mergeReferences(section, tag.node, getAllTagReferenceNodes(tag.node));
+    ((0, import_babel_utils37.getProgram)().node.extra ??= {}).isInteractive = true;
   },
   translate: {
     exit(tag) {
@@ -8328,13 +8692,13 @@ var lifecycle_default = {
 
 // src/translator/core/log.ts
 var import_compiler45 = require("@marko/compiler");
-var import_babel_utils37 = require("@marko/compiler/babel-utils");
+var import_babel_utils38 = require("@marko/compiler/babel-utils");
 var log_default = {
   analyze(tag) {
     const [valueAttr] = tag.node.attributes;
-    (0, import_babel_utils37.assertNoArgs)(tag);
-    (0, import_babel_utils37.assertNoVar)(tag);
-    (0, import_babel_utils37.assertNoParams)(tag);
+    (0, import_babel_utils38.assertNoArgs)(tag);
+    (0, import_babel_utils38.assertNoVar)(tag);
+    (0, import_babel_utils38.assertNoParams)(tag);
     assertNoBodyContent(tag);
     if (!valueAttr) {
       throw tag.get("name").buildCodeFrameError("The `log` tag requires a value.");
@@ -8380,7 +8744,7 @@ var log_default = {
 
 // src/translator/core/script.ts
 var import_compiler46 = require("@marko/compiler");
-var import_babel_utils38 = require("@marko/compiler/babel-utils");
+var import_babel_utils39 = require("@marko/compiler/babel-utils");
 var htmlScriptTagAlternateMsg = " For a native html `script` tag use the `html-script` core tag instead.";
 var script_default = {
   parse(tag) {
@@ -8400,7 +8764,7 @@ var script_default = {
       }
       const start = body[0]?.start;
       const end = body[body.length - 1]?.end;
-      const bodyStatements = (0, import_babel_utils38.parseStatements)(tag.hub.file, code, start, end);
+      const bodyStatements = (0, import_babel_utils39.parseStatements)(tag.hub.file, code, start, end);
       const valueFn = import_compiler46.types.arrowFunctionExpression(
         [],
         import_compiler46.types.blockStatement(bodyStatements),
@@ -8412,10 +8776,10 @@ var script_default = {
   },
   analyze(tag) {
     const { node } = tag;
-    (0, import_babel_utils38.assertNoArgs)(tag);
-    (0, import_babel_utils38.assertNoParams)(tag);
+    (0, import_babel_utils39.assertNoArgs)(tag);
+    (0, import_babel_utils39.assertNoParams)(tag);
     assertNoBodyContent(tag);
-    (0, import_babel_utils38.assertNoAttributeTags)(tag);
+    (0, import_babel_utils39.assertNoAttributeTags)(tag);
     if (node.var) {
       throw tag.hub.buildError(
         node.var,
@@ -8430,7 +8794,7 @@ var script_default = {
         }
         seenValueAttr = true;
         (attr2.value.extra ??= {}).isEffect = true;
-        ((0, import_babel_utils38.getProgram)().node.extra ??= {}).isInteractive = true;
+        ((0, import_babel_utils39.getProgram)().node.extra ??= {}).isInteractive = true;
       } else {
         throw tag.hub.buildError(
           attr2,
@@ -8519,7 +8883,7 @@ function isAwaitExpression(node) {
 
 // src/translator/core/server.ts
 var import_compiler47 = require("@marko/compiler");
-var import_babel_utils39 = require("@marko/compiler/babel-utils");
+var import_babel_utils40 = require("@marko/compiler/babel-utils");
 var server_default = {
   parse(tag) {
     const {
@@ -8529,7 +8893,7 @@ var server_default = {
     const rawValue = node.rawValue;
     const code = rawValue.replace(/^server\s*/, "").trim();
     const start = node.name.start + (rawValue.length - code.length);
-    let body = (0, import_babel_utils39.parseStatements)(file, code, start, start + code.length);
+    let body = (0, import_babel_utils40.parseStatements)(file, code, start, start + code.length);
     if (body.length === 1 && import_compiler47.types.isBlockStatement(body[0])) {
       body = body[0].body;
     }
@@ -8550,7 +8914,7 @@ var server_default = {
 
 // src/translator/core/static.ts
 var import_compiler48 = require("@marko/compiler");
-var import_babel_utils40 = require("@marko/compiler/babel-utils");
+var import_babel_utils41 = require("@marko/compiler/babel-utils");
 var static_default = {
   parse(tag) {
     const {
@@ -8560,7 +8924,7 @@ var static_default = {
     const rawValue = node.rawValue;
     const code = rawValue.replace(/^static\s*/, "").trim();
     const start = node.name.start + (rawValue.length - code.length);
-    let body = (0, import_babel_utils40.parseStatements)(file, code, start, start + code.length);
+    let body = (0, import_babel_utils41.parseStatements)(file, code, start, start + code.length);
     if (body.length === 1 && import_compiler48.types.isBlockStatement(body[0])) {
       body = body[0].body;
     }
@@ -8581,16 +8945,16 @@ var static_default = {
 
 // src/translator/core/style.ts
 var import_compiler49 = require("@marko/compiler");
-var import_babel_utils41 = require("@marko/compiler/babel-utils");
+var import_babel_utils42 = require("@marko/compiler/babel-utils");
 var import_magic_string = __toESM(require("magic-string"));
 var import_path3 = __toESM(require("path"));
 var STYLE_EXT_REG = /^style((?:\.[a-zA-Z0-9$_-]+)+)?/;
 var htmlStyleTagAlternateMsg = " For a native html `style` tag use the `html-style` core tag instead.";
 var style_default = {
   analyze(tag) {
-    (0, import_babel_utils41.assertNoArgs)(tag);
-    (0, import_babel_utils41.assertNoParams)(tag);
-    (0, import_babel_utils41.assertNoAttributeTags)(tag);
+    (0, import_babel_utils42.assertNoArgs)(tag);
+    (0, import_babel_utils42.assertNoParams)(tag);
+    (0, import_babel_utils42.assertNoAttributeTags)(tag);
     const { node } = tag;
     const ext = STYLE_EXT_REG.exec(node.rawValue || "")?.[1]?.slice(1);
     for (const attr2 of node.attributes) {
@@ -8629,49 +8993,49 @@ var style_default = {
     }
     const markoText = node.body.body[0];
     const { resolveVirtualDependency } = getMarkoOpts();
-    const start = (0, import_babel_utils41.getStart)(file, markoText);
-    const end = (0, import_babel_utils41.getEnd)(file, markoText);
+    const start = (0, import_babel_utils42.getStart)(file, markoText);
+    const end = (0, import_babel_utils42.getEnd)(file, markoText);
     let code = markoText.value;
-    let map2;
+    let map;
     if (resolveVirtualDependency && sourceMaps && start !== null && end !== null) {
       const magicString = new import_magic_string.default(file.code, { filename });
       magicString.remove(0, start);
       magicString.remove(end, file.code.length);
-      map2 = magicString.generateMap({
+      map = magicString.generateMap({
         source: filename,
         includeContent: true
       });
       if (sourceMaps === "inline" || sourceMaps === "both") {
         code += `
-/*# sourceMappingURL=${map2.toUrl()}*/`;
+/*# sourceMappingURL=${map.toUrl()}*/`;
         if (sourceMaps === "inline") {
-          map2 = void 0;
+          map = void 0;
         }
       }
     }
     const importPath = resolveVirtualDependency?.(filename, {
       virtualPath: `./${import_path3.default.basename(filename) + ext}`,
       code,
-      map: map2
+      map
     });
     if (importPath) {
       if (!node.var) {
-        (0, import_babel_utils41.getProgram)().node.body.push(
+        (0, import_babel_utils42.getProgram)().node.body.push(
           import_compiler49.types.importDeclaration([], import_compiler49.types.stringLiteral(importPath))
         );
       } else if (import_compiler49.types.isIdentifier(node.var)) {
-        (0, import_babel_utils41.getProgram)().node.body.push(
+        (0, import_babel_utils42.getProgram)().node.body.push(
           import_compiler49.types.importDeclaration(
             [import_compiler49.types.importDefaultSpecifier(node.var)],
             import_compiler49.types.stringLiteral(importPath)
           )
         );
       } else {
-        (0, import_babel_utils41.getProgram)().node.body.push(
+        (0, import_babel_utils42.getProgram)().node.body.push(
           import_compiler49.types.variableDeclaration("const", [
             import_compiler49.types.variableDeclarator(
               node.var,
-              (0, import_babel_utils41.importDefault)(file, importPath, "style")
+              (0, import_babel_utils42.importDefault)(file, importPath, "style")
             )
           ])
         );
@@ -8690,32 +9054,27 @@ var style_default = {
 
 // src/translator/core/try.ts
 var import_compiler50 = require("@marko/compiler");
-var import_babel_utils42 = require("@marko/compiler/babel-utils");
+var import_babel_utils43 = require("@marko/compiler/babel-utils");
 var kDOMBinding2 = Symbol("try tag dom binding");
 var try_default = {
   analyze(tag) {
-    (0, import_babel_utils42.assertNoVar)(tag);
-    (0, import_babel_utils42.assertNoArgs)(tag);
-    (0, import_babel_utils42.assertNoParams)(tag);
-    (0, import_babel_utils42.assertNoAttributes)(tag);
+    (0, import_babel_utils43.assertNoVar)(tag);
+    (0, import_babel_utils43.assertNoArgs)(tag);
+    (0, import_babel_utils43.assertNoParams)(tag);
+    (0, import_babel_utils43.assertNoAttributes)(tag);
     assertNoSpreadAttrs(tag);
     analyzeAttributeTags(tag);
-    const { node } = tag;
     const section = getOrCreateSection(tag);
-    const tagExtra = tag.node.extra ??= {};
-    const tagBody = tag.get("body");
-    tagExtra[kDOMBinding2] = createBinding(
-      "#text",
-      0 /* dom */,
+    const tagExtra = mergeReferences(
       section,
-      void 0,
-      tagExtra
+      tag.node,
+      getAllTagReferenceNodes(tag.node)
     );
-    if (!node.body.body.length) {
+    tagExtra[kDOMBinding2] = createBinding("#text", 0 /* dom */, section);
+    if (!tag.node.body.body.length) {
       throw tag.get("name").buildCodeFrameError("The `try` tag requires body content.");
     }
-    startSection(tagBody);
-    mergeReferences(section, tag.node, getAllTagReferenceNodes(tag.node));
+    startSection(tag.get("body"));
   },
   translate: translateByTarget({
     html: {
@@ -8802,7 +9161,7 @@ var try_default = {
             translatedAttrs.statements
           );
         }
-        (0, import_babel_utils42.getProgram)().node.body.push(
+        (0, import_babel_utils43.getProgram)().node.body.push(
           import_compiler50.types.expressionStatement(callRuntime("enableCatch"))
         );
         addValue(
@@ -8902,7 +9261,7 @@ var document_type_default = {
 
 // src/translator/visitors/function.ts
 var import_compiler51 = require("@marko/compiler");
-var import_babel_utils43 = require("@marko/compiler/babel-utils");
+var import_babel_utils44 = require("@marko/compiler/babel-utils");
 var function_default = {
   analyze(fn) {
     if (fn !== getFnRoot(fn)) {
@@ -8912,7 +9271,7 @@ var function_default = {
     if (markoRoot && (markoRoot.isMarkoPlaceholder() || markoRoot.isMarkoScriptlet() && markoRoot.node.target === "server")) {
       return;
     }
-    if (isMarkoAttribute(markoRoot) && ((0, import_babel_utils43.isNativeTag)(markoRoot.parentPath) && /^on[A-Z-]/.test(markoRoot.node.name) || isCoreTagName(markoRoot.parentPath, "script") || isCoreTagName(markoRoot.parentPath, "lifecycle") || isCoreTagName(markoRoot.parentPath, "for"))) {
+    if (isMarkoAttribute(markoRoot) && ((0, import_babel_utils44.isNativeTag)(markoRoot.parentPath) && /^on[A-Z-]/.test(markoRoot.node.name) || isCoreTagName(markoRoot.parentPath, "script") || isCoreTagName(markoRoot.parentPath, "lifecycle") || isCoreTagName(markoRoot.parentPath, "for"))) {
       return;
     }
     const { node } = fn;
@@ -8921,14 +9280,14 @@ var function_default = {
     const {
       markoOpts,
       opts: { filename }
-    } = (0, import_babel_utils43.getFile)();
+    } = (0, import_babel_utils44.getFile)();
     const name2 = extra.name = generateUid(
       fn.node.id?.name || (isMarkoAttribute(markoRoot) ? markoRoot.node.default ? import_compiler51.types.toIdentifier(
         markoRoot.parentPath.has("var") ? markoRoot.parentPath.get("var") : markoRoot.parentPath.get("name")
       ) : markoRoot.node.name : import_compiler51.types.isVariableDeclarator(fn.parent) && import_compiler51.types.isIdentifier(fn.parent.id) ? fn.parent.id.name : import_compiler51.types.isObjectMethod(node) && import_compiler51.types.isIdentifier(node.key) ? node.key.name : "anonymous")
     );
     extra.section = section;
-    extra.registerId = (0, import_babel_utils43.getTemplateId)(
+    extra.registerId = (0, import_babel_utils44.getTemplateId)(
       markoOpts,
       filename,
       `${section.id}/${name2.slice(1)}`
@@ -8940,13 +9299,13 @@ function isMarkoAttribute(path5) {
 }
 
 // src/translator/visitors/import-declaration.ts
-var import_babel_utils44 = require("@marko/compiler/babel-utils");
+var import_babel_utils45 = require("@marko/compiler/babel-utils");
 var import_declaration_default = {
   analyze(importDecl) {
     const { node } = importDecl;
     const { source } = node;
     const { value } = source;
-    const tagImport = (0, import_babel_utils44.resolveTagImport)(importDecl, value);
+    const tagImport = (0, import_babel_utils45.resolveTagImport)(importDecl, value);
     if (tagImport) {
       node.extra ??= {};
       node.extra.tagImport = tagImport;
@@ -8987,7 +9346,7 @@ function isNonHTMLText(placeholder) {
 }
 
 // src/translator/visitors/placeholder.ts
-var kBinding = Symbol("placeholder node binding");
+var kNodeBinding4 = Symbol("placeholder node binding");
 var kSiblingText = Symbol("placeholder has sibling text");
 var placeholder_default = {
   analyze(placeholder) {
@@ -8997,15 +9356,13 @@ var placeholder_default = {
     const { confident, computed } = valueExtra;
     if (!(confident && (node.escape || isVoid2(computed)))) {
       const section = getOrCreateSection(placeholder);
-      const binding = (node.extra ??= {})[kBinding] = createBinding(
+      const nodeBinding = (node.extra ??= {})[kNodeBinding4] = createBinding(
         "#text",
         0 /* dom */,
-        section,
-        void 0,
-        valueExtra
+        section
       );
       analyzeSiblingText(placeholder);
-      addBindingSerializeReasonExpr(section, binding, valueExtra);
+      addBindingSerializeReasonExpr(section, nodeBinding, valueExtra);
     }
   },
   translate: {
@@ -9022,7 +9379,7 @@ var placeholder_default = {
       const isHTML = isOutputHTML();
       const write2 = writeTo(placeholder);
       const extra = node.extra || {};
-      const nodeBinding = extra[kBinding];
+      const nodeBinding = extra[kNodeBinding4];
       const canWriteHTML = isHTML || confident && node.escape;
       const method = canWriteHTML ? node.escape ? "escapeXML" : "toString" : node.escape ? "data" : "html";
       const section = getSection(placeholder);
@@ -9033,7 +9390,11 @@ var placeholder_default = {
       } else {
         if (siblingText === 1 /* Before */) {
           if (isHTML && markerSerializeReason) {
-            write2`<!>`;
+            if (markerSerializeReason === true) {
+              write2`<!>`;
+            } else {
+              write2`${callRuntime("commentSeparator", getSerializeGuard(markerSerializeReason))}`;
+            }
           }
           visit(placeholder, 37 /* Replace */);
         } else if (siblingText === 2 /* After */) {
@@ -9044,8 +9405,8 @@ var placeholder_default = {
         }
         if (isHTML) {
           write2`${callRuntime(method, value)}`;
-          if (markerSerializeReason) {
-            markNode(placeholder, nodeBinding);
+          if (nodeBinding) {
+            markNode(placeholder, nodeBinding, markerSerializeReason);
           }
         } else {
           addStatement(
@@ -9242,7 +9603,7 @@ var scriptlet_default = {
       }
       if (isHTML) {
       } else {
-        traverseReplace(node, "body", replaceRegisteredFunctionNode);
+        traverseReplace(node, "body", replaceRegisteredFunctionNode2);
         scriptlet.replaceWithMultiple(node.body);
       }
     }
@@ -9251,20 +9612,20 @@ var scriptlet_default = {
 
 // src/translator/visitors/tag/index.ts
 var import_compiler58 = require("@marko/compiler");
-var import_babel_utils48 = require("@marko/compiler/babel-utils");
+var import_babel_utils49 = require("@marko/compiler/babel-utils");
 
 // src/translator/visitors/tag/attribute-tag.ts
 var import_compiler55 = require("@marko/compiler");
-var import_babel_utils45 = require("@marko/compiler/babel-utils");
+var import_babel_utils46 = require("@marko/compiler/babel-utils");
 var attribute_tag_default = {
   analyze: {
     enter(tag) {
-      (0, import_babel_utils45.assertNoVar)(tag);
-      (0, import_babel_utils45.assertNoArgs)(tag);
+      (0, import_babel_utils46.assertNoVar)(tag);
+      (0, import_babel_utils46.assertNoArgs)(tag);
       const body = tag.get("body");
       startSection(body);
       trackParamsReferences(body, 3 /* param */);
-      if (!(0, import_babel_utils45.findParentTag)(tag)) {
+      if (!(0, import_babel_utils46.findParentTag)(tag)) {
         throw tag.get("name").buildCodeFrameError("@tags must be nested within another tag.");
       }
     }
@@ -9286,16 +9647,19 @@ var attribute_tag_default = {
 
 // src/translator/visitors/tag/custom-tag.ts
 var import_compiler56 = require("@marko/compiler");
-var import_babel_utils46 = require("@marko/compiler/babel-utils");
+var import_babel_utils47 = require("@marko/compiler/babel-utils");
 var import_path4 = __toESM(require("path"));
 var kChildScopeBinding = Symbol("custom tag child scope");
 var kChildOffsetScopeBinding = Symbol("custom tag scope offset");
+var kChildInputSerializePropIds = Symbol(
+  "custom tag child serialize reasons"
+);
 var custom_tag_default = {
   analyze: {
     enter(tag) {
-      (0, import_babel_utils46.assertAttributesOrSingleArg)(tag);
+      (0, import_babel_utils47.assertAttributesOrSingleArg)(tag);
       analyzeAttributeTags(tag);
-      const templateFile = (0, import_babel_utils46.getTagTemplate)(tag);
+      const templateFile = (0, import_babel_utils47.getTagTemplate)(tag);
       if (!templateFile) {
         const tagName = getTagName(tag);
         if (tagName && tag.scope.hasBinding(tagName)) {
@@ -9311,42 +9675,75 @@ var custom_tag_default = {
       const childScopeBinding = tagExtra[kChildScopeBinding] = createBinding(
         "#childScope",
         0 /* dom */,
-        section,
-        void 0,
-        tagExtra
+        section
       );
       const attrExprs = /* @__PURE__ */ new Set([tagExtra]);
-      const hasVar = !!tag.node.var;
-      if (hasVar) {
-        trackVarReferences(tag, 4 /* derived */);
-        tag.node.var.extra.binding.scopeOffset = tagExtra[kChildOffsetScopeBinding] = createBinding(
-          "#scopeOffset",
-          0 /* dom */,
-          section,
-          void 0,
-          tagExtra
-        );
-      }
       startSection(tagBody);
       trackParamsReferences(tagBody, 3 /* param */);
-      const childFile = (0, import_babel_utils46.loadFileForTag)(tag);
+      const childFile = (0, import_babel_utils47.loadFileForTag)(tag);
+      if (!childFile) {
+        throw tag.get("name").buildCodeFrameError("Unable to resolve file for tag.");
+      }
+      const varBinding = trackVarReferences(tag, 4 /* derived */);
+      if (varBinding) {
+        varBinding.scopeOffset = tagExtra[kChildOffsetScopeBinding] = createBinding("#scopeOffset", 0 /* dom */, section);
+      }
       if (childFile.opts.filename === tag.hub.file.opts.filename) {
         mergeReferences(section, tag.node, getAllTagReferenceNodes(tag.node));
+        if (varBinding) {
+          const varSerializeReason = (0, import_babel_utils47.getProgram)().node.extra.returnValueExpr;
+          setBindingValueExpr(varBinding, varSerializeReason);
+          addBindingSerializeReasonExpr(
+            section,
+            childScopeBinding,
+            varSerializeReason
+          );
+        }
       } else {
-        const childProgramExtra = childFile.ast.program.extra;
+        const childProgram = childFile.ast.program;
+        const childExtra = childProgram.extra;
+        const childInputBinding = childProgram.params[0].extra?.binding;
+        const inputExpr = {};
         analyzeAttrs(
           tagExtra,
           section,
           tag,
-          childProgramExtra?.domExports.input,
-          attrExprs
+          childExtra?.domExports.input,
+          attrExprs,
+          inputExpr
         );
-        (0, import_babel_utils46.getProgram)().node.extra.hasInteractiveChild = childProgramExtra?.isInteractive || childProgramExtra?.hasInteractiveChild || false;
+        if (varBinding) {
+          const varSerializeReason = mapChildReasonToLocalReason(
+            childExtra.returnSerializeReason,
+            childInputBinding,
+            inputExpr
+          );
+          setBindingValueExpr(varBinding, varSerializeReason);
+          addBindingSerializeReasonExpr(
+            section,
+            childScopeBinding,
+            varSerializeReason
+          );
+        }
+        if (childExtra.inputSerializeReasons) {
+          const childInputSerializePropIds = tagExtra[kChildInputSerializePropIds] = [];
+          for (const reason of childExtra.inputSerializeReasons) {
+            const propId = Symbol();
+            childInputSerializePropIds.push(propId);
+            addBindingSerializeReasonExpr(
+              section,
+              childScopeBinding,
+              mapChildReasonToLocalReason(reason, childInputBinding, inputExpr),
+              propId
+            );
+          }
+        }
+        (0, import_babel_utils47.getProgram)().node.extra.hasInteractiveChild = childExtra?.isInteractive || childExtra?.hasInteractiveChild || false;
       }
       addBindingSerializeReasonExpr(
         section,
         childScopeBinding,
-        hasVar || fromIter(attrExprs)
+        fromIter(attrExprs)
       );
     }
   },
@@ -9375,13 +9772,15 @@ function translateHTML(tag) {
   writeHTMLResumeStatements(tagBody);
   if (import_compiler56.types.isStringLiteral(node.name)) {
     const relativePath = getTagRelativePath(tag);
-    tagIdentifier = isCircularRequest(tag.hub.file, relativePath) ? import_compiler56.types.identifier(getTemplateContentName()) : (0, import_babel_utils46.importDefault)(tag.hub.file, relativePath, getTagName(tag));
+    tagIdentifier = isCircularRequest(tag.hub.file, relativePath) ? import_compiler56.types.identifier(getTemplateContentName()) : (0, import_babel_utils47.importDefault)(tag.hub.file, relativePath, getTagName(tag));
   } else {
     tagIdentifier = node.name;
   }
   const tagVar = node.var;
   const section = getSection(tag);
-  const inputExport = (0, import_babel_utils46.loadFileForTag)(tag)?.ast.program.extra?.domExports?.input;
+  const childProgram = (0, import_babel_utils47.loadFileForTag)(tag).ast.program;
+  const childExtra = childProgram.extra;
+  const inputExport = childExtra.domExports?.input;
   const { properties, statements } = inputExport ? translateAttrs(tag, inputExport.props) : {
     properties: [],
     statements: []
@@ -9391,11 +9790,46 @@ function translateHTML(tag) {
     section,
     childScopeBinding
   );
+  const childSerializeReasonIds = tagExtra[kChildInputSerializePropIds];
+  let childSerializeReasonExpr;
+  if (childSerializeReasonIds) {
+    if (childSerializeReasonIds.length === 1) {
+      childSerializeReasonExpr = getSerializeGuard(
+        getBindingSerializeReason(
+          section,
+          childScopeBinding,
+          childSerializeReasonIds[0]
+        )
+      );
+    } else {
+      const props = [];
+      let hasDynamicReasons = false;
+      let hasSkippedReasons = false;
+      for (let i = 0; i < childSerializeReasonIds.length; i++) {
+        const reason = getBindingSerializeReason(
+          section,
+          childScopeBinding,
+          childSerializeReasonIds[i]
+        );
+        if (reason) {
+          hasDynamicReasons ||= reason !== true;
+          props.push(
+            import_compiler56.types.objectProperty(import_compiler56.types.numericLiteral(i), getSerializeGuard(reason))
+          );
+        } else {
+          hasSkippedReasons = true;
+        }
+      }
+      if (props.length) {
+        childSerializeReasonExpr = hasDynamicReasons || hasSkippedReasons ? import_compiler56.types.objectExpression(props) : import_compiler56.types.numericLiteral(1);
+      }
+    }
+  }
   if (childScopeSerializeReason) {
     const peekScopeId = generateUidIdentifier(childScopeBinding?.name);
     tag.insertBefore(
       import_compiler56.types.variableDeclaration("const", [
-        import_compiler56.types.variableDeclarator(peekScopeId, callRuntime("peekNextScope"))
+        import_compiler56.types.variableDeclarator(peekScopeId, callRuntime("peekNextScopeId"))
       ])
     );
     setBindingSerializedValue(
@@ -9443,7 +9877,8 @@ function translateHTML(tag) {
     }
     let renderTagExpr = callExpression(
       tagIdentifier,
-      propsToExpression(properties)
+      propsToExpression(properties),
+      childSerializeReasonExpr
     );
     if (tagVar) {
       translateVar(tag, import_compiler56.types.unaryExpression("void", import_compiler56.types.numericLiteral(0)), "let");
@@ -9459,12 +9894,19 @@ function translateHTML(tag) {
   } else if (tagVar) {
     translateVar(
       tag,
-      callExpression(tagIdentifier, propsToExpression(properties))
+      callExpression(
+        tagIdentifier,
+        propsToExpression(properties),
+        childSerializeReasonExpr
+      )
     );
-    serializeSectionIfNeeded(section, true);
   } else {
     statements.push(
-      callStatement(tagIdentifier, propsToExpression(properties))
+      callStatement(
+        tagIdentifier,
+        propsToExpression(properties),
+        childSerializeReasonExpr
+      )
     );
   }
   for (const replacement of tag.replaceWithMultiple(statements)) {
@@ -9480,7 +9922,7 @@ function translateDOM(tag) {
   const { file } = tag.hub;
   const tagName = import_compiler56.types.isIdentifier(node.name) ? node.name.name : import_compiler56.types.isStringLiteral(node.name) ? node.name.value : "tag";
   const relativePath = getTagRelativePath(tag);
-  const childFile = (0, import_babel_utils46.loadFileForTag)(tag);
+  const childFile = (0, import_babel_utils47.loadFileForTag)(tag);
   const childExports = childFile.ast.program.extra.domExports;
   const tagIdentifier = importOrSelfReferenceName(
     file,
@@ -9498,10 +9940,10 @@ function translateDOM(tag) {
       attrTagCallsByTag: void 0
     });
   }
-  write2`${(0, import_babel_utils46.importNamed)(file, relativePath, childExports.template, `${tagName}_template`)}`;
+  write2`${(0, import_babel_utils47.importNamed)(file, relativePath, childExports.template, `${tagName}_template`)}`;
   injectWalks(
     tag,
-    (0, import_babel_utils46.importNamed)(file, relativePath, childExports.walks, `${tagName}_walks`)
+    (0, import_babel_utils47.importNamed)(file, relativePath, childExports.walks, `${tagName}_walks`)
   );
   if (node.var) {
     const source = initValue(
@@ -9548,8 +9990,8 @@ function getTagRelativePath(tag) {
   } = tag;
   let relativePath;
   if (import_compiler56.types.isStringLiteral(node.name)) {
-    const template = (0, import_babel_utils46.getTagTemplate)(tag);
-    relativePath = template && (0, import_babel_utils46.resolveRelativePath)(file, template);
+    const template = (0, import_babel_utils47.getTagTemplate)(tag);
+    relativePath = template && (0, import_babel_utils47.resolveRelativePath)(file, template);
   } else if (node.extra?.tagNameImported) {
     relativePath = node.extra.tagNameImported;
   }
@@ -9564,19 +10006,20 @@ function getTagRelativePath(tag) {
   }
   return relativePath;
 }
-function analyzeAttrs(rootTagExtra, section, tag, templateExport, rootAttrExprs) {
+function analyzeAttrs(rootTagExtra, section, tag, templateExport, rootAttrExprs, inputExpr) {
   if (!templateExport) {
     dropReferences(getAllTagReferenceNodes(tag.node));
     return;
   }
   if (!templateExport.props || tag.node.arguments?.length) {
-    mergeReferences(section, tag.node, getAllTagReferenceNodes(tag.node));
+    inputExpr.value = mergeReferences(
+      section,
+      tag.node,
+      getAllTagReferenceNodes(tag.node)
+    );
     return;
   }
-  const bodySection = getSectionForBody(tag.get("body"));
-  if (bodySection) {
-    bodySection.downstreamBinding = (templateExport.props.content || templateExport.props).binding;
-  }
+  const known = inputExpr.known = {};
   const attrTagLookup = analyzeAttributeTags(tag);
   const seen = /* @__PURE__ */ new Set();
   if (attrTagLookup) {
@@ -9599,7 +10042,7 @@ function analyzeAttrs(rootTagExtra, section, tag, templateExport, rootAttrExprs)
     const attrTags2 = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
     for (const child of attrTags2) {
       if (child.isMarkoTag()) {
-        if ((0, import_babel_utils46.isAttributeTag)(child)) {
+        if ((0, import_babel_utils47.isAttributeTag)(child)) {
           const attrTagMeta = attrTagLookup[getTagName(child)];
           const childAttrExports = templateExport.props[attrTagMeta.name];
           if (childAttrExports) {
@@ -9609,7 +10052,8 @@ function analyzeAttrs(rootTagExtra, section, tag, templateExport, rootAttrExprs)
                 section,
                 child,
                 childAttrExports,
-                rootAttrExprs
+                rootAttrExprs,
+                known[attrTagMeta.name] = {}
               );
             } else {
               analyzeDynamicChildGroup(attrTagMeta.group, child);
@@ -9634,12 +10078,27 @@ function analyzeAttrs(rootTagExtra, section, tag, templateExport, rootAttrExprs)
         }
       }
     }
-    for (const {
-      firstTag: { node },
-      referenceNodes
-    } of nodeReferencesByGroup.values()) {
-      mergeReferences(section, node, referenceNodes);
-      rootAttrExprs.add(node.extra);
+    for (const [
+      group,
+      {
+        firstTag: { node },
+        referenceNodes
+      }
+    ] of nodeReferencesByGroup) {
+      const groupExtra = mergeReferences(section, node, referenceNodes);
+      const groupKnownValue = { value: groupExtra };
+      rootAttrExprs.add(groupExtra);
+      for (const name2 of group) {
+        known[attrTagLookup[name2].name] = groupKnownValue;
+      }
+    }
+  }
+  if (!seen.has("content")) {
+    const bodySection = getSectionForBody(tag.get("body"));
+    if (bodySection) {
+      seen.add("content");
+      known.content = { value: void 0 };
+      bodySection.downstreamBinding = (templateExport.props.content || templateExport.props).binding;
     }
   }
   const { attributes } = tag.node;
@@ -9658,11 +10117,13 @@ function analyzeAttrs(rootTagExtra, section, tag, templateExport, rootAttrExprs)
     } else if (import_compiler56.types.isMarkoSpreadAttribute(attr2)) {
       spreadReferenceNodes = [attr2.value];
     } else {
-      rootAttrExprs.add(attr2.value.extra ??= {});
+      const attrValueExtra = attr2.value.extra ??= {};
+      known[attr2.name] = { value: attrValueExtra };
+      rootAttrExprs.add(attrValueExtra);
     }
   }
   if (spreadReferenceNodes) {
-    mergeReferences(section, tag.node, spreadReferenceNodes);
+    inputExpr.value = mergeReferences(section, tag.node, spreadReferenceNodes);
   }
 }
 function writeAttrsToExports(tag, templateExport, importAlias, info) {
@@ -9703,7 +10164,7 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
       );
     }
     let translatedProps = propsToExpression(translatedAttrs.properties);
-    if ((0, import_babel_utils46.isAttributeTag)(tag)) {
+    if ((0, import_babel_utils47.isAttributeTag)(tag)) {
       const attrTagName = getTagName(tag);
       const parentTag = tag.parentPath;
       const repeated = analyzeAttributeTags(parentTag)?.[attrTagName]?.repeated;
@@ -9775,7 +10236,7 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
     for (let i = 0; i < attrTags2.length; i++) {
       const child = attrTags2[i];
       if (child.isMarkoTag()) {
-        if ((0, import_babel_utils46.isAttributeTag)(child)) {
+        if ((0, import_babel_utils47.isAttributeTag)(child)) {
           const attrTagMeta = attrTagLookup[getTagName(child)];
           const childAttrExport = templateExport.props[attrTagMeta.name];
           if (childAttrExport) {
@@ -9832,7 +10293,7 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
   if (bodySection && !seen.has("content")) {
     seen.add("content");
     if (templateExport.props.content) {
-      const contentExportIdentifier = (0, import_babel_utils46.importNamed)(
+      const contentExportIdentifier = (0, import_babel_utils47.importNamed)(
         tag.hub.file,
         info.relativePath,
         templateExport.props.content.id,
@@ -9921,7 +10382,37 @@ function importOrSelfReferenceName(file, request, name2, nameHint) {
   if (isCircularRequest(file, request)) {
     return import_compiler56.types.identifier(name2);
   }
-  return (0, import_babel_utils46.importNamed)(file, request, name2, nameHint);
+  return (0, import_babel_utils47.importNamed)(file, request, name2, nameHint);
+}
+function mapChildReasonToLocalReason(childReason, childInputBinding, inputExpr) {
+  if (childReason) {
+    if (childReason === true) return true;
+    return filterMap(
+      childReason,
+      (inputBinding) => resolveChildInputExpr(childInputBinding, inputBinding, inputExpr)
+    );
+  }
+}
+function resolveChildInputExpr(inputBinding, propBinding, expr) {
+  if (expr) {
+    let curExpr = expr;
+    if (inputBinding !== propBinding) {
+      const props = [propBinding.property];
+      let curBinding = propBinding;
+      while (inputBinding !== (curBinding = curBinding.upstreamAlias)) {
+        props.push(curBinding.property);
+      }
+      for (let i = props.length; i--; ) {
+        const nestedExpr = curExpr.known?.[props[i]];
+        if (nestedExpr) {
+          curExpr = nestedExpr;
+        } else {
+          break;
+        }
+      }
+    }
+    return curExpr.value;
+  }
 }
 function isCircularRequest(file, request) {
   const { filename } = file.opts;
@@ -9948,42 +10439,33 @@ function always() {
 
 // src/translator/visitors/tag/dynamic-tag.ts
 var import_compiler57 = require("@marko/compiler");
-var import_babel_utils47 = require("@marko/compiler/babel-utils");
+var import_babel_utils48 = require("@marko/compiler/babel-utils");
 var kDOMBinding3 = Symbol("dynamic tag dom binding");
 var kChildOffsetScopeBinding2 = Symbol("custom tag scope offset");
 var dynamic_tag_default = {
   analyze: {
     enter(tag) {
-      (0, import_babel_utils47.assertAttributesOrArgs)(tag);
+      (0, import_babel_utils48.assertAttributesOrArgs)(tag);
       analyzeAttributeTags(tag);
       const tagSection = getOrCreateSection(tag);
-      const tagExtra = tag.node.extra ??= {};
+      const tagExtra = mergeReferences(tagSection, tag.node, [
+        tag.node.name,
+        ...getAllTagReferenceNodes(tag.node)
+      ]);
       const tagBody = tag.get("body");
       const isClassAPI = tagExtra.featureType === "class";
       const hasVar = !!tag.node.var;
       const nodeBinding = tagExtra[kDOMBinding3] = createBinding(
         "#text",
         0 /* dom */,
-        tagSection,
-        void 0,
-        tagExtra
+        tagSection
       );
       if (hasVar) {
         trackVarReferences(tag, 4 /* derived */);
-        tag.node.var.extra.binding.scopeOffset = tagExtra[kChildOffsetScopeBinding2] = createBinding(
-          "#scopeOffset",
-          0 /* dom */,
-          tagSection,
-          void 0,
-          tagExtra
-        );
+        tag.node.var.extra.binding.scopeOffset = tagExtra[kChildOffsetScopeBinding2] = createBinding("#scopeOffset", 0 /* dom */, tagSection);
       }
       startSection(tagBody);
       trackParamsReferences(tagBody, 3 /* param */);
-      mergeReferences(tagSection, tag.node, [
-        tag.node.name,
-        ...getAllTagReferenceNodes(tag.node)
-      ]);
       addBindingSerializeReasonExpr(
         tagSection,
         nodeBinding,
@@ -10010,7 +10492,7 @@ var dynamic_tag_default = {
       const isClassAPI = tagExtra.featureType === "class";
       let tagExpression = node.name;
       if (import_compiler57.types.isStringLiteral(tagExpression)) {
-        tagExpression = (0, import_babel_utils47.importDefault)(
+        tagExpression = (0, import_babel_utils48.importDefault)(
           tag.hub.file,
           getTagRelativePath(tag),
           tagExpression.value
@@ -10018,15 +10500,15 @@ var dynamic_tag_default = {
       }
       if (isClassAPI) {
         if (isOutputHTML()) {
-          (0, import_babel_utils47.getProgram)().node.body.push(
+          (0, import_babel_utils48.getProgram)().node.body.push(
             import_compiler57.types.markoScriptlet(
               [
                 import_compiler57.types.expressionStatement(
                   import_compiler57.types.callExpression(
-                    (0, import_babel_utils47.importNamed)(tag.hub.file, getCompatRuntimeFile(), "s"),
+                    (0, import_babel_utils48.importNamed)(tag.hub.file, getCompatRuntimeFile(), "s"),
                     [
                       import_compiler57.types.identifier(tagExpression.name),
-                      import_compiler57.types.stringLiteral((0, import_babel_utils47.loadFileForTag)(tag).metadata.marko.id)
+                      import_compiler57.types.stringLiteral((0, import_babel_utils48.loadFileForTag)(tag).metadata.marko.id)
                     ]
                   )
                 )
@@ -10035,11 +10517,11 @@ var dynamic_tag_default = {
             )
           );
         } else {
-          (0, import_babel_utils47.getProgram)().node.body.push(
+          (0, import_babel_utils48.getProgram)().node.body.push(
             import_compiler57.types.expressionStatement(
               callRuntime(
                 "register",
-                import_compiler57.types.stringLiteral((0, import_babel_utils47.loadFileForTag)(tag).metadata.marko.id),
+                import_compiler57.types.stringLiteral((0, import_babel_utils48.loadFileForTag)(tag).metadata.marko.id),
                 import_compiler57.types.identifier(tagExpression.name)
               )
             )
@@ -10084,7 +10566,7 @@ var dynamic_tag_default = {
           import_compiler57.types.arrayExpression(args),
           import_compiler57.types.numericLiteral(0),
           import_compiler57.types.numericLiteral(1),
-          serializeReason ? import_compiler57.types.numericLiteral(1) : void 0
+          getSerializeGuard(serializeReason)
         ) : callRuntime(
           "dynamicTag",
           getScopeIdIdentifier(tagSection),
@@ -10093,15 +10575,17 @@ var dynamic_tag_default = {
           args[0],
           args[1] || (serializeReason ? import_compiler57.types.numericLiteral(0) : void 0),
           serializeReason ? import_compiler57.types.numericLiteral(0) : void 0,
-          serializeReason ? import_compiler57.types.numericLiteral(1) : void 0
+          getSerializeGuard(serializeReason)
         );
         if (node.var) {
-          const dynamicScopeIdentifier = generateUidIdentifier("dynamicScope");
+          const dynamicScopeIdentifier = generateUidIdentifier(
+            tag.get("name").toString() + "_scope"
+          );
           statements.push(
             import_compiler57.types.variableDeclaration("const", [
               import_compiler57.types.variableDeclarator(
                 dynamicScopeIdentifier,
-                callRuntime("peekNextScope")
+                callRuntime("peekNextScopeId")
               )
             ])
           );
@@ -10219,7 +10703,7 @@ var tag_default = {
   },
   analyze: {
     enter(tag) {
-      const tagDef = (0, import_babel_utils48.getTagDef)(tag);
+      const tagDef = (0, import_babel_utils49.getTagDef)(tag);
       const type = analyzeTagNameType(tag);
       const hook = tagDef?.analyzer?.hook;
       if (hook) {
@@ -10243,7 +10727,7 @@ var tag_default = {
       }
     },
     exit(tag) {
-      const hook = (0, import_babel_utils48.getTagDef)(tag)?.analyzer?.hook;
+      const hook = (0, import_babel_utils49.getTagDef)(tag)?.analyzer?.hook;
       if (hook) {
         exit(hook, tag);
         return;
@@ -10252,7 +10736,7 @@ var tag_default = {
   },
   translate: {
     enter(tag) {
-      const tagDef = (0, import_babel_utils48.getTagDef)(tag);
+      const tagDef = (0, import_babel_utils49.getTagDef)(tag);
       const extra = tag.node.extra;
       if (tagDef?.translator) {
         if (tagDef.translator.path) {
@@ -10269,7 +10753,7 @@ var tag_default = {
             );
           }
           if (attr2.node.modifier) {
-            if ((0, import_babel_utils48.isNativeTag)(attr2.parentPath)) {
+            if ((0, import_babel_utils49.isNativeTag)(attr2.parentPath)) {
               attr2.node.name += `:${attr2.node.modifier}`;
             } else {
               throw attr2.buildCodeFrameError(
@@ -10305,7 +10789,7 @@ var tag_default = {
       }
     },
     exit(tag) {
-      const translator = (0, import_babel_utils48.getTagDef)(tag)?.translator;
+      const translator = (0, import_babel_utils49.getTagDef)(tag)?.translator;
       if (translator) {
         exit(translator.hook, tag);
         return;