marko 6.0.0-next.3.22 → 6.0.0-next.3.23

package/dist/translator/index.js

@@ -546,6 +546,7 @@ var KNOWN_OBJECTS = /* @__PURE__ */ new Map([
 // src/html/writer.ts
 var K_SCOPE_ID = Symbol("Scope ID");
 var kPendingContexts = Symbol("Pending Contexts");
+var branchIdKey = Symbol();
 var tick = globalThis.setImmediate || globalThis.setTimeout || globalThis.queueMicrotask || ((cb) => Promise.resolve().then(cb));
 
 // src/html/attrs.ts
@@ -626,7 +627,8 @@ var pureFunctions = [
   "value",
   "state",
   "intersection",
-  "closure",
+  "loopClosure",
+  "conditionalClosure",
   "dynamicClosure",
   "loopOf",
   "loopIn",
@@ -857,9 +859,6 @@ function find(data, cb) {
     }
   }
 }
-function map(data, cb) {
-  return data ? Array.isArray(data) ? data.map(cb) : [cb(data, 0)] : [];
-}
 function findSorted(compare, data, item) {
   let max = data.length;
   let pos = 0;
@@ -936,17 +935,17 @@ function joinRepeatable(compare, a, b) {
 
 // src/translator/util/state.ts
 var createProgramState = (init) => {
-  const map2 = /* @__PURE__ */ new WeakMap();
+  const map = /* @__PURE__ */ new WeakMap();
   return [
     () => {
-      let state = map2.get(currentProgramPath);
+      let state = map.get(currentProgramPath);
       if (!state) {
-        map2.set(currentProgramPath, state = init());
+        map.set(currentProgramPath, state = init());
       }
       return state;
     },
     (value) => {
-      map2.set(currentProgramPath, value);
+      map.set(currentProgramPath, value);
     }
   ];
 };
@@ -1124,7 +1123,8 @@ function startSection(path5) {
       bindings: void 0,
       content: getContentInfo(path5),
       upstreamExpression: void 0,
-      hasCleanup: false
+      hasAbortSignal: false,
+      isBranch: false
     };
     sections.push(section);
   }
@@ -1963,9 +1963,9 @@ var [getSignals] = createSectionState(
   "signals",
   () => /* @__PURE__ */ new Map()
 );
-var [getSubscribeBuilder, _setSubscribeBuilder] = createSectionState("queue");
-function setSubscriberBuilder(tag, builder) {
-  _setSubscribeBuilder(getSectionForBody(tag.get("body")), builder);
+var [getClosureSignalBuilder, _setClosureSignalBuilder] = createSectionState("queue");
+function setClosureSignalBuilder(tag, builder) {
+  _setClosureSignalBuilder(getSectionForBody(tag.get("body")), builder);
 }
 var [forceResumeScope, _setForceResumeScope] = createSectionState("forceResumeScope");
 function setForceResumeScope(section) {
@@ -1997,7 +1997,7 @@ function getSignal(section, referencedBindings, name2 = generateSignalName(refer
         subscribers: [],
         closures: /* @__PURE__ */ new Map(),
         hasDownstreamIntersections: () => {
-          let hasDownstreamIntersections = !!(signal.intersection || signal.closures.size);
+          let hasDownstreamIntersections = !!signal.intersection;
           if (!hasDownstreamIntersections) {
             for (const value of signal.values) {
               if (value.signal.hasDownstreamIntersections()) {
@@ -2051,24 +2051,41 @@ function getSignal(section, referencedBindings, name2 = generateSignalName(refer
         signal
       );
       signal.build = () => {
-        const builder = getSubscribeBuilder(section);
+        const builder = getClosureSignalBuilder(section);
         const ownerScope = getScopeExpression(
           section,
           referencedBindings.section
         );
         const isImmediateOwner = ownerScope.object === scopeIdentifier;
-        const isDynamicClosure = signal.isDynamicClosure = !(isImmediateOwner && builder);
-        return callRuntime(
-          isDynamicClosure ? "dynamicClosure" : "closure",
+        const isDynamicClosure = !isImmediateOwner || !builder;
+        const render = getSignalFn(signal, [
+          scopeIdentifier,
+          import_compiler17.types.identifier(referencedBindings.name)
+        ]);
+        signal.isDynamicClosure = isDynamicClosure;
+        const intersection = buildSignalIntersections(signal);
+        return isDynamicClosure ? callRuntime(
+          "dynamicClosure",
           getScopeAccessorLiteral(referencedBindings),
-          getSignalFn(signal, [
-            scopeIdentifier,
-            import_compiler17.types.identifier(referencedBindings.name)
-          ]),
+          render,
           isImmediateOwner ? null : import_compiler17.types.arrowFunctionExpression([scopeIdentifier], ownerScope),
-          buildSignalIntersections(signal)
-        );
+          intersection
+        ) : builder(signal, render, intersection);
       };
+      addStatement(
+        "render",
+        section,
+        void 0,
+        import_compiler17.types.expressionStatement(
+          import_compiler17.types.callExpression(
+            import_compiler17.types.memberExpression(signal.identifier, import_compiler17.types.identifier("_")),
+            [
+              scopeIdentifier,
+              createScopeReadExpression(section, referencedBindings)
+            ]
+          )
+        )
+      );
     }
   }
   return signal;
@@ -2106,8 +2123,9 @@ function initValue(binding, runtimeHelper = "value") {
 function getSignalFn(signal, params, referencedBindings) {
   const section = signal.section;
   const binding = signal.referencedBindings;
-  if (binding && !Array.isArray(binding) && binding.section === section) {
-    const [scopeIdentifier2, valueIdentifier] = params;
+  const [scopeIdentifier2, valueIdentifier] = params;
+  const isValueSignal = binding && !Array.isArray(binding) && binding.section === section;
+  if (isValueSignal) {
     for (const alias of binding.aliases) {
       const aliasSignal = getSignal(alias.section, alias);
       signal.render.push(
@@ -2144,12 +2162,29 @@ function getSignalFn(signal, params, referencedBindings) {
       )
     );
   }
+  if (isValueSignal) {
+    const closureEntries = Array.from(signal.closures.entries()).sort(
+      ([a], [b]) => a.id - b.id
+    );
+    for (const [_closureSection, closureSignal] of closureEntries) {
+      if (isStatefulReferences(closureSignal.referencedBindings)) {
+        signal.render.push(
+          import_compiler17.types.expressionStatement(
+            import_compiler17.types.callExpression(closureSignal.identifier, [
+              scopeIdentifier2,
+              valueIdentifier
+            ])
+          )
+        );
+      }
+    }
+  }
   if (referencedBindings) {
     signal.render.unshift(
       import_compiler17.types.variableDeclaration("const", [
         import_compiler17.types.variableDeclarator(
           createScopeReadPattern(section, referencedBindings),
-          scopeIdentifier
+          scopeIdentifier2
         )
       ])
     );
@@ -2169,7 +2204,6 @@ function getTranslatedExtraArgs(signal) {
   return emptyExtraArgs;
 }
 function buildSignalIntersections(signal) {
-  const section = signal.section;
   let intersections = signal.intersection;
   const binding = signal.referencedBindings;
   if (binding && !Array.isArray(binding) && binding.section === signal.section) {
@@ -2200,24 +2234,6 @@ function buildSignalIntersections(signal) {
       );
     }
   }
-  const closureEntries = Array.from(signal.closures.entries()).sort(
-    ([a], [b]) => a.id - b.id
-  );
-  for (const [closureSection, closureSignal] of closureEntries) {
-    const builder = getSubscribeBuilder(closureSection);
-    const isImmediateOwner = closureSection.parent === section;
-    if (builder && isImmediateOwner) {
-      intersections = push(intersections, builder(closureSignal.identifier));
-    } else if (!signal.hasDynamicSubscribers) {
-      signal.hasDynamicSubscribers = true;
-    }
-  }
-  if (signal.hasDynamicSubscribers) {
-    intersections = push(
-      intersections,
-      callRuntime("dynamicSubscribers", signal.valueAccessor)
-    );
-  }
   return intersections && import_compiler17.types.arrowFunctionExpression(
     [],
     Array.isArray(intersections) ? callRuntime("intersections", import_compiler17.types.arrayExpression(intersections)) : intersections
@@ -2530,7 +2546,7 @@ function writeHTMLResumeStatements(path5, tagVarIdentifier) {
       }
       setForceResumeScope(closure.section);
       const isImmediateOwner = section.parent?.id === closure.section.id;
-      const isDynamicClosure = !getSubscribeBuilder(section) || !isImmediateOwner;
+      const isDynamicClosure = !getClosureSignalBuilder(section) || !isImmediateOwner;
       if (isDynamicClosure) {
         path5.pushContainer(
           "body",
@@ -2602,6 +2618,15 @@ function writeHTMLResumeStatements(path5, tagVarIdentifier) {
       )
     );
   }
+  const resumeClosestBranch2 = !section.isBranch && (section.hasAbortSignal || !!section.closures || !!find(section.bindings, (binding) => binding.type === 1 /* let */));
+  if (resumeClosestBranch2) {
+    path5.pushContainer(
+      "body",
+      import_compiler17.types.expressionStatement(
+        callRuntime("resumeClosestBranch", scopeIdIdentifier)
+      )
+    );
+  }
   if (path5.get("body").length) {
     path5.unshiftContainer(
       "body",
@@ -2790,7 +2815,6 @@ var dom_default = {
       const templateIdentifier = import_compiler18.types.identifier(domExports.template);
       const walksIdentifier = import_compiler18.types.identifier(domExports.walks);
       const setupIdentifier = import_compiler18.types.identifier(domExports.setup);
-      const closuresIdentifier = import_compiler18.types.identifier(domExports.closures);
       const paramsBinding = program.node.extra.binding;
       const programParamsSignal = paramsBinding && bindingHasDownstreamExpressions(paramsBinding) ? initValue(paramsBinding) : void 0;
       const styleFile = getStyleFile(program.hub.file);
@@ -2801,14 +2825,12 @@ var dom_default = {
         if (childSection !== section) {
           const tagParamsSignal = childSection.params && initValue(childSection.params);
           const { walks: walks2, writes: writes2, setup: setup2 } = getSectionMeta(childSection);
-          const closures2 = getSectionClosuresExpr(childSection);
           const identifier = import_compiler18.types.identifier(childSection.name);
           const renderer = callRuntime(
             getSectionParentIsOwner(childSection) ? "createRenderer" : "createRendererWithOwner",
             writes2,
             walks2,
             setup2,
-            closures2 && import_compiler18.types.arrowFunctionExpression([], closures2),
             tagParamsSignal?.identifier && import_compiler18.types.arrowFunctionExpression([], tagParamsSignal.identifier)
           );
           writeSignals(childSection);
@@ -2828,7 +2850,6 @@ var dom_default = {
           );
         }
       });
-      const closures = getSectionClosuresExpr(section);
       writeSignals(section);
       writeRegisteredFns();
       if (!setup) {
@@ -2858,15 +2879,6 @@ var dom_default = {
           ])
         )
       );
-      if (closures) {
-        program.node.body.push(
-          import_compiler18.types.exportNamedDeclaration(
-            import_compiler18.types.variableDeclaration("const", [
-              import_compiler18.types.variableDeclarator(closuresIdentifier, closures)
-            ])
-          )
-        );
-      }
       program.node.body.push(
         import_compiler18.types.exportDefaultDeclaration(
           callRuntime(
@@ -2875,7 +2887,6 @@ var dom_default = {
             templateIdentifier,
             walksIdentifier,
             setupIdentifier,
-            closures && import_compiler18.types.arrowFunctionExpression([], closuresIdentifier),
             programParamsSignal?.identifier && import_compiler18.types.arrowFunctionExpression([], programParamsSignal.identifier)
           )
         )
@@ -2883,16 +2894,6 @@ var dom_default = {
     }
   }
 };
-function getSectionClosuresExpr(section) {
-  if (section.closures) {
-    return import_compiler18.types.arrayExpression(
-      map(
-        section.closures,
-        (closure) => getSignal(section, closure).identifier
-      ).reverse()
-    );
-  }
-}
 
 // src/translator/visitors/program/html.ts
 var import_compiler19 = require("@marko/compiler");
@@ -3947,8 +3948,6 @@ var await_default = {
           setForceResumeScope(bodySection);
         }
         flushInto(tag);
-        setSubscriberBuilder(tag, () => {
-        });
         writeHTMLResumeStatements(tagBody);
         tag.replaceWith(
           import_compiler22.types.expressionStatement(
@@ -3973,7 +3972,6 @@ var await_default = {
           return;
         }
         setSectionParentIsOwner(bodySection, true);
-        setSubscriberBuilder(tag, (signal) => signal);
       },
       exit(tag) {
         tag.remove();
@@ -4936,7 +4934,6 @@ function isInvokedFunction(expr) {
 
 // src/translator/core/for.ts
 var kForMarkerBinding = Symbol("for marker binding");
-var kForScopeStartIndex = Symbol("for scope start index");
 var kOnlyChildInParent = Symbol("only child in parent");
 var for_default = {
   analyze(tag) {
@@ -4972,6 +4969,7 @@ var for_default = {
       dropReferences(getAllTagReferenceNodes(tag.node));
       return;
     }
+    bodySection.isBranch = true;
     const section = getOrCreateSection(tag);
     if (isOnlyChildInParent(tag)) {
       const parentTag = getParentTag(tag).node;
@@ -5002,22 +5000,12 @@ var for_default = {
           tag.remove();
           return;
         }
-        const tagExtra = tag.node.extra;
-        const isStateful = isStatefulReferences(tagExtra.referencedBindings);
         setSectionParentIsOwner(bodySection, true);
         if (!isOnlyChildInParent(tag)) {
           visit(tag, 37 /* Replace */);
           enterShallow(tag);
         }
         flushBefore(tag);
-        if (isStateful && !bodySection.content?.singleChild) {
-          tagExtra[kForScopeStartIndex] = tag.scope.generateUidIdentifier("k");
-          writeTo(tagBody)`${callRuntime(
-            "markResumeScopeStart",
-            getScopeIdIdentifier(bodySection),
-            import_compiler29.types.updateExpression("++", tagExtra[kForScopeStartIndex])
-          )}`;
-        }
       },
       exit(tag) {
         if (tag.node.body.attributeTags) return;
@@ -5035,22 +5023,12 @@ var for_default = {
         const statements = [];
         const bodyStatements = node.body.body;
         const hasStatefulClosures = checkStatefulClosures(bodySection, true);
+        const singleNodeOptimization = bodySection.content === null || bodySection.content.singleChild;
         let keyExpression;
         if (isStateful && isOnlyChildInParent(tag)) {
           parentTag.node.extra[kSerializeMarker] = true;
         }
-        if (tagExtra[kForScopeStartIndex]) {
-          statements.push(
-            import_compiler29.types.variableDeclaration("let", [
-              import_compiler29.types.variableDeclarator(
-                tagExtra[kForScopeStartIndex],
-                import_compiler29.types.numericLiteral(0)
-              )
-            ])
-          );
-        }
         if (isStateful || hasStatefulClosures) {
-          const singleNodeOptimization = bodySection.content === null || bodySection.content.singleChild;
           const defaultParamNames = {
             of: ["list", "index"],
             in: ["key", "value"],
@@ -5101,50 +5079,33 @@ var for_default = {
           } else {
             keyExpression = params[defaultByParamIndex];
           }
-          const write2 = writeTo(tag);
-          const forScopeIdsIdentifier = tag.scope.generateUidIdentifier("forScopeIds");
           const forScopesIdentifier = getScopeIdentifier(bodySection);
           statements.push(
-            import_compiler29.types.variableDeclaration(
-              "const",
-              [
-                isStateful && singleNodeOptimization && import_compiler29.types.variableDeclarator(
-                  forScopeIdsIdentifier,
-                  import_compiler29.types.arrayExpression([])
-                ),
-                import_compiler29.types.variableDeclarator(
-                  forScopesIdentifier,
-                  import_compiler29.types.newExpression(import_compiler29.types.identifier("Map"), [])
-                )
-              ].filter(Boolean)
-            )
+            import_compiler29.types.variableDeclaration("const", [
+              import_compiler29.types.variableDeclarator(
+                forScopesIdentifier,
+                import_compiler29.types.newExpression(import_compiler29.types.identifier("Map"), [])
+              )
+            ])
           );
-          if (isStateful) {
-            if (singleNodeOptimization) {
-              bodyStatements.push(
-                import_compiler29.types.expressionStatement(
-                  import_compiler29.types.callExpression(
-                    import_compiler29.types.memberExpression(
-                      forScopeIdsIdentifier,
-                      import_compiler29.types.identifier("push")
-                    ),
-                    [getScopeIdIdentifier(bodySection)]
-                  )
+          if (keyExpression && (isStateful || hasStatefulClosures)) {
+            bodyStatements.push(
+              import_compiler29.types.expressionStatement(
+                import_compiler29.types.callExpression(
+                  import_compiler29.types.memberExpression(
+                    getScopeIdentifier(bodySection),
+                    import_compiler29.types.identifier("set")
+                  ),
+                  [
+                    keyExpression,
+                    callRuntime(
+                      "ensureScopeWithId",
+                      getScopeIdIdentifier(bodySection)
+                    )
+                  ]
                 )
-              );
-              write2`${callRuntime(
-                "markResumeControlSingleNodeEnd",
-                getScopeIdIdentifier(tagSection),
-                getScopeAccessorLiteral(nodeRef2),
-                forScopeIdsIdentifier
-              )}`;
-            } else {
-              write2`${callRuntime(
-                "markResumeControlEnd",
-                getScopeIdIdentifier(tagSection),
-                getScopeAccessorLiteral(nodeRef2)
-              )}`;
-            }
+              )
+            );
           }
           getSerializedScopeProperties(tagSection).set(
             import_compiler29.types.stringLiteral(
@@ -5158,30 +5119,22 @@ var for_default = {
           );
         }
         flushInto(tag);
-        setSubscriberBuilder(tag, () => {
+        setClosureSignalBuilder(tag, () => {
         });
         writeHTMLResumeStatements(tagBody);
-        if (keyExpression && (isStateful || hasStatefulClosures)) {
-          bodyStatements.push(
-            import_compiler29.types.expressionStatement(
-              import_compiler29.types.callExpression(
-                import_compiler29.types.memberExpression(
-                  getScopeIdentifier(bodySection),
-                  import_compiler29.types.identifier("set")
-                ),
-                [
-                  keyExpression,
-                  callRuntime(
-                    "getScopeById",
-                    getScopeIdIdentifier(bodySection)
-                  )
-                ]
-              )
-            )
+        const forTagArgs = getBaseArgsInForTag(forType, forAttrs);
+        const forTagHTMLRuntime = isStateful ? forTypeToHTMLResumeRuntime(forType, singleNodeOptimization) : forTypeToRuntime(forType);
+        forTagArgs.push(
+          import_compiler29.types.arrowFunctionExpression(params, import_compiler29.types.blockStatement(bodyStatements))
+        );
+        if (isStateful) {
+          forTagArgs.push(
+            getScopeIdIdentifier(tagSection),
+            getScopeAccessorLiteral(nodeRef2)
           );
         }
         statements.push(
-          buildForRuntimeCall(forType, forAttrs, params, bodyStatements)
+          import_compiler29.types.expressionStatement(callRuntime(forTagHTMLRuntime, ...forTagArgs))
         );
         for (const replacement of tag.replaceWithMultiple(statements)) {
           replacement.skip();
@@ -5212,11 +5165,12 @@ var for_default = {
         const tagExtra = node.extra;
         const { referencedBindings } = tagExtra;
         const nodeRef2 = isOnlyChildInParent(tag) ? getParentTag(tag).node.extra[kNativeTagBinding] : tag.node.extra[kForMarkerBinding];
-        setSubscriberBuilder(tag, (signal2) => {
+        setClosureSignalBuilder(tag, (_closureSignal, render, intersection) => {
           return callRuntime(
-            "inLoopScope",
-            signal2,
-            getScopeAccessorLiteral(nodeRef2)
+            "loopClosure",
+            getScopeAccessorLiteral(nodeRef2),
+            render,
+            intersection
           );
         });
         const forType = getForType(node);
@@ -5355,6 +5309,27 @@ function forTypeToRuntime(type) {
       return "forTo";
   }
 }
+function forTypeToHTMLResumeRuntime(type, singleNodeOptimization) {
+  if (singleNodeOptimization) {
+    switch (type) {
+      case "of":
+        return "resumeSingleNodeForOf";
+      case "in":
+        return "resumeSingleNodeForIn";
+      case "to":
+        return "resumeSingleNodeForTo";
+    }
+  } else {
+    switch (type) {
+      case "of":
+        return "resumeForOf";
+      case "in":
+        return "resumeForIn";
+      case "to":
+        return "resumeForTo";
+    }
+  }
+}
 function forTypeToDOMRuntime(type) {
   switch (type) {
     case "of":
@@ -6899,6 +6874,7 @@ var IfTag = {
       let singleNodeOptimization = true;
       for (const [branchTag, branchBodySection] of branches) {
         if (branchBodySection) {
+          branchBodySection.isBranch = true;
           branchBodySection.upstreamExpression = rootExtra;
           if (!(branchBodySection.content === null || branchBodySection.content?.singleChild)) {
             singleNodeOptimization = false;
@@ -6926,9 +6902,6 @@ var IfTag = {
         if (tag.node.body.attributeTags) return;
         const tagBody = tag.get("body");
         const bodySection = getSectionForBody(tagBody);
-        const rootExtra = getRoot(tag).node.extra;
-        const isStateful = isStatefulReferences(rootExtra.referencedBindings);
-        const singleNodeOptimization = rootExtra.singleNodeOptimization;
         if (isRoot(tag)) {
           visit(tag, 37 /* Replace */);
         }
@@ -6936,12 +6909,6 @@ var IfTag = {
         flushBefore(tag);
         if (bodySection) {
           setSectionParentIsOwner(bodySection, true);
-          if (isStateful && !singleNodeOptimization) {
-            writeTo(tagBody)`${callRuntime(
-              "markResumeScopeStart",
-              getScopeIdIdentifier(bodySection)
-            )}`;
-          }
         }
       },
       exit(tag) {
@@ -6960,12 +6927,11 @@ var IfTag = {
             setForceResumeScope(bodySection);
           }
           flushInto(tag);
-          setSubscriberBuilder(tag, () => {
+          setClosureSignalBuilder(tag, () => {
           });
           writeHTMLResumeStatements(tagBody);
         }
         if (isLast) {
-          const write2 = writeTo(tag);
           const nextTag = tag.getNextSibling();
           const ifScopeIdIdentifier = tag.scope.generateUidIdentifier("ifScopeId");
           const ifRendererIdentifier = tag.scope.generateUidIdentifier("ifRenderer");
@@ -7026,6 +6992,31 @@ var IfTag = {
           if (!(isStateful || hasStatefulClosures)) {
             nextTag.insertBefore(statement);
           } else {
+            if (isStateful) {
+              getSerializedScopeProperties(section).set(
+                import_compiler38.types.stringLiteral(
+                  getScopeAccessorLiteral(nodeRef2).value + "(" /* ConditionalRenderer */
+                ),
+                ifRendererIdentifier
+              );
+              const cbNode = import_compiler38.types.arrowFunctionExpression(
+                [],
+                import_compiler38.types.blockStatement([statement])
+              );
+              statement = import_compiler38.types.expressionStatement(
+                singleNodeOptimization ? callRuntime(
+                  "resumeSingleNodeConditional",
+                  cbNode,
+                  getScopeIdIdentifier(section),
+                  getScopeAccessorLiteral(nodeRef2)
+                ) : callRuntime(
+                  "resumeConditional",
+                  cbNode,
+                  getScopeIdIdentifier(section),
+                  getScopeAccessorLiteral(nodeRef2)
+                )
+              );
+            }
             nextTag.insertBefore([
               import_compiler38.types.variableDeclaration(
                 "let",
@@ -7036,28 +7027,6 @@ var IfTag = {
               ),
               statement
             ]);
-            if (isStateful) {
-              if (singleNodeOptimization) {
-                write2`${callRuntime(
-                  "markResumeControlSingleNodeEnd",
-                  getScopeIdIdentifier(section),
-                  getScopeAccessorLiteral(nodeRef2),
-                  ifScopeIdIdentifier
-                )}`;
-              } else {
-                write2`${callRuntime(
-                  "markResumeControlEnd",
-                  getScopeIdIdentifier(section),
-                  getScopeAccessorLiteral(nodeRef2)
-                )}`;
-              }
-              getSerializedScopeProperties(section).set(
-                import_compiler38.types.stringLiteral(
-                  getScopeAccessorLiteral(nodeRef2).value + "(" /* ConditionalRenderer */
-                ),
-                ifRendererIdentifier
-              );
-            }
             getSerializedScopeProperties(section).set(
               import_compiler38.types.stringLiteral(
                 getScopeAccessorLiteral(nodeRef2).value + "!" /* ConditionalScope */
@@ -7096,14 +7065,21 @@ var IfTag = {
             const [branchTag, branchBodySection] = branches[i];
             const [testAttr] = branchTag.node.attributes;
             const consequent = branchBodySection ? import_compiler38.types.identifier(branchBodySection.name) : import_compiler38.types.numericLiteral(0);
-            setSubscriberBuilder(branchTag, (subscriber) => {
-              return callRuntime(
-                "inConditionalScope",
-                subscriber,
-                getScopeAccessorLiteral(nodeRef2)
-                /*t.identifier(section.name)*/
-              );
-            });
+            setClosureSignalBuilder(
+              branchTag,
+              (_closureSignal, render, intersection) => {
+                return callRuntime(
+                  "conditionalClosure",
+                  getScopeAccessorLiteral(nodeRef2),
+                  import_compiler38.types.arrowFunctionExpression(
+                    [],
+                    import_compiler38.types.identifier(branchBodySection.name)
+                  ),
+                  render,
+                  intersection
+                );
+              }
+            );
             branchTag.remove();
             expr = testAttr ? import_compiler38.types.conditionalExpression(testAttr.value, consequent, expr) : consequent;
           }
@@ -7235,9 +7211,6 @@ function getBranches(tag, bodySection) {
   }
   return [isLast, branches];
 }
-function getRoot(tag) {
-  return isRoot(tag) ? tag : BRANCHES_LOOKUP.get(tag)[0][0];
-}
 function isRoot(tag) {
   return isCoreTagName(tag, "if");
 }
@@ -7751,27 +7724,27 @@ var style_default = {
     const start = (0, import_babel_utils35.getStart)(file, markoText);
     const end = (0, import_babel_utils35.getEnd)(file, markoText);
     let code = markoText.value;
-    let map2;
+    let map;
     if (resolveVirtualDependency && sourceMaps && start !== null && end !== null) {
       const magicString = new import_magic_string.default(file.code, { filename });
       magicString.remove(0, start);
       magicString.remove(end, file.code.length);
-      map2 = magicString.generateMap({
+      map = magicString.generateMap({
         source: filename,
         includeContent: true
       });
       if (sourceMaps === "inline" || sourceMaps === "both") {
         code += `
-/*# sourceMappingURL=${map2.toUrl()}*/`;
+/*# sourceMappingURL=${map.toUrl()}*/`;
         if (sourceMaps === "inline") {
-          map2 = void 0;
+          map = void 0;
         }
       }
     }
     const importPath = resolveVirtualDependency?.(filename, {
       virtualPath: `./${import_path3.default.basename(filename) + ext}`,
       code,
-      map: map2
+      map
     });
     if (importPath) {
       if (!node.var) {
@@ -7881,7 +7854,6 @@ function setAllSectionsParentIsOwner(tag) {
   const bodySection = getSectionForBody(tag.get("body"));
   if (bodySection) {
     setSectionParentIsOwner(bodySection, true);
-    setSubscriberBuilder(tag, (signal) => signal);
   }
 }
 
@@ -8197,7 +8169,11 @@ var referenced_identifier_default = {
   analyze(identifier) {
     const { name: name2 } = identifier.node;
     if (identifier.scope.hasBinding(name2)) return;
-    if (name2 === "$global" || name2 === "$signal") {
+    if (name2 === "$global") {
+      setReferencesScope(identifier);
+    } else if (name2 === "$signal") {
+      const section = getOrCreateSection(identifier);
+      section.hasAbortSignal = true;
       setReferencesScope(identifier);
     }
   },
@@ -8218,13 +8194,6 @@ var referenced_identifier_default = {
         break;
       case "$signal":
         if (isOutputHTML()) {
-          const section = getSection(identifier);
-          if (!section.hasCleanup) {
-            section.hasCleanup = true;
-            const exprRoot = getExprRoot(identifier);
-            const write2 = writeTo(exprRoot);
-            write2`${callRuntime("markResumeCleanup", getScopeIdIdentifier(section))}`;
-          }
           identifier.replaceWith(
             import_compiler49.types.callExpression(
               import_compiler49.types.arrowFunctionExpression(
@@ -9059,7 +9028,6 @@ var dynamic_tag_default = {
       if (isOutputHTML()) {
         flushInto(tag);
         writeHTMLResumeStatements(tag.get("body"));
-        const write2 = writeTo(tag);
         if (node.var) {
           if (!hasMultipleArgs && args.length === 1) {
             args.push(import_compiler52.types.unaryExpression("void", import_compiler52.types.numericLiteral(0)));
@@ -9083,12 +9051,14 @@ var dynamic_tag_default = {
         const dynamicScopeIdentifier = currentProgramPath.scope.generateUidIdentifier("dynamicScope");
         const dynamicTagExpr = hasMultipleArgs ? callRuntime(
           "dynamicTagArgs",
-          dynamicScopeIdentifier,
+          getScopeIdIdentifier(section),
+          getScopeAccessorLiteral(nodeRef2),
           tagExpression,
           import_compiler52.types.arrayExpression(args)
         ) : callRuntime(
           "dynamicTagInput",
-          dynamicScopeIdentifier,
+          getScopeIdIdentifier(section),
+          getScopeAccessorLiteral(nodeRef2),
           tagExpression,
           ...args
         );
@@ -9105,11 +9075,6 @@ var dynamic_tag_default = {
             import_compiler52.types.variableDeclarator(node.var, dynamicTagExpr)
           ]) : import_compiler52.types.expressionStatement(dynamicTagExpr)
         );
-        write2`${callRuntime(
-          "markResumeControlEnd",
-          getScopeIdIdentifier(section),
-          getScopeAccessorLiteral(nodeRef2)
-        )}`;
         getSerializedScopeProperties(section).set(
           import_compiler52.types.stringLiteral(
             getScopeAccessorLiteral(nodeRef2).value + "!" /* ConditionalScope */