marko 6.0.130 → 6.0.132

package/dist/translator/index.js

@@ -128,7 +128,7 @@ var AccessorPrefix = /* @__PURE__ */ ((AccessorPrefix4) => {
   AccessorPrefix4["DynamicHTMLLastChild"] = "DynamicHTMLLastChild:";
   AccessorPrefix4["EventAttributes"] = "EventAttributes:";
   AccessorPrefix4["Getter"] = "Getter:";
-  AccessorPrefix4["LifecycleAbortController"] = "LifecycleAbortController:";
+  AccessorPrefix4["Lifecycle"] = "Lifecycle:";
   AccessorPrefix4["Promise"] = "Promise:";
   AccessorPrefix4["TagVariableChange"] = "TagVariableChange:";
   return AccessorPrefix4;
@@ -1118,6 +1118,15 @@ function fromIter(data) {
   }
   return many || one;
 }
+function* toIter(data) {
+  if (data !== void 0) {
+    if (Array.isArray(data)) {
+      yield* data;
+    } else {
+      yield data;
+    }
+  }
+}
 function includes(data, item) {
   return data !== void 0 ? Array.isArray(data) ? data.includes(item) : data === item : false;
 }
@@ -1284,7 +1293,7 @@ var AccessorPrefix2 = /* @__PURE__ */ ((AccessorPrefix4) => {
   AccessorPrefix4["DynamicHTMLLastChild"] = "H";
   AccessorPrefix4["EventAttributes"] = "I";
   AccessorPrefix4["Getter"] = "J";
-  AccessorPrefix4["LifecycleAbortController"] = "K";
+  AccessorPrefix4["Lifecycle"] = "K";
   AccessorPrefix4["Promise"] = "L";
   AccessorPrefix4["TagVariableChange"] = "M";
   return AccessorPrefix4;
@@ -1886,7 +1895,10 @@ function getSectionRegisterReasons(section) {
   if (section.isBranch) return false;
   const { downstreamBinding } = section;
   if (downstreamBinding) {
-    return getAllSerializeReasonsForBinding(downstreamBinding);
+    return getAllSerializeReasonsForBinding(
+      downstreamBinding.binding,
+      downstreamBinding.properties
+    );
   } else if (downstreamBinding === false) {
     return false;
   }
@@ -1963,7 +1975,10 @@ function finalizeParamSerializeReasonGroups(section) {
 }
 function ensureParamReasonGroup(section, reason) {
   const { paramReasonGroups } = section;
-  const group = { id: Symbol(), reason };
+  const group = {
+    id: Symbol(getDebugNames(reason)),
+    reason
+  };
   if (paramReasonGroups) {
     const found = findSorted(compareParamGroups, paramReasonGroups, group);
     if (found) return found;
@@ -2061,7 +2076,7 @@ function canIgnoreRegister(markoRoot, exprRoot) {
     markoRoot.isMarkoPlaceholder() || // bail within a server only statement
     markoRoot.isMarkoScriptlet() && (!markoRoot.node.static || markoRoot.node.target === "server") || // bail within the tag name
     markoRoot.isMarkoTag() && markoRoot.node.name == exprRoot.node || isMarkoAttribute(markoRoot) && (analyzeTagNameType(markoRoot.parentPath) === 0 /* NativeTag */ && // TODO: all native tag functions should avoid registration but right now change handlers require it.
-    /^on[A-Z-]/.test(markoRoot.node.name) || isCoreTagName(markoRoot.parentPath, "script") || isCoreTagName(markoRoot.parentPath, "lifecycle") || isCoreTagName(markoRoot.parentPath, "for"))
+    /^on[A-Z-]/.test(markoRoot.node.name) && !hasSpreadAttributeAfter(markoRoot) || isCoreTagName(markoRoot.parentPath, "script") || isCoreTagName(markoRoot.parentPath, "lifecycle") || isCoreTagName(markoRoot.parentPath, "for"))
   );
 }
 function getStaticDeclRefs(fnExtra, path7, refs = /* @__PURE__ */ new Set()) {
@@ -2110,6 +2125,13 @@ function shouldAlwaysRegister(markoRoot) {
   }
   return false;
 }
+function hasSpreadAttributeAfter(attr) {
+  const attrs = attr.parent.attributes;
+  for (let i = attr.key + 1; i < attrs.length; i++) {
+    if (attrs[i].type === "MarkoSpreadAttribute") return true;
+  }
+  return false;
+}
 function getTagFromMarkoRoot(markoRoot) {
   let cur = markoRoot;
   do {
@@ -2233,26 +2255,17 @@ var import_compiler27 = require("@marko/compiler");
 var import_babel_utils17 = require("@marko/compiler/babel-utils");
 var import_path2 = __toESM(require("path"));
 
-// src/translator/util/binding-has-downstream-expressions.ts
-function bindingHasDownstreamExpressions(binding) {
-  if (binding.downstreamExpressions.size) return true;
-  for (const alias of binding.aliases) {
-    if (bindingHasDownstreamExpressions(alias)) return true;
-  }
-  for (const alias of binding.propertyAliases.values()) {
-    if (bindingHasDownstreamExpressions(alias)) return true;
-  }
-  return false;
-}
-
 // src/translator/util/binding-prop-tree.ts
 function getBindingPropTree(binding) {
+  if (pruneBinding(binding)) {
+    return void 0;
+  }
   const props = {
     binding,
     props: void 0,
     rest: void 0
   };
-  if (!binding.downstreamExpressions.size) {
+  if (!binding.reads.size) {
     if (!binding.aliases.size) {
       props.props = {};
       for (const [property, alias] of binding.propertyAliases) {
@@ -2291,12 +2304,20 @@ function hasSupersetExcludeProperties(binding, excludeProperties) {
   }
   return true;
 }
-function getBindingPropTreeProp(propTree, name2) {
-  return propTree.props?.[name2] || propTree.rest?.props?.[name2];
+function getKnownFromPropTree(propTree, name2) {
+  return propTree === true ? true : propTree.props ? propTree.props[name2] || (propTree.rest ? getKnownFromPropTree(propTree.rest, name2) : void 0) : includes(propTree.binding.excludeProperties, name2) ? void 0 : true;
 }
-function getAllBindingPropTreePropKeys(propTree) {
+function getAllKnownPropNames(propTree) {
   const keys = propTree.props ? Object.keys(propTree.props) : [];
-  return propTree.rest?.props ? keys.concat(Object.keys(propTree.rest.props)) : keys;
+  if (propTree.rest?.props) {
+    for (const key of Object.keys(propTree.rest.props)) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+function hasAllKnownProps(propTree) {
+  return propTree.props && (!propTree.rest || !!propTree.rest.props);
 }
 
 // src/translator/util/entry-builder.ts
@@ -2626,6 +2647,36 @@ function getCompatRuntimeFile() {
 var import_compiler23 = require("@marko/compiler");
 var import_babel_utils16 = require("@marko/compiler/babel-utils");
 
+// src/translator/util/binding-has-prop.ts
+function bindingHasProperty(binding, properties) {
+  if (binding.pruned) {
+    return false;
+  } else if (binding.pruned === void 0) {
+    throw new Error("Binding must be pruned before checking properties");
+  }
+  if (binding.reads.size || !properties) {
+    return true;
+  }
+  let property;
+  let rest2;
+  if (Array.isArray(properties)) {
+    property = properties[0];
+    rest2 = properties.length === 2 ? properties[1] : properties.slice(1);
+  } else {
+    property = properties;
+  }
+  const propBinding = binding.propertyAliases.get(property);
+  if (propBinding && bindingHasProperty(propBinding, rest2)) {
+    return true;
+  }
+  for (const alias of binding.aliases) {
+    if (bindingHasProperty(alias, properties)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 // src/translator/util/get-style-file.ts
 var import_path = __toESM(require("path"));
 function getStyleFile(file) {
@@ -3998,7 +4049,7 @@ function writeHoists(section) {
         import_compiler22.types.variableDeclaration("const", [
           import_compiler22.types.variableDeclarator(
             hoistIdentifier,
-            hoistedBinding.downstreamExpressions.size ? callRuntime(
+            hoistedBinding.reads.size ? callRuntime(
               "_resume",
               // TODO: add _hoist_resume runtime
               import_compiler22.types.stringLiteral(
@@ -4013,7 +4064,7 @@ function writeHoists(section) {
           )
         ])
       );
-      if (hoistedBinding.downstreamExpressions.size) {
+      if (hoistedBinding.reads.size) {
         addValue(
           hoistedBinding.section,
           void 0,
@@ -4493,7 +4544,7 @@ var dom_default = {
       const walksIdentifier = import_compiler23.types.identifier(domExports.walks);
       const setupIdentifier = import_compiler23.types.identifier(domExports.setup);
       const inputBinding = program.node.params[0].extra?.binding;
-      const programInputSignal = inputBinding && bindingHasDownstreamExpressions(inputBinding) ? initValue(inputBinding) : void 0;
+      const programInputSignal = inputBinding && !inputBinding.pruned ? initValue(inputBinding) : void 0;
       let extraDecls = decls;
       const styleFile = getStyleFile(program.hub.file);
       if (styleFile) {
@@ -4527,7 +4578,10 @@ var dom_default = {
           const { walks: walks2, writes: writes2, decls: decls2 } = getSectionMeta(childSection);
           const setup = getSetup(childSection);
           writeSignals(childSection);
-          if (!childSection.downstreamBinding || bindingHasDownstreamExpressions(childSection.downstreamBinding)) {
+          if (!childSection.downstreamBinding || bindingHasProperty(
+            childSection.downstreamBinding.binding,
+            childSection.downstreamBinding.properties
+          )) {
             if (getSectionParentIsOwner(childSection)) {
               setBranchRendererArgs(childSection, [
                 writes2,
@@ -4653,7 +4707,7 @@ var html_default = {
         const sectionDynamicSubscribers = /* @__PURE__ */ new Set();
         forEach(section.hoisted, (binding) => {
           for (const hoistedBinding of binding.hoists.values()) {
-            if (hoistedBinding.downstreamExpressions.size) {
+            if (hoistedBinding.reads.size) {
               getHTMLSectionStatements(hoistedBinding.section).push(
                 import_compiler24.types.variableDeclaration("const", [
                   import_compiler24.types.variableDeclarator(
@@ -5208,7 +5262,7 @@ var program_default = {
       finalizeReferences();
       const programExtra = program.node.extra;
       const paramsBinding = programExtra.binding;
-      if (paramsBinding && bindingHasDownstreamExpressions(paramsBinding)) {
+      if (paramsBinding && !paramsBinding.pruned) {
         programExtra.domExports.params = getBindingPropTree(paramsBinding);
       }
     }
@@ -5401,40 +5455,39 @@ var [getTagDownstreams] = createSectionState(
   () => /* @__PURE__ */ new Map()
 );
 function setTagDownstream(tag, binding) {
-  getTagDownstreams(getSection(tag)).set(tag, binding || false);
+  if (binding) {
+    getTagDownstreams(getSection(tag)).set(tag, binding);
+  }
 }
 function finalizeTagDownstreams(section) {
   for (const [tag, binding] of getTagDownstreams(section)) {
-    crawlSectionsAndSetBinding(
-      tag,
-      binding,
-      binding ? getBindingPropTree(binding) : void 0
-    );
+    crawlSectionsAndSetBinding(tag, binding);
   }
 }
-function crawlSectionsAndSetBinding(tag, binding, tree, skip2) {
-  const attrTags2 = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
+function crawlSectionsAndSetBinding(tag, binding, properties, skip2) {
   if (!skip2) {
     const contentSection = getSectionForBody(tag.get("body"));
     if (contentSection) {
-      contentSection.downstreamBinding = tree && (tree.props?.["content"]?.binding || tree.binding) || binding;
+      contentSection.downstreamBinding = {
+        binding,
+        properties: concat(properties, "content")
+      };
     }
   }
+  const attrTagLookup = analyzeAttributeTags(tag);
+  if (!attrTagLookup) return;
+  const attrTags2 = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
   for (const child of attrTags2) {
     if (child.isMarkoTag()) {
       if ((0, import_babel_utils19.isAttributeTag)(child)) {
-        if (tree?.props) {
-          const attrProp = tree.props[getTagName(child).slice(1)];
-          if (attrProp) {
-            crawlSectionsAndSetBinding(child, attrProp.binding, attrProp);
-          } else {
-            crawlSectionsAndSetBinding(child, false, void 0);
-          }
-        } else {
-          crawlSectionsAndSetBinding(child, binding, void 0);
-        }
+        const attrTagMeta = attrTagLookup[getTagName(child)];
+        crawlSectionsAndSetBinding(
+          child,
+          binding,
+          concat(properties, attrTagMeta.name)
+        );
       } else {
-        crawlSectionsAndSetBinding(child, binding, tree, true);
+        crawlSectionsAndSetBinding(child, binding, properties, true);
       }
     }
   }
@@ -5621,7 +5674,7 @@ var native_tag_default = {
         const valueExtra = attr.value.extra ??= {};
         if (import_compiler33.types.isMarkoAttribute(attr)) {
           if (seen[attr.name]) {
-            dropReferences(attr.value);
+            dropNodes(attr.value);
             continue;
           }
           seen[attr.name] = attr;
@@ -6612,7 +6665,7 @@ var for_default = {
     if (isAttrTag) return;
     const bodySection = startSection(tagBody);
     if (!bodySection) {
-      dropReferences(getAllTagReferenceNodes(tag.node));
+      dropNodes(getAllTagReferenceNodes(tag.node));
       return;
     }
     const nodeBinding = getOptimizedOnlyChildNodeBinding(tag, tagSection);
@@ -6627,7 +6680,7 @@ var for_default = {
       const keyBinding = paramsBinding.propertyAliases.get(
         forType === "of" ? "1" : "0"
       );
-      if (keyBinding) {
+      if (keyBinding && !getKnownAttrValues(tag.node).by) {
         keyBinding.type = 7 /* constant */;
         keyBinding.scopeAccessor = getAccessorProp().LoopKey;
       }
@@ -6937,15 +6990,14 @@ function getBaseArgsInForTag(type, attrs) {
 
 // src/translator/util/translate-attrs.ts
 var contentProps = /* @__PURE__ */ new WeakSet();
-function translateAttrs(tag, propTree, skip2, statements = [], contentKey = "content") {
-  const templateExports = propTree && !propTree.rest ? propTree.props : void 0;
+function translateAttrs(tag, propTree = true, skip2, statements = [], contentKey = "content") {
   const properties = [];
   const attrTagLookup = tag.node.extra?.attributeTags;
   const seen = new Set(skip2);
   if (attrTagLookup) {
     for (const name2 in attrTagLookup) {
       const attrTagMeta = attrTagLookup[name2];
-      if (!seen.has(attrTagMeta.name) && usesExport(templateExports, attrTagMeta.name)) {
+      if (!seen.has(attrTagMeta.name) && getKnownFromPropTree(propTree, attrTagMeta.name)) {
         seen.add(attrTagMeta.name);
         if (attrTagMeta.dynamic) {
           statements.push(
@@ -6975,13 +7027,13 @@ function translateAttrs(tag, propTree, skip2, statements = [], contentKey = "con
               i,
               attrTagLookup,
               statements,
-              templateExports,
+              propTree,
               contentKey
             );
           } else {
             const translatedAttrTag = translateAttrs(
               child,
-              templateExports?.[attrTagMeta.name],
+              getKnownFromPropTree(propTree, attrTagMeta.name),
               void 0,
               statements,
               contentKey
@@ -7023,14 +7075,14 @@ function translateAttrs(tag, propTree, skip2, statements = [], contentKey = "con
             i,
             attrTagLookup,
             statements,
-            templateExports,
+            propTree,
             contentKey
           );
         }
       }
     }
   }
-  if (!seen.has(contentKey) && usesExport(templateExports, contentKey)) {
+  if (!seen.has(contentKey) && getKnownFromPropTree(propTree, contentKey)) {
     const contentExpression = buildContent(tag.get("body"));
     if (contentExpression) {
       const contentProp = import_compiler36.types.objectProperty(
@@ -7048,7 +7100,7 @@ function translateAttrs(tag, propTree, skip2, statements = [], contentKey = "con
     const { value } = attr;
     if (import_compiler36.types.isMarkoSpreadAttribute(attr)) {
       properties.push(import_compiler36.types.spreadElement(value));
-    } else if (!seen.has(attr.name) && usesExport(templateExports, attr.name)) {
+    } else if (!seen.has(attr.name) && getKnownFromPropTree(propTree, attr.name)) {
       seen.add(attr.name);
       properties.push(toObjectProperty(attr.name, value));
     }
@@ -7063,15 +7115,16 @@ function getTranslatedBodyContentProperty(props) {
     }
   }
 }
-function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements, templateExports, contentKey = "content") {
+function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements, propTree, contentKey = "content") {
   const tag = attrTags2[index];
   if (tag.isMarkoTag()) {
     if ((0, import_babel_utils24.isAttributeTag)(tag)) {
       const attrTagMeta = attrTagLookup[getTagName(tag)];
-      if (usesExport(templateExports, attrTagMeta.name) && attrTagMeta.dynamic) {
+      const attrTagExport = getKnownFromPropTree(propTree, attrTagMeta.name);
+      if (attrTagExport && attrTagMeta.dynamic) {
         const translatedAttrTag = translateAttrs(
           tag,
-          templateExports?.[attrTagMeta.name],
+          attrTagExport,
           void 0,
           statements,
           contentKey
@@ -7113,7 +7166,7 @@ function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements
             index,
             attrTagLookup,
             statements,
-            templateExports,
+            propTree,
             contentKey
           );
         case "for": {
@@ -7122,7 +7175,7 @@ function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements
             index,
             attrTagLookup,
             statements,
-            templateExports,
+            propTree,
             contentKey
           );
         }
@@ -7134,14 +7187,14 @@ function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements
 function propsToExpression(props) {
   return props.length === 1 && import_compiler36.types.isSpreadElement(props[0]) ? props[0].argument : import_compiler36.types.objectExpression(props);
 }
-function translateForAttrTag(attrTags2, index, attrTagLookup, statements, templateExports, contentKey) {
+function translateForAttrTag(attrTags2, index, attrTagLookup, statements, propTree, contentKey) {
   const forTag = attrTags2[index];
   const bodyStatements = [];
   addAllAttrTagsAsDynamic(
     forTag,
     attrTagLookup,
     bodyStatements,
-    templateExports,
+    propTree,
     contentKey
   );
   statements.push(
@@ -7154,7 +7207,7 @@ function translateForAttrTag(attrTags2, index, attrTagLookup, statements, templa
   );
   return index;
 }
-function translateIfAttrTag(attrTags2, index, attrTagLookup, statements, templateExports, contentKey) {
+function translateIfAttrTag(attrTags2, index, attrTagLookup, statements, propTree, contentKey) {
   const ifTag = attrTags2[index];
   const consequentStatements = [];
   let ifStatement = import_compiler36.types.ifStatement(
@@ -7166,7 +7219,7 @@ function translateIfAttrTag(attrTags2, index, attrTagLookup, statements, templat
     ifTag,
     attrTagLookup,
     consequentStatements,
-    templateExports,
+    propTree,
     contentKey
   );
   let nextIndex = index + 1;
@@ -7182,7 +7235,7 @@ function translateIfAttrTag(attrTags2, index, attrTagLookup, statements, templat
             nextTag,
             attrTagLookup,
             alternateStatements,
-            templateExports,
+            propTree,
             contentKey
           );
           if (testValue) {
@@ -7203,7 +7256,7 @@ function translateIfAttrTag(attrTags2, index, attrTagLookup, statements, templat
   }
   return nextIndex - 1;
 }
-function addAllAttrTagsAsDynamic(tag, attrTagLookup, statements, templateExports, contentKey) {
+function addAllAttrTagsAsDynamic(tag, attrTagLookup, statements, propTree, contentKey) {
   const attrTags2 = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
   for (let i = 0; i < attrTags2.length; i++) {
     i = addDynamicAttrTagStatements(
@@ -7211,14 +7264,11 @@ function addAllAttrTagsAsDynamic(tag, attrTagLookup, statements, templateExports
       i,
       attrTagLookup,
       statements,
-      templateExports,
+      propTree,
       contentKey
     );
   }
 }
-function usesExport(templateExports, name2) {
-  return !templateExports || !!templateExports[name2];
-}
 function findObjectProperty(name2, props) {
   for (const prop of props) {
     if (prop.type === "ObjectProperty") {
@@ -7537,7 +7587,7 @@ function finalizeKnownTags(section) {
 function analyzeParams(rootTagExtra, section, tag, propTree, rootAttrExprs) {
   const inputExpr = {};
   if (!propTree) {
-    dropReferences(getAllTagReferenceNodes(tag.node));
+    dropNodes(getAllTagReferenceNodes(tag.node));
     return inputExpr;
   }
   if (!propTree.props || tag.node.arguments?.some((node) => import_compiler37.types.isSpreadElement(node))) {
@@ -7555,7 +7605,7 @@ function analyzeParams(rootTagExtra, section, tag, propTree, rootAttrExprs) {
     for (const arg of tag.node.arguments) {
       const argExport = propTree.props[i];
       if (!argExport) {
-        dropReferences(arg);
+        dropNodes(arg);
         continue;
       }
       const argValueExtra = arg.extra ??= {};
@@ -7575,7 +7625,7 @@ function analyzeParams(rootTagExtra, section, tag, propTree, rootAttrExprs) {
   } else {
     const args = tag.node.arguments;
     tag.node.arguments = null;
-    dropReferences(getAllTagReferenceNodes(tag.node));
+    dropNodes(getAllTagReferenceNodes(tag.node));
     tag.node.arguments = args;
   }
   return inputExpr;
@@ -7594,10 +7644,12 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
   const known = inputExpr.known = {};
   const attrTagLookup = analyzeAttributeTags(tag);
   const seen = /* @__PURE__ */ new Set();
-  const unknownReferences = [];
+  const remaining = new Set(getAllKnownPropNames(propTree));
+  const dropReferenceNodes = [];
+  let restReferenceNodes;
   if (attrTagLookup) {
     const nodeReferencesByGroup = /* @__PURE__ */ new Map();
-    const analyzeDynamicChildGroup = (group, child) => {
+    const analyzeDynamicAttrTagChildGroup = (group, child) => {
       const referenceNodes = getAllTagReferenceNodes(child.node);
       const groupReferences = nodeReferencesByGroup.get(group);
       if (groupReferences) {
@@ -7617,35 +7669,44 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
       if (child.isMarkoTag()) {
         if ((0, import_babel_utils25.isAttributeTag)(child)) {
           const attrTagMeta = attrTagLookup[getTagName(child)];
-          const childAttrExports = propTree.props[attrTagMeta.name];
-          if (childAttrExports) {
-            if (childAttrExports.props && !attrTagMeta.dynamic) {
-              known[attrTagMeta.name] = analyzeAttrs(
-                rootTagExtra,
-                section,
-                child,
-                childAttrExports,
-                rootAttrExprs
-              );
-            } else {
-              analyzeDynamicChildGroup(attrTagMeta.group, child);
-            }
+          const childAttrExport = getKnownFromPropTree(
+            propTree,
+            attrTagMeta.name
+          );
+          if (!childAttrExport) {
+            getAllTagReferenceNodes(child.node, dropReferenceNodes);
+          } else if (attrTagMeta.dynamic) {
+            analyzeDynamicAttrTagChildGroup(attrTagMeta.group, child);
+          } else if (childAttrExport === true) {
+            getAllTagReferenceNodes(child.node, restReferenceNodes ||= []);
+            known[attrTagMeta.name] = {
+              value: rootTagExtra
+            };
+          } else if (childAttrExport.props) {
+            remaining.delete(attrTagMeta.name);
+            known[attrTagMeta.name] = analyzeAttrs(
+              rootTagExtra,
+              section,
+              child,
+              childAttrExport,
+              rootAttrExprs
+            );
           } else {
-            unknownReferences.push(getAllTagReferenceNodes(child.node));
+            analyzeDynamicAttrTagChildGroup(attrTagMeta.group, child);
           }
         } else {
           const group = child.node.extra.attributeTagGroup;
           let childUsesGroupProp = false;
           for (const name2 of group) {
-            if (propTree.props[attrTagLookup[name2].name]) {
+            if (getKnownFromPropTree(propTree, attrTagLookup[name2].name)) {
               childUsesGroupProp = true;
               break;
             }
           }
           if (childUsesGroupProp) {
-            analyzeDynamicChildGroup(group, child);
+            analyzeDynamicAttrTagChildGroup(group, child);
           } else {
-            unknownReferences.push(getAllTagReferenceNodes(child.node));
+            getAllTagReferenceNodes(child.node, dropReferenceNodes);
           }
         }
       }
@@ -7657,126 +7718,146 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
         referenceNodes
       }
     ] of nodeReferencesByGroup) {
-      const groupExtra = mergeReferences(section, node, referenceNodes);
-      const groupKnownValue = { value: groupExtra };
       let bindings;
-      rootAttrExprs.add(groupExtra);
+      let hasRest = false;
       for (const tagName of group) {
         const attrName = tagName.slice(1);
-        const templateExportAttr = propTree.props[attrName];
-        if (!templateExportAttr) {
-          bindings = propTree.binding;
+        const templateExportAttr = getKnownFromPropTree(propTree, attrName);
+        if (templateExportAttr === true) {
+          hasRest = true;
           break;
+        } else {
+          bindings = bindingUtil.add(bindings, templateExportAttr.binding);
+        }
+      }
+      if (hasRest) {
+        const groupKnownValue2 = {
+          value: rootTagExtra
+        };
+        restReferenceNodes ||= [];
+        for (const node2 of referenceNodes) {
+          restReferenceNodes.push(node2);
+        }
+        for (const name2 of group) {
+          const attrTagMeta = attrTagLookup[name2];
+          known[attrTagMeta.name] = groupKnownValue2;
         }
-        bindings = bindingUtil.add(bindings, templateExportAttr.binding);
+        continue;
       }
+      const groupExtra = mergeReferences(section, node, referenceNodes);
+      const groupKnownValue = { value: groupExtra };
+      rootAttrExprs.add(groupExtra);
       forEach(bindings, (binding) => {
         setBindingDownstream(binding, groupExtra);
       });
       for (const name2 of group) {
-        known[attrTagLookup[name2].name] = groupKnownValue;
+        const attrTagMeta = attrTagLookup[name2];
+        remaining.delete(attrTagMeta.name);
+        known[attrTagMeta.name] = groupKnownValue;
       }
     }
   }
-  if (!seen.has("content")) {
+  const contentExport = getKnownFromPropTree(propTree, "content");
+  if (contentExport && !seen.has("content")) {
     const bodySection = getSectionForBody(tag.get("body"));
     if (bodySection) {
       seen.add("content");
-      known.content = { value: void 0 };
+      if (contentExport === true) {
+        known.content = { value: rootTagExtra };
+      } else {
+        remaining.delete("content");
+        known.content = { value: void 0 };
+      }
     }
   }
-  let knownSpreadBinding;
+  let knownSpread;
   let spreadReferenceNodes;
   const { attributes } = tag.node;
   for (let i = attributes.length; i--; ) {
     const attr = attributes[i];
     if (import_compiler37.types.isMarkoAttribute(attr)) {
-      const templateExportAttr = getBindingPropTreeProp(propTree, attr.name);
+      const templateExportAttr = getKnownFromPropTree(propTree, attr.name);
       if (!templateExportAttr || seen.has(attr.name)) {
-        unknownReferences.push(attr.value);
+        dropReferenceNodes.push(attr.value);
         continue;
       }
-      const attrExtra = attr.value.extra ??= {};
       seen.add(attr.name);
-      setBindingDownstream(templateExportAttr.binding, attrExtra);
-      if (knownSpreadBinding && !includes(knownSpreadBinding.excludeProperties, attr.name)) {
-        const propBinding = getOrCreatePropertyAlias(
-          knownSpreadBinding,
-          attr.name
-        );
-        addRead(attrExtra, void 0, propBinding, section);
+      if (spreadReferenceNodes) {
+        spreadReferenceNodes.push(attr.value);
+      } else if (templateExportAttr === true) {
+        (restReferenceNodes ||= []).push(attr.value);
+        known[attr.name] = { value: rootTagExtra };
+      } else {
+        const attrExtra = attr.value.extra ??= {};
+        remaining.delete(attr.name);
+        known[attr.name] = { value: attrExtra };
+        rootAttrExprs.add(attrExtra);
+        setBindingDownstream(templateExportAttr.binding, attrExtra);
+        if (knownSpread && !includes(knownSpread.binding.excludeProperties, attr.name)) {
+          const propBinding = getOrCreatePropertyAlias(
+            knownSpread.binding,
+            attr.name
+          );
+          addRead(attrExtra, void 0, propBinding, section);
+        }
       }
-    }
-    if (spreadReferenceNodes) {
+    } else if (spreadReferenceNodes) {
       spreadReferenceNodes.push(attr.value);
-    } else if (import_compiler37.types.isMarkoSpreadAttribute(attr)) {
-      knownSpreadBinding = getSingleKnownSpreadBinding(attributes);
-      if (knownSpreadBinding) {
-        if (!propTree.rest || propTree.rest.props) {
-          dropRead(attr.value.extra);
-        }
+    } else {
+      knownSpread = hasAllKnownProps(propTree) ? getSingleKnownSpread(attributes) : void 0;
+      if (knownSpread) {
+        dropNodes(attr.value);
       } else {
-        spreadReferenceNodes = [attr.value];
+        (spreadReferenceNodes = restReferenceNodes || []).push(attr.value);
       }
-    } else {
-      const attrValueExtra = attr.value.extra ??= {};
-      known[attr.name] = { value: attrValueExtra };
-      rootAttrExprs.add(attrValueExtra);
     }
   }
-  if (knownSpreadBinding) {
-    for (const prop of getAllBindingPropTreePropKeys(propTree)) {
-      if (!seen.has(prop)) {
-        const propBinding = getOrCreatePropertyAlias(knownSpreadBinding, prop);
-        const propExtra = { section };
-        known[prop] = { value: propExtra };
-        rootAttrExprs.add(propExtra);
-        addRead(propExtra, propExtra, propBinding, section);
-      }
+  if (knownSpread) {
+    for (const prop of remaining) {
+      const propBinding = getOrCreatePropertyAlias(knownSpread.binding, prop);
+      const propExtra = { section };
+      const templateExportAttr = getKnownFromPropTree(propTree, prop);
+      known[prop] = { value: propExtra };
+      rootAttrExprs.add(propExtra);
+      addRead(propExtra, propExtra, propBinding, section);
+      setBindingDownstream(
+        templateExportAttr === true ? propTree.rest.binding : templateExportAttr.binding,
+        propExtra
+      );
     }
   } else if (spreadReferenceNodes) {
-    setBindingDownstream(
-      seen.size ? createBinding(
-        generateUid(`${getTagName(tag)}_attrs`),
-        propTree.binding.type,
-        propTree.binding.section,
-        propTree.binding,
-        void 0,
-        fromIter(seen),
-        spreadReferenceNodes[0].loc,
-        true
-      ) : propTree.binding,
+    if (remaining.size || propTree.rest && !propTree.rest.props) {
       inputExpr.value = mergeReferences(
         section,
         tag.node,
         spreadReferenceNodes
-      )
-    );
-  }
-  if (propTree.rest) {
-    const restExtra = inputExpr.value = mergeReferences(
-      section,
-      tag.node,
-      unknownReferences.flat()
-    );
-    setBindingDownstream(propTree.binding, restExtra);
-    if (knownSpreadBinding && !propTree.rest.props) {
-      addRead(restExtra, void 0, knownSpreadBinding, section);
+      );
+      setBindingDownstream(
+        propTree.rest?.binding || propTree.binding,
+        inputExpr.value
+      );
+    } else {
+      dropNodes(spreadReferenceNodes);
     }
-  } else {
-    unknownReferences.forEach(dropReferences);
+  } else if (restReferenceNodes) {
+    inputExpr.value = mergeReferences(section, tag.node, restReferenceNodes);
+    setBindingDownstream(propTree.rest.binding, inputExpr.value);
   }
+  dropNodes(dropReferenceNodes);
   return inputExpr;
 }
-function getSingleKnownSpreadBinding(attributes) {
+function getSingleKnownSpread(attributes) {
   let binding;
+  let extra;
   for (let i = attributes.length; i--; ) {
     const attr = attributes[i];
-    if (attr.type === "MarkoSpreadAttribute" ? binding || !(binding = attr.value.extra?.spreadFrom) : binding && !includes(binding.excludeProperties, attr.name)) {
+    if (attr.type === "MarkoSpreadAttribute" ? binding || !(binding = (extra = attr.value.extra)?.spreadFrom) : binding && !includes(binding.excludeProperties, attr.name)) {
       return;
     }
   }
-  return binding;
+  if (binding) {
+    return { extra, binding };
+  }
 }
 function writeParamsToSignals(tag, propTree, importAlias, info) {
   if (!propTree.props || tag.node.arguments?.some((node) => import_compiler37.types.isSpreadElement(node))) {
@@ -7848,275 +7929,420 @@ function writeParamsToSignals(tag, propTree, importAlias, info) {
     writeAttrsToSignals(tag, attrPropsTree, `${importAlias}_input`, info);
   }
 }
-function writeAttrsToSignals(tag, propTree, importAlias, info) {
-  let translatedAttrs;
-  let seen;
-  let spreadId;
-  if (propTree.props) {
-    const attrTagLookup = analyzeAttributeTags(tag);
-    seen = /* @__PURE__ */ new Set();
-    if (attrTagLookup) {
-      const attrTags2 = tag.get("attributeTags");
-      const statementsByGroup = /* @__PURE__ */ new Map();
-      const translateDynamicAttrTagChildInGroup = (group, index) => {
-        const child = attrTags2[index];
-        let statements = statementsByGroup.get(group)?.statements;
-        if (!statements) {
-          statements = [];
-          statementsByGroup.set(group, {
-            referencedBindings: child.node.extra?.referencedBindings,
-            statements
-          });
-        }
-        return addDynamicAttrTagStatements(
-          attrTags2,
-          index,
-          attrTagLookup,
-          statements,
-          propTree.props
+function applyAttrObject(tag, propTree, tagInputIdentifier, info) {
+  const referencedBindings = tag.node.extra?.referencedBindings;
+  const translatedAttrs = translateAttrs(
+    tag,
+    true,
+    propTree.rest && new Set(toIter(propTree.rest.binding.excludeProperties))
+  );
+  let translatedProps = propsToExpression(translatedAttrs.properties);
+  if (translatedAttrs.statements.length) {
+    addStatement(
+      "render",
+      info.tagSection,
+      referencedBindings,
+      translatedAttrs.statements
+    );
+  }
+  if ((0, import_babel_utils25.isAttributeTag)(tag)) {
+    const attrTagName = getTagName(tag);
+    const parentTag = tag.parentPath;
+    const repeated = analyzeAttributeTags(parentTag)?.[attrTagName]?.repeated;
+    if (repeated) {
+      let attrTagCallsForTag = (info.attrTagCallsByTag ||= /* @__PURE__ */ new Map()).get(
+        parentTag
+      );
+      if (!attrTagCallsForTag) {
+        info.attrTagCallsByTag.set(parentTag, attrTagCallsForTag = /* @__PURE__ */ new Map());
+      }
+      const attrTagCall = attrTagCallsForTag.get(attrTagName);
+      if (attrTagCall) {
+        attrTagCall.expression = callRuntime(
+          "attrTags",
+          attrTagCall.expression,
+          translatedProps
         );
-      };
-      for (const attrTagName in attrTagLookup) {
-        seen.add(attrTagLookup[attrTagName].name);
-      }
-      for (let i = 0; i < attrTags2.length; i++) {
-        const child = attrTags2[i];
-        if (child.isMarkoTag()) {
-          if ((0, import_babel_utils25.isAttributeTag)(child)) {
-            const attrTagMeta = attrTagLookup[getTagName(child)];
-            const childAttrExport = propTree.props[attrTagMeta.name];
-            if (childAttrExport) {
-              if (attrTagMeta.dynamic) {
-                i = translateDynamicAttrTagChildInGroup(attrTagMeta.group, i);
-              } else {
-                writeAttrsToSignals(
-                  child,
-                  childAttrExport,
-                  `${importAlias}_${attrTagMeta.name}`,
-                  info
-                );
-              }
+        return;
+      } else {
+        attrTagCallsForTag.set(
+          attrTagName,
+          translatedProps = import_compiler37.types.parenthesizedExpression(
+            callRuntime("attrTag", translatedProps)
+          )
+        );
+      }
+    } else {
+      translatedProps = callRuntime("attrTag", translatedProps);
+    }
+  }
+  addStatement(
+    "render",
+    info.tagSection,
+    referencedBindings,
+    import_compiler37.types.expressionStatement(
+      import_compiler37.types.callExpression(tagInputIdentifier, [
+        createScopeReadExpression(info.childScopeBinding, info.tagSection),
+        translatedProps
+      ])
+    ),
+    void 0,
+    true
+  );
+}
+function translateAttrTag(tag, attrTagMeta, info, statements) {
+  const translatedAttrs = translateAttrs(tag, true, void 0, statements);
+  let translatedProps = propsToExpression(translatedAttrs.properties);
+  const attrTagName = getTagName(tag);
+  const parentTag = tag.parentPath;
+  if (attrTagMeta.repeated) {
+    let attrTagCallsForTag = (info.attrTagCallsByTag ||= /* @__PURE__ */ new Map()).get(
+      parentTag
+    );
+    if (!attrTagCallsForTag) {
+      info.attrTagCallsByTag.set(parentTag, attrTagCallsForTag = /* @__PURE__ */ new Map());
+    }
+    const attrTagCall = attrTagCallsForTag.get(attrTagName);
+    if (attrTagCall) {
+      attrTagCall.expression = callRuntime(
+        "attrTags",
+        attrTagCall.expression,
+        translatedProps
+      );
+      return;
+    } else {
+      attrTagCallsForTag.set(
+        attrTagName,
+        translatedProps = import_compiler37.types.parenthesizedExpression(
+          callRuntime("attrTag", translatedProps)
+        )
+      );
+    }
+  } else {
+    translatedProps = callRuntime("attrTag", translatedProps);
+  }
+  return translatedProps;
+}
+function writeAttrsToSignals(tag, propTree, importAlias, info) {
+  if (!propTree.props) {
+    applyAttrObject(
+      tag,
+      propTree,
+      info.getBindingIdentifier(propTree.binding, importAlias),
+      info
+    );
+    return;
+  }
+  const attrTagLookup = analyzeAttributeTags(tag);
+  const seen = /* @__PURE__ */ new Set();
+  const tagReferencedBindings = tag.node.extra?.referencedBindings;
+  const remaining = new Set(getAllKnownPropNames(propTree));
+  let restProps;
+  if (attrTagLookup) {
+    const attrTags2 = tag.get("attributeTags");
+    const statementsByGroup = /* @__PURE__ */ new Map();
+    const translateDynamicAttrTagChildInGroup = (group, index) => {
+      const child = attrTags2[index];
+      let statements = statementsByGroup.get(group)?.statements;
+      if (!statements) {
+        statements = [];
+        statementsByGroup.set(group, {
+          referencedBindings: child.node.extra?.referencedBindings,
+          statements
+        });
+      }
+      return addDynamicAttrTagStatements(
+        attrTags2,
+        index,
+        attrTagLookup,
+        statements,
+        propTree
+      );
+    };
+    for (const attrTagName in attrTagLookup) {
+      seen.add(attrTagLookup[attrTagName].name);
+    }
+    for (let i = 0; i < attrTags2.length; i++) {
+      const child = attrTags2[i];
+      if (child.isMarkoTag()) {
+        if ((0, import_babel_utils25.isAttributeTag)(child)) {
+          const attrTagMeta = attrTagLookup[getTagName(child)];
+          const childAttrExport = getKnownFromPropTree(
+            propTree,
+            attrTagMeta.name
+          );
+          if (!childAttrExport) {
+          } else if (attrTagMeta.dynamic) {
+            i = translateDynamicAttrTagChildInGroup(attrTagMeta.group, i);
+          } else if (childAttrExport === true) {
+            const statements = [];
+            const translatedAttrs = translateAttrTag(
+              child,
+              attrTagMeta,
+              info,
+              statements
+            );
+            addStatement(
+              "render",
+              info.tagSection,
+              tagReferencedBindings,
+              statements
+            );
+            if (translatedAttrs) {
+              (restProps ||= []).push(
+                toObjectProperty(attrTagMeta.name, translatedAttrs)
+              );
             }
-          } else if (child.node.extra?.attributeTagGroup) {
-            i = translateDynamicAttrTagChildInGroup(
-              child.node.extra.attributeTagGroup,
-              i
+          } else {
+            remaining.delete(attrTagMeta.name);
+            writeAttrsToSignals(
+              child,
+              childAttrExport,
+              `${importAlias}_${attrTagMeta.name}`,
+              info
             );
           }
+        } else {
+          const group = child.node.extra.attributeTagGroup;
+          let childUsesGroupProp = false;
+          for (const name2 of group) {
+            if (getKnownFromPropTree(propTree, attrTagLookup[name2].name)) {
+              childUsesGroupProp = true;
+              break;
+            }
+          }
+          if (childUsesGroupProp) {
+            i = translateDynamicAttrTagChildInGroup(group, i);
+          } else if (getTagName(child) === "if") {
+            while (++i < attrTags2.length) {
+              const nextTag = attrTags2[i];
+              switch (nextTag.isMarkoTag() && getTagName(nextTag)) {
+                case "else":
+                case "else-if":
+                  continue;
+              }
+              i--;
+              break;
+            }
+          }
+        }
+      }
+    }
+    for (const [
+      group,
+      { referencedBindings, statements }
+    ] of statementsByGroup) {
+      const decls = [];
+      let hasRest = false;
+      for (const name2 of group) {
+        const attrTagMeta = attrTagLookup[name2];
+        const childAttrExports = getKnownFromPropTree(
+          propTree,
+          attrTagMeta.name
+        );
+        decls.push(import_compiler37.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta)));
+        if (childAttrExports === true) {
+          hasRest = true;
         }
       }
-      for (const [
-        group,
-        { referencedBindings, statements }
-      ] of statementsByGroup) {
-        const decls = [];
+      addStatement(
+        "render",
+        info.tagSection,
+        hasRest ? tagReferencedBindings : referencedBindings,
+        [import_compiler37.types.variableDeclaration("let", decls), ...statements]
+      );
+      if (hasRest) {
         for (const name2 of group) {
           const attrTagMeta = attrTagLookup[name2];
-          const childAttrExports = propTree.props[attrTagMeta.name];
-          if (!childAttrExports) continue;
-          const attrExportIdentifier = info.getBindingIdentifier(
-            childAttrExports.binding,
-            `${importAlias}_${attrTagMeta.name}`
+          (restProps ||= []).push(
+            toObjectProperty(
+              attrTagMeta.name,
+              getAttrTagIdentifier(attrTagMeta)
+            )
           );
-          decls.push(import_compiler37.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta)));
-          addStatement("render", info.tagSection, referencedBindings, [
-            import_compiler37.types.variableDeclaration("let", decls),
-            ...statements
-          ]);
+        }
+      } else {
+        for (const name2 of group) {
+          const attrTagMeta = attrTagLookup[name2];
+          const childAttrExports = getKnownFromPropTree(
+            propTree,
+            attrTagMeta.name
+          );
+          remaining.delete(attrTagMeta.name);
           addStatement(
             "render",
             info.tagSection,
             referencedBindings,
             import_compiler37.types.expressionStatement(
-              import_compiler37.types.callExpression(attrExportIdentifier, [
-                createScopeReadExpression(
-                  info.childScopeBinding,
-                  info.tagSection
+              import_compiler37.types.callExpression(
+                info.getBindingIdentifier(
+                  childAttrExports.binding,
+                  `${importAlias}_${attrTagMeta.name}`
                 ),
-                getAttrTagIdentifier(attrTagMeta)
-              ])
+                [
+                  createScopeReadExpression(
+                    info.childScopeBinding,
+                    info.tagSection
+                  ),
+                  getAttrTagIdentifier(attrTagMeta)
+                ]
+              )
             )
           );
         }
       }
     }
-    const bodySection = tag.node.body.extra?.section;
-    if (bodySection && !seen.has("content")) {
+  }
+  const contentExport = getKnownFromPropTree(propTree, "content");
+  if (!seen.has("content") && contentExport) {
+    const bodySection = getSectionForBody(tag.get("body"));
+    if (bodySection) {
       seen.add("content");
-      if (propTree.props.content) {
-        const contentExportIdentifier = info.getBindingIdentifier(
-          propTree.props.content.binding,
-          `${importAlias}_content`
-        );
+      const bodyValue = import_compiler37.types.callExpression(import_compiler37.types.identifier(bodySection.name), [
+        scopeIdentifier
+      ]);
+      if (contentExport === true) {
+        (restProps ||= []).push(toObjectProperty("content", bodyValue));
+      } else {
+        remaining.delete("content");
         addStatement(
           "render",
           info.tagSection,
           void 0,
           // TODO: pretty sure content needs to have the reference group of it's param defaults.
           import_compiler37.types.expressionStatement(
-            import_compiler37.types.callExpression(contentExportIdentifier, [
-              createScopeReadExpression(
-                info.childScopeBinding,
-                info.tagSection
+            import_compiler37.types.callExpression(
+              info.getBindingIdentifier(
+                contentExport.binding,
+                `${importAlias}_content`
               ),
-              import_compiler37.types.callExpression(import_compiler37.types.identifier(bodySection.name), [
-                scopeIdentifier
-              ])
-            ])
+              [
+                createScopeReadExpression(
+                  info.childScopeBinding,
+                  info.tagSection
+                ),
+                bodyValue
+              ]
+            )
           ),
           void 0,
           true
         );
       }
     }
-    let knownSpreadBinding;
-    let spreadProps;
-    const staticAttrs = [];
-    const { attributes } = tag.node;
-    for (let i = attributes.length; i--; ) {
-      const attr = attributes[i];
-      if (import_compiler37.types.isMarkoAttribute(attr)) {
-        if (!getBindingPropTreeProp(propTree, attr.name) || seen.has(attr.name) || spreadProps?.push(toObjectProperty(attr.name, attr.value))) {
-          continue;
-        }
-        seen.add(attr.name);
-        staticAttrs.push(attr);
-      } else if (spreadProps) {
-        spreadProps.push(import_compiler37.types.spreadElement(attr.value));
-      } else {
-        knownSpreadBinding = getSingleKnownSpreadBinding(attributes);
-        if (!knownSpreadBinding) {
-          spreadProps = [import_compiler37.types.spreadElement(attr.value)];
-        }
-      }
+  }
+  let knownSpread;
+  let spreadProps;
+  const staticAttrs = [];
+  const { attributes } = tag.node;
+  for (let i = attributes.length; i--; ) {
+    const attr = attributes[i];
+    if (import_compiler37.types.isMarkoAttribute(attr)) {
+      const templateExportAttr = getKnownFromPropTree(propTree, attr.name);
+      if (!templateExportAttr || seen.has(attr.name)) {
+        continue;
+      }
+      seen.add(attr.name);
+      if (spreadProps) {
+        spreadProps.push(toObjectProperty(attr.name, attr.value));
+      } else if (templateExportAttr === true) {
+        (restProps ||= []).push(toObjectProperty(attr.name, attr.value));
+      } else {
+        staticAttrs.push(attr);
+      }
+    } else if (spreadProps) {
+      spreadProps.push(import_compiler37.types.spreadElement(attr.value));
+    } else {
+      knownSpread = hasAllKnownProps(propTree) ? getSingleKnownSpread(attributes) : void 0;
+      if (!knownSpread) {
+        (spreadProps = restProps || []).push(import_compiler37.types.spreadElement(attr.value));
+      }
     }
-    for (const attr of staticAttrs.reverse()) {
-      const childAttrExports = getBindingPropTreeProp(propTree, attr.name);
+  }
+  for (let i = staticAttrs.length; i--; ) {
+    const attr = staticAttrs[i];
+    const childAttrExports = getKnownFromPropTree(
+      propTree,
+      attr.name
+    );
+    const attrExportIdentifier = info.getBindingIdentifier(
+      childAttrExports.binding,
+      `${importAlias}_${attr.name}`
+    );
+    remaining.delete(attr.name);
+    addStatement(
+      "render",
+      info.tagSection,
+      attr.value.extra?.referencedBindings,
+      import_compiler37.types.expressionStatement(
+        import_compiler37.types.callExpression(attrExportIdentifier, [
+          createScopeReadExpression(info.childScopeBinding, info.tagSection),
+          attr.value
+          // TODO: use spreadBinding property alias after we optimize `in`
+        ])
+      ),
+      void 0,
+      true
+    );
+  }
+  if (knownSpread) {
+    for (const prop of remaining) {
+      const childAttrExports = getKnownFromPropTree(
+        propTree,
+        prop
+      );
       const attrExportIdentifier = info.getBindingIdentifier(
         childAttrExports.binding,
-        `${importAlias}_${attr.name}`
+        `${importAlias}_${prop}`
       );
+      const propBinding = knownSpread.binding.propertyAliases.get(prop);
       addStatement(
         "render",
         info.tagSection,
-        attr.value.extra?.referencedBindings,
+        propBinding,
         import_compiler37.types.expressionStatement(
           import_compiler37.types.callExpression(attrExportIdentifier, [
             createScopeReadExpression(info.childScopeBinding, info.tagSection),
-            // TODO: use spreadBinding property alias after we optimize `in`
-            attr.value
+            createScopeReadExpression(propBinding, info.tagSection)
           ])
         ),
         void 0,
         true
       );
     }
-    const missing = new Set(getAllBindingPropTreePropKeys(propTree));
-    for (const name2 of seen) missing.delete(name2);
-    if (missing.size) {
-      if (knownSpreadBinding) {
-        for (const prop of missing) {
-          const childAttrExports = getBindingPropTreeProp(propTree, prop);
-          const attrExportIdentifier = info.getBindingIdentifier(
-            childAttrExports.binding,
-            `${importAlias}_${prop}`
-          );
-          const propBinding = knownSpreadBinding.propertyAliases.get(prop);
-          addStatement(
-            "render",
-            info.tagSection,
-            propBinding,
-            import_compiler37.types.expressionStatement(
-              import_compiler37.types.callExpression(attrExportIdentifier, [
-                createScopeReadExpression(
-                  info.childScopeBinding,
-                  info.tagSection
-                ),
-                createScopeReadExpression(propBinding, info.tagSection)
-              ])
-            ),
-            void 0,
-            true
-          );
-        }
-      } else {
-        const referencedBindings = tag.node.extra?.referencedBindings;
-        if (spreadProps) {
-          const spreadExpr = propsToExpression(
-            propTree.rest ? (translatedAttrs = translateAttrs(tag, propTree, seen)).properties : spreadProps.reverse()
-          );
-          if (isSimpleReference(spreadExpr)) {
-            spreadId = spreadExpr;
-          } else {
-            spreadId = generateUidIdentifier(`${importAlias}_spread`);
-            if (translatedAttrs) {
-              translatedAttrs.properties = [import_compiler37.types.spreadElement(spreadId)];
-            }
-            addStatement("render", info.tagSection, referencedBindings, [
-              import_compiler37.types.variableDeclaration("const", [
-                import_compiler37.types.variableDeclarator(spreadId, spreadExpr)
-              ])
-            ]);
-          }
-        }
-        for (const name2 of missing) {
-          const childAttrExports = getBindingPropTreeProp(propTree, name2);
-          const attrExportIdentifier = info.getBindingIdentifier(
-            childAttrExports.binding,
-            `${importAlias}_${name2}`
-          );
-          addStatement(
-            "render",
-            info.tagSection,
-            spreadProps && referencedBindings,
-            import_compiler37.types.expressionStatement(
-              import_compiler37.types.callExpression(
-                attrExportIdentifier,
-                spreadId ? [
-                  createScopeReadExpression(
-                    info.childScopeBinding,
-                    info.tagSection
-                  ),
-                  toMemberExpression(import_compiler37.types.cloneNode(spreadId, true), name2)
-                ] : [
-                  createScopeReadExpression(
-                    info.childScopeBinding,
-                    info.tagSection
-                  )
-                ]
-              )
-            )
-          );
-        }
-      }
-    }
-  }
-  if (!propTree.props || propTree.rest && !propTree.rest.props) {
-    if (!translatedAttrs) {
-      if (propTree.rest) {
-        seen ||= /* @__PURE__ */ new Set();
-        forEach(
-          propTree.rest.binding.excludeProperties,
-          (prop) => seen.add(prop)
-        );
-      }
-      translatedAttrs = translateAttrs(tag, propTree.rest, seen);
+  } else if (spreadProps) {
+    const spreadExpr = propsToExpression(spreadProps.reverse());
+    let spreadId = spreadExpr;
+    if (!isSimpleReference(spreadExpr)) {
+      spreadId = generateUidIdentifier(`${importAlias}_spread`);
+      addStatement("render", info.tagSection, tagReferencedBindings, [
+        import_compiler37.types.variableDeclaration("const", [
+          import_compiler37.types.variableDeclarator(spreadId, spreadExpr)
+        ])
+      ]);
     }
-    const referencedBindings = tag.node.extra?.referencedBindings;
-    const tagInputIdentifier = info.getBindingIdentifier(
-      propTree.rest?.binding || propTree.binding,
-      propTree.rest ? importAlias + "_$rest" : importAlias
-    );
-    if (translatedAttrs.statements.length) {
+    for (const name2 of remaining) {
+      const childAttrExports = getKnownFromPropTree(
+        propTree,
+        name2
+      );
+      const attrExportIdentifier = info.getBindingIdentifier(
+        childAttrExports.binding,
+        `${importAlias}_${name2}`
+      );
       addStatement(
         "render",
         info.tagSection,
-        referencedBindings,
-        translatedAttrs.statements
+        tagReferencedBindings,
+        import_compiler37.types.expressionStatement(
+          import_compiler37.types.callExpression(attrExportIdentifier, [
+            createScopeReadExpression(info.childScopeBinding, info.tagSection),
+            toMemberExpression(import_compiler37.types.cloneNode(spreadId, true), name2)
+          ])
+        )
       );
     }
-    let translatedProps = propsToExpression(translatedAttrs.properties);
-    if (propTree.rest && spreadId) {
+    if (propTree.rest && !propTree.rest.props) {
       const props = [];
       const restId = import_compiler37.types.identifier(propTree.rest.binding.name);
       forEach(propTree.rest.binding.excludeProperties, (name2) => {
@@ -8132,58 +8358,77 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
         );
       });
       props.push(import_compiler37.types.restElement(restId));
-      translatedProps = import_compiler37.types.callExpression(
-        import_compiler37.types.arrowFunctionExpression([import_compiler37.types.objectPattern(props)], restId),
-        [spreadId]
+      addStatement(
+        "render",
+        info.tagSection,
+        tagReferencedBindings,
+        import_compiler37.types.expressionStatement(
+          import_compiler37.types.callExpression(
+            info.getBindingIdentifier(
+              propTree.rest.binding,
+              importAlias + "_$rest"
+            ),
+            [
+              createScopeReadExpression(
+                info.childScopeBinding,
+                info.tagSection
+              ),
+              import_compiler37.types.callExpression(
+                import_compiler37.types.arrowFunctionExpression([import_compiler37.types.objectPattern(props)], restId),
+                [spreadId]
+              )
+            ]
+          )
+        ),
+        void 0,
+        true
       );
     }
-    if ((0, import_babel_utils25.isAttributeTag)(tag)) {
-      const attrTagName = getTagName(tag);
-      const parentTag = tag.parentPath;
-      const repeated = analyzeAttributeTags(parentTag)?.[attrTagName]?.repeated;
-      if (repeated) {
-        let attrTagCallsForTag = (info.attrTagCallsByTag ||= /* @__PURE__ */ new Map()).get(
-          parentTag
-        );
-        if (!attrTagCallsForTag) {
-          info.attrTagCallsByTag.set(
-            parentTag,
-            attrTagCallsForTag = /* @__PURE__ */ new Map()
-          );
-        }
-        const attrTagCall = attrTagCallsForTag.get(attrTagName);
-        if (attrTagCall) {
-          attrTagCall.expression = callRuntime(
-            "attrTags",
-            attrTagCall.expression,
-            translatedProps
-          );
-          return;
-        } else {
-          attrTagCallsForTag.set(
-            attrTagName,
-            translatedProps = import_compiler37.types.parenthesizedExpression(
-              callRuntime("attrTag", translatedProps)
-            )
-          );
-        }
-      } else {
-        translatedProps = callRuntime("attrTag", translatedProps);
-      }
+  } else {
+    for (const name2 of remaining) {
+      const childAttrExports = getKnownFromPropTree(
+        propTree,
+        name2
+      );
+      const attrExportIdentifier = info.getBindingIdentifier(
+        childAttrExports.binding,
+        `${importAlias}_${name2}`
+      );
+      addStatement(
+        "render",
+        info.tagSection,
+        void 0,
+        import_compiler37.types.expressionStatement(
+          import_compiler37.types.callExpression(attrExportIdentifier, [
+            createScopeReadExpression(info.childScopeBinding, info.tagSection)
+          ])
+        )
+      );
+    }
+    if (propTree.rest && !propTree.rest.props) {
+      addStatement(
+        "render",
+        info.tagSection,
+        tagReferencedBindings,
+        import_compiler37.types.expressionStatement(
+          import_compiler37.types.callExpression(
+            info.getBindingIdentifier(
+              propTree.rest.binding,
+              importAlias + "_$rest"
+            ),
+            [
+              createScopeReadExpression(
+                info.childScopeBinding,
+                info.tagSection
+              ),
+              import_compiler37.types.objectExpression(restProps || [])
+            ]
+          )
+        ),
+        void 0,
+        true
+      );
     }
-    addStatement(
-      "render",
-      info.tagSection,
-      referencedBindings,
-      import_compiler37.types.expressionStatement(
-        import_compiler37.types.callExpression(tagInputIdentifier, [
-          createScopeReadExpression(info.childScopeBinding, info.tagSection),
-          translatedProps
-        ])
-      ),
-      void 0,
-      true
-    );
   }
 }
 function mapParamReasonToExpr(exprs, reason) {
@@ -8248,15 +8493,16 @@ function createBinding(name2, type, section, upstreamAlias, property, excludePro
     assignmentSections: void 0,
     excludeProperties,
     sources: void 0,
+    reads: /* @__PURE__ */ new Set(),
     aliases: /* @__PURE__ */ new Set(),
     hoists: /* @__PURE__ */ new Map(),
     propertyAliases: /* @__PURE__ */ new Map(),
     upstreamAlias,
-    downstreamExpressions: /* @__PURE__ */ new Set(),
     scopeOffset: void 0,
     scopeAccessor: void 0,
     export: void 0,
-    nullable: excludeProperties === void 0
+    nullable: excludeProperties === void 0,
+    pruned: void 0
   };
   if (property) {
     if (declared) upstreamAlias.nullable = false;
@@ -8534,6 +8780,7 @@ function trackAssignment(assignment, binding) {
           true
         );
         idExtra.assignmentTo = changeBinding;
+        changeBinding.pruned = false;
         addReadToExpression(id, changeBinding);
       }
     }
@@ -8581,7 +8828,7 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAl
             scope,
             section,
             patternBinding,
-            property,
+            void 0,
             excludeProperties
           );
         } else {
@@ -8673,13 +8920,48 @@ function trackReference(referencePath, binding) {
   }
   addReadToExpression(root, reference);
 }
-var [getMergedReferences] = createProgramState(
-  () => /* @__PURE__ */ new Map()
-);
 function mergeReferences(section, target, nodes) {
   const targetExtra = target.extra ??= {};
+  const readsByExpression = getReadsByExpression();
+  const fnReadsByExpression = getFunctionReadsByExpression();
+  let reads = readsByExpression.get(targetExtra);
+  let exprFnReads = fnReadsByExpression.get(targetExtra);
+  let { isEffect } = targetExtra;
+  for (const node of nodes) {
+    if (!node) continue;
+    const extra = node.extra ??= {};
+    extra.merged = targetExtra;
+    if (isReferencedExtra(extra)) {
+      const additionalReads = readsByExpression.get(extra);
+      const additionalExprFnReads = fnReadsByExpression.get(extra);
+      isEffect ||= extra.isEffect;
+      if (additionalReads) {
+        forEach(additionalReads, (read) => {
+          read.binding.reads.delete(extra);
+          read.binding.reads.add(targetExtra);
+        });
+        reads = concat(reads, additionalReads);
+        readsByExpression.delete(extra);
+      }
+      if (additionalExprFnReads) {
+        if (exprFnReads) {
+          for (const [key, value] of additionalExprFnReads) {
+            exprFnReads.set(key, value);
+          }
+        } else {
+          fnReadsByExpression.set(
+            targetExtra,
+            exprFnReads = new Map(additionalExprFnReads)
+          );
+        }
+      }
+    } else if (extra?.pruned) {
+      throw new Error("Cannot merged a dropped reference.");
+    }
+  }
+  readsByExpression.set(targetExtra, reads);
+  targetExtra.isEffect = isEffect;
   targetExtra.section = section;
-  getMergedReferences().set(target, nodes);
   return targetExtra;
 }
 function compareReferences(a, b) {
@@ -8703,53 +8985,20 @@ function finalizeReferences() {
   const bindings = getBindings();
   const readsByExpression = getReadsByExpression();
   const fnReadsByExpression = getFunctionReadsByExpression();
-  const mergedReferences = getMergedReferences();
-  if (mergedReferences.size) {
-    for (const [target, nodes] of mergedReferences) {
-      const targetExtra = target.extra;
-      let reads = readsByExpression.get(targetExtra);
-      let exprFnReads = fnReadsByExpression.get(targetExtra);
-      let { isEffect } = targetExtra;
-      for (const node of nodes) {
-        const extra = node?.extra;
-        if (extra) {
-          setCanonicalExtra(extra, targetExtra);
-          if (isReferencedExtra(extra)) {
-            const additionalReads = readsByExpression.get(extra);
-            const additionalExprFnReads = fnReadsByExpression.get(extra);
-            isEffect ||= extra.isEffect;
-            if (additionalReads) {
-              reads = concat(reads, additionalReads);
-              readsByExpression.delete(extra);
-            }
-            if (additionalExprFnReads) {
-              if (exprFnReads) {
-                for (const [key, value] of additionalExprFnReads) {
-                  exprFnReads.set(key, value);
-                }
-              } else {
-                fnReadsByExpression.set(
-                  targetExtra,
-                  exprFnReads = new Map(additionalExprFnReads)
-                );
-              }
-            }
-          }
-        }
-      }
-      readsByExpression.set(targetExtra, reads);
-      targetExtra.isEffect = isEffect;
-    }
-  }
   const intersectionsBySection = /* @__PURE__ */ new Map();
   for (const [expr, reads] of readsByExpression) {
     if (isReferencedExtra(expr)) {
       const { referencedBindings, constantBindings } = resolveReferencedBindings(expr, reads, intersectionsBySection);
       expr.referencedBindings = referencedBindings;
-      if (referencedBindings) {
+      if (expr.isEffect) {
         forEach(referencedBindings, (binding) => {
-          binding.downstreamExpressions.add(expr);
+          addSerializeReason(binding.section, true, binding);
+        });
+        forEach(constantBindings, (binding) => {
+          addSerializeReason(binding.section, true, binding);
         });
+      }
+      if (referencedBindings) {
         const exprFnReads = fnReadsByExpression.get(expr);
         if (exprFnReads) {
           for (const [fn, fnReads] of exprFnReads) {
@@ -8764,16 +9013,13 @@ function finalizeReferences() {
           }
         }
       }
-      if (constantBindings) {
-        forEach(constantBindings, (binding) => {
-          binding.downstreamExpressions.add(expr);
-        });
-      }
     }
   }
   for (const binding of bindings) {
-    if (binding.type !== 0 /* dom */ && !binding.upstreamAlias) {
-      pruneBinding(bindings, binding);
+    if (binding.type !== 0 /* dom */) {
+      if (pruneBinding(binding)) {
+        bindings.delete(binding);
+      }
     }
   }
   forEachSection(finalizeTagDownstreams);
@@ -8796,11 +9042,7 @@ function finalizeReferences() {
       section.bindings,
       getCanonicalBinding(binding)
     );
-    for (const {
-      referencedBindings,
-      isEffect,
-      section: section2
-    } of binding.downstreamExpressions) {
+    for (const { isEffect, section: section2 } of binding.reads) {
       if (section2 !== binding.section) {
         const canonicalUpstreamAlias = getCanonicalBinding(binding);
         canonicalUpstreamAlias.closureSections = sectionUtil.add(
@@ -8824,12 +9066,6 @@ function finalizeReferences() {
           );
         }
       }
-      if (isEffect) {
-        forEach(
-          referencedBindings,
-          (binding2) => addSerializeReason(binding2.section, true, binding2)
-        );
-      }
     }
   }
   forEachSection((section) => {
@@ -8940,7 +9176,7 @@ function finalizeReferences() {
   finalizeFunctionRegistry();
   const referencedExprs = /* @__PURE__ */ new Set();
   for (const binding of bindings) {
-    for (const expr of binding.downstreamExpressions) {
+    for (const expr of binding.reads) {
       referencedExprs.add(expr);
     }
   }
@@ -8999,7 +9235,6 @@ function finalizeReferences() {
       programExtra.returnValueExpr
     );
   }
-  mergedReferences.clear();
   readsByExpression.clear();
   fnReadsByExpression.clear();
 }
@@ -9160,12 +9395,10 @@ var [getReadsByExpression] = createProgramState(
 var [getFunctionReadsByExpression] = createProgramState(
   () => /* @__PURE__ */ new Map()
 );
-function addRead(exprExtra, readExtra, binding, section) {
+function addRead(exprExtra, extra, binding, section) {
   const readsByExpression = getReadsByExpression();
-  const read = {
-    binding,
-    extra: readExtra
-  };
+  const read = { binding, extra };
+  binding.reads.add(exprExtra);
   exprExtra.section = section;
   readsByExpression.set(
     exprExtra,
@@ -9173,8 +9406,28 @@ function addRead(exprExtra, readExtra, binding, section) {
   );
   return read;
 }
-function dropRead(exprExtra) {
-  getReadsByExpression().delete(exprExtra);
+function dropNodes(node) {
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      dropExtra(item.extra ??= {});
+    }
+  } else {
+    dropExtra(node.extra ??= {});
+  }
+}
+function dropExtra(exprExtra) {
+  if (exprExtra.merged) {
+    throw new Error("Cannot drop a merged reference");
+  }
+  const readsByExpr = getReadsByExpression();
+  const reads = readsByExpr.get(exprExtra);
+  exprExtra.pruned = true;
+  if (reads) {
+    readsByExpr.delete(exprExtra);
+    forEach(reads, (read) => {
+      read.binding.reads.delete(exprExtra);
+    });
+  }
 }
 function addReadToExpression(root, binding) {
   const { node } = root;
@@ -9197,15 +9450,6 @@ function addReadToExpression(root, binding) {
     exprFnReads.set(fnExtra, push(exprFnReads.get(fnExtra), read));
   }
 }
-function dropReferences(node) {
-  if (Array.isArray(node)) {
-    for (const item of node) {
-      (item.extra ??= {}).pruned = true;
-    }
-  } else {
-    (node.extra ??= {}).pruned = true;
-  }
-}
 function getCanonicalBinding(binding) {
   const alias = binding.upstreamAlias;
   if (alias && binding.property === void 0 && binding.excludeProperties === void 0) {
@@ -9390,28 +9634,38 @@ function hasNonConstantPropertyAlias(ref) {
   }
   return false;
 }
-function pruneBinding(bindings, binding) {
-  let shouldPrune = !binding.downstreamExpressions.size;
+function pruneBinding(binding) {
+  if (binding.pruned !== void 0) {
+    return binding.pruned;
+  }
+  for (const read of binding.reads) {
+    let upstream = binding.upstreamAlias;
+    while (upstream && !upstream.reads.has(read)) {
+      upstream = upstream.upstreamAlias;
+    }
+    if (upstream) {
+      binding.reads.delete(read);
+    }
+  }
+  let shouldPrune = !binding.reads.size;
   if (binding.hoists.size) {
     shouldPrune = false;
   }
   for (const alias of binding.aliases) {
-    if (pruneBinding(bindings, alias)) {
+    if (pruneBinding(alias)) {
       binding.aliases.delete(alias);
     } else if (alias.type !== 7 /* constant */) {
       shouldPrune = false;
     }
   }
   for (const [key, alias] of binding.propertyAliases) {
-    if (pruneBinding(bindings, alias)) {
+    if (pruneBinding(alias)) {
       binding.propertyAliases.delete(key);
     } else if (alias.type !== 7 /* constant */) {
       shouldPrune = false;
     }
   }
-  if (shouldPrune) {
-    bindings.delete(binding);
-  }
+  binding.pruned = shouldPrune;
   return shouldPrune;
 }
 function resolveReferencedBindingsInFunction(refs, reads) {
@@ -9597,6 +9851,7 @@ function getCanonicalExtra(extra) {
 }
 var serializeReasonCache = /* @__PURE__ */ new WeakMap();
 function getAllSerializeReasonsForExtra(extra) {
+  if (extra.isEffect) return true;
   let reason = serializeReasonCache.get(extra);
   if (reason === false) return;
   if (reason === void 0) {
@@ -9607,7 +9862,7 @@ function getAllSerializeReasonsForExtra(extra) {
       forEach(extra.downstream, (binding) => {
         reason = mergeSerializeReasons(
           reason,
-          getAllSerializeReasonsForBinding(binding)
+          getAllSerializeReasonsForBinding(binding, true)
         );
       });
     }
@@ -9617,32 +9872,34 @@ function getAllSerializeReasonsForExtra(extra) {
   }
   return reason;
 }
-function getAllSerializeReasonsForBinding(binding) {
+function getAllSerializeReasonsForBinding(binding, properties) {
   let reason = serializeReasonCache.get(binding);
-  if (reason === false) return;
   if (reason === void 0) {
     reason = getSerializeReason(binding.section, binding);
     if (reason !== true) {
-      if (!reason) {
-        serializeReasonCache.set(binding, false);
-      }
-      for (const expr of binding.downstreamExpressions) {
-        reason = expr.isEffect || mergeSerializeReasons(reason, getAllSerializeReasonsForExtra(expr));
-        if (reason === true) break;
+      serializeReasonCache.set(binding, reason || false);
+      if (properties !== true && binding.upstreamAlias) {
+        reason = mergeSerializeReasons(
+          reason,
+          getAllSerializeReasonsForBinding(
+            binding.upstreamAlias,
+            binding.property
+          )
+        );
       }
       if (reason !== true) {
-        for (const alias of binding.aliases) {
+        for (const expr of binding.reads) {
           reason = mergeSerializeReasons(
             reason,
-            getAllSerializeReasonsForBinding(alias)
+            getAllSerializeReasonsForExtra(expr)
           );
           if (reason === true) break;
         }
         if (reason !== true) {
-          for (const propBinding of binding.propertyAliases.values()) {
+          for (const alias of binding.aliases) {
             reason = mergeSerializeReasons(
               reason,
-              getAllSerializeReasonsForBinding(propBinding)
+              getAllSerializeReasonsForBinding(alias, properties)
             );
             if (reason === true) break;
           }
@@ -9653,11 +9910,56 @@ function getAllSerializeReasonsForBinding(binding) {
       serializeReasonCache.set(binding, reason);
     }
   }
+  if (reason === false) {
+    reason = void 0;
+  }
+  if (properties !== void 0) {
+    if (properties === true) {
+      if (reason !== true) {
+        for (const propBinding of binding.propertyAliases.values()) {
+          reason = mergeSerializeReasons(
+            reason,
+            getAllSerializeReasonsForBinding(propBinding, true)
+          );
+          if (reason === true) break;
+        }
+      }
+    } else {
+      let property;
+      let rest2;
+      if (Array.isArray(properties)) {
+        property = properties[0];
+        rest2 = properties.length === 2 ? properties[1] : properties.slice(1);
+      } else {
+        property = properties;
+      }
+      if (includes(binding.excludeProperties, property)) {
+        reason = void 0;
+      } else {
+        const propBinding = binding.propertyAliases.get(property);
+        if (propBinding) {
+          reason = mergeSerializeReasons(
+            reason,
+            getAllSerializeReasonsForBinding(propBinding, rest2)
+          );
+        }
+        if (reason !== true) {
+          for (const alias of binding.aliases) {
+            const propBinding2 = alias.propertyAliases.get(property);
+            if (propBinding2) {
+              reason = mergeSerializeReasons(
+                reason,
+                getAllSerializeReasonsForBinding(propBinding2, rest2)
+              );
+              if (reason === true) break;
+            }
+          }
+        }
+      }
+    }
+  }
   return reason;
 }
-function setCanonicalExtra(extra, merged) {
-  extra.merged = merged;
-}
 function addNumericPropertiesUntil(props, len) {
   let result = props;
   for (let i = len; i--; ) {
@@ -9876,7 +10178,7 @@ var const_default = {
     const valueExtra = evaluate(valueAttr.value);
     const upstreamAlias = import_compiler41.types.isIdentifier(valueAttr.value) ? tag.scope.getBinding(valueAttr.value.name)?.identifier.extra?.binding : void 0;
     if (upstreamAlias) {
-      valueExtra.pruned = true;
+      dropNodes(valueAttr.value);
     }
     const binding = trackVarReferences(tag, 5 /* derived */, upstreamAlias);
     if (binding) {
@@ -9987,7 +10289,7 @@ var define_default = {
     const bodySection = startSection(tagBody);
     const varBinding = trackVarReferences(tag, 5 /* derived */);
     if (!varBinding) {
-      dropReferences(getAllTagReferenceNodes(tag.node));
+      dropNodes(getAllTagReferenceNodes(tag.node));
       return;
     }
     trackParamsReferences(tagBody, 3 /* param */);
@@ -10004,13 +10306,13 @@ var define_default = {
           }
           if (ref.parent.type === "MarkoTag" && ref.parent.name === ref.node) {
             (ref.parent.extra ??= {}).defineBodySection = bodySection;
-            dropReferences(ref.parent.name);
+            dropNodes(ref.parent.name);
           } else {
             allDirectReferences = false;
           }
         }
         if (allDirectReferences) {
-          dropReferences(getAllTagReferenceNodes(tag.node));
+          dropNodes(getAllTagReferenceNodes(tag.node));
           return;
         }
       }
@@ -10897,7 +11199,7 @@ var let_default = {
 // src/translator/core/lifecycle.ts
 var import_compiler50 = require("@marko/compiler");
 var import_babel_utils39 = require("@marko/compiler/babel-utils");
-var kRef = Symbol("lifecycle attrs reference");
+var [getIndex, setIndex] = createSectionState("lifecycleIndex", () => 0);
 var lifecycle_default = {
   analyze(tag) {
     (0, import_babel_utils39.assertNoArgs)(tag);
@@ -10911,12 +11213,7 @@ var lifecycle_default = {
       tag.node,
       getAllTagReferenceNodes(tag.node)
     );
-    const binding = tagExtra[kRef] = createBinding(
-      generateUid("lifecycle"),
-      5 /* derived */,
-      section
-    );
-    binding.downstreamExpressions.add(tagExtra);
+    tagExtra.isEffect = true;
     if (node.attributes.length === 0) {
       throw tag.get("name").buildCodeFrameError(
         "The [`<lifecycle>` tag](https://markojs.com/docs/reference/core-tag#lifecycle) requires at least one attribute."
@@ -10928,7 +11225,6 @@ var lifecycle_default = {
           "The [`<lifecycle>` tag](https://markojs.com/docs/reference/core-tag#lifecycle) does not support [`...spread` attributes](https://markojs.com/docs/reference/language#spread-attributes)."
         );
       }
-      (attr.value.extra ??= {}).isEffect = true;
     }
     (0, import_babel_utils39.getProgram)().node.extra.isInteractive = true;
   },
@@ -10938,16 +11234,17 @@ var lifecycle_default = {
       const section = getSection(tag);
       const tagExtra = node.extra;
       const { referencedBindings } = tagExtra;
-      const lifecycleAttrsRef = tagExtra[kRef];
       if (isOutputDOM()) {
         const translatedAttrs = translateAttrs(tag);
+        const index = getIndex(section);
+        setIndex(section, index + 1);
         translatedAttrs.statements.push(
           import_compiler50.types.expressionStatement(
             callRuntime(
               "_lifecycle",
               scopeIdentifier,
-              getScopeAccessorLiteral(lifecycleAttrsRef, true),
-              propsToExpression(translatedAttrs.properties)
+              propsToExpression(translatedAttrs.properties),
+              index > 0 ? import_compiler50.types.numericLiteral(index) : void 0
             )
           )
         );
@@ -11093,7 +11390,7 @@ var script_default = {
       }
     }
     if (!seenValueAttr) {
-      dropReferences(getAllTagReferenceNodes(node));
+      dropNodes(getAllTagReferenceNodes(node));
     }
   },
   translate: {