marko 6.0.85 → 6.0.87

package/dist/translator/index.js

@@ -112,7 +112,7 @@ var attrs_default = {
 };
 
 // src/translator/core/await.ts
-var import_compiler35 = require("@marko/compiler");
+var import_compiler36 = require("@marko/compiler");
 var import_babel_utils26 = require("@marko/compiler/babel-utils");
 
 // src/common/accessor.debug.ts
@@ -235,7 +235,7 @@ function isNullableExpr(expr) {
 }
 
 // src/translator/util/references.ts
-var import_compiler34 = require("@marko/compiler");
+var import_compiler35 = require("@marko/compiler");
 var import_babel_utils25 = require("@marko/compiler/babel-utils");
 
 // src/html/serializer.ts
@@ -690,16 +690,9 @@ function getMarkoRoot(path5) {
 }
 function getExprRoot(path5) {
   let curPath = path5;
-  let assignmentPath;
   while (!isMarko(curPath.parentPath)) {
-    if (curPath.isAssignmentPattern()) {
-      assignmentPath = curPath;
-    }
     curPath = curPath.parentPath;
   }
-  if (assignmentPath && curPath.parentPath.isMarkoTag() && (curPath.key === "var" || curPath.listKey === "params")) {
-    return assignmentPath;
-  }
   return curPath;
 }
 function getFnRoot(path5) {
@@ -1627,17 +1620,17 @@ function startSection(path5) {
   const extra = path5.node.extra ??= {};
   let section = extra.section;
   if (!section && (path5.type === "Program" || path5.get("body").length)) {
+    const parentTag = path5.parentPath?.isMarkoTag() ? path5.parentPath : void 0;
     const parentSection = path5.parentPath ? getOrCreateSection(path5.parentPath) : void 0;
-    const sectionNamePath = path5.parentPath?.get(
-      "name"
-    );
-    const sectionName = path5.isProgram() ? "" : generateUid(sectionNamePath.toString() + "_content");
+    const sectionName = parentTag ? generateUid(
+      (isCoreTagName(parentTag, "define") && import_compiler7.types.isIdentifier(parentTag.node.var) ? parentTag.node.var.name : parentTag.get("name").toString()) + "_content"
+    ) : "";
     const programExtra = path5.hub.file.path.node.extra ??= {};
     const sections = programExtra.sections ??= [];
     section = extra.section = {
       id: sections.length,
       name: sectionName,
-      loc: sectionNamePath?.node.loc || void 0,
+      loc: parentTag?.node.name.loc || void 0,
       depth: parentSection ? parentSection.depth + 1 : 0,
       parent: parentSection,
       sectionAccessor: void 0,
@@ -2113,11 +2106,11 @@ function isEventOrChangeHandler(prop) {
 }
 
 // src/translator/util/known-tag.ts
-var import_compiler33 = require("@marko/compiler");
+var import_compiler34 = require("@marko/compiler");
 var import_babel_utils24 = require("@marko/compiler/babel-utils");
 
 // src/translator/visitors/program/index.ts
-var import_compiler25 = require("@marko/compiler");
+var import_compiler26 = require("@marko/compiler");
 var import_babel_utils17 = require("@marko/compiler/babel-utils");
 var import_path2 = __toESM(require("path"));
 
@@ -2650,74 +2643,85 @@ var import_compiler14 = require("@marko/compiler");
 
 // src/translator/util/with-comment.ts
 function withLeadingComment(node, value) {
-  const comment = {
-    type: "CommentBlock",
-    value: ` ${value} `
-  };
-  node.leadingComments = node.leadingComments ? [...node.leadingComments, comment] : [comment];
+  if (value) {
+    const comment = {
+      type: "CommentBlock",
+      value: ` ${value} `
+    };
+    node.leadingComments = node.leadingComments ? [...node.leadingComments, comment] : [comment];
+  }
   return node;
 }
 
 // src/translator/util/serialize-guard.ts
-function getSerializeGuard(reason, optional) {
-  return !reason ? import_compiler14.types.numericLiteral(0) : reason === true || reason.state ? optional ? void 0 : reason === true ? import_compiler14.types.numericLiteral(1) : withLeadingComment(import_compiler14.types.numericLiteral(1), getDebugNames(reason.state)) : getInputSerializeReasonGuard(reason);
+function getSerializeGuard(section, reason, optional) {
+  if (!isReasonDynamic(reason)) {
+    return reason ? optional ? void 0 : withLeadingComment(
+      import_compiler14.types.numericLiteral(1),
+      getDebugNames(reason === true ? void 0 : reason.state)
+    ) : import_compiler14.types.numericLiteral(0);
+  }
+  let expr;
+  for (const [paramsSection, params] of groupParamsBySection(reason.param)) {
+    if (!isSameOrChildSection(paramsSection, section)) {
+      return optional ? void 0 : withLeadingComment(import_compiler14.types.numericLiteral(1), getDebugNames(params));
+    }
+    const serializeIdentifier = import_compiler14.types.identifier(
+      getSharedUid(`scope${paramsSection.id}_reason`, paramsSection)
+    );
+    const guard = paramsSection.paramReasonGroups ? callRuntime(
+      "_serialize_guard",
+      serializeIdentifier,
+      withLeadingComment(
+        import_compiler14.types.numericLiteral(getParamReasonGroupIndex(paramsSection, params)),
+        getDebugNames(params)
+      )
+    ) : serializeIdentifier;
+    expr = expr ? import_compiler14.types.logicalExpression("||", expr, guard) : guard;
+  }
+  return expr;
 }
-function getSerializeGuardForAny(reasons, optional) {
+function getSerializeGuardForAny(section, reasons, optional) {
   if (!reasons || reasons === true) {
-    return getSerializeGuard(reasons, optional);
+    return getSerializeGuard(section, reasons, optional);
   }
   if (reasons.length === 1) {
-    return getSerializeGuard(reasons[0], optional);
+    return getSerializeGuard(section, reasons[0], optional);
   }
   let expr;
   for (const reason of reasons) {
-    if (reason.state) {
+    if (!isReasonDynamic(reason)) {
       return optional ? void 0 : withLeadingComment(import_compiler14.types.numericLiteral(1), getDebugNames(reason.state));
     }
-    const guard = getSerializeGuard(reason, false);
+    const guard = getSerializeGuard(section, reason, false);
     expr = expr ? import_compiler14.types.logicalExpression("||", expr, guard) : guard;
   }
   return expr;
 }
-function getExprIfSerialized(reason, expr) {
+function getExprIfSerialized(section, reason, expr) {
   if (!isReasonDynamic(reason)) {
     return reason && expr;
   }
   let orExpr;
-  for (const [section, reasons] of groupParamsBySection(reason.param)) {
+  for (const [paramsSection, params] of groupParamsBySection(reason.param)) {
+    if (!isSameOrChildSection(paramsSection, section)) {
+      return expr;
+    }
     const serializeIdentifier = import_compiler14.types.identifier(
-      getSharedUid("serialize", section)
+      getSharedUid(`scope${paramsSection.id}_reason`, paramsSection)
     );
-    const guard = section.paramReasonGroups ? callRuntime(
+    const guard = paramsSection.paramReasonGroups ? callRuntime(
       "_serialize_if",
       serializeIdentifier,
       withLeadingComment(
-        import_compiler14.types.numericLiteral(getParamReasonGroupIndex(section, reasons)),
-        getDebugNames(reasons)
+        import_compiler14.types.numericLiteral(getParamReasonGroupIndex(paramsSection, params)),
+        getDebugNames(params)
       )
     ) : serializeIdentifier;
     orExpr = orExpr ? import_compiler14.types.logicalExpression("||", orExpr, guard) : guard;
   }
   return import_compiler14.types.logicalExpression("&&", orExpr, expr);
 }
-function getInputSerializeReasonGuard(reason) {
-  let expr;
-  for (const [section, reasons] of groupParamsBySection(reason.param)) {
-    const serializeIdentifier = import_compiler14.types.identifier(
-      getSharedUid("serialize", section)
-    );
-    const guard = section.paramReasonGroups ? callRuntime(
-      "_serialize_guard",
-      serializeIdentifier,
-      withLeadingComment(
-        import_compiler14.types.numericLiteral(getParamReasonGroupIndex(section, reasons)),
-        getDebugNames(reasons)
-      )
-    ) : serializeIdentifier;
-    expr = expr ? import_compiler14.types.logicalExpression("||", expr, guard) : guard;
-  }
-  return expr;
-}
 
 // src/translator/util/walks.ts
 var import_compiler15 = require("@marko/compiler");
@@ -2986,7 +2990,7 @@ function markNode(path5, nodeBinding, reason) {
         "_el_resume",
         getScopeIdIdentifier(section),
         getScopeAccessorLiteral(nodeBinding),
-        getSerializeGuard(reason, true)
+        getSerializeGuard(section, reason, true)
       )}`;
     }
   }
@@ -4051,7 +4055,11 @@ function writeHTMLResumeStatements(path5) {
     serializedProperties.push(
       toObjectProperty(
         accessor,
-        sectionSerializeReason && (sectionSerializeReason === reason || sectionSerializeReason !== true && reason !== true && compareSources(sectionSerializeReason, reason) === 0) ? getDeclaredBindingExpression(binding) : getExprIfSerialized(reason, getDeclaredBindingExpression(binding))
+        sectionSerializeReason && (sectionSerializeReason === reason || sectionSerializeReason !== true && reason !== true && compareSources(sectionSerializeReason, reason) === 0) ? getDeclaredBindingExpression(binding) : getExprIfSerialized(
+          section,
+          reason,
+          getDeclaredBindingExpression(binding)
+        )
       )
     );
     if (debug) {
@@ -4085,14 +4093,14 @@ function writeHTMLResumeStatements(path5) {
       serializedProperties.push(
         toObjectProperty(
           ownerAccessor,
-          sectionSerializeReason && (sectionSerializeReason === ownerReason || sectionSerializeReason !== true && ownerReason !== true && compareSources(sectionSerializeReason, ownerReason) === 0) ? getOwnerExpr : getExprIfSerialized(ownerReason, getOwnerExpr)
+          sectionSerializeReason && (sectionSerializeReason === ownerReason || sectionSerializeReason !== true && ownerReason !== true && compareSources(sectionSerializeReason, ownerReason) === 0) ? getOwnerExpr : getExprIfSerialized(section, ownerReason, getOwnerExpr)
         )
       );
     }
   }
   for (const [key, { expression, reason }] of serializedLookup) {
     serializedProperties.push(
-      toObjectProperty(key, getExprIfSerialized(reason, expression))
+      toObjectProperty(key, getExprIfSerialized(section, reason, expression))
     );
   }
   if (sectionSerializeReason) {
@@ -4116,15 +4124,15 @@ function writeHTMLResumeStatements(path5) {
         writeScopeArgs.push(import_compiler22.types.objectExpression(debugVars));
       }
     }
-    let writeScopeCall = writeScopeBuilder ? writeScopeBuilder(callRuntime("_scope", ...writeScopeArgs)) : callRuntime("_scope", ...writeScopeArgs);
-    if (sectionSerializeReason !== true && !sectionSerializeReason.state) {
-      writeScopeCall = import_compiler22.types.logicalExpression(
-        "&&",
-        getSerializeGuard(sectionSerializeReason, false),
-        writeScopeCall
-      );
-    }
-    body.push(import_compiler22.types.expressionStatement(writeScopeCall));
+    body.push(
+      import_compiler22.types.expressionStatement(
+        getExprIfSerialized(
+          section,
+          sectionSerializeReason,
+          writeScopeBuilder ? writeScopeBuilder(callRuntime("_scope", ...writeScopeArgs)) : callRuntime("_scope", ...writeScopeArgs)
+        )
+      )
+    );
   }
   const resumeClosestBranch = !section.isBranch && (section.hasAbortSignal || !!section.referencedClosures || !!find(section.bindings, (binding) => binding.type === 1 /* let */));
   if (resumeClosestBranch) {
@@ -4519,8 +4527,8 @@ var html_default = {
         renderContent.push(
           import_compiler24.types.variableDeclaration("const", [
             import_compiler24.types.variableDeclarator(
-              import_compiler24.types.identifier(getSharedUid("serialize", section)),
-              callRuntime("_get_serialize_reason")
+              import_compiler24.types.identifier(getSharedUid(`scope${section.id}_reason`, section)),
+              callRuntime("_scope_reason")
             )
           ])
         );
@@ -4644,6 +4652,285 @@ function getRegisteredFnExpression2(node) {
   }
 }
 
+// src/translator/visitors/program/pre-analyze.ts
+var import_compiler25 = require("@marko/compiler");
+
+// src/translator/util/with-previous-location.ts
+function withPreviousLocation(newNode, originalNode) {
+  newNode.start = originalNode.start;
+  newNode.loc = originalNode.loc;
+  newNode.end = originalNode.end;
+  return newNode;
+}
+
+// src/translator/visitors/program/pre-analyze.ts
+var TAG_NAME_IDENTIFIER_REG = /^[A-Z][a-zA-Z0-9_$]*$/;
+var BINDING_CHANGE_HANDLER = /* @__PURE__ */ new WeakMap();
+function preAnalyze(program) {
+  const state = { crawl: false };
+  normalizeBody(state, program.get("body"));
+  if (state.crawl) {
+    program.scope.crawl();
+  }
+}
+function normalizeBody(state, body) {
+  for (const child of body) {
+    if (child.isMarkoTag()) {
+      normalizeTag(state, child);
+    }
+  }
+}
+function normalizeTag(state, tag) {
+  const { node } = tag;
+  const { name: name2, attributes } = node;
+  normalizeBody(state, tag.get("body").get("body"));
+  if (node.var) {
+    const insertions = getAssignmentInsertions(node.var);
+    if (insertions) {
+      state.crawl = true;
+      tag.insertAfter(insertions);
+    }
+  }
+  if (node.body.params.length) {
+    let insertions;
+    for (const param of node.body.params) {
+      insertions = getAssignmentInsertions(param, insertions);
+    }
+    if (insertions) {
+      state.crawl = true;
+      node.body.body = [...insertions, ...node.body.body];
+    }
+  }
+  if (name2.type === "StringLiteral") {
+    const tagName = name2.value;
+    if (tag.scope.getBinding(tagName) && TAG_NAME_IDENTIFIER_REG.test(tagName)) {
+      state.crawl = true;
+      node.name = withPreviousLocation(import_compiler25.types.identifier(tagName), name2);
+    }
+  }
+  for (let i = 0; i < attributes.length; i++) {
+    const attr = attributes[i];
+    if (import_compiler25.types.isMarkoAttribute(attr) && attr.bound) {
+      state.crawl = true;
+      attr.bound = false;
+      attributes.splice(++i, 0, getChangeHandler(tag, attr));
+    }
+  }
+}
+function getChangeHandler(tag, attr) {
+  const attrName = attr.name;
+  const changeAttrName = attrName + "Change";
+  if (import_compiler25.types.isIdentifier(attr.value)) {
+    const binding = tag.scope.getBinding(attr.value.name);
+    if (!binding)
+      return import_compiler25.types.markoAttribute(
+        changeAttrName,
+        buildChangeHandlerFunction(attr.value)
+      );
+    const existingChangedAttr = BINDING_CHANGE_HANDLER.get(binding.identifier);
+    if (!existingChangedAttr) {
+      const bindingIdentifierPath = binding.path.getOuterBindingIdentifierPaths()[binding.identifier.name];
+      const changeAttrExpr = bindingIdentifierPath ? bindingIdentifierPath.parentPath === binding.path ? buildChangeHandlerFunction(attr.value) : bindingIdentifierPath.parentPath.isObjectProperty() ? getChangeHandlerFromObjectPattern(
+        bindingIdentifierPath.parentPath
+      ) : void 0 : void 0;
+      if (!changeAttrExpr) {
+        throw tag.hub.buildError(attr.value, "Unable to bind to value.");
+      }
+      const changeHandlerAttr = import_compiler25.types.markoAttribute(
+        changeAttrName,
+        changeAttrExpr
+      );
+      BINDING_CHANGE_HANDLER.set(binding.identifier, changeHandlerAttr);
+      return changeHandlerAttr;
+    }
+    if (existingChangedAttr.type === "Identifier") {
+      return import_compiler25.types.markoAttribute(
+        changeAttrName,
+        withPreviousLocation(
+          import_compiler25.types.identifier(existingChangedAttr.name),
+          attr.value
+        )
+      );
+    }
+    const markoRoot = isMarko(binding.path) ? binding.path : getMarkoRoot(binding.path);
+    if (!(markoRoot?.isMarkoTag() || markoRoot?.isMarkoTagBody())) {
+      throw tag.hub.buildError(attr.value, "Unable to bind to value.");
+    }
+    const changeHandlerId = generateUid(changeAttrName);
+    const changeHandlerConst = import_compiler25.types.markoTag(
+      import_compiler25.types.stringLiteral("const"),
+      [import_compiler25.types.markoAttribute("value", existingChangedAttr.value, null, null, true)],
+      import_compiler25.types.markoTagBody([]),
+      null,
+      import_compiler25.types.identifier(changeHandlerId)
+    );
+    BINDING_CHANGE_HANDLER.set(
+      binding.identifier,
+      existingChangedAttr.value = import_compiler25.types.identifier(changeHandlerId)
+    );
+    if (markoRoot.isMarkoTag()) {
+      markoRoot.insertAfter(changeHandlerConst);
+    } else {
+      markoRoot.unshiftContainer("body", changeHandlerConst);
+    }
+    markoRoot.scope.crawl();
+    return import_compiler25.types.markoAttribute(
+      changeAttrName,
+      withPreviousLocation(import_compiler25.types.identifier(changeHandlerId), attr.value)
+    );
+  } else if (import_compiler25.types.isMemberExpression(attr.value)) {
+    const prop = attr.value.property;
+    if (!import_compiler25.types.isPrivateName(attr.value.property)) {
+      return import_compiler25.types.markoAttribute(
+        changeAttrName,
+        import_compiler25.types.memberExpression(
+          import_compiler25.types.cloneNode(attr.value.object),
+          prop.type === "Identifier" ? withPreviousLocation(import_compiler25.types.identifier(prop.name + "Change"), prop) : import_compiler25.types.binaryExpression(
+            "+",
+            import_compiler25.types.cloneNode(prop),
+            import_compiler25.types.stringLiteral("Change")
+          ),
+          prop.type !== "Identifier"
+        )
+      );
+    }
+  }
+  throw tag.hub.buildError(
+    attr.value,
+    "Attributes may only be bound to identifiers or member expressions"
+  );
+}
+function buildChangeHandlerFunction(id) {
+  const newId = "_new_" + id.name;
+  return import_compiler25.types.arrowFunctionExpression(
+    [withPreviousLocation(import_compiler25.types.identifier(newId), id)],
+    import_compiler25.types.blockStatement([
+      import_compiler25.types.expressionStatement(
+        import_compiler25.types.assignmentExpression(
+          "=",
+          withPreviousLocation(import_compiler25.types.identifier(id.name), id),
+          withPreviousLocation(import_compiler25.types.identifier(newId), id)
+        )
+      )
+    ])
+  );
+}
+function getChangeHandlerFromObjectPattern(parent) {
+  let changeKey;
+  const pattern = parent.parentPath;
+  if (parent.node.computed) {
+    changeKey = generateUidIdentifier("dynamicChange");
+    pattern.pushContainer(
+      "properties",
+      import_compiler25.types.objectProperty(
+        import_compiler25.types.binaryExpression(
+          "+",
+          parent.get("key").node,
+          import_compiler25.types.stringLiteral("Change")
+        ),
+        changeKey,
+        true
+      )
+    );
+  } else {
+    const key = parent.get("key");
+    const searchKey = `${getStringOrIdentifierValue(key)}Change`;
+    for (const prop of pattern.get("properties")) {
+      if (prop.isObjectProperty()) {
+        const propKey = prop.get("key");
+        const propValue = prop.get("value");
+        if (!prop.node.computed && getStringOrIdentifierValue(propKey) === searchKey && propValue.isIdentifier()) {
+          changeKey = propValue.node;
+          break;
+        }
+      }
+    }
+    if (!changeKey) {
+      pattern.unshiftContainer(
+        "properties",
+        import_compiler25.types.objectProperty(
+          import_compiler25.types.stringLiteral(searchKey),
+          changeKey = generateUidIdentifier(searchKey)
+        )
+      );
+    }
+  }
+  return changeKey;
+}
+function getStringOrIdentifierValue(path5) {
+  return getLiteralName(path5.node);
+}
+function getLiteralName(node) {
+  switch (node.type) {
+    case "Identifier":
+      return node.name;
+    case "StringLiteral":
+      return node.value;
+  }
+}
+function getAssignmentInsertions(node, insertions) {
+  switch (node.type) {
+    case "ObjectPattern":
+      for (const prop of node.properties) {
+        if (prop.type === "ObjectProperty") {
+          if (prop.value.type === "AssignmentPattern") {
+            const { left, right } = prop.value;
+            const sourceName = generateUid(
+              getLiteralName(left) || getLiteralName(prop.key) || "pattern"
+            );
+            prop.shorthand = false;
+            prop.value = import_compiler25.types.identifier(sourceName);
+            (insertions ||= []).push(
+              toConstTag(left, toFallbackExpr(sourceName, right))
+            );
+            getAssignmentInsertions(left, insertions);
+          } else {
+            insertions = getAssignmentInsertions(prop.value, insertions);
+          }
+        }
+      }
+      break;
+    case "ArrayPattern":
+      for (let i = 0, len = node.elements.length; i < len; i++) {
+        const el = node.elements[i];
+        if (el != null) {
+          if (el.type === "AssignmentPattern") {
+            const { left, right } = el;
+            const sourceName = generateUid(getLiteralName(left) || "pattern");
+            node.elements[i] = import_compiler25.types.identifier(sourceName);
+            (insertions ||= []).push(
+              toConstTag(left, toFallbackExpr(sourceName, right))
+            );
+            getAssignmentInsertions(left, insertions);
+          } else {
+            insertions = getAssignmentInsertions(el, insertions);
+          }
+        }
+      }
+      break;
+  }
+  return insertions;
+}
+function toFallbackExpr(id, fallback) {
+  return import_compiler25.types.conditionalExpression(
+    import_compiler25.types.binaryExpression("!==", buildUndefined(), import_compiler25.types.identifier(id)),
+    import_compiler25.types.identifier(id),
+    fallback
+  );
+}
+function toConstTag(id, expr) {
+  return import_compiler25.types.markoTag(
+    import_compiler25.types.stringLiteral("const"),
+    [import_compiler25.types.markoAttribute("value", expr, null, null, true)],
+    import_compiler25.types.markoTagBody(),
+    null,
+    id
+  );
+}
+function buildUndefined() {
+  return import_compiler25.types.unaryExpression("void", import_compiler25.types.numericLiteral(0));
+}
+
 // src/translator/visitors/program/index.ts
 var cleanIdentifier;
 var scopeIdentifier;
@@ -4653,12 +4940,15 @@ function isScopeIdentifier(node) {
 var program_default = {
   migrate: {
     enter(program) {
-      program.node.params = [import_compiler25.types.identifier("input")];
+      program.node.params = [import_compiler26.types.identifier("input")];
     },
     exit(program) {
       program.scope.crawl();
     }
   },
+  transform: {
+    exit: preAnalyze
+  },
   analyze: {
     enter(program) {
       startSection(program);
@@ -4736,7 +5026,7 @@ var program_default = {
             body.push(child);
           }
         }
-        body[0] ??= import_compiler25.types.importDeclaration([], import_compiler25.types.stringLiteral(compatFile));
+        body[0] ??= import_compiler26.types.importDeclaration([], import_compiler26.types.stringLiteral(compatFile));
         program.node.body = body;
       }
     }
@@ -4750,7 +5040,7 @@ function resolveRelativeToEntry(entryFile, file, req) {
 }
 
 // src/translator/util/nested-attribute-tags.ts
-var import_compiler26 = require("@marko/compiler");
+var import_compiler27 = require("@marko/compiler");
 var import_babel_utils18 = require("@marko/compiler/babel-utils");
 var attrTagToIdentifierLookup = /* @__PURE__ */ new WeakMap();
 function getAttrTagIdentifier(meta) {
@@ -4759,7 +5049,7 @@ function getAttrTagIdentifier(meta) {
     name2 = generateUid(meta.name);
     attrTagToIdentifierLookup.set(meta, name2);
   }
-  return import_compiler26.types.identifier(name2);
+  return import_compiler27.types.identifier(name2);
 }
 function analyzeAttributeTags(tag) {
   if (tag.node.extra?.attributeTags) return tag.node.extra.attributeTags;
@@ -4872,7 +5162,7 @@ function getConditionRoot(tag) {
 }
 
 // src/translator/util/set-tag-sections-downstream.ts
-var import_compiler27 = require("@marko/compiler");
+var import_compiler28 = require("@marko/compiler");
 var import_babel_utils19 = require("@marko/compiler/babel-utils");
 var [getTagDownstreams] = createSectionState(
   "tag-downstreams",
@@ -4919,23 +5209,23 @@ function crawlSectionsAndSetBinding(tag, binding, tree, skip2) {
 }
 
 // src/translator/util/translate-attrs.ts
-var import_compiler32 = require("@marko/compiler");
+var import_compiler33 = require("@marko/compiler");
 var import_babel_utils23 = require("@marko/compiler/babel-utils");
 
 // src/translator/core/for.ts
-var import_compiler31 = require("@marko/compiler");
+var import_compiler32 = require("@marko/compiler");
 var import_babel_utils22 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/is-only-child-in-parent.ts
-var import_compiler30 = require("@marko/compiler");
+var import_compiler31 = require("@marko/compiler");
 var import_babel_utils21 = require("@marko/compiler/babel-utils");
 
 // src/translator/visitors/tag/native-tag.ts
-var import_compiler29 = require("@marko/compiler");
+var import_compiler30 = require("@marko/compiler");
 var import_babel_utils20 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/translate-var.ts
-var import_compiler28 = require("@marko/compiler");
+var import_compiler29 = require("@marko/compiler");
 function translateVar(tag, initialValue, kind = "const") {
   const {
     node: { var: tagVar }
@@ -4953,15 +5243,15 @@ function translateVar(tag, initialValue, kind = "const") {
     if (changeBinding && changeName !== changeBinding.name) {
       getDestructurePattern(id)?.pushContainer(
         "properties",
-        import_compiler28.types.objectProperty(
-          import_compiler28.types.identifier(changeName),
-          import_compiler28.types.identifier(changeBinding.name)
+        import_compiler29.types.objectProperty(
+          import_compiler29.types.identifier(changeName),
+          import_compiler29.types.identifier(changeBinding.name)
         )
       );
     }
   });
   tag.insertBefore(
-    import_compiler28.types.variableDeclaration(kind, [import_compiler28.types.variableDeclarator(tagVar, initialValue)])
+    import_compiler29.types.variableDeclaration(kind, [import_compiler29.types.variableDeclarator(tagVar, initialValue)])
   );
 }
 function getDestructurePattern(id) {
@@ -4981,39 +5271,13 @@ var kGetterId = Symbol("node getter id");
 var kTagContentAttr = Symbol("tag could have dynamic content attribute");
 var htmlSelectArgs = /* @__PURE__ */ new WeakMap();
 var native_tag_default = {
-  transform: {
-    enter(tag) {
-      const tagName = getTagName(tag);
-      if (tagName === "textarea" && tag.node.body.body.length) {
-        const parts = [];
-        for (const child of tag.node.body.body) {
-          if (child.type === "MarkoText" || child.type === "MarkoPlaceholder" && child.escape) {
-            parts.push(child.value);
-          } else {
-            throw tag.hub.file.hub.buildError(
-              child,
-              "Unexpected content in textarea, only text and placeholders are supported.",
-              SyntaxError
-            );
-          }
-        }
-        tag.node.attributes.push(
-          import_compiler29.types.markoAttribute(
-            "value",
-            normalizeStringExpression(parts) || buildUndefined()
-          )
-        );
-        tag.node.body.body = [];
-      }
-    }
-  },
   analyze: {
     enter(tag) {
       (0, import_babel_utils20.assertNoArgs)(tag);
       (0, import_babel_utils20.assertNoParams)(tag);
       (0, import_babel_utils20.assertNoAttributeTags)(tag);
       const { node } = tag;
-      if (node.var && !import_compiler29.types.isIdentifier(node.var)) {
+      if (node.var && !import_compiler30.types.isIdentifier(node.var)) {
         throw tag.get("var").buildCodeFrameError(
           "Tag variables on [native tags](https://markojs.com/docs/reference/native-tag) cannot be destructured."
         );
@@ -5029,7 +5293,7 @@ var native_tag_default = {
       for (let i = attributes.length; i--; ) {
         const attr = attributes[i];
         const valueExtra = attr.value.extra ??= {};
-        if (import_compiler29.types.isMarkoAttribute(attr)) {
+        if (import_compiler30.types.isMarkoAttribute(attr)) {
           if (seen[attr.name]) {
             dropReferences(attr.value);
             continue;
@@ -5041,14 +5305,14 @@ var native_tag_default = {
           } else if (!evaluate(attr.value).confident) {
             hasDynamicAttributes = true;
           }
-        } else if (import_compiler29.types.isMarkoSpreadAttribute(attr)) {
+        } else if (import_compiler30.types.isMarkoSpreadAttribute(attr)) {
           valueExtra.isEffect = true;
           hasEventHandlers = true;
           hasDynamicAttributes = true;
         }
         if (spreadReferenceNodes) {
           spreadReferenceNodes.push(attr.value);
-        } else if (import_compiler29.types.isMarkoSpreadAttribute(attr)) {
+        } else if (import_compiler30.types.isMarkoSpreadAttribute(attr)) {
           spreadReferenceNodes = [attr.value];
           relatedControllable = getRelatedControllable(tagName, seen);
         } else {
@@ -5060,7 +5324,7 @@ var native_tag_default = {
         const tagExtra = node.extra ??= {};
         const tagSection = getOrCreateSection(tag);
         const nodeBinding = tagExtra[kNativeTagBinding] = createBinding(
-          "#" + (node.name.type === "StringLiteral" ? node.name.value : import_compiler29.types.toIdentifier(tag.get("name"))),
+          "#" + (node.name.type === "StringLiteral" ? node.name.value : import_compiler30.types.toIdentifier(tag.get("name"))),
           0 /* dom */,
           tagSection
         );
@@ -5139,7 +5403,7 @@ var native_tag_default = {
             callRuntime(
               "_el",
               getterId && getScopeIdIdentifier(tagSection),
-              getterId && import_compiler29.types.stringLiteral(getterId)
+              getterId && import_compiler30.types.stringLiteral(getterId)
             )
           );
         }
@@ -5165,24 +5429,24 @@ var native_tag_default = {
         if (tagName === "select") {
           if (staticControllable) {
             htmlSelectArgs.set(tag.node, {
-              value: staticControllable.attrs[0]?.value || buildUndefined(),
-              valueChange: staticControllable.attrs[1]?.value || buildUndefined()
+              value: staticControllable.attrs[0]?.value || buildUndefined2(),
+              valueChange: staticControllable.attrs[1]?.value || buildUndefined2()
             });
           } else if (spreadExpression) {
             const spreadIdentifier = generateUidIdentifier("select_input");
             tag.insertBefore(
-              import_compiler29.types.variableDeclaration("const", [
-                import_compiler29.types.variableDeclarator(spreadIdentifier, spreadExpression)
+              import_compiler30.types.variableDeclaration("const", [
+                import_compiler30.types.variableDeclarator(spreadIdentifier, spreadExpression)
               ])
             );
             htmlSelectArgs.set(tag.node, {
-              value: import_compiler29.types.memberExpression(
+              value: import_compiler30.types.memberExpression(
                 spreadIdentifier,
-                import_compiler29.types.identifier("value")
+                import_compiler30.types.identifier("value")
               ),
-              valueChange: import_compiler29.types.memberExpression(
+              valueChange: import_compiler30.types.memberExpression(
                 spreadIdentifier,
-                import_compiler29.types.identifier("valueChange")
+                import_compiler30.types.identifier("valueChange")
               )
             });
             spreadExpression = spreadIdentifier;
@@ -5196,14 +5460,14 @@ var native_tag_default = {
           } else if (spreadExpression) {
             const spreadIdentifier = generateUidIdentifier("textarea_input");
             tag.insertBefore(
-              import_compiler29.types.variableDeclaration("const", [
-                import_compiler29.types.variableDeclarator(spreadIdentifier, spreadExpression)
+              import_compiler30.types.variableDeclaration("const", [
+                import_compiler30.types.variableDeclarator(spreadIdentifier, spreadExpression)
               ])
             );
-            value = import_compiler29.types.memberExpression(spreadIdentifier, import_compiler29.types.identifier("value"));
-            valueChange = import_compiler29.types.memberExpression(
+            value = import_compiler30.types.memberExpression(spreadIdentifier, import_compiler30.types.identifier("value"));
+            valueChange = import_compiler30.types.memberExpression(
               spreadIdentifier,
-              import_compiler29.types.identifier("valueChange")
+              import_compiler30.types.identifier("valueChange")
             );
             spreadExpression = spreadIdentifier;
           }
@@ -5244,7 +5508,7 @@ var native_tag_default = {
               } else if (isEventHandler(name2)) {
                 addHTMLEffectCall(tagSection, valueReferences);
               } else {
-                write`${callRuntime("_attr", import_compiler29.types.stringLiteral(name2), value)}`;
+                write`${callRuntime("_attr", import_compiler30.types.stringLiteral(name2), value)}`;
               }
               break;
           }
@@ -5276,13 +5540,14 @@ var native_tag_default = {
             write`>`;
             tagExtra[kTagContentAttr] = true;
             tag.node.body.body = [
-              import_compiler29.types.expressionStatement(
+              import_compiler30.types.expressionStatement(
                 callRuntime(
                   "_attr_content",
                   visitAccessor,
                   getScopeIdIdentifier(tagSection),
                   usedAttrs.staticContentAttr.value,
                   getSerializeGuard(
+                    tagSection,
                     nodeBinding && getSerializeReason(tagSection, nodeBinding),
                     true
                   )
@@ -5291,12 +5556,13 @@ var native_tag_default = {
             ];
           } else if (spreadExpression && !hasChildren) {
             const serializeReason = getSerializeGuard(
+              tagSection,
               nodeBinding && getSerializeReason(tagSection, nodeBinding),
               true
             );
             tagExtra[kTagContentAttr] = true;
             tag.node.body.body = [
-              skipExpression ? import_compiler29.types.expressionStatement(
+              skipExpression ? import_compiler30.types.expressionStatement(
                 callRuntime(
                   "_attrs_partial_content",
                   spreadExpression,
@@ -5306,7 +5572,7 @@ var native_tag_default = {
                   tag.node.name,
                   serializeReason
                 )
-              ) : import_compiler29.types.expressionStatement(
+              ) : import_compiler30.types.expressionStatement(
                 callRuntime(
                   "_attrs_content",
                   spreadExpression,
@@ -5323,7 +5589,7 @@ var native_tag_default = {
         }
         if (tagExtra.tagNameNullable) {
           tag.insertBefore(
-            import_compiler29.types.ifStatement(tag.node.name, consumeHTML(tag))
+            import_compiler30.types.ifStatement(tag.node.name, consumeHTML(tag))
           )[0].skip();
         }
         if (writeAtStartOfBody) {
@@ -5349,16 +5615,16 @@ var native_tag_default = {
           }
           flushInto(tag);
           tag.insertBefore(
-            import_compiler29.types.expressionStatement(
+            import_compiler30.types.expressionStatement(
               callRuntime(
                 "_attr_select_value",
                 getScopeIdIdentifier(getSection(tag)),
                 nodeBinding && getScopeAccessorLiteral(nodeBinding),
                 selectArgs.value,
                 selectArgs.valueChange,
-                import_compiler29.types.arrowFunctionExpression(
+                import_compiler30.types.arrowFunctionExpression(
                   [],
-                  import_compiler29.types.blockStatement(tag.node.body.body)
+                  import_compiler30.types.blockStatement(tag.node.body.body)
                 )
               )
             )
@@ -5375,7 +5641,7 @@ var native_tag_default = {
         }
         if (tagExtra.tagNameNullable) {
           tag.insertBefore(
-            import_compiler29.types.ifStatement(tag.node.name, consumeHTML(tag))
+            import_compiler30.types.ifStatement(tag.node.name, consumeHTML(tag))
           )[0].skip();
         }
         if (markerSerializeReason) {
@@ -5400,13 +5666,13 @@ var native_tag_default = {
           if (getterId) {
             getterFnIdentifier = generateUidIdentifier(`get_${varName}`);
             (0, import_babel_utils20.getProgram)().node.body.push(
-              import_compiler29.types.variableDeclaration("const", [
-                import_compiler29.types.variableDeclarator(
+              import_compiler30.types.variableDeclaration("const", [
+                import_compiler30.types.variableDeclarator(
                   getterFnIdentifier,
                   callRuntime(
                     "_el",
-                    import_compiler29.types.stringLiteral(getterId),
-                    import_compiler29.types.stringLiteral(
+                    import_compiler30.types.stringLiteral(getterId),
+                    import_compiler30.types.stringLiteral(
                       getAccessorPrefix().Getter + getScopeAccessorLiteral(nodeBinding).value
                     )
                   )
@@ -5419,22 +5685,22 @@ var native_tag_default = {
             if (isSameOrChildSection(tagSection, referenceSection)) {
               if (isInvokedFunction(reference)) {
                 reference.parentPath.replaceWith(
-                  import_compiler29.types.expressionStatement(
+                  import_compiler30.types.expressionStatement(
                     createScopeReadExpression(referenceSection, nodeBinding)
                   )
                 );
               } else if (getterFnIdentifier) {
                 reference.replaceWith(
-                  import_compiler29.types.callExpression(getterFnIdentifier, [
+                  import_compiler30.types.callExpression(getterFnIdentifier, [
                     getScopeExpression(referenceSection, getSection(tag))
                   ])
                 );
               } else {
                 reference.replaceWith(
-                  import_compiler29.types.expressionStatement(
-                    import_compiler29.types.memberExpression(
+                  import_compiler30.types.expressionStatement(
+                    import_compiler30.types.memberExpression(
                       getScopeExpression(tagSection, referenceSection),
-                      import_compiler29.types.stringLiteral(
+                      import_compiler30.types.stringLiteral(
                         getAccessorPrefix().Getter + getScopeAccessorLiteral(nodeBinding).value
                       ),
                       true
@@ -5464,7 +5730,7 @@ var native_tag_default = {
             "render",
             tagSection,
             referencedBindings,
-            import_compiler29.types.expressionStatement(
+            import_compiler30.types.expressionStatement(
               callRuntime(helper, scopeIdentifier, visitAccessor, ...values)
             )
           );
@@ -5473,7 +5739,7 @@ var native_tag_default = {
               "effect",
               tagSection,
               void 0,
-              import_compiler29.types.expressionStatement(
+              import_compiler30.types.expressionStatement(
                 callRuntime(`${helper}_script`, scopeIdentifier, visitAccessor)
               )
             );
@@ -5490,7 +5756,7 @@ var native_tag_default = {
               if (confident) {
                 write`${getHTMLRuntime()[helper](computed)}`;
               } else {
-                const nodeExpr = import_compiler29.types.memberExpression(
+                const nodeExpr = import_compiler30.types.memberExpression(
                   scopeIdentifier,
                   visitAccessor,
                   true
@@ -5503,7 +5769,7 @@ var native_tag_default = {
                 let stmt;
                 trackDelimitedAttrValue(value, meta);
                 if (meta.dynamicItems) {
-                  stmt = import_compiler29.types.expressionStatement(
+                  stmt = import_compiler30.types.expressionStatement(
                     callRuntime(helper, nodeExpr, value)
                   );
                 } else {
@@ -5515,11 +5781,11 @@ var native_tag_default = {
                     if (keys.length === 1) {
                       const [key] = keys;
                       const value2 = meta.dynamicValues[key];
-                      stmt = import_compiler29.types.expressionStatement(
+                      stmt = import_compiler30.types.expressionStatement(
                         callRuntime(
                           `_attr_${name2}_item`,
                           nodeExpr,
-                          import_compiler29.types.stringLiteral(key),
+                          import_compiler30.types.stringLiteral(key),
                           value2
                         )
                       );
@@ -5528,14 +5794,14 @@ var native_tag_default = {
                       for (const key of keys) {
                         const value2 = meta.dynamicValues[key];
                         props.push(
-                          import_compiler29.types.objectProperty(toPropertyName(key), value2)
+                          import_compiler30.types.objectProperty(toPropertyName(key), value2)
                         );
                       }
-                      stmt = import_compiler29.types.expressionStatement(
+                      stmt = import_compiler30.types.expressionStatement(
                         callRuntime(
                           `_attr_${name2}_items`,
                           nodeExpr,
-                          import_compiler29.types.objectExpression(props)
+                          import_compiler30.types.objectExpression(props)
                         )
                       );
                     }
@@ -5555,11 +5821,11 @@ var native_tag_default = {
                   "effect",
                   tagSection,
                   valueReferences,
-                  import_compiler29.types.expressionStatement(
+                  import_compiler30.types.expressionStatement(
                     callRuntime(
                       "_on",
-                      import_compiler29.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                      import_compiler29.types.stringLiteral(getEventHandlerName(name2)),
+                      import_compiler30.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                      import_compiler30.types.stringLiteral(getEventHandlerName(name2)),
                       value
                     )
                   )
@@ -5569,11 +5835,11 @@ var native_tag_default = {
                   "render",
                   tagSection,
                   valueReferences,
-                  import_compiler29.types.expressionStatement(
+                  import_compiler30.types.expressionStatement(
                     callRuntime(
                       "_attr",
-                      import_compiler29.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                      import_compiler29.types.stringLiteral(name2),
+                      import_compiler30.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                      import_compiler30.types.stringLiteral(name2),
                       value
                     )
                   )
@@ -5589,7 +5855,7 @@ var native_tag_default = {
               "render",
               tagSection,
               tagExtra.referencedBindings,
-              import_compiler29.types.expressionStatement(
+              import_compiler30.types.expressionStatement(
                 callRuntime(
                   canHaveAttrContent ? "_attrs_partial_content" : "_attrs_partial",
                   scopeIdentifier,
@@ -5604,7 +5870,7 @@ var native_tag_default = {
               "render",
               tagSection,
               tagExtra.referencedBindings,
-              import_compiler29.types.expressionStatement(
+              import_compiler30.types.expressionStatement(
                 callRuntime(
                   canHaveAttrContent ? "_attrs_content" : "_attrs",
                   scopeIdentifier,
@@ -5618,7 +5884,7 @@ var native_tag_default = {
             "effect",
             tagSection,
             tagExtra.referencedBindings,
-            import_compiler29.types.expressionStatement(
+            import_compiler30.types.expressionStatement(
               callRuntime("_attrs_script", scopeIdentifier, visitAccessor)
             ),
             false
@@ -5630,7 +5896,7 @@ var native_tag_default = {
             "render",
             tagSection,
             contentAttrValue.extra?.referencedBindings,
-            import_compiler29.types.expressionStatement(
+            import_compiler30.types.expressionStatement(
               callRuntime(
                 "_attr_content",
                 scopeIdentifier,
@@ -5748,7 +6014,7 @@ function getUsedAttrs(tagName, tag) {
   for (let i = attributes.length; i--; ) {
     const attr = attributes[i];
     const { value } = attr;
-    if (import_compiler29.types.isMarkoSpreadAttribute(attr)) {
+    if (import_compiler30.types.isMarkoSpreadAttribute(attr)) {
       if (!spreadProps) {
         spreadProps = [];
         staticControllable = getRelatedControllable(tagName, seen);
@@ -5762,7 +6028,7 @@ function getUsedAttrs(tagName, tag) {
           staticControllable = void 0;
         }
       }
-      spreadProps.push(import_compiler29.types.spreadElement(value));
+      spreadProps.push(import_compiler30.types.spreadElement(value));
     } else if (!seen[attr.name] || !(attr.name === "content" && tag.body.body.length)) {
       seen[attr.name] = attr;
       if (spreadProps) {
@@ -5794,18 +6060,18 @@ function getUsedAttrs(tagName, tag) {
       for (const attr of staticControllable.attrs) {
         if (attr) {
           (skipProps ||= []).push(
-            toObjectProperty(attr.name, import_compiler29.types.numericLiteral(1))
+            toObjectProperty(attr.name, import_compiler30.types.numericLiteral(1))
           );
         }
       }
     }
     for (const { name: name2 } of staticAttrs) {
-      (skipProps ||= []).push(toObjectProperty(name2, import_compiler29.types.numericLiteral(1)));
+      (skipProps ||= []).push(toObjectProperty(name2, import_compiler30.types.numericLiteral(1)));
     }
     spreadExpression = propsToExpression(spreadProps);
   }
   if (skipProps) {
-    skipExpression = import_compiler29.types.objectExpression(skipProps);
+    skipExpression = import_compiler30.types.objectExpression(skipProps);
   }
   return {
     staticAttrs,
@@ -5892,14 +6158,14 @@ function trackDelimitedAttrObjectProperties(obj, meta) {
     (meta.staticItems ||= []).push(staticProps);
   }
   if (dynamicProps) {
-    (meta.dynamicItems ||= []).push(import_compiler29.types.objectExpression(dynamicProps));
+    (meta.dynamicItems ||= []).push(import_compiler30.types.objectExpression(dynamicProps));
   }
 }
 function isNativeTagChangeHandler(propName) {
   return /^(?:value|checked(?:Value)?|open)Change$/.test(propName);
 }
-function buildUndefined() {
-  return import_compiler29.types.unaryExpression("void", import_compiler29.types.numericLiteral(0));
+function buildUndefined2() {
+  return import_compiler30.types.unaryExpression("void", import_compiler30.types.numericLiteral(0));
 }
 
 // src/translator/util/is-only-child-in-parent.ts
@@ -6035,39 +6301,45 @@ var for_default = {
         const forTagArgs = getBaseArgsInForTag(forType, forAttrs);
         const forTagHTMLRuntime = branchSerializeReason ? forTypeToHTMLResumeRuntime(forType) : forTypeToRuntime(forType);
         forTagArgs.push(
-          import_compiler31.types.arrowFunctionExpression(params, import_compiler31.types.blockStatement(bodyStatements))
+          import_compiler32.types.arrowFunctionExpression(params, import_compiler32.types.blockStatement(bodyStatements))
         );
         if (branchSerializeReason) {
           const skipParentEnd = onlyChildParentTagName && markerSerializeReason;
           const statefulSerializeArg = getSerializeGuard(
+            tagSection,
             getSerializeReason(tagSection, kStatefulReason),
             !(skipParentEnd || singleNodeOptimization)
           );
           const markerSerializeArg = getSerializeGuard(
+            tagSection,
             markerSerializeReason,
             !statefulSerializeArg
           );
           forTagArgs.push(
-            forAttrs.by || import_compiler31.types.numericLiteral(0),
+            forAttrs.by || import_compiler32.types.numericLiteral(0),
             getScopeIdIdentifier(tagSection),
             getScopeAccessorLiteral(nodeBinding),
-            getSerializeGuard(branchSerializeReason, !markerSerializeArg),
+            getSerializeGuard(
+              tagSection,
+              branchSerializeReason,
+              !markerSerializeArg
+            ),
             markerSerializeArg,
             statefulSerializeArg
           );
           if (skipParentEnd) {
             getParentTag(tag).node.extra[kSkipEndTag] = true;
-            forTagArgs.push(import_compiler31.types.stringLiteral(`</${onlyChildParentTagName}>`));
+            forTagArgs.push(import_compiler32.types.stringLiteral(`</${onlyChildParentTagName}>`));
           }
           if (singleNodeOptimization) {
             if (!skipParentEnd) {
-              forTagArgs.push(import_compiler31.types.numericLiteral(0));
+              forTagArgs.push(import_compiler32.types.numericLiteral(0));
             }
-            forTagArgs.push(import_compiler31.types.numericLiteral(1));
+            forTagArgs.push(import_compiler32.types.numericLiteral(1));
           }
         }
         statements.push(
-          import_compiler31.types.expressionStatement(callRuntime(forTagHTMLRuntime, ...forTagArgs))
+          import_compiler32.types.expressionStatement(callRuntime(forTagHTMLRuntime, ...forTagArgs))
         );
         for (const replacement of tag.replaceWithMultiple(statements)) {
           replacement.skip();
@@ -6112,7 +6384,7 @@ var for_default = {
           return callRuntime(
             forTypeToDOMRuntime(forType),
             getScopeAccessorLiteral(nodeRef),
-            import_compiler31.types.identifier(bodySection.name)
+            import_compiler32.types.identifier(bodySection.name)
           );
         };
         const forAttrs = getKnownAttrValues(node);
@@ -6124,7 +6396,7 @@ var for_default = {
           tagSection,
           referencedBindings,
           signal,
-          import_compiler31.types.arrayExpression(loopArgs)
+          import_compiler32.types.arrayExpression(loopArgs)
         );
         tag.remove();
       }
@@ -6202,11 +6474,11 @@ var for_default = {
   ]
 };
 function buildForRuntimeCall(type, attrs, params, statements) {
-  return import_compiler31.types.expressionStatement(
+  return import_compiler32.types.expressionStatement(
     callRuntime(
       forTypeToRuntime(type),
       ...getBaseArgsInForTag(type, attrs),
-      import_compiler31.types.arrowFunctionExpression(params, import_compiler31.types.blockStatement(statements))
+      import_compiler32.types.arrowFunctionExpression(params, import_compiler32.types.blockStatement(statements))
     )
   );
 }
@@ -6268,14 +6540,14 @@ function getBaseArgsInForTag(type, attrs) {
     case "to":
       return [
         attrs.to,
-        attrs.from || import_compiler31.types.numericLiteral(0),
-        attrs.step || import_compiler31.types.numericLiteral(1)
+        attrs.from || import_compiler32.types.numericLiteral(0),
+        attrs.step || import_compiler32.types.numericLiteral(1)
       ];
     case "until":
       return [
         attrs.until,
-        attrs.from || import_compiler31.types.numericLiteral(0),
-        attrs.step || import_compiler31.types.numericLiteral(1)
+        attrs.from || import_compiler32.types.numericLiteral(0),
+        attrs.step || import_compiler32.types.numericLiteral(1)
       ];
   }
 }
@@ -6293,8 +6565,8 @@ function translateAttrs(tag, templateExports, statements = [], contentKey = "con
         seen.add(attrTagMeta.name);
         if (attrTagMeta.dynamic) {
           statements.push(
-            import_compiler32.types.variableDeclaration("let", [
-              import_compiler32.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta))
+            import_compiler33.types.variableDeclaration("let", [
+              import_compiler33.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta))
             ])
           );
           properties.push(
@@ -6375,8 +6647,8 @@ function translateAttrs(tag, templateExports, statements = [], contentKey = "con
   if (!seen.has(contentKey) && usesExport(templateExports, contentKey)) {
     const contentExpression = buildContent(tag.get("body"));
     if (contentExpression) {
-      const contentProp = import_compiler32.types.objectProperty(
-        import_compiler32.types.identifier(contentKey),
+      const contentProp = import_compiler33.types.objectProperty(
+        import_compiler33.types.identifier(contentKey),
         contentExpression
       );
       seen.add(contentKey);
@@ -6388,8 +6660,8 @@ function translateAttrs(tag, templateExports, statements = [], contentKey = "con
   for (let i = attributes.length; i--; ) {
     const attr = attributes[i];
     const { value } = attr;
-    if (import_compiler32.types.isMarkoSpreadAttribute(attr)) {
-      properties.push(import_compiler32.types.spreadElement(value));
+    if (import_compiler33.types.isMarkoSpreadAttribute(attr)) {
+      properties.push(import_compiler33.types.spreadElement(value));
     } else if (!seen.has(attr.name) && usesExport(templateExports, attr.name)) {
       seen.add(attr.name);
       properties.push(toObjectProperty(attr.name, value));
@@ -6419,8 +6691,8 @@ function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements
         );
         if (attrTagMeta.repeated) {
           statements.push(
-            import_compiler32.types.expressionStatement(
-              import_compiler32.types.assignmentExpression(
+            import_compiler33.types.expressionStatement(
+              import_compiler33.types.assignmentExpression(
                 "=",
                 getAttrTagIdentifier(attrTagMeta),
                 callRuntime(
@@ -6433,8 +6705,8 @@ function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements
           );
         } else {
           statements.push(
-            import_compiler32.types.expressionStatement(
-              import_compiler32.types.assignmentExpression(
+            import_compiler33.types.expressionStatement(
+              import_compiler33.types.assignmentExpression(
                 "=",
                 getAttrTagIdentifier(attrTagMeta),
                 callRuntime(
@@ -6473,7 +6745,7 @@ function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements
   return index;
 }
 function propsToExpression(props) {
-  return props.length === 1 && import_compiler32.types.isSpreadElement(props[0]) ? props[0].argument : import_compiler32.types.objectExpression(props);
+  return props.length === 1 && import_compiler33.types.isSpreadElement(props[0]) ? props[0].argument : import_compiler33.types.objectExpression(props);
 }
 function translateForAttrTag(attrTags2, index, attrTagLookup, statements, templateExports, contentKey) {
   const forTag = attrTags2[index];
@@ -6498,9 +6770,9 @@ function translateForAttrTag(attrTags2, index, attrTagLookup, statements, templa
 function translateIfAttrTag(attrTags2, index, attrTagLookup, statements, templateExports, contentKey) {
   const ifTag = attrTags2[index];
   const consequentStatements = [];
-  let ifStatement = import_compiler32.types.ifStatement(
+  let ifStatement = import_compiler33.types.ifStatement(
     getConditionTestValue(ifTag),
-    import_compiler32.types.blockStatement(consequentStatements)
+    import_compiler33.types.blockStatement(consequentStatements)
   );
   statements.push(ifStatement);
   addAllAttrTagsAsDynamic(
@@ -6527,14 +6799,14 @@ function translateIfAttrTag(attrTags2, index, attrTagLookup, statements, templat
             contentKey
           );
           if (testValue) {
-            ifStatement.alternate = ifStatement = import_compiler32.types.ifStatement(
+            ifStatement.alternate = ifStatement = import_compiler33.types.ifStatement(
               testValue,
-              import_compiler32.types.blockStatement(alternateStatements)
+              import_compiler33.types.blockStatement(alternateStatements)
             );
             nextIndex++;
             continue;
           } else {
-            ifStatement.alternate = import_compiler32.types.blockStatement(alternateStatements);
+            ifStatement.alternate = import_compiler33.types.blockStatement(alternateStatements);
             break;
           }
         }
@@ -6600,20 +6872,22 @@ function buildContent(body) {
       }
       if (dynamicSerializeReason) {
         body.node.body.unshift(
-          import_compiler32.types.variableDeclaration("const", [
-            import_compiler32.types.variableDeclarator(
-              import_compiler32.types.identifier(getSharedUid("serialize", bodySection)),
-              callRuntime("_get_serialize_reason")
+          import_compiler33.types.variableDeclaration("const", [
+            import_compiler33.types.variableDeclarator(
+              import_compiler33.types.identifier(
+                getSharedUid(`scope${bodySection.id}_reason`, bodySection)
+              ),
+              callRuntime("_scope_reason")
             )
           ])
         );
       }
       return callRuntime(
         serialized ? "_content_resume" : "_content",
-        import_compiler32.types.stringLiteral(getResumeRegisterId(bodySection, "content")),
-        import_compiler32.types.arrowFunctionExpression(
+        import_compiler33.types.stringLiteral(getResumeRegisterId(bodySection, "content")),
+        import_compiler33.types.arrowFunctionExpression(
           body.node.params,
-          import_compiler32.types.blockStatement(body.node.body)
+          import_compiler33.types.blockStatement(body.node.body)
         ),
         serialized ? getScopeIdIdentifier(
           getSection(
@@ -6624,17 +6898,17 @@ function buildContent(body) {
         ) : void 0
       );
     } else {
-      return import_compiler32.types.callExpression(
-        import_compiler32.types.identifier(bodySection.name),
+      return import_compiler33.types.callExpression(
+        import_compiler33.types.identifier(bodySection.name),
         bodySection.referencedLocalClosures ? [
           scopeIdentifier,
-          import_compiler32.types.objectExpression(
+          import_compiler33.types.objectExpression(
             toArray(bodySection.referencedLocalClosures, (ref) => {
               const accessor = getScopeAccessor(ref);
               const isShorthand = accessor === ref.name;
-              return import_compiler32.types.objectProperty(
+              return import_compiler33.types.objectProperty(
                 toPropertyName(accessor),
-                import_compiler32.types.identifier(ref.name),
+                import_compiler33.types.identifier(ref.name),
                 false,
                 isShorthand
               );
@@ -6719,8 +6993,8 @@ function knownTagTranslateHTML(tag, tagIdentifier, contentSection, propTree) {
   if (childScopeSerializeReason) {
     const peekScopeId = generateUidIdentifier(childScopeBinding?.name);
     tag.insertBefore(
-      import_compiler33.types.variableDeclaration("const", [
-        import_compiler33.types.variableDeclarator(peekScopeId, callRuntime("_peek_scope_id"))
+      import_compiler34.types.variableDeclaration("const", [
+        import_compiler34.types.variableDeclarator(peekScopeId, callRuntime("_peek_scope_id"))
       ])
     );
     setBindingSerializedValue(
@@ -6730,13 +7004,13 @@ function knownTagTranslateHTML(tag, tagIdentifier, contentSection, propTree) {
     );
     if (tagVar) {
       statements.push(
-        import_compiler33.types.expressionStatement(
+        import_compiler34.types.expressionStatement(
           callRuntime(
             "_var",
             getScopeIdIdentifier(section),
             getScopeAccessorLiteral(tag.node.extra[kChildOffsetScopeBinding]),
             peekScopeId,
-            import_compiler33.types.stringLiteral(
+            import_compiler34.types.stringLiteral(
               getResumeRegisterId(
                 section,
                 node.var.extra?.binding,
@@ -6754,7 +7028,7 @@ function knownTagTranslateHTML(tag, tagIdentifier, contentSection, propTree) {
     if (contentSection.paramReasonGroups.length === 1) {
       const [group] = contentSection.paramReasonGroups;
       const reason = getSerializeReason(section, childScopeBinding, group.id);
-      childSerializeReasonExpr = reason && getSerializeGuard(reason, false);
+      childSerializeReasonExpr = reason && getSerializeGuard(section, reason, false);
     } else {
       const props = [];
       let hasDynamicReasons = false;
@@ -6765,12 +7039,12 @@ function knownTagTranslateHTML(tag, tagIdentifier, contentSection, propTree) {
         if (reason) {
           hasDynamicReasons ||= reason !== true && !reason.state;
           props.push(
-            import_compiler33.types.objectProperty(
+            import_compiler34.types.objectProperty(
               withLeadingComment(
-                import_compiler33.types.numericLiteral(i),
+                import_compiler34.types.numericLiteral(i),
                 getDebugNames(group.reason)
               ),
-              getSerializeGuard(reason, false)
+              getSerializeGuard(section, reason, false)
             )
           );
         } else {
@@ -6778,12 +7052,12 @@ function knownTagTranslateHTML(tag, tagIdentifier, contentSection, propTree) {
         }
       }
       if (props.length) {
-        childSerializeReasonExpr = hasDynamicReasons || hasSkippedReasons ? import_compiler33.types.objectExpression(props) : import_compiler33.types.numericLiteral(1);
+        childSerializeReasonExpr = hasDynamicReasons || hasSkippedReasons ? import_compiler34.types.objectExpression(props) : import_compiler34.types.numericLiteral(1);
       }
     }
     if (childSerializeReasonExpr) {
       tag.insertBefore(
-        import_compiler33.types.expressionStatement(
+        import_compiler34.types.expressionStatement(
           callRuntime("_set_serialize_reason", childSerializeReasonExpr)
         )
       );
@@ -6806,8 +7080,8 @@ function knownTagTranslateHTML(tag, tagIdentifier, contentSection, propTree) {
       const contentExpression = contentProp.value;
       contentProp.value = contentId = generateUidIdentifier("content");
       const [contentPath] = tag.insertBefore(
-        import_compiler33.types.variableDeclaration("const", [
-          import_compiler33.types.variableDeclarator(
+        import_compiler34.types.variableDeclaration("const", [
+          import_compiler34.types.variableDeclarator(
             contentId,
             // TODO: only register if needed (child template analysis)
             contentExpression
@@ -6821,13 +7095,13 @@ function knownTagTranslateHTML(tag, tagIdentifier, contentSection, propTree) {
       ...getArgs()
     );
     if (tagVar) {
-      translateVar(tag, import_compiler33.types.unaryExpression("void", import_compiler33.types.numericLiteral(0)), "let");
-      renderTagExpr = import_compiler33.types.assignmentExpression("=", tagVar, renderTagExpr);
+      translateVar(tag, import_compiler34.types.unaryExpression("void", import_compiler34.types.numericLiteral(0)), "let");
+      renderTagExpr = import_compiler34.types.assignmentExpression("=", tagVar, renderTagExpr);
     }
     statements.push(
-      import_compiler33.types.ifStatement(
+      import_compiler34.types.ifStatement(
         tagIdentifier,
-        import_compiler33.types.expressionStatement(renderTagExpr),
+        import_compiler34.types.expressionStatement(renderTagExpr),
         contentId && callStatement(contentId)
       )
     );
@@ -6858,15 +7132,15 @@ function knownTagTranslateDOM(tag, propTree, getBindingIdentifier, callSetup) {
         value
       ];
       if (!isOptimize()) {
-        changeArgs.push(import_compiler33.types.stringLiteral(varBinding.name));
+        changeArgs.push(import_compiler34.types.stringLiteral(varBinding.name));
       }
-      return import_compiler33.types.callExpression(importRuntime("_var_change"), changeArgs);
+      return import_compiler34.types.callExpression(importRuntime("_var_change"), changeArgs);
     };
     addStatement(
       "render",
       tagSection,
       void 0,
-      import_compiler33.types.expressionStatement(
+      import_compiler34.types.expressionStatement(
         callRuntime(
           "_var",
           scopeIdentifier,
@@ -6911,7 +7185,7 @@ function analyzeParams(rootTagExtra, section, tag, propTree, rootAttrExprs) {
     dropReferences(getAllTagReferenceNodes(tag.node));
     return inputExpr;
   }
-  if (!propTree.props || tag.node.arguments?.some((node) => import_compiler33.types.isSpreadElement(node))) {
+  if (!propTree.props || tag.node.arguments?.some((node) => import_compiler34.types.isSpreadElement(node))) {
     const extra = inputExpr.value = mergeReferences(
       section,
       tag.node,
@@ -7061,7 +7335,7 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
   let spreadReferenceNodes;
   for (let i = attributes.length; i--; ) {
     const attr = attributes[i];
-    if (import_compiler33.types.isMarkoAttribute(attr)) {
+    if (import_compiler34.types.isMarkoAttribute(attr)) {
       const templateExportAttr = propTree.props[attr.name];
       if (!templateExportAttr || seen.has(attr.name)) {
         dropReferences(attr.value);
@@ -7075,7 +7349,7 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
     }
     if (spreadReferenceNodes) {
       spreadReferenceNodes.push(attr.value);
-    } else if (import_compiler33.types.isMarkoSpreadAttribute(attr)) {
+    } else if (import_compiler34.types.isMarkoSpreadAttribute(attr)) {
       spreadReferenceNodes = [attr.value];
     } else {
       const attrValueExtra = attr.value.extra ??= {};
@@ -7107,7 +7381,7 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
   return inputExpr;
 }
 function writeParamsToSignals(tag, propTree, importAlias, info) {
-  if (!propTree.props || tag.node.arguments?.some((node) => import_compiler33.types.isSpreadElement(node))) {
+  if (!propTree.props || tag.node.arguments?.some((node) => import_compiler34.types.isSpreadElement(node))) {
     const referencedBindings = tag.node.extra?.referencedBindings;
     const tagInputIdentifier = info.getBindingIdentifier(
       propTree.binding,
@@ -7135,8 +7409,8 @@ function writeParamsToSignals(tag, propTree, importAlias, info) {
       "render",
       info.tagSection,
       referencedBindings,
-      import_compiler33.types.expressionStatement(
-        import_compiler33.types.callExpression(tagInputIdentifier, [import_compiler33.types.arrayExpression(renderArgs)])
+      import_compiler34.types.expressionStatement(
+        import_compiler34.types.callExpression(tagInputIdentifier, [import_compiler34.types.arrayExpression(renderArgs)])
       )
     );
     return;
@@ -7155,8 +7429,8 @@ function writeParamsToSignals(tag, propTree, importAlias, info) {
           info.tagSection,
           arg.extra?.referencedBindings,
           // TODO: pretty sure content needs to have the reference group of it's param defaults.
-          import_compiler33.types.expressionStatement(
-            import_compiler33.types.callExpression(argExportIdentifier, [
+          import_compiler34.types.expressionStatement(
+            import_compiler34.types.callExpression(argExportIdentifier, [
               createScopeReadExpression(
                 info.tagSection,
                 info.childScopeBinding
@@ -7216,7 +7490,7 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
         } else {
           attrTagCallsForTag.set(
             attrTagName,
-            translatedProps = import_compiler33.types.parenthesizedExpression(
+            translatedProps = import_compiler34.types.parenthesizedExpression(
               callRuntime("attrTag", translatedProps)
             )
           );
@@ -7229,8 +7503,8 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
       "render",
       info.tagSection,
       referencedBindings,
-      import_compiler33.types.expressionStatement(
-        import_compiler33.types.callExpression(tagInputIdentifier, [
+      import_compiler34.types.expressionStatement(
+        import_compiler34.types.callExpression(tagInputIdentifier, [
           createScopeReadExpression(info.tagSection, info.childScopeBinding),
           translatedProps
         ])
@@ -7303,17 +7577,17 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
           childAttrExports.binding,
           `${importAlias}_${attrTagMeta.name}`
         );
-        decls.push(import_compiler33.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta)));
+        decls.push(import_compiler34.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta)));
         addStatement("render", info.tagSection, referencedBindings, [
-          import_compiler33.types.variableDeclaration("let", decls),
+          import_compiler34.types.variableDeclaration("let", decls),
           ...statements
         ]);
         addStatement(
           "render",
           info.tagSection,
           referencedBindings,
-          import_compiler33.types.expressionStatement(
-            import_compiler33.types.callExpression(attrExportIdentifier, [
+          import_compiler34.types.expressionStatement(
+            import_compiler34.types.callExpression(attrExportIdentifier, [
               createScopeReadExpression(
                 info.tagSection,
                 info.childScopeBinding
@@ -7338,10 +7612,10 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
         info.tagSection,
         void 0,
         // TODO: pretty sure content needs to have the reference group of it's param defaults.
-        import_compiler33.types.expressionStatement(
-          import_compiler33.types.callExpression(contentExportIdentifier, [
+        import_compiler34.types.expressionStatement(
+          import_compiler34.types.callExpression(contentExportIdentifier, [
             createScopeReadExpression(info.tagSection, info.childScopeBinding),
-            import_compiler33.types.callExpression(import_compiler33.types.identifier(bodySection.name), [scopeIdentifier])
+            import_compiler34.types.callExpression(import_compiler34.types.identifier(bodySection.name), [scopeIdentifier])
           ])
         )
       );
@@ -7352,7 +7626,7 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
   let spreadProps;
   for (let i = attributes.length; i--; ) {
     const attr = attributes[i];
-    if (import_compiler33.types.isMarkoAttribute(attr)) {
+    if (import_compiler34.types.isMarkoAttribute(attr)) {
       const childAttrExports = propTree.props[attr.name];
       if (!childAttrExports || seen.has(attr.name)) continue;
       seen.add(attr.name);
@@ -7362,9 +7636,9 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
       }
       staticAttrs.push(attr);
     } else if (spreadProps) {
-      spreadProps.push(import_compiler33.types.spreadElement(attr.value));
+      spreadProps.push(import_compiler34.types.spreadElement(attr.value));
     } else {
-      spreadProps = [import_compiler33.types.spreadElement(attr.value)];
+      spreadProps = [import_compiler34.types.spreadElement(attr.value)];
     }
   }
   for (const attr of staticAttrs.reverse()) {
@@ -7377,8 +7651,8 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
       "render",
       info.tagSection,
       attr.value.extra?.referencedBindings,
-      import_compiler33.types.expressionStatement(
-        import_compiler33.types.callExpression(attrExportIdentifier, [
+      import_compiler34.types.expressionStatement(
+        import_compiler34.types.callExpression(attrExportIdentifier, [
           createScopeReadExpression(info.tagSection, info.childScopeBinding),
           attr.value
         ])
@@ -7389,14 +7663,14 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
   for (const name2 of seen) missing.delete(name2);
   if (missing.size) {
     const referencedBindings = tag.node.extra?.referencedBindings;
-    let getMissingPropValue = buildUndefined2;
+    let getMissingPropValue = buildUndefined3;
     if (spreadProps) {
       const spreadId = generateUidIdentifier(`${importAlias}_spread`);
       spreadProps.reverse();
       getMissingPropValue = (name2) => toMemberExpression(spreadId, name2);
       addStatement("render", info.tagSection, referencedBindings, [
-        import_compiler33.types.variableDeclaration("const", [
-          import_compiler33.types.variableDeclarator(spreadId, propsToExpression(spreadProps))
+        import_compiler34.types.variableDeclaration("const", [
+          import_compiler34.types.variableDeclarator(spreadId, propsToExpression(spreadProps))
         ])
       ]);
     }
@@ -7410,8 +7684,8 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
         "render",
         info.tagSection,
         referencedBindings,
-        import_compiler33.types.expressionStatement(
-          import_compiler33.types.callExpression(attrExportIdentifier, [
+        import_compiler34.types.expressionStatement(
+          import_compiler34.types.callExpression(attrExportIdentifier, [
             createScopeReadExpression(info.tagSection, info.childScopeBinding),
             getMissingPropValue(name2)
           ])
@@ -7447,21 +7721,13 @@ function mapParamReasonToExpr(exprs, reason) {
   }
 }
 function callStatement(id, ...args) {
-  return import_compiler33.types.expressionStatement(callExpression(id, ...args));
+  return import_compiler34.types.expressionStatement(callExpression(id, ...args));
 }
 function callExpression(id, ...args) {
-  return import_compiler33.types.callExpression(id, args.filter(Boolean));
-}
-function buildUndefined2() {
-  return import_compiler33.types.unaryExpression("void", import_compiler33.types.numericLiteral(0));
+  return import_compiler34.types.callExpression(id, args.filter(Boolean));
 }
-
-// src/translator/util/with-previous-location.ts
-function withPreviousLocation(newNode, originalNode) {
-  newNode.start = originalNode.start;
-  newNode.loc = originalNode.loc;
-  newNode.end = originalNode.end;
-  return newNode;
+function buildUndefined3() {
+  return import_compiler34.types.unaryExpression("void", import_compiler34.types.numericLiteral(0));
 }
 
 // src/translator/util/references.ts
@@ -7574,7 +7840,7 @@ function trackParamsReferences(body, type, upstreamAlias) {
           void 0,
           i > 0 ? addNumericPropertiesUntil(void 0, i - 1) : void 0
         );
-      } else if (import_compiler34.types.isLVal(param)) {
+      } else if (import_compiler35.types.isLVal(param)) {
         createBindingsAndTrackReferences(
           param,
           type,
@@ -7745,7 +8011,7 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAl
           if (hasRest) {
             excludeProperties = propsUtil.add(excludeProperties, key);
           }
-          if (import_compiler34.types.isLVal(prop.value)) {
+          if (import_compiler35.types.isLVal(prop.value)) {
             createBindingsAndTrackReferences(
               prop.value,
               type,
@@ -7785,7 +8051,7 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAl
               property,
               excludeProperties
             );
-          } else if (import_compiler34.types.isLVal(element)) {
+          } else if (import_compiler35.types.isLVal(element)) {
             createBindingsAndTrackReferences(
               element,
               type,
@@ -7800,23 +8066,6 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAl
       }
       break;
     }
-    case "AssignmentPattern":
-      createBindingsAndTrackReferences(
-        lVal.left,
-        type,
-        scope,
-        section,
-        upstreamAlias,
-        property,
-        void 0
-      );
-      if (lVal.left.extra?.binding) {
-        setBindingDownstream(
-          lVal.left.extra.binding,
-          lVal.right.extra ??= {}
-        );
-      }
-      break;
   }
 }
 function trackReference(referencePath, binding) {
@@ -7825,7 +8074,7 @@ function trackReference(referencePath, binding) {
   let propPath = binding.name;
   while (true) {
     const { parent } = root;
-    if (!import_compiler34.types.isMemberExpression(parent)) break;
+    if (!import_compiler35.types.isMemberExpression(parent)) break;
     const prop = getMemberExpressionPropString(parent);
     if (prop === void 0) break;
     if (reference.upstreamAlias && reference.excludeProperties !== void 0 && !propsUtil.has(reference.excludeProperties, prop)) {
@@ -8038,6 +8287,8 @@ function finalizeReferences() {
         }
       }
     }
+  });
+  forEachSection((section) => {
     forEach(section.referencedLocalClosures, (closure) => {
       addSerializeReason(
         section,
@@ -8046,41 +8297,39 @@ function finalizeReferences() {
       );
     });
     forEach(section.referencedClosures, (closure) => {
-      if (!isForceSerialized(closure.section, closure)) {
-        const sourceSection = closure.section;
-        let serializeReason;
-        let currentSection = section;
-        while (currentSection !== sourceSection) {
-          const upstreamReason = currentSection.downstreamBinding ? getSectionRegisterReasons(currentSection) || void 0 : !currentSection.upstreamExpression || getSerializeSourcesForExpr(currentSection.upstreamExpression);
-          if (upstreamReason === true) {
-            serializeReason = true;
-            break;
-          }
-          serializeReason = mergeSerializeReasons(
-            serializeReason,
-            upstreamReason
-          );
-          currentSection = currentSection.parent;
+      const sourceSection = closure.section;
+      let currentSection = section;
+      let branchesReason;
+      while (currentSection !== sourceSection) {
+        const upstreamReason = currentSection.downstreamBinding ? getSectionRegisterReasons(currentSection) || void 0 : !currentSection.upstreamExpression || getSerializeSourcesForExpr(currentSection.upstreamExpression);
+        if (upstreamReason === true) {
+          branchesReason = true;
+          break;
         }
-        addSerializeReason(closure.section, serializeReason, closure);
+        branchesReason = mergeSerializeReasons(branchesReason, upstreamReason);
+        currentSection = currentSection.parent;
       }
+      addSerializeReason(sourceSection, branchesReason, closure);
       addSerializeReason(
-        closure.section,
-        getSerializeReason(closure.section, closure)
+        sourceSection,
+        getSerializeReason(sourceSection, closure)
       );
-      if (closure.sources && isDynamicClosure(section, closure)) {
-        addSerializeReason(
-          closure.section,
-          closure.sources,
-          closure,
-          getAccessorPrefix().ClosureScopes
-        );
-        addSerializeReason(
-          section,
-          closure.sources,
-          closure,
-          getAccessorPrefix().ClosureSignalIndex
-        );
+      if (isDynamicClosure(section, closure)) {
+        addOwnerSerializeReason(section, sourceSection, branchesReason);
+        if (closure.sources) {
+          addSerializeReason(
+            sourceSection,
+            closure.sources,
+            closure,
+            getAccessorPrefix().ClosureScopes
+          );
+          addSerializeReason(
+            section,
+            closure.sources,
+            closure,
+            getAccessorPrefix().ClosureSignalIndex
+          );
+        }
       }
     });
   });
@@ -8356,9 +8605,9 @@ function getAllTagReferenceNodes(tag, referenceNodes = []) {
 function getScopeAccessorLiteral(binding, includeId) {
   const canonicalBinding = getCanonicalBinding(binding);
   if (isOptimize()) {
-    return import_compiler34.types.numericLiteral(canonicalBinding.id);
+    return import_compiler35.types.numericLiteral(canonicalBinding.id);
   }
-  return import_compiler34.types.stringLiteral(
+  return import_compiler35.types.stringLiteral(
     canonicalBinding.name + (includeId || canonicalBinding.type === 0 /* dom */ ? `/${canonicalBinding.id}` : "")
   );
 }
@@ -8406,7 +8655,7 @@ function getSectionInstancesAccessor(section) {
 }
 function getSectionInstancesAccessorLiteral(section) {
   const accessor = getSectionInstancesAccessor(section);
-  return accessor ? typeof accessor === "number" ? import_compiler34.types.numericLiteral(accessor) : import_compiler34.types.stringLiteral(accessor) : void 0;
+  return accessor ? typeof accessor === "number" ? import_compiler35.types.numericLiteral(accessor) : import_compiler35.types.stringLiteral(accessor) : void 0;
 }
 function getReadReplacement(node) {
   const { extra } = node;
@@ -8424,18 +8673,18 @@ function getReadReplacement(node) {
   if (binding) {
     if (node.type === "Identifier") {
       if (binding.type === 6 /* hoist */) {
-        replacement = node.extra?.[kIsInvoked] ? import_compiler34.types.callExpression(getHoistFunctionIdentifier(binding), [
+        replacement = node.extra?.[kIsInvoked] ? import_compiler35.types.callExpression(getHoistFunctionIdentifier(binding), [
           getScopeExpression(node.extra.section, binding.section)
-        ]) : import_compiler34.types.identifier(binding.name);
+        ]) : import_compiler35.types.identifier(binding.name);
       } else if (binding.name !== node.name) {
         node.name = binding.name;
       }
     } else {
-      replacement = import_compiler34.types.identifier(binding.name);
+      replacement = import_compiler35.types.identifier(binding.name);
     }
   } else if (read) {
     replacement = toMemberExpression(
-      import_compiler34.types.identifier(read.binding.name),
+      import_compiler35.types.identifier(read.binding.name),
       Array.isArray(read.props) ? read.props[0] : read.props
     );
     if (Array.isArray(read.props)) {
@@ -8648,7 +8897,7 @@ var await_default = {
         "The [`<await>` tag](https://markojs.com/docs/reference/core-tag#await) requires a [`value=` attribute](https://markojs.com/docs/reference/language#shorthand-value)."
       );
     }
-    if (node.attributes.length > 1 || !import_compiler35.types.isMarkoAttribute(valueAttr) || valueAttr.name !== "value") {
+    if (node.attributes.length > 1 || !import_compiler36.types.isMarkoAttribute(valueAttr) || valueAttr.name !== "value") {
       throw tag.get("name").buildCodeFrameError(
         "The [`<await>` tag](https://markojs.com/docs/reference/core-tag#await) only supports the [`value=` attribute](https://markojs.com/docs/reference/language#shorthand-value)."
       );
@@ -8658,7 +8907,7 @@ var await_default = {
         "The [`<await>` tag](https://markojs.com/docs/reference/core-tag#await) requires [content](https://markojs.com/docs/reference/language#tag-content)."
       );
     }
-    if (node.body.params.length && (node.body.params.length > 1 || import_compiler35.types.isSpreadElement(node.body.params[0]))) {
+    if (node.body.params.length && (node.body.params.length > 1 || import_compiler36.types.isSpreadElement(node.body.params[0]))) {
       throw tag.get("name").buildCodeFrameError(
         "The [`<await>` tag](https://markojs.com/docs/reference/core-tag#await) only supports a single parameter."
       );
@@ -8695,17 +8944,17 @@ var await_default = {
         flushInto(tag);
         writeHTMLResumeStatements(tagBody);
         tag.replaceWith(
-          import_compiler35.types.expressionStatement(
+          import_compiler36.types.expressionStatement(
             callRuntime(
               "_await",
               getScopeIdIdentifier(section),
               getScopeAccessorLiteral(nodeRef),
               valueAttr.value,
-              import_compiler35.types.arrowFunctionExpression(
+              import_compiler36.types.arrowFunctionExpression(
                 node.body.params,
                 toFirstExpressionOrBlock(node.body.body)
               ),
-              getSerializeGuard(bodySection?.serializeReason, true)
+              getSerializeGuard(section, bodySection?.serializeReason, true)
             )
           )
         )[0].skip();
@@ -8735,7 +8984,7 @@ var await_default = {
           return callRuntime(
             "_await",
             getScopeAccessorLiteral(nodeRef),
-            import_compiler35.types.identifier(bodySection.name)
+            import_compiler36.types.identifier(bodySection.name)
           );
         };
         addValue(
@@ -8759,7 +9008,7 @@ var await_default = {
 };
 
 // src/translator/core/client.ts
-var import_compiler36 = require("@marko/compiler");
+var import_compiler37 = require("@marko/compiler");
 var import_babel_utils27 = require("@marko/compiler/babel-utils");
 var client_default = {
   parse(tag) {
@@ -8771,10 +9020,10 @@ var client_default = {
     const code = rawValue.replace(/^client\s*/, "");
     const start = node.start + (rawValue.length - code.length);
     let body = (0, import_babel_utils27.parseStatements)(file, code, start, start + code.length);
-    if (body.length === 1 && import_compiler36.types.isBlockStatement(body[0])) {
+    if (body.length === 1 && import_compiler37.types.isBlockStatement(body[0])) {
       body = body[0].body;
     }
-    tag.replaceWith(import_compiler36.types.markoScriptlet(body, true, "client"));
+    tag.replaceWith(import_compiler37.types.markoScriptlet(body, true, "client"));
   },
   parseOptions: {
     statement: true,
@@ -8790,7 +9039,7 @@ var client_default = {
 };
 
 // src/translator/core/const.ts
-var import_compiler37 = require("@marko/compiler");
+var import_compiler38 = require("@marko/compiler");
 var import_babel_utils28 = require("@marko/compiler/babel-utils");
 var const_default = {
   analyze(tag) {
@@ -8809,13 +9058,13 @@ var const_default = {
         "The [`<const>` tag](https://markojs.com/docs/reference/core-tag#const) requires a [`value=` attribute](https://markojs.com/docs/reference/language#shorthand-value)."
       );
     }
-    if (node.attributes.length > 1 || !import_compiler37.types.isMarkoAttribute(valueAttr) || !valueAttr.default && valueAttr.name !== "value") {
+    if (node.attributes.length > 1 || !import_compiler38.types.isMarkoAttribute(valueAttr) || !valueAttr.default && valueAttr.name !== "value") {
       throw tag.get("name").buildCodeFrameError(
         "The [`<const>` tag](https://markojs.com/docs/reference/core-tag#const) only supports the [`value=` attribute](https://markojs.com/docs/reference/language#shorthand-value)."
       );
     }
     const valueExtra = evaluate(valueAttr.value);
-    const upstreamAlias = import_compiler37.types.isIdentifier(valueAttr.value) ? tag.scope.getBinding(valueAttr.value.name)?.identifier.extra?.binding : void 0;
+    const upstreamAlias = import_compiler38.types.isIdentifier(valueAttr.value) ? tag.scope.getBinding(valueAttr.value.name)?.identifier.extra?.binding : void 0;
     if (upstreamAlias) {
       valueExtra.pruned = true;
     }
@@ -8865,7 +9114,7 @@ var const_default = {
 };
 
 // src/translator/core/debug.ts
-var import_compiler38 = require("@marko/compiler");
+var import_compiler39 = require("@marko/compiler");
 var import_babel_utils29 = require("@marko/compiler/babel-utils");
 var debug_default = {
   analyze(tag) {
@@ -8874,7 +9123,7 @@ var debug_default = {
     (0, import_babel_utils29.assertNoArgs)(tag);
     (0, import_babel_utils29.assertNoParams)(tag);
     assertNoBodyContent(tag);
-    if (tag.node.attributes.length > 1 || tag.node.attributes.length === 1 && (!import_compiler38.types.isMarkoAttribute(valueAttr) || !valueAttr.default && valueAttr.name !== "value")) {
+    if (tag.node.attributes.length > 1 || tag.node.attributes.length === 1 && (!import_compiler39.types.isMarkoAttribute(valueAttr) || !valueAttr.default && valueAttr.name !== "value")) {
       throw tag.get("name").buildCodeFrameError(
         "The [`<debug>` tag](https://markojs.com/docs/reference/core-tag#debug) only supports the [`value=` attribute](https://markojs.com/docs/reference/language#shorthand-value)."
       );
@@ -8885,7 +9134,7 @@ var debug_default = {
       const section = getSection(tag);
       const [valueAttr] = tag.node.attributes;
       const referencedBindings = valueAttr?.value.extra?.referencedBindings;
-      const statement = withPreviousLocation(import_compiler38.types.debuggerStatement(), tag.node);
+      const statement = withPreviousLocation(import_compiler39.types.debuggerStatement(), tag.node);
       if (isOutputHTML()) {
         tag.insertBefore(statement);
       } else {
@@ -8908,7 +9157,7 @@ var debug_default = {
 };
 
 // src/translator/core/define.ts
-var import_compiler39 = require("@marko/compiler");
+var import_compiler40 = require("@marko/compiler");
 var import_babel_utils30 = require("@marko/compiler/babel-utils");
 var define_default = {
   analyze(tag) {
@@ -8928,7 +9177,7 @@ var define_default = {
     trackParamsReferences(tagBody, 3 /* param */);
     setTagDownstream(tag, varBinding);
     if (bodySection) {
-      if (import_compiler39.types.isIdentifier(tag.node.var)) {
+      if (import_compiler40.types.isIdentifier(tag.node.var)) {
         const babelBinding = tag.scope.getBinding(tag.node.var.name);
         let allDirectReferences = true;
         for (const ref of babelBinding.referencePaths) {
@@ -8972,7 +9221,7 @@ var define_default = {
         tag.insertBefore(translatedAttrs.statements);
         translateVar(tag, propsToExpression(translatedAttrs.properties));
       } else {
-        if (import_compiler39.types.isIdentifier(node.var)) {
+        if (import_compiler40.types.isIdentifier(node.var)) {
           const babelBinding = tag.scope.getBinding(node.var.name);
           let hasDirectReferences = false;
           let allDirectReferences = true;
@@ -9027,7 +9276,7 @@ var define_default = {
 };
 
 // src/translator/core/effect.ts
-var import_compiler40 = require("@marko/compiler");
+var import_compiler41 = require("@marko/compiler");
 var import_babel_utils31 = require("@marko/compiler/babel-utils");
 var effect_default = {
   migrate: [
@@ -9043,8 +9292,8 @@ var effect_default = {
         fix() {
           const { node } = tag;
           tag.replaceWith(
-            import_compiler40.types.markoTag(
-              withPreviousLocation(import_compiler40.types.stringLiteral("script"), node.name),
+            import_compiler41.types.markoTag(
+              withPreviousLocation(import_compiler41.types.stringLiteral("script"), node.name),
               node.attributes,
               node.body,
               node.arguments,
@@ -9081,20 +9330,20 @@ var export_default = {
 };
 
 // src/translator/core/html-comment.ts
-var import_compiler42 = require("@marko/compiler");
+var import_compiler43 = require("@marko/compiler");
 var import_babel_utils33 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/body-to-text-literal.ts
-var import_compiler41 = require("@marko/compiler");
+var import_compiler42 = require("@marko/compiler");
 function bodyToTextLiteral(body) {
   const templateQuasis = [];
   const templateExpressions = [];
   let currentQuasi = "";
   let placeholderExtra;
   for (const child of body.body) {
-    if (import_compiler41.types.isMarkoText(child)) {
+    if (import_compiler42.types.isMarkoText(child)) {
       currentQuasi += child.value;
-    } else if (import_compiler41.types.isMarkoPlaceholder(child)) {
+    } else if (import_compiler42.types.isMarkoPlaceholder(child)) {
       placeholderExtra ||= child.value.extra;
       templateQuasis.push(templateElement(currentQuasi, false));
       templateExpressions.push(child.value);
@@ -9103,14 +9352,14 @@ function bodyToTextLiteral(body) {
   }
   if (templateExpressions.length) {
     templateQuasis.push(templateElement(currentQuasi, true));
-    const literal = import_compiler41.types.templateLiteral(templateQuasis, templateExpressions);
+    const literal = import_compiler42.types.templateLiteral(templateQuasis, templateExpressions);
     literal.extra = placeholderExtra;
     return literal;
   }
-  return import_compiler41.types.stringLiteral(currentQuasi);
+  return import_compiler42.types.stringLiteral(currentQuasi);
 }
 function templateElement(value, tail) {
-  return import_compiler41.types.templateElement(
+  return import_compiler42.types.templateElement(
     {
       raw: value.replace(/`/g, "\\`"),
       cooked: value
@@ -9131,7 +9380,7 @@ var html_comment_default = {
     let needsBinding = false;
     let needsGetter = false;
     if (tagVar) {
-      if (!import_compiler42.types.isIdentifier(tagVar)) {
+      if (!import_compiler43.types.isIdentifier(tagVar)) {
         throw tag.get("var").buildCodeFrameError(
           "The [`<html-comment>` tag](https://markojs.com/docs/reference/core-tag#html-comment) tag variable cannot be destructured."
         );
@@ -9183,7 +9432,7 @@ var html_comment_default = {
             callRuntime(
               "_el",
               getterId && getScopeIdIdentifier(getSection(tag)),
-              getterId && import_compiler42.types.stringLiteral(getterId)
+              getterId && import_compiler43.types.stringLiteral(getterId)
             )
           );
         } else {
@@ -9193,12 +9442,12 @@ var html_comment_default = {
           if (getterId) {
             getterFnIdentifier = generateUidIdentifier(`get_${varName}`);
             (0, import_babel_utils33.getProgram)().node.body.push(
-              import_compiler42.types.variableDeclaration("const", [
-                import_compiler42.types.variableDeclarator(
+              import_compiler43.types.variableDeclaration("const", [
+                import_compiler43.types.variableDeclarator(
                   getterFnIdentifier,
                   callRuntime(
                     "_el",
-                    import_compiler42.types.stringLiteral(getterId),
+                    import_compiler43.types.stringLiteral(getterId),
                     getScopeAccessorLiteral(nodeBinding)
                   )
                 )
@@ -9209,13 +9458,13 @@ var html_comment_default = {
             const referenceSection = getSection(reference);
             if (isInvokedFunction(reference)) {
               reference.parentPath.replaceWith(
-                import_compiler42.types.expressionStatement(
+                import_compiler43.types.expressionStatement(
                   createScopeReadExpression(referenceSection, nodeBinding)
                 )
               );
             } else if (getterFnIdentifier) {
               reference.replaceWith(
-                import_compiler42.types.callExpression(getterFnIdentifier, [
+                import_compiler43.types.callExpression(getterFnIdentifier, [
                   getScopeExpression(referenceSection, getSection(tag))
                 ])
               );
@@ -9236,25 +9485,25 @@ var html_comment_default = {
       const write = writeTo(tag);
       if (isOutputHTML()) {
         for (const child of tag.node.body.body) {
-          if (import_compiler42.types.isMarkoText(child)) {
+          if (import_compiler43.types.isMarkoText(child)) {
             write`${child.value}`;
-          } else if (import_compiler42.types.isMarkoPlaceholder(child)) {
+          } else if (import_compiler43.types.isMarkoPlaceholder(child)) {
             write`${callRuntime("_escape", child.value)}`;
           }
         }
       } else {
         const textLiteral = bodyToTextLiteral(tag.node.body);
-        if (import_compiler42.types.isStringLiteral(textLiteral)) {
+        if (import_compiler43.types.isStringLiteral(textLiteral)) {
           write`${textLiteral}`;
         } else {
           addStatement(
             "render",
             getSection(tag),
             tagExtra.referencedBindings,
-            import_compiler42.types.expressionStatement(
+            import_compiler43.types.expressionStatement(
               callRuntime(
                 "_text",
-                import_compiler42.types.memberExpression(
+                import_compiler43.types.memberExpression(
                   scopeIdentifier,
                   getScopeAccessorLiteral(nodeBinding),
                   true
@@ -9290,7 +9539,7 @@ var html_comment_default = {
 };
 
 // src/translator/core/html-script.ts
-var import_compiler43 = require("@marko/compiler");
+var import_compiler44 = require("@marko/compiler");
 var import_babel_utils34 = require("@marko/compiler/babel-utils");
 var kNodeBinding2 = Symbol("script tag node binding");
 var kGetterId3 = Symbol("node getter id");
@@ -9299,7 +9548,7 @@ var html_script_default = {
     (0, import_babel_utils34.assertNoArgs)(tag);
     (0, import_babel_utils34.assertNoParams)(tag);
     const { node } = tag;
-    if (node.var && !import_compiler43.types.isIdentifier(node.var)) {
+    if (node.var && !import_compiler44.types.isIdentifier(node.var)) {
       throw tag.get("var").buildCodeFrameError(
         "Tag variables on native elements cannot be destructured."
       );
@@ -9313,7 +9562,7 @@ var html_script_default = {
     for (let i = attributes.length; i--; ) {
       const attr = attributes[i];
       const valueExtra = attr.value.extra ??= {};
-      if (import_compiler43.types.isMarkoAttribute(attr)) {
+      if (import_compiler44.types.isMarkoAttribute(attr)) {
         if (seen[attr.name]) {
           dropReferences(attr.value);
           continue;
@@ -9325,14 +9574,14 @@ var html_script_default = {
         } else if (!evaluate(attr.value).confident) {
           hasDynamicAttributes = true;
         }
-      } else if (import_compiler43.types.isMarkoSpreadAttribute(attr)) {
+      } else if (import_compiler44.types.isMarkoSpreadAttribute(attr)) {
         valueExtra.isEffect = true;
         hasEventHandlers = true;
         hasDynamicAttributes = true;
       }
       if (spreadReferenceNodes) {
         spreadReferenceNodes.push(attr.value);
-      } else if (import_compiler43.types.isMarkoSpreadAttribute(attr)) {
+      } else if (import_compiler44.types.isMarkoSpreadAttribute(attr)) {
         spreadReferenceNodes = [attr.value];
       } else {
         exprExtras = push(exprExtras, valueExtra);
@@ -9341,10 +9590,10 @@ var html_script_default = {
     const bodyPlaceholderNodes = [];
     let hasBodyPlaceholders = false;
     for (const child of tag.node.body.body) {
-      if (import_compiler43.types.isMarkoPlaceholder(child)) {
+      if (import_compiler44.types.isMarkoPlaceholder(child)) {
         bodyPlaceholderNodes.push(child.value);
         hasBodyPlaceholders = true;
-      } else if (!import_compiler43.types.isMarkoText(child)) {
+      } else if (!import_compiler44.types.isMarkoText(child)) {
         throw tag.hub.buildError(
           child,
           "Invalid child. Only text is allowed inside an html-script."
@@ -9413,7 +9662,7 @@ var html_script_default = {
             callRuntime(
               "_el",
               getterId && getScopeIdIdentifier(tagSection),
-              getterId && import_compiler43.types.stringLiteral(getterId)
+              getterId && import_compiler44.types.stringLiteral(getterId)
             )
           );
         } else {
@@ -9423,12 +9672,12 @@ var html_script_default = {
           if (getterId) {
             getterFnIdentifier = generateUidIdentifier(`get_${varName}`);
             (0, import_babel_utils34.getProgram)().node.body.push(
-              import_compiler43.types.variableDeclaration("const", [
-                import_compiler43.types.variableDeclarator(
+              import_compiler44.types.variableDeclaration("const", [
+                import_compiler44.types.variableDeclarator(
                   getterFnIdentifier,
                   callRuntime(
                     "_el",
-                    import_compiler43.types.stringLiteral(getterId),
+                    import_compiler44.types.stringLiteral(getterId),
                     getScopeAccessorLiteral(nodeBinding)
                   )
                 )
@@ -9439,13 +9688,13 @@ var html_script_default = {
             const referenceSection = getSection(reference);
             if (isInvokedFunction(reference)) {
               reference.parentPath.replaceWith(
-                import_compiler43.types.expressionStatement(
+                import_compiler44.types.expressionStatement(
                   createScopeReadExpression(referenceSection, nodeBinding)
                 )
               );
             } else if (getterFnIdentifier) {
               reference.replaceWith(
-                import_compiler43.types.callExpression(getterFnIdentifier, [
+                import_compiler44.types.callExpression(getterFnIdentifier, [
                   getScopeExpression(referenceSection, getSection(tag))
                 ])
               );
@@ -9477,10 +9726,10 @@ var html_script_default = {
                 "render",
                 tagSection,
                 valueReferences,
-                import_compiler43.types.expressionStatement(
+                import_compiler44.types.expressionStatement(
                   callRuntime(
                     helper,
-                    import_compiler43.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                    import_compiler44.types.memberExpression(scopeIdentifier, visitAccessor, true),
                     value
                   )
                 )
@@ -9495,18 +9744,18 @@ var html_script_default = {
               if (isEventHandler(name2)) {
                 addHTMLEffectCall(tagSection, valueReferences);
               } else {
-                write`${callRuntime("_attr", import_compiler43.types.stringLiteral(name2), value)}`;
+                write`${callRuntime("_attr", import_compiler44.types.stringLiteral(name2), value)}`;
               }
             } else if (isEventHandler(name2)) {
               addStatement(
                 "effect",
                 tagSection,
                 valueReferences,
-                import_compiler43.types.expressionStatement(
+                import_compiler44.types.expressionStatement(
                   callRuntime(
                     "_on",
-                    import_compiler43.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                    import_compiler43.types.stringLiteral(getEventHandlerName(name2)),
+                    import_compiler44.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                    import_compiler44.types.stringLiteral(getEventHandlerName(name2)),
                     value
                   )
                 )
@@ -9516,11 +9765,11 @@ var html_script_default = {
                 "render",
                 tagSection,
                 valueReferences,
-                import_compiler43.types.expressionStatement(
+                import_compiler44.types.expressionStatement(
                   callRuntime(
                     "_attr",
-                    import_compiler43.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                    import_compiler43.types.stringLiteral(name2),
+                    import_compiler44.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                    import_compiler44.types.stringLiteral(name2),
                     value
                   )
                 )
@@ -9533,9 +9782,9 @@ var html_script_default = {
         if (isHTML) {
           addHTMLEffectCall(tagSection, tagExtra.referencedBindings);
           if (skipExpression) {
-            write`${callRuntime("_attrs_partial", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(tagSection), import_compiler43.types.stringLiteral("script"))}`;
+            write`${callRuntime("_attrs_partial", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(tagSection), import_compiler44.types.stringLiteral("script"))}`;
           } else {
-            write`${callRuntime("_attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(tagSection), import_compiler43.types.stringLiteral("script"))}`;
+            write`${callRuntime("_attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(tagSection), import_compiler44.types.stringLiteral("script"))}`;
           }
         } else {
           if (skipExpression) {
@@ -9543,7 +9792,7 @@ var html_script_default = {
               "render",
               tagSection,
               tagExtra.referencedBindings,
-              import_compiler43.types.expressionStatement(
+              import_compiler44.types.expressionStatement(
                 callRuntime(
                   "_attrs_partial",
                   scopeIdentifier,
@@ -9558,7 +9807,7 @@ var html_script_default = {
               "render",
               tagSection,
               tagExtra.referencedBindings,
-              import_compiler43.types.expressionStatement(
+              import_compiler44.types.expressionStatement(
                 callRuntime(
                   "_attrs",
                   scopeIdentifier,
@@ -9572,7 +9821,7 @@ var html_script_default = {
             "effect",
             tagSection,
             tagExtra.referencedBindings,
-            import_compiler43.types.expressionStatement(
+            import_compiler44.types.expressionStatement(
               callRuntime("_attrs_script", scopeIdentifier, visitAccessor)
             ),
             false
@@ -9589,25 +9838,25 @@ var html_script_default = {
       const write = writeTo(tag);
       if (isOutputHTML()) {
         for (const child of tag.node.body.body) {
-          if (import_compiler43.types.isMarkoText(child)) {
+          if (import_compiler44.types.isMarkoText(child)) {
             write`${child.value}`;
-          } else if (import_compiler43.types.isMarkoPlaceholder(child)) {
+          } else if (import_compiler44.types.isMarkoPlaceholder(child)) {
             write`${callRuntime("_escape_script", child.value)}`;
           }
         }
       } else {
         const textLiteral = bodyToTextLiteral(tag.node.body);
-        if (import_compiler43.types.isStringLiteral(textLiteral)) {
+        if (import_compiler44.types.isStringLiteral(textLiteral)) {
           write`${textLiteral.value}`;
         } else {
           addStatement(
             "render",
             getSection(tag),
             textLiteral.extra?.referencedBindings,
-            import_compiler43.types.expressionStatement(
+            import_compiler44.types.expressionStatement(
               callRuntime(
                 "_text_content",
-                import_compiler43.types.memberExpression(
+                import_compiler44.types.memberExpression(
                   scopeIdentifier,
                   getScopeAccessorLiteral(nodeBinding),
                   true
@@ -9662,11 +9911,11 @@ function getUsedAttrs2(tag) {
   for (let i = attributes.length; i--; ) {
     const attr = attributes[i];
     const { value } = attr;
-    if (import_compiler43.types.isMarkoSpreadAttribute(attr)) {
+    if (import_compiler44.types.isMarkoSpreadAttribute(attr)) {
       if (!spreadProps) {
         spreadProps = [];
       }
-      spreadProps.push(import_compiler43.types.spreadElement(value));
+      spreadProps.push(import_compiler44.types.spreadElement(value));
     } else if (!seen[attr.name]) {
       seen[attr.name] = attr;
       if (spreadProps) {
@@ -9680,10 +9929,10 @@ function getUsedAttrs2(tag) {
   if (spreadProps) {
     spreadProps.reverse();
     for (const { name: name2 } of staticAttrs) {
-      (skipProps ||= []).push(toObjectProperty(name2, import_compiler43.types.numericLiteral(1)));
+      (skipProps ||= []).push(toObjectProperty(name2, import_compiler44.types.numericLiteral(1)));
     }
     if (skipProps) {
-      skipExpression = import_compiler43.types.objectExpression(skipProps);
+      skipExpression = import_compiler44.types.objectExpression(skipProps);
     }
     spreadExpression = propsToExpression(spreadProps);
   }
@@ -9695,7 +9944,7 @@ function getUsedAttrs2(tag) {
 }
 
 // src/translator/core/html-style.ts
-var import_compiler44 = require("@marko/compiler");
+var import_compiler45 = require("@marko/compiler");
 var import_babel_utils35 = require("@marko/compiler/babel-utils");
 var kNodeBinding3 = Symbol("style tag node binding");
 var kGetterId4 = Symbol("node getter id");
@@ -9704,7 +9953,7 @@ var html_style_default = {
     (0, import_babel_utils35.assertNoArgs)(tag);
     (0, import_babel_utils35.assertNoParams)(tag);
     const { node } = tag;
-    if (node.var && !import_compiler44.types.isIdentifier(node.var)) {
+    if (node.var && !import_compiler45.types.isIdentifier(node.var)) {
       throw tag.get("var").buildCodeFrameError(
         "Tag variables on native elements cannot be destructured."
       );
@@ -9718,7 +9967,7 @@ var html_style_default = {
     for (let i = attributes.length; i--; ) {
       const attr = attributes[i];
       const valueExtra = attr.value.extra ??= {};
-      if (import_compiler44.types.isMarkoAttribute(attr)) {
+      if (import_compiler45.types.isMarkoAttribute(attr)) {
         if (seen[attr.name]) {
           dropReferences(attr.value);
           continue;
@@ -9730,14 +9979,14 @@ var html_style_default = {
         } else if (!evaluate(attr.value).confident) {
           hasDynamicAttributes = true;
         }
-      } else if (import_compiler44.types.isMarkoSpreadAttribute(attr)) {
+      } else if (import_compiler45.types.isMarkoSpreadAttribute(attr)) {
         valueExtra.isEffect = true;
         hasEventHandlers = true;
         hasDynamicAttributes = true;
       }
       if (spreadReferenceNodes) {
         spreadReferenceNodes.push(attr.value);
-      } else if (import_compiler44.types.isMarkoSpreadAttribute(attr)) {
+      } else if (import_compiler45.types.isMarkoSpreadAttribute(attr)) {
         spreadReferenceNodes = [attr.value];
       } else {
         exprExtras = push(exprExtras, valueExtra);
@@ -9746,10 +9995,10 @@ var html_style_default = {
     const bodyPlaceholderNodes = [];
     let hasBodyPlaceholders = false;
     for (const child of tag.node.body.body) {
-      if (import_compiler44.types.isMarkoPlaceholder(child)) {
+      if (import_compiler45.types.isMarkoPlaceholder(child)) {
         bodyPlaceholderNodes.push(child.value);
         hasBodyPlaceholders = true;
-      } else if (!import_compiler44.types.isMarkoText(child)) {
+      } else if (!import_compiler45.types.isMarkoText(child)) {
         throw tag.hub.buildError(
           child,
           "Invalid child. Only text is allowed inside an html-style."
@@ -9818,7 +10067,7 @@ var html_style_default = {
             callRuntime(
               "_el",
               getterId && getScopeIdIdentifier(tagSection),
-              getterId && import_compiler44.types.stringLiteral(getterId)
+              getterId && import_compiler45.types.stringLiteral(getterId)
             )
           );
         } else {
@@ -9828,12 +10077,12 @@ var html_style_default = {
           if (getterId) {
             getterFnIdentifier = generateUidIdentifier(`get_${varName}`);
             (0, import_babel_utils35.getProgram)().node.body.push(
-              import_compiler44.types.variableDeclaration("const", [
-                import_compiler44.types.variableDeclarator(
+              import_compiler45.types.variableDeclaration("const", [
+                import_compiler45.types.variableDeclarator(
                   getterFnIdentifier,
                   callRuntime(
                     "_el",
-                    import_compiler44.types.stringLiteral(getterId),
+                    import_compiler45.types.stringLiteral(getterId),
                     getScopeAccessorLiteral(nodeBinding)
                   )
                 )
@@ -9844,13 +10093,13 @@ var html_style_default = {
             const referenceSection = getSection(reference);
             if (isInvokedFunction(reference)) {
               reference.parentPath.replaceWith(
-                import_compiler44.types.expressionStatement(
+                import_compiler45.types.expressionStatement(
                   createScopeReadExpression(referenceSection, nodeBinding)
                 )
               );
             } else if (getterFnIdentifier) {
               reference.replaceWith(
-                import_compiler44.types.callExpression(getterFnIdentifier, [
+                import_compiler45.types.callExpression(getterFnIdentifier, [
                   getScopeExpression(referenceSection, getSection(tag))
                 ])
               );
@@ -9882,10 +10131,10 @@ var html_style_default = {
                 "render",
                 tagSection,
                 valueReferences,
-                import_compiler44.types.expressionStatement(
+                import_compiler45.types.expressionStatement(
                   callRuntime(
                     helper,
-                    import_compiler44.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                    import_compiler45.types.memberExpression(scopeIdentifier, visitAccessor, true),
                     value
                   )
                 )
@@ -9900,18 +10149,18 @@ var html_style_default = {
               if (isEventHandler(name2)) {
                 addHTMLEffectCall(tagSection, valueReferences);
               } else {
-                write`${callRuntime("_attr", import_compiler44.types.stringLiteral(name2), value)}`;
+                write`${callRuntime("_attr", import_compiler45.types.stringLiteral(name2), value)}`;
               }
             } else if (isEventHandler(name2)) {
               addStatement(
                 "effect",
                 tagSection,
                 valueReferences,
-                import_compiler44.types.expressionStatement(
+                import_compiler45.types.expressionStatement(
                   callRuntime(
                     "_on",
-                    import_compiler44.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                    import_compiler44.types.stringLiteral(getEventHandlerName(name2)),
+                    import_compiler45.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                    import_compiler45.types.stringLiteral(getEventHandlerName(name2)),
                     value
                   )
                 )
@@ -9921,11 +10170,11 @@ var html_style_default = {
                 "render",
                 tagSection,
                 valueReferences,
-                import_compiler44.types.expressionStatement(
+                import_compiler45.types.expressionStatement(
                   callRuntime(
                     "_attr",
-                    import_compiler44.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                    import_compiler44.types.stringLiteral(name2),
+                    import_compiler45.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                    import_compiler45.types.stringLiteral(name2),
                     value
                   )
                 )
@@ -9938,9 +10187,9 @@ var html_style_default = {
         if (isHTML) {
           addHTMLEffectCall(tagSection, tagExtra.referencedBindings);
           if (skipExpression) {
-            write`${callRuntime("_attrs_partial", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(tagSection), import_compiler44.types.stringLiteral("style"))}`;
+            write`${callRuntime("_attrs_partial", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(tagSection), import_compiler45.types.stringLiteral("style"))}`;
           } else {
-            write`${callRuntime("_attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(tagSection), import_compiler44.types.stringLiteral("style"))}`;
+            write`${callRuntime("_attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(tagSection), import_compiler45.types.stringLiteral("style"))}`;
           }
         } else {
           if (skipExpression) {
@@ -9948,7 +10197,7 @@ var html_style_default = {
               "render",
               tagSection,
               tagExtra.referencedBindings,
-              import_compiler44.types.expressionStatement(
+              import_compiler45.types.expressionStatement(
                 callRuntime(
                   "_attrs_partial",
                   scopeIdentifier,
@@ -9963,7 +10212,7 @@ var html_style_default = {
               "render",
               tagSection,
               tagExtra.referencedBindings,
-              import_compiler44.types.expressionStatement(
+              import_compiler45.types.expressionStatement(
                 callRuntime(
                   "_attrs",
                   scopeIdentifier,
@@ -9977,7 +10226,7 @@ var html_style_default = {
             "effect",
             tagSection,
             tagExtra.referencedBindings,
-            import_compiler44.types.expressionStatement(
+            import_compiler45.types.expressionStatement(
               callRuntime("_attrs_script", scopeIdentifier, visitAccessor)
             ),
             false
@@ -9994,25 +10243,25 @@ var html_style_default = {
       const write = writeTo(tag);
       if (isOutputHTML()) {
         for (const child of tag.node.body.body) {
-          if (import_compiler44.types.isMarkoText(child)) {
+          if (import_compiler45.types.isMarkoText(child)) {
             write`${child.value}`;
-          } else if (import_compiler44.types.isMarkoPlaceholder(child)) {
+          } else if (import_compiler45.types.isMarkoPlaceholder(child)) {
             write`${callRuntime("_escape_style", child.value)}`;
           }
         }
       } else {
         const textLiteral = bodyToTextLiteral(tag.node.body);
-        if (import_compiler44.types.isStringLiteral(textLiteral)) {
+        if (import_compiler45.types.isStringLiteral(textLiteral)) {
           write`${textLiteral}`;
         } else {
           addStatement(
             "render",
             getSection(tag),
             textLiteral.extra?.referencedBindings,
-            import_compiler44.types.expressionStatement(
+            import_compiler45.types.expressionStatement(
               callRuntime(
                 "_text_content",
-                import_compiler44.types.memberExpression(
+                import_compiler45.types.memberExpression(
                   scopeIdentifier,
                   getScopeAccessorLiteral(nodeBinding),
                   true
@@ -10062,11 +10311,11 @@ function getUsedAttrs3(tag) {
   for (let i = attributes.length; i--; ) {
     const attr = attributes[i];
     const { value } = attr;
-    if (import_compiler44.types.isMarkoSpreadAttribute(attr)) {
+    if (import_compiler45.types.isMarkoSpreadAttribute(attr)) {
       if (!spreadProps) {
         spreadProps = [];
       }
-      spreadProps.push(import_compiler44.types.spreadElement(value));
+      spreadProps.push(import_compiler45.types.spreadElement(value));
     } else if (!seen[attr.name]) {
       seen[attr.name] = attr;
       if (spreadProps) {
@@ -10080,10 +10329,10 @@ function getUsedAttrs3(tag) {
   if (spreadProps) {
     spreadProps.reverse();
     for (const { name: name2 } of staticAttrs) {
-      (skipProps ||= []).push(toObjectProperty(name2, import_compiler44.types.numericLiteral(1)));
+      (skipProps ||= []).push(toObjectProperty(name2, import_compiler45.types.numericLiteral(1)));
     }
     if (skipProps) {
-      skipExpression = import_compiler44.types.objectExpression(skipProps);
+      skipExpression = import_compiler45.types.objectExpression(skipProps);
     }
     spreadExpression = propsToExpression(spreadProps);
   }
@@ -10095,7 +10344,7 @@ function getUsedAttrs3(tag) {
 }
 
 // src/translator/core/id.ts
-var import_compiler45 = require("@marko/compiler");
+var import_compiler46 = require("@marko/compiler");
 var import_babel_utils36 = require("@marko/compiler/babel-utils");
 var id_default = {
   analyze(tag) {
@@ -10110,12 +10359,12 @@ var id_default = {
         "The [`<id>` tag](https://markojs.com/docs/reference/core-tag#id) requires a [tag variable](https://markojs.com/docs/reference/language#tag-variables)."
       );
     }
-    if (!import_compiler45.types.isIdentifier(node.var)) {
+    if (!import_compiler46.types.isIdentifier(node.var)) {
       throw tag.get("var").buildCodeFrameError(
         "The [`<id>` tag](https://markojs.com/docs/reference/core-tag#id) cannot be destructured."
       );
     }
-    if (tag.node.attributes.length > 1 || tag.node.attributes.length === 1 && (!import_compiler45.types.isMarkoAttribute(valueAttr) || !valueAttr.default && valueAttr.name !== "value")) {
+    if (tag.node.attributes.length > 1 || tag.node.attributes.length === 1 && (!import_compiler46.types.isMarkoAttribute(valueAttr) || !valueAttr.default && valueAttr.name !== "value")) {
       throw tag.get("name").buildCodeFrameError(
         "The [`<id>` tag](https://markojs.com/docs/reference/core-tag#id) only supports the [`value=` attribute](https://markojs.com/docs/reference/language#shorthand-value)."
       );
@@ -10132,10 +10381,10 @@ var id_default = {
       const [valueAttr] = tag.node.attributes;
       if (isOutputHTML()) {
         tag.replaceWith(
-          import_compiler45.types.variableDeclaration("const", [
-            import_compiler45.types.variableDeclarator(
+          import_compiler46.types.variableDeclaration("const", [
+            import_compiler46.types.variableDeclarator(
               node.var,
-              valueAttr ? import_compiler45.types.logicalExpression("||", valueAttr.value, id) : id
+              valueAttr ? import_compiler46.types.logicalExpression("||", valueAttr.value, id) : id
             )
           ])
         );
@@ -10148,7 +10397,7 @@ var id_default = {
             section,
             value.extra?.referencedBindings,
             source,
-            import_compiler45.types.logicalExpression("||", value, id)
+            import_compiler46.types.logicalExpression("||", value, id)
           );
         } else {
           addValue(section, void 0, source, id);
@@ -10173,17 +10422,17 @@ var id_default = {
 };
 
 // src/translator/core/if.ts
-var import_compiler47 = require("@marko/compiler");
+var import_compiler48 = require("@marko/compiler");
 var import_babel_utils37 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/to-first-statement-or-block.ts
-var import_compiler46 = require("@marko/compiler");
+var import_compiler47 = require("@marko/compiler");
 function toFirstStatementOrBlock(body) {
   if (Array.isArray(body)) {
     if (body.length === 1) {
       return body[0];
     }
-    return import_compiler46.types.blockStatement(body);
+    return import_compiler47.types.blockStatement(body);
   }
   return body;
 }
@@ -10291,14 +10540,14 @@ var IfTag = {
                   }
                 }
                 bodyStatements.push(
-                  import_compiler47.types.returnStatement(import_compiler47.types.numericLiteral(i))
+                  import_compiler48.types.returnStatement(import_compiler48.types.numericLiteral(i))
                 );
               }
             }
             const [testAttr] = branchTag.node.attributes;
             const curStatement = toFirstStatementOrBlock(bodyStatements);
             if (testAttr) {
-              statement = import_compiler47.types.ifStatement(
+              statement = import_compiler48.types.ifStatement(
                 testAttr.value,
                 curStatement,
                 statement
@@ -10314,31 +10563,34 @@ var IfTag = {
               getParentTag(ifTag).node.extra[kSkipEndTag] = true;
             }
             const statefulSerializeArg = getSerializeGuard(
+              ifTagSection,
               getSerializeReason(ifTagSection, kStatefulReason2),
               !(skipParentEnd || singleNodeOptimization)
             );
             const markerSerializeArg = getSerializeGuard(
+              ifTagSection,
               markerSerializeReason,
               !statefulSerializeArg
             );
-            const cbNode = import_compiler47.types.arrowFunctionExpression(
+            const cbNode = import_compiler48.types.arrowFunctionExpression(
               [],
-              import_compiler47.types.blockStatement([statement])
+              import_compiler48.types.blockStatement([statement])
             );
-            statement = import_compiler47.types.expressionStatement(
+            statement = import_compiler48.types.expressionStatement(
               callRuntime(
                 "_if",
                 cbNode,
                 getScopeIdIdentifier(ifTagSection),
                 getScopeAccessorLiteral(nodeBinding),
                 getSerializeGuardForAny(
+                  ifTagSection,
                   branchSerializeReasons,
                   !markerSerializeArg
                 ),
                 markerSerializeArg,
                 statefulSerializeArg,
-                skipParentEnd ? import_compiler47.types.stringLiteral(`</${onlyChildParentTagName}>`) : singleNodeOptimization ? import_compiler47.types.numericLiteral(0) : void 0,
-                singleNodeOptimization ? import_compiler47.types.numericLiteral(1) : void 0
+                skipParentEnd ? import_compiler48.types.stringLiteral(`</${onlyChildParentTagName}>`) : singleNodeOptimization ? import_compiler48.types.numericLiteral(0) : void 0,
+                singleNodeOptimization ? import_compiler48.types.numericLiteral(1) : void 0
               )
             );
           }
@@ -10368,25 +10620,25 @@ var IfTag = {
           const ifTagExtra = branches[0][0].node.extra;
           const nodeRef = getOptimizedOnlyChildNodeBinding(ifTag, ifTagSection);
           const rendererIdentifiers = [];
-          let expr = import_compiler47.types.numericLiteral(branches.length);
+          let expr = import_compiler48.types.numericLiteral(branches.length);
           for (let i = branches.length; i--; ) {
             const [branchTag, branchBodySection] = branches[i];
             const [testAttr] = branchTag.node.attributes;
-            const consequent = import_compiler47.types.numericLiteral(branchBodySection ? i : -1);
+            const consequent = import_compiler48.types.numericLiteral(branchBodySection ? i : -1);
             if (branchBodySection) {
-              rendererIdentifiers.push(import_compiler47.types.identifier(branchBodySection.name));
+              rendererIdentifiers.push(import_compiler48.types.identifier(branchBodySection.name));
               setClosureSignalBuilder(branchTag, (closure, render) => {
                 return callRuntime(
                   "_if_closure",
                   getScopeAccessorLiteral(closure),
                   getScopeAccessorLiteral(nodeRef),
-                  import_compiler47.types.numericLiteral(i),
+                  import_compiler48.types.numericLiteral(i),
                   render
                 );
               });
             }
             branchTag.remove();
-            expr = testAttr ? import_compiler47.types.conditionalExpression(testAttr.value, consequent, expr) : consequent;
+            expr = testAttr ? import_compiler48.types.conditionalExpression(testAttr.value, consequent, expr) : consequent;
           }
           const signal = getSignal(ifTagSection, nodeRef, "if");
           signal.build = () => {
@@ -10468,7 +10720,7 @@ function assertHasBody(tag) {
 function assertHasValueAttribute(tag) {
   const { node } = tag;
   const [valueAttr] = node.attributes;
-  if (!import_compiler47.types.isMarkoAttribute(valueAttr) || !valueAttr.default) {
+  if (!import_compiler48.types.isMarkoAttribute(valueAttr) || !valueAttr.default) {
     throw tag.get("name").buildCodeFrameError(
       `The [\`${getTagName(tag)}\` tag](https://markojs.com/docs/reference/core-tag#if--else) requires a [\`value=\` attribute](https://markojs.com/docs/reference/language#shorthand-value).`
     );
@@ -10554,7 +10806,7 @@ var import_default = {
 };
 
 // src/translator/core/let.ts
-var import_compiler48 = require("@marko/compiler");
+var import_compiler49 = require("@marko/compiler");
 var import_babel_utils39 = require("@marko/compiler/babel-utils");
 var let_default = {
   analyze(tag) {
@@ -10563,7 +10815,7 @@ var let_default = {
     let valueAttr;
     let valueChangeAttr;
     for (const attr of node.attributes) {
-      if (import_compiler48.types.isMarkoAttribute(attr)) {
+      if (import_compiler49.types.isMarkoAttribute(attr)) {
         if (attr.name === "value") {
           valueAttr = attr;
         } else if (attr.name === "valueChange") {
@@ -10593,7 +10845,7 @@ var let_default = {
         "The [`<let>` tag](https://markojs.com/docs/reference/core-tag#let) requires a [tag variable](https://markojs.com/docs/reference/language#tag-variables)."
       );
     }
-    if (!import_compiler48.types.isIdentifier(tagVar)) {
+    if (!import_compiler49.types.isIdentifier(tagVar)) {
       throw tag.get("var").buildCodeFrameError(
         "The [`<let>` tag](https://markojs.com/docs/reference/core-tag#let) variable cannot be destructured."
       );
@@ -10623,10 +10875,10 @@ var let_default = {
       const { node } = tag;
       const tagVar = node.var;
       const valueAttr = node.attributes.find(
-        (attr) => import_compiler48.types.isMarkoAttribute(attr) && (attr.default || attr.name === "value")
-      ) ?? import_compiler48.types.markoAttribute("value", import_compiler48.types.identifier("undefined"));
+        (attr) => import_compiler49.types.isMarkoAttribute(attr) && (attr.default || attr.name === "value")
+      ) ?? import_compiler49.types.markoAttribute("value", import_compiler49.types.identifier("undefined"));
       const valueChangeAttr = node.attributes.find(
-        (attr) => import_compiler48.types.isMarkoAttribute(attr) && attr.name === "valueChange"
+        (attr) => import_compiler49.types.isMarkoAttribute(attr) && attr.name === "valueChange"
       );
       const section = getSection(tag);
       const binding = tagVar.extra.binding;
@@ -10639,7 +10891,7 @@ var let_default = {
         }
         signal.buildAssignment = (valueSection, value) => {
           if (valueChangeAttr || signalHasStatements(signal)) {
-            return import_compiler48.types.callExpression(signal.identifier, [
+            return import_compiler49.types.callExpression(signal.identifier, [
               getScopeExpression(valueSection, signal.section),
               value
             ]);
@@ -10651,10 +10903,10 @@ var let_default = {
           setBindingSerializedValue(
             section,
             binding,
-            import_compiler48.types.logicalExpression(
+            import_compiler49.types.logicalExpression(
               "||",
               valueChangeAttr.value,
-              import_compiler48.types.unaryExpression("void", import_compiler48.types.numericLiteral(0))
+              import_compiler49.types.unaryExpression("void", import_compiler49.types.numericLiteral(0))
             ),
             getAccessorPrefix().TagVariableChange
           );
@@ -10677,7 +10929,7 @@ var let_default = {
 };
 
 // src/translator/core/lifecycle.ts
-var import_compiler49 = require("@marko/compiler");
+var import_compiler50 = require("@marko/compiler");
 var import_babel_utils40 = require("@marko/compiler/babel-utils");
 var kRef = Symbol("lifecycle attrs reference");
 var lifecycle_default = {
@@ -10705,7 +10957,7 @@ var lifecycle_default = {
       );
     }
     for (const attr of node.attributes) {
-      if (import_compiler49.types.isMarkoSpreadAttribute(attr)) {
+      if (import_compiler50.types.isMarkoSpreadAttribute(attr)) {
         throw tag.get("name").buildCodeFrameError(
           "The [`<lifecycle>` tag](https://markojs.com/docs/reference/core-tag#lifecycle) does not support [`...spread` attributes](https://markojs.com/docs/reference/language#spread-attributes)."
         );
@@ -10724,7 +10976,7 @@ var lifecycle_default = {
       if (isOutputDOM()) {
         const translatedAttrs = translateAttrs(tag);
         translatedAttrs.statements.push(
-          import_compiler49.types.expressionStatement(
+          import_compiler50.types.expressionStatement(
             callRuntime(
               "_lifecycle",
               scopeIdentifier,
@@ -10759,7 +11011,7 @@ var lifecycle_default = {
 };
 
 // src/translator/core/log.ts
-var import_compiler50 = require("@marko/compiler");
+var import_compiler51 = require("@marko/compiler");
 var import_babel_utils41 = require("@marko/compiler/babel-utils");
 var log_default = {
   analyze(tag) {
@@ -10773,7 +11025,7 @@ var log_default = {
         "The [`<log>` tag](https://markojs.com/docs/reference/core-tag#log) requires a [`value=` attribute](https://markojs.com/docs/reference/language#shorthand-value)."
       );
     }
-    if (tag.node.attributes.length > 1 || !import_compiler50.types.isMarkoAttribute(valueAttr) || !valueAttr.default && valueAttr.name !== "value") {
+    if (tag.node.attributes.length > 1 || !import_compiler51.types.isMarkoAttribute(valueAttr) || !valueAttr.default && valueAttr.name !== "value") {
       throw tag.get("name").buildCodeFrameError(
         "The [`<log>` tag](https://markojs.com/docs/reference/core-tag#log) only supports the [`value=` attribute](https://markojs.com/docs/reference/language#shorthand-value)."
       );
@@ -10785,9 +11037,9 @@ var log_default = {
       const [valueAttr] = tag.node.attributes;
       const { value } = valueAttr;
       const referencedBindings = value.extra?.referencedBindings;
-      const statement = import_compiler50.types.expressionStatement(
-        import_compiler50.types.callExpression(
-          import_compiler50.types.memberExpression(import_compiler50.types.identifier("console"), import_compiler50.types.identifier("log")),
+      const statement = import_compiler51.types.expressionStatement(
+        import_compiler51.types.callExpression(
+          import_compiler51.types.memberExpression(import_compiler51.types.identifier("console"), import_compiler51.types.identifier("log")),
           [value]
         )
       );
@@ -10813,7 +11065,7 @@ var log_default = {
 };
 
 // src/translator/core/script.ts
-var import_compiler51 = require("@marko/compiler");
+var import_compiler52 = require("@marko/compiler");
 var import_babel_utils42 = require("@marko/compiler/babel-utils");
 var htmlScriptTagAlternateMsg = " For a native html [`<script>` tag](https://markojs.com/docs/reference/core-tag#script) use the `html-script` core tag instead.";
 var script_default = {
@@ -10836,12 +11088,12 @@ var script_default = {
       const end = body[body.length - 1]?.end;
       const bodyStatements = (0, import_babel_utils42.parseStatements)(tag.hub.file, code, start, end);
       if (bodyStatements.length) {
-        const valueFn = import_compiler51.types.arrowFunctionExpression(
+        const valueFn = import_compiler52.types.arrowFunctionExpression(
           [],
-          import_compiler51.types.blockStatement(bodyStatements),
+          import_compiler52.types.blockStatement(bodyStatements),
           traverseContains(bodyStatements, isAwaitExpression)
         );
-        node.attributes.push(import_compiler51.types.markoAttribute("value", valueFn));
+        node.attributes.push(import_compiler52.types.markoAttribute("value", valueFn));
       }
       node.body.body = [];
     }
@@ -10891,28 +11143,28 @@ var script_default = {
       const referencedBindings = value.extra?.referencedBindings;
       if (isOutputDOM()) {
         const { value: value2 } = valueAttr;
-        const isFunction2 = import_compiler51.types.isFunctionExpression(value2) || import_compiler51.types.isArrowFunctionExpression(value2);
+        const isFunction2 = import_compiler52.types.isFunctionExpression(value2) || import_compiler52.types.isArrowFunctionExpression(value2);
         let inlineBody = null;
         if (isFunction2 && !(value2.async || value2.generator)) {
-          if (import_compiler51.types.isBlockStatement(value2.body)) {
+          if (import_compiler52.types.isBlockStatement(value2.body)) {
             let hasDeclaration = false;
             for (const child of value2.body.body) {
-              if (import_compiler51.types.isDeclaration(child)) {
+              if (import_compiler52.types.isDeclaration(child)) {
                 hasDeclaration = true;
                 break;
               }
             }
             inlineBody = hasDeclaration ? value2.body : value2.body.body;
           } else {
-            inlineBody = import_compiler51.types.expressionStatement(value2.body);
+            inlineBody = import_compiler52.types.expressionStatement(value2.body);
           }
         }
         addStatement(
           "effect",
           section,
           referencedBindings,
-          inlineBody || import_compiler51.types.expressionStatement(
-            import_compiler51.types.callExpression(value2, isFunction2 ? [] : [scopeIdentifier])
+          inlineBody || import_compiler52.types.expressionStatement(
+            import_compiler52.types.callExpression(value2, isFunction2 ? [] : [scopeIdentifier])
           )
         );
       } else {
@@ -10953,7 +11205,7 @@ function isAwaitExpression(node) {
 }
 
 // src/translator/core/server.ts
-var import_compiler52 = require("@marko/compiler");
+var import_compiler53 = require("@marko/compiler");
 var import_babel_utils43 = require("@marko/compiler/babel-utils");
 var server_default = {
   parse(tag) {
@@ -10965,10 +11217,10 @@ var server_default = {
     const code = rawValue.replace(/^server\s*/, "");
     const start = node.start + (rawValue.length - code.length);
     let body = (0, import_babel_utils43.parseStatements)(file, code, start, start + code.length);
-    if (body.length === 1 && import_compiler52.types.isBlockStatement(body[0])) {
+    if (body.length === 1 && import_compiler53.types.isBlockStatement(body[0])) {
       body = body[0].body;
     }
-    tag.replaceWith(import_compiler52.types.markoScriptlet(body, true, "server"));
+    tag.replaceWith(import_compiler53.types.markoScriptlet(body, true, "server"));
   },
   parseOptions: {
     statement: true,
@@ -10984,7 +11236,7 @@ var server_default = {
 };
 
 // src/translator/core/static.ts
-var import_compiler53 = require("@marko/compiler");
+var import_compiler54 = require("@marko/compiler");
 var import_babel_utils44 = require("@marko/compiler/babel-utils");
 var static_default = {
   parse(tag) {
@@ -10996,10 +11248,10 @@ var static_default = {
     const code = rawValue.replace(/^static\s*/, "");
     const start = node.start + (rawValue.length - code.length);
     let body = (0, import_babel_utils44.parseStatements)(file, code, start, start + code.length);
-    if (body.length === 1 && import_compiler53.types.isBlockStatement(body[0])) {
+    if (body.length === 1 && import_compiler54.types.isBlockStatement(body[0])) {
       body = body[0].body;
     }
-    tag.replaceWith(import_compiler53.types.markoScriptlet(body, true));
+    tag.replaceWith(import_compiler54.types.markoScriptlet(body, true));
   },
   parseOptions: {
     statement: true,
@@ -11015,7 +11267,7 @@ var static_default = {
 };
 
 // src/translator/core/style.ts
-var import_compiler54 = require("@marko/compiler");
+var import_compiler55 = require("@marko/compiler");
 var import_babel_utils45 = require("@marko/compiler/babel-utils");
 var import_magic_string = __toESM(require("magic-string"));
 var import_path3 = __toESM(require("path"));
@@ -11092,21 +11344,21 @@ var style_default = {
     if (importPath) {
       if (!node.var) {
         (0, import_babel_utils45.getProgram)().node.body.push(
-          import_compiler54.types.importDeclaration([], import_compiler54.types.stringLiteral(importPath))
+          import_compiler55.types.importDeclaration([], import_compiler55.types.stringLiteral(importPath))
         );
-      } else if (import_compiler54.types.isIdentifier(node.var)) {
+      } else if (import_compiler55.types.isIdentifier(node.var)) {
         (0, import_babel_utils45.getProgram)().node.body.push(
-          import_compiler54.types.importDeclaration(
-            [import_compiler54.types.importNamespaceSpecifier(node.var)],
-            import_compiler54.types.stringLiteral(importPath)
+          import_compiler55.types.importDeclaration(
+            [import_compiler55.types.importNamespaceSpecifier(node.var)],
+            import_compiler55.types.stringLiteral(importPath)
           )
         );
       } else {
-        const varDecl = import_compiler54.types.variableDeclaration("const", [
-          import_compiler54.types.variableDeclarator(node.var, (0, import_babel_utils45.importStar)(file, importPath, "style"))
+        const varDecl = import_compiler55.types.variableDeclaration("const", [
+          import_compiler55.types.variableDeclarator(node.var, (0, import_babel_utils45.importStar)(file, importPath, "style"))
         ]);
         (0, import_babel_utils45.getProgram)().node.body.push(
-          isOutputDOM() ? varDecl : import_compiler54.types.markoScriptlet([varDecl], true)
+          isOutputDOM() ? varDecl : import_compiler55.types.markoScriptlet([varDecl], true)
         );
       }
     }
@@ -11121,8 +11373,43 @@ var style_default = {
   attributes: {}
 };
 
+// src/translator/core/textarea.ts
+var import_compiler56 = require("@marko/compiler");
+var textarea_default = {
+  parse(tag) {
+    if (tag.node.body.body.length) {
+      const parts = [];
+      for (const child of tag.node.body.body) {
+        if (child.type === "MarkoText" || child.type === "MarkoPlaceholder" && child.escape) {
+          parts.push(child.value);
+        } else {
+          throw tag.hub.file.hub.buildError(
+            child,
+            "Unexpected content in textarea, only text and placeholders are supported.",
+            SyntaxError
+          );
+        }
+      }
+      tag.node.attributes.push(
+        import_compiler56.types.markoAttribute(
+          "value",
+          normalizeStringExpression(parts) || buildUndefined4()
+        )
+      );
+      tag.node.body.body = [];
+    }
+  },
+  parseOptions: {
+    text: true,
+    preserveWhitespace: true
+  }
+};
+function buildUndefined4() {
+  return import_compiler56.types.unaryExpression("void", import_compiler56.types.numericLiteral(0));
+}
+
 // src/translator/core/try.ts
-var import_compiler55 = require("@marko/compiler");
+var import_compiler57 = require("@marko/compiler");
 var import_babel_utils46 = require("@marko/compiler/babel-utils");
 var kDOMBinding2 = Symbol("try tag dom binding");
 var try_default = {
@@ -11182,7 +11469,7 @@ var try_default = {
         writeHTMLResumeStatements(tagBody);
         tag.insertBefore(translatedAttrs.statements);
         tag.replaceWith(
-          import_compiler55.types.expressionStatement(
+          import_compiler57.types.expressionStatement(
             callRuntime(
               "_try",
               getScopeIdIdentifier(section),
@@ -11224,7 +11511,7 @@ var try_default = {
           return callRuntime(
             "_try",
             getScopeAccessorLiteral(nodeRef),
-            import_compiler55.types.identifier(bodySection.name)
+            import_compiler57.types.identifier(bodySection.name)
           );
         };
         if (translatedAttrs.statements.length) {
@@ -11236,7 +11523,7 @@ var try_default = {
           );
         }
         (0, import_babel_utils46.getProgram)().node.body.push(
-          import_compiler55.types.expressionStatement(callRuntime("_enable_catch"))
+          import_compiler57.types.expressionStatement(callRuntime("_enable_catch"))
         );
         addValue(
           section,
@@ -11286,6 +11573,7 @@ var core_default = {
   "<server>": server_default,
   "<static>": static_default,
   "<style>": style_default,
+  "<textarea>": textarea_default,
   "<try>": try_default
 };
 
@@ -11362,10 +11650,10 @@ var import_declaration_default = {
 };
 
 // src/translator/visitors/placeholder.ts
-var import_compiler57 = require("@marko/compiler");
+var import_compiler59 = require("@marko/compiler");
 
 // src/translator/util/is-non-html-text.ts
-var import_compiler56 = require("@marko/compiler");
+var import_compiler58 = require("@marko/compiler");
 function isNonHTMLText(placeholder) {
   const parentTag = placeholder.parentPath.isMarkoTagBody() && placeholder.parentPath.parentPath;
   if (parentTag && isCoreTag(parentTag)) {
@@ -11435,7 +11723,7 @@ var placeholder_default = {
             if (markerSerializeReason === true || markerSerializeReason.state) {
               write`<!>`;
             } else {
-              write`${callRuntime("_sep", getSerializeGuard(markerSerializeReason, true))}`;
+              write`${callRuntime("_sep", getSerializeGuard(section, markerSerializeReason, true))}`;
             }
           }
           visit(placeholder, 37 /* Replace */);
@@ -11455,10 +11743,10 @@ var placeholder_default = {
             "render",
             getSection(placeholder),
             valueExtra.referencedBindings,
-            import_compiler57.types.expressionStatement(
+            import_compiler59.types.expressionStatement(
               method === "_text" ? callRuntime(
                 "_text",
-                import_compiler57.types.memberExpression(
+                import_compiler59.types.memberExpression(
                   scopeIdentifier,
                   getScopeAccessorLiteral(nodeBinding),
                   true
@@ -11497,7 +11785,7 @@ function analyzeSiblingText(placeholder) {
       break;
     }
   }
-  if (!prev.node && import_compiler57.types.isProgram(placeholder.parentPath)) {
+  if (!prev.node && import_compiler59.types.isProgram(placeholder.parentPath)) {
     return placeholderExtra[kSiblingText] = 1 /* Before */;
   }
   let next = placeholder.getNextSibling();
@@ -11514,7 +11802,7 @@ function analyzeSiblingText(placeholder) {
       break;
     }
   }
-  if (!next.node && import_compiler57.types.isProgram(placeholder.parentPath)) {
+  if (!next.node && import_compiler59.types.isProgram(placeholder.parentPath)) {
     return placeholderExtra[kSiblingText] = 2 /* After */;
   }
   return placeholderExtra[kSiblingText] = 0 /* None */;
@@ -11556,7 +11844,7 @@ function isEmptyPlaceholder(placeholder) {
 }
 
 // src/translator/visitors/referenced-identifier.ts
-var import_compiler58 = require("@marko/compiler");
+var import_compiler60 = require("@marko/compiler");
 var abortIdsByExpressionForSection = /* @__PURE__ */ new WeakMap();
 var referenced_identifier_default = {
   migrate(identifier) {
@@ -11564,8 +11852,8 @@ var referenced_identifier_default = {
     if (identifier.scope.hasBinding(name2)) return;
     switch (name2) {
       case "out":
-        if (import_compiler58.types.isMemberExpression(identifier.parent) && import_compiler58.types.isIdentifier(identifier.parent.property) && identifier.parent.property.name === "global") {
-          identifier.parentPath.replaceWith(import_compiler58.types.identifier("$global"));
+        if (import_compiler60.types.isMemberExpression(identifier.parent) && import_compiler60.types.isIdentifier(identifier.parent.property) && identifier.parent.property.name === "global") {
+          identifier.parentPath.replaceWith(import_compiler60.types.identifier("$global"));
         } else {
           throw identifier.buildCodeFrameError(
             "Only `out.global` is supported for compatibility."
@@ -11592,24 +11880,24 @@ var referenced_identifier_default = {
       case "$global":
         if (isOutputHTML()) {
           identifier.replaceWith(
-            import_compiler58.types.callExpression(importRuntime("$global"), [])
+            import_compiler60.types.callExpression(importRuntime("$global"), [])
           );
         } else {
           identifier.replaceWith(
-            import_compiler58.types.memberExpression(scopeIdentifier, import_compiler58.types.identifier("$global"))
+            import_compiler60.types.memberExpression(scopeIdentifier, import_compiler60.types.identifier("$global"))
           );
         }
         break;
       case "$signal":
         if (isOutputHTML()) {
           identifier.replaceWith(
-            import_compiler58.types.callExpression(
-              import_compiler58.types.arrowFunctionExpression(
+            import_compiler60.types.callExpression(
+              import_compiler60.types.arrowFunctionExpression(
                 [],
-                import_compiler58.types.blockStatement([
-                  import_compiler58.types.throwStatement(
-                    import_compiler58.types.newExpression(import_compiler58.types.identifier("Error"), [
-                      import_compiler58.types.stringLiteral("Cannot use $signal in a server render.")
+                import_compiler60.types.blockStatement([
+                  import_compiler60.types.throwStatement(
+                    import_compiler60.types.newExpression(import_compiler60.types.identifier("Error"), [
+                      import_compiler60.types.stringLiteral("Cannot use $signal in a server render.")
                     ])
                   )
                 ])
@@ -11635,19 +11923,19 @@ var referenced_identifier_default = {
               "render",
               section,
               exprRoot.node.extra?.referencedBindings,
-              import_compiler58.types.expressionStatement(
-                import_compiler58.types.callExpression(importRuntime("$signalReset"), [
+              import_compiler60.types.expressionStatement(
+                import_compiler60.types.callExpression(importRuntime("$signalReset"), [
                   scopeIdentifier,
-                  import_compiler58.types.numericLiteral(exprId)
+                  import_compiler60.types.numericLiteral(exprId)
                 ])
               ),
               false
             );
           }
           identifier.replaceWith(
-            import_compiler58.types.callExpression(importRuntime("$signal"), [
+            import_compiler60.types.callExpression(importRuntime("$signal"), [
               scopeIdentifier,
-              import_compiler58.types.numericLiteral(exprId)
+              import_compiler60.types.numericLiteral(exprId)
             ])
           );
         }
@@ -11691,11 +11979,11 @@ var scriptlet_default = {
 };
 
 // src/translator/visitors/tag/index.ts
-var import_compiler62 = require("@marko/compiler");
+var import_compiler64 = require("@marko/compiler");
 var import_babel_utils52 = require("@marko/compiler/babel-utils");
 
 // src/translator/visitors/tag/attribute-tag.ts
-var import_compiler59 = require("@marko/compiler");
+var import_compiler61 = require("@marko/compiler");
 var import_babel_utils49 = require("@marko/compiler/babel-utils");
 var attribute_tag_default = {
   analyze: {
@@ -11728,7 +12016,7 @@ var attribute_tag_default = {
 };
 
 // src/translator/visitors/tag/custom-tag.ts
-var import_compiler60 = require("@marko/compiler");
+var import_compiler62 = require("@marko/compiler");
 var import_babel_utils50 = require("@marko/compiler/babel-utils");
 var import_path4 = __toESM(require("path"));
 var custom_tag_default = {
@@ -11782,9 +12070,9 @@ function translateHTML(tag) {
   const childProgram = (0, import_babel_utils50.loadFileForTag)(tag).ast.program;
   const childExtra = childProgram.extra;
   let tagIdentifier;
-  if (import_compiler60.types.isStringLiteral(node.name)) {
+  if (import_compiler62.types.isStringLiteral(node.name)) {
     const relativePath = getTagRelativePath(tag);
-    tagIdentifier = isCircularRequest(tag.hub.file, relativePath) ? import_compiler60.types.identifier(getTemplateContentName()) : (0, import_babel_utils50.importDefault)(tag.hub.file, relativePath, getTagName(tag));
+    tagIdentifier = isCircularRequest(tag.hub.file, relativePath) ? import_compiler62.types.identifier(getTemplateContentName()) : (0, import_babel_utils50.importDefault)(tag.hub.file, relativePath, getTagName(tag));
   } else {
     tagIdentifier = node.name;
   }
@@ -11805,7 +12093,7 @@ function translateDOM(tag) {
   const childExtra = childFile.ast.program.extra;
   const childExports = childExtra.domExports;
   const childSection = childExtra.section;
-  const tagName = import_compiler60.types.isIdentifier(node.name) ? node.name.name : import_compiler60.types.isStringLiteral(node.name) ? node.name.value : "tag";
+  const tagName = import_compiler62.types.isIdentifier(node.name) ? node.name.name : import_compiler62.types.isStringLiteral(node.name) ? node.name.value : "tag";
   if (programSection === childSection) {
     knownTagTranslateDOM(
       tag,
@@ -11816,16 +12104,16 @@ function translateDOM(tag) {
           "render",
           section,
           void 0,
-          import_compiler60.types.expressionStatement(
-            import_compiler60.types.callExpression(import_compiler60.types.identifier(childExports.setup), [
+          import_compiler62.types.expressionStatement(
+            import_compiler62.types.callExpression(import_compiler62.types.identifier(childExports.setup), [
               createScopeReadExpression(section, childBinding)
             ])
           )
         );
       }
     );
-    write`${import_compiler60.types.identifier(childExports.template)}`;
-    injectWalks(tag, import_compiler60.types.identifier(childExports.walks));
+    write`${import_compiler62.types.identifier(childExports.template)}`;
+    injectWalks(tag, import_compiler62.types.identifier(childExports.walks));
   } else {
     knownTagTranslateDOM(
       tag,
@@ -11841,8 +12129,8 @@ function translateDOM(tag) {
           "render",
           section,
           void 0,
-          import_compiler60.types.expressionStatement(
-            import_compiler60.types.callExpression(
+          import_compiler62.types.expressionStatement(
+            import_compiler62.types.callExpression(
               importOrSelfReferenceName(
                 file,
                 relativePath,
@@ -11869,7 +12157,7 @@ function getTagRelativePath(tag) {
     hub: { file }
   } = tag;
   let relativePath;
-  if (import_compiler60.types.isStringLiteral(node.name)) {
+  if (import_compiler62.types.isStringLiteral(node.name)) {
     const template = (0, import_babel_utils50.getTagTemplate)(tag);
     relativePath = template && (0, import_babel_utils50.resolveRelativePath)(file, template);
   } else if (node.extra?.tagNameImported) {
@@ -11890,7 +12178,7 @@ function getTagRelativePath(tag) {
 }
 function importOrSelfReferenceName(file, request, name2, nameHint) {
   if (isCircularRequest(file, request)) {
-    return import_compiler60.types.identifier(name2);
+    return import_compiler62.types.identifier(name2);
   }
   return (0, import_babel_utils50.importNamed)(file, request, name2, nameHint);
 }
@@ -11900,7 +12188,7 @@ function isCircularRequest(file, request) {
 }
 
 // src/translator/visitors/tag/dynamic-tag.ts
-var import_compiler61 = require("@marko/compiler");
+var import_compiler63 = require("@marko/compiler");
 var import_babel_utils51 = require("@marko/compiler/babel-utils");
 var kDOMBinding3 = Symbol("dynamic tag dom binding");
 var kChildOffsetScopeBinding2 = Symbol("custom tag scope offset");
@@ -11932,7 +12220,7 @@ var dynamic_tag_default = {
         tagSection
       );
       if (hasVar || tag.node.attributes.some(
-        (attr) => import_compiler61.types.isMarkoSpreadAttribute(attr) || isEventOrChangeHandler(attr.name)
+        (attr) => import_compiler63.types.isMarkoSpreadAttribute(attr) || isEventOrChangeHandler(attr.name)
       )) {
         (0, import_babel_utils51.getProgram)().node.extra.isInteractive = true;
       }
@@ -11972,7 +12260,7 @@ var dynamic_tag_default = {
         if (isOutputHTML()) {
           knownTagTranslateHTML(
             tag,
-            import_compiler61.types.memberExpression(tag.node.name, import_compiler61.types.identifier("content")),
+            import_compiler63.types.memberExpression(tag.node.name, import_compiler63.types.identifier("content")),
             definedBodySection,
             propTree
           );
@@ -11989,9 +12277,9 @@ var dynamic_tag_default = {
                   "render",
                   section,
                   void 0,
-                  import_compiler61.types.expressionStatement(
-                    import_compiler61.types.callExpression(
-                      import_compiler61.types.memberExpression(signal.identifier, import_compiler61.types.identifier("_")),
+                  import_compiler63.types.expressionStatement(
+                    import_compiler63.types.callExpression(
+                      import_compiler63.types.memberExpression(signal.identifier, import_compiler63.types.identifier("_")),
                       [
                         createScopeReadExpression(section, childBinding),
                         getScopeExpression(section, definedBodySection.parent)
@@ -12015,7 +12303,7 @@ var dynamic_tag_default = {
       const nodeBinding = tagExtra[kDOMBinding3];
       const isClassAPI = tagExtra.featureType === "class";
       let tagExpression = node.name;
-      if (import_compiler61.types.isStringLiteral(tagExpression)) {
+      if (import_compiler63.types.isStringLiteral(tagExpression)) {
         tagExpression = (0, import_babel_utils51.importDefault)(
           tag.hub.file,
           getTagRelativePath(tag),
@@ -12025,14 +12313,14 @@ var dynamic_tag_default = {
       if (isClassAPI) {
         if (isOutputHTML()) {
           (0, import_babel_utils51.getProgram)().node.body.push(
-            import_compiler61.types.markoScriptlet(
+            import_compiler63.types.markoScriptlet(
               [
-                import_compiler61.types.expressionStatement(
-                  import_compiler61.types.callExpression(
+                import_compiler63.types.expressionStatement(
+                  import_compiler63.types.callExpression(
                     (0, import_babel_utils51.importNamed)(tag.hub.file, getCompatRuntimeFile(), "s"),
                     [
-                      import_compiler61.types.identifier(tagExpression.name),
-                      import_compiler61.types.stringLiteral((0, import_babel_utils51.loadFileForTag)(tag).metadata.marko.id)
+                      import_compiler63.types.identifier(tagExpression.name),
+                      import_compiler63.types.stringLiteral((0, import_babel_utils51.loadFileForTag)(tag).metadata.marko.id)
                     ]
                   )
                 )
@@ -12042,11 +12330,11 @@ var dynamic_tag_default = {
           );
         } else {
           (0, import_babel_utils51.getProgram)().node.body.push(
-            import_compiler61.types.expressionStatement(
+            import_compiler63.types.expressionStatement(
               callRuntime(
                 "_resume",
-                import_compiler61.types.stringLiteral((0, import_babel_utils51.loadFileForTag)(tag).metadata.marko.id),
-                import_compiler61.types.identifier(tagExpression.name)
+                import_compiler63.types.stringLiteral((0, import_babel_utils51.loadFileForTag)(tag).metadata.marko.id),
+                import_compiler63.types.identifier(tagExpression.name)
               )
             )
           );
@@ -12079,6 +12367,7 @@ var dynamic_tag_default = {
         flushInto(tag);
         writeHTMLResumeStatements(tag.get("body"));
         const serializeArg = getSerializeGuard(
+          tagSection,
           getSerializeReason(tagSection, nodeBinding),
           true
         );
@@ -12087,9 +12376,9 @@ var dynamic_tag_default = {
           getScopeIdIdentifier(tagSection),
           getScopeAccessorLiteral(nodeBinding),
           tagExpression,
-          import_compiler61.types.arrayExpression(args),
-          import_compiler61.types.numericLiteral(0),
-          import_compiler61.types.numericLiteral(1),
+          import_compiler63.types.arrayExpression(args),
+          import_compiler63.types.numericLiteral(0),
+          import_compiler63.types.numericLiteral(1),
           serializeArg
         ) : callRuntime(
           "_dynamic_tag",
@@ -12097,8 +12386,8 @@ var dynamic_tag_default = {
           getScopeAccessorLiteral(nodeBinding),
           tagExpression,
           args[0],
-          args[1] || (serializeArg ? import_compiler61.types.numericLiteral(0) : void 0),
-          serializeArg ? import_compiler61.types.numericLiteral(0) : void 0,
+          args[1] || (serializeArg ? import_compiler63.types.numericLiteral(0) : void 0),
+          serializeArg ? import_compiler63.types.numericLiteral(0) : void 0,
           serializeArg
         );
         if (node.var) {
@@ -12106,18 +12395,18 @@ var dynamic_tag_default = {
             tag.get("name").toString() + "_scope"
           );
           statements.push(
-            import_compiler61.types.variableDeclaration("const", [
-              import_compiler61.types.variableDeclarator(
+            import_compiler63.types.variableDeclaration("const", [
+              import_compiler63.types.variableDeclarator(
                 dynamicScopeIdentifier,
                 callRuntime("_peek_scope_id")
               )
             ])
           );
           statements.push(
-            import_compiler61.types.variableDeclaration("let", [
-              import_compiler61.types.variableDeclarator(node.var, dynamicTagExpr)
+            import_compiler63.types.variableDeclaration("let", [
+              import_compiler63.types.variableDeclarator(node.var, dynamicTagExpr)
             ]),
-            import_compiler61.types.expressionStatement(
+            import_compiler63.types.expressionStatement(
               callRuntime(
                 "_var",
                 getScopeIdIdentifier(tagSection),
@@ -12125,7 +12414,7 @@ var dynamic_tag_default = {
                   tag.node.extra[kChildOffsetScopeBinding2]
                 ),
                 dynamicScopeIdentifier,
-                import_compiler61.types.stringLiteral(
+                import_compiler63.types.stringLiteral(
                   getResumeRegisterId(
                     tagSection,
                     node.var.extra?.binding,
@@ -12137,7 +12426,7 @@ var dynamic_tag_default = {
             )
           );
         } else {
-          statements.push(import_compiler61.types.expressionStatement(dynamicTagExpr));
+          statements.push(import_compiler63.types.expressionStatement(dynamicTagExpr));
         }
         for (const replacement of tag.replaceWithMultiple(statements)) {
           replacement.skip();
@@ -12156,9 +12445,9 @@ var dynamic_tag_default = {
           tagVarSignal.register = true;
           tagVarSignal.buildAssignment = (valueSection, value) => {
             const changeArgs = [
-              import_compiler61.types.memberExpression(
+              import_compiler63.types.memberExpression(
                 getScopeExpression(tagVarSignal.section, valueSection),
-                import_compiler61.types.stringLiteral(
+                import_compiler63.types.stringLiteral(
                   getAccessorPrefix().ConditionalScope + getScopeAccessor(nodeBinding)
                 ),
                 true
@@ -12166,28 +12455,28 @@ var dynamic_tag_default = {
               value
             ];
             if (!isOptimize()) {
-              changeArgs.push(import_compiler61.types.stringLiteral(varBinding.name));
+              changeArgs.push(import_compiler63.types.stringLiteral(varBinding.name));
             }
-            return import_compiler61.types.callExpression(importRuntime("_var_change"), changeArgs);
+            return import_compiler63.types.callExpression(importRuntime("_var_change"), changeArgs);
           };
         }
         signal.build = () => {
           return callRuntime(
             "_dynamic_tag",
             getScopeAccessorLiteral(nodeBinding),
-            bodySection && import_compiler61.types.identifier(bodySection.name),
-            tagVarSignal ? import_compiler61.types.arrowFunctionExpression([], tagVarSignal.identifier) : void 0,
-            hasTagArgs && import_compiler61.types.numericLiteral(1)
+            bodySection && import_compiler63.types.identifier(bodySection.name),
+            tagVarSignal ? import_compiler63.types.arrowFunctionExpression([], tagVarSignal.identifier) : void 0,
+            hasTagArgs && import_compiler63.types.numericLiteral(1)
           );
         };
         if (args.length) {
-          const argsOrInput = hasTagArgs ? import_compiler61.types.arrayExpression(args) : args[0];
-          if (!import_compiler61.types.isObjectExpression(argsOrInput) || argsOrInput.properties.length) {
+          const argsOrInput = hasTagArgs ? import_compiler63.types.arrayExpression(args) : args[0];
+          if (!import_compiler63.types.isObjectExpression(argsOrInput) || argsOrInput.properties.length) {
             signal.extraArgs = [
-              import_compiler61.types.arrowFunctionExpression(
+              import_compiler63.types.arrowFunctionExpression(
                 [],
-                statements.length ? import_compiler61.types.blockStatement(
-                  statements.concat(import_compiler61.types.returnStatement(argsOrInput))
+                statements.length ? import_compiler63.types.blockStatement(
+                  statements.concat(import_compiler63.types.returnStatement(argsOrInput))
                 ) : argsOrInput
               )
             ];
@@ -12201,34 +12490,7 @@ var dynamic_tag_default = {
 };
 
 // src/translator/visitors/tag/index.ts
-var TAG_NAME_IDENTIFIER_REG = /^[A-Z][a-zA-Z0-9_$]*$/;
-var BINDING_CHANGE_HANDLER = /* @__PURE__ */ new WeakMap();
 var tag_default = {
-  transform: {
-    enter(tag) {
-      const { node } = tag;
-      const { name: name2, attributes } = tag.node;
-      let crawl = false;
-      if (import_compiler62.types.isStringLiteral(name2)) {
-        const tagName = name2.value;
-        if (tag.scope.getBinding(tagName) && TAG_NAME_IDENTIFIER_REG.test(tagName)) {
-          node.name = withPreviousLocation(import_compiler62.types.identifier(tagName), name2);
-          crawl = true;
-        }
-      }
-      for (let i = 0; i < attributes.length; i++) {
-        const attr = attributes[i];
-        if (import_compiler62.types.isMarkoAttribute(attr) && attr.bound) {
-          attr.bound = false;
-          attributes.splice(++i, 0, getChangeHandler(tag, attr));
-          crawl = true;
-        }
-      }
-      if (crawl) {
-        tag.scope.crawl();
-      }
-    }
-  },
   analyze: {
     enter(tag) {
       const tagDef = (0, import_babel_utils52.getTagDef)(tag);
@@ -12294,8 +12556,8 @@ var tag_default = {
       if (extra.tagNameDynamic && extra.tagNameNullable && !tag.get("name").isIdentifier() && isOutputHTML()) {
         const tagNameId = generateUidIdentifier("tagName");
         const [tagNameVarPath] = tag.insertBefore(
-          import_compiler62.types.variableDeclaration("const", [
-            import_compiler62.types.variableDeclarator(tagNameId, tag.node.name)
+          import_compiler64.types.variableDeclaration("const", [
+            import_compiler64.types.variableDeclarator(tagNameId, tag.node.name)
           ])
         );
         tagNameVarPath.skip();
@@ -12339,152 +12601,9 @@ var tag_default = {
     }
   }
 };
-function getChangeHandler(tag, attr) {
-  const attrName = attr.name;
-  const changeAttrName = attrName + "Change";
-  if (import_compiler62.types.isIdentifier(attr.value)) {
-    const binding = tag.scope.getBinding(attr.value.name);
-    if (!binding)
-      return import_compiler62.types.markoAttribute(
-        changeAttrName,
-        buildChangeHandlerFunction(attr.value)
-      );
-    const existingChangedAttr = BINDING_CHANGE_HANDLER.get(binding.identifier);
-    if (!existingChangedAttr) {
-      const bindingIdentifierPath = binding.path.getOuterBindingIdentifierPaths()[binding.identifier.name];
-      const changeAttrExpr = bindingIdentifierPath ? bindingIdentifierPath.parentPath === binding.path ? buildChangeHandlerFunction(attr.value) : bindingIdentifierPath.parentPath.isObjectProperty() ? getChangeHandlerFromObjectPattern(
-        bindingIdentifierPath.parentPath
-      ) : void 0 : void 0;
-      if (!changeAttrExpr) {
-        throw tag.hub.buildError(attr.value, "Unable to bind to value.");
-      }
-      const changeHandlerAttr = import_compiler62.types.markoAttribute(
-        changeAttrName,
-        changeAttrExpr
-      );
-      BINDING_CHANGE_HANDLER.set(binding.identifier, changeHandlerAttr);
-      return changeHandlerAttr;
-    }
-    if (existingChangedAttr.type === "Identifier") {
-      return import_compiler62.types.markoAttribute(
-        changeAttrName,
-        withPreviousLocation(
-          import_compiler62.types.identifier(existingChangedAttr.name),
-          attr.value
-        )
-      );
-    }
-    const markoRoot = isMarko(binding.path) ? binding.path : getMarkoRoot(binding.path);
-    if (!(markoRoot?.isMarkoTag() || markoRoot?.isMarkoTagBody())) {
-      throw tag.hub.buildError(attr.value, "Unable to bind to value.");
-    }
-    const changeHandlerId = generateUid(changeAttrName);
-    const changeHandlerConst = import_compiler62.types.markoTag(
-      import_compiler62.types.stringLiteral("const"),
-      [import_compiler62.types.markoAttribute("value", existingChangedAttr.value, null, null, true)],
-      import_compiler62.types.markoTagBody([]),
-      null,
-      import_compiler62.types.identifier(changeHandlerId)
-    );
-    BINDING_CHANGE_HANDLER.set(
-      binding.identifier,
-      existingChangedAttr.value = import_compiler62.types.identifier(changeHandlerId)
-    );
-    if (markoRoot.isMarkoTag()) {
-      markoRoot.insertAfter(changeHandlerConst);
-    } else {
-      markoRoot.unshiftContainer("body", changeHandlerConst);
-    }
-    markoRoot.scope.crawl();
-    return import_compiler62.types.markoAttribute(
-      changeAttrName,
-      withPreviousLocation(import_compiler62.types.identifier(changeHandlerId), attr.value)
-    );
-  } else if (import_compiler62.types.isMemberExpression(attr.value)) {
-    const prop = attr.value.property;
-    if (!import_compiler62.types.isPrivateName(attr.value.property)) {
-      return import_compiler62.types.markoAttribute(
-        changeAttrName,
-        import_compiler62.types.memberExpression(
-          import_compiler62.types.cloneNode(attr.value.object),
-          prop.type === "Identifier" ? withPreviousLocation(import_compiler62.types.identifier(prop.name + "Change"), prop) : import_compiler62.types.binaryExpression(
-            "+",
-            import_compiler62.types.cloneNode(prop),
-            import_compiler62.types.stringLiteral("Change")
-          ),
-          prop.type !== "Identifier"
-        )
-      );
-    }
-  }
-  throw tag.hub.buildError(
-    attr.value,
-    "Attributes may only be bound to identifiers or member expressions"
-  );
-}
-function buildChangeHandlerFunction(id) {
-  const newId = "_new_" + id.name;
-  return import_compiler62.types.arrowFunctionExpression(
-    [withPreviousLocation(import_compiler62.types.identifier(newId), id)],
-    import_compiler62.types.blockStatement([
-      import_compiler62.types.expressionStatement(
-        import_compiler62.types.assignmentExpression(
-          "=",
-          withPreviousLocation(import_compiler62.types.identifier(id.name), id),
-          withPreviousLocation(import_compiler62.types.identifier(newId), id)
-        )
-      )
-    ])
-  );
-}
-function getChangeHandlerFromObjectPattern(parent) {
-  let changeKey;
-  const pattern = parent.parentPath;
-  if (parent.node.computed) {
-    changeKey = generateUidIdentifier(`dynamicChange`);
-    pattern.pushContainer(
-      "properties",
-      import_compiler62.types.objectProperty(
-        import_compiler62.types.binaryExpression(
-          "+",
-          parent.get("key").node,
-          import_compiler62.types.stringLiteral("Change")
-        ),
-        changeKey,
-        true
-      )
-    );
-  } else {
-    const key = parent.get("key");
-    const searchKey = `${getStringOrIdentifierValue(key)}Change`;
-    for (const prop of pattern.get("properties")) {
-      if (prop.isObjectProperty()) {
-        const propKey = prop.get("key");
-        const propValue = prop.get("value");
-        if (!prop.node.computed && getStringOrIdentifierValue(propKey) === searchKey && propValue.isIdentifier()) {
-          changeKey = propValue.node;
-          break;
-        }
-      }
-    }
-    if (!changeKey) {
-      pattern.unshiftContainer(
-        "properties",
-        import_compiler62.types.objectProperty(
-          import_compiler62.types.stringLiteral(searchKey),
-          changeKey = generateUidIdentifier(searchKey)
-        )
-      );
-    }
-  }
-  return changeKey;
-}
-function getStringOrIdentifierValue(path5) {
-  return path5.isStringLiteral() ? path5.node.value : path5.node.name;
-}
 
 // src/translator/visitors/text.ts
-var import_compiler63 = require("@marko/compiler");
+var import_compiler65 = require("@marko/compiler");
 var text_default = {
   translate: {
     exit(text) {