@qwik.dev/core 2.0.0-beta.29 → 2.0.0-beta.30

package/dist/testing/index.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/testing 2.0.0-beta.29-dev+bc61b71
+ * @qwik.dev/core/testing 2.0.0-beta.30-dev+5421ed4
  * Copyright QwikDev. All Rights Reserved.
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://github.com/QwikDev/qwik/blob/main/LICENSE
@@ -22985,12 +22985,12 @@ ${file}:${line}:${column}: ERROR: ${pluginText}${e.text}`;
       }
       return result2;
     }
-    function convertOutputFiles({ path: path3, contents, hash: hash3 }) {
+    function convertOutputFiles({ path: path3, contents, hash: hash2 }) {
       let text = null;
       return {
         path: path3,
         contents,
-        hash: hash3,
+        hash: hash2,
         get text() {
           const binary = this.contents;
           if (text === null || binary !== contents) {
@@ -23645,7 +23645,7 @@ import { _isJSXNode, _isStringifiable } from "@qwik.dev/core/internal";
 import { expect } from "vitest";
 
 // packages/qwik/src/core/client/vnode-utils.ts
-import { isDev as isDev25 } from "@qwik.dev/core/build";
+import { isDev as isDev26 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/shared/error/assert.ts
 import { isDev } from "@qwik.dev/core/build";
@@ -23654,7 +23654,6 @@ import { isDev } from "@qwik.dev/core/build";
 var g = globalThis;
 var qDev = g.qDev !== false;
 var qInspector = g.qInspector === true;
-var qSerialize = g.qSerialize !== false;
 var qDynamicPlatform = g.qDynamicPlatform !== false;
 var qTest = g.qTest === true;
 var qRuntimeQrl = g.qRuntimeQrl === true;
@@ -23950,8 +23949,8 @@ var QScopedStyle = "q:sstyle";
 var QCtxAttr = "q:ctx";
 var QBackRefs = "q:brefs";
 var QFuncsPrefix = "qFuncs_";
-var getQFuncs = (document2, hash3) => {
-  return document2[QFuncsPrefix + hash3] || [];
+var getQFuncs = (document2, hash2) => {
+  return document2[QFuncsPrefix + hash2] || [];
 };
 var QRenderAttr = "q:render";
 var QRuntimeAttr = "q:runtime";
@@ -23998,8 +23997,8 @@ var createPlatform = () => {
     isServer,
     importSymbol(containerEl, url, symbolName) {
       if (isServer) {
-        const hash3 = getSymbolHash(symbolName);
-        const regSym = globalThis.__qwik_reg_symbols?.get(hash3);
+        const hash2 = getSymbolHash(symbolName);
+        const regSym = globalThis.__qwik_reg_symbols?.get(hash2);
         if (regSym) {
           return regSym;
         }
@@ -24131,10 +24130,10 @@ function retryOnPromise(fn, onError = justThrow) {
 }
 
 // packages/qwik/src/core/use/use-core.ts
-import { isDev as isDev21 } from "@qwik.dev/core/build";
+import { isDev as isDev22 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/client/dom-container.ts
-import { isDev as isDev20 } from "@qwik.dev/core/build";
+import { isDev as isDev21 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/use/use-sequential-scope.ts
 var useSequentialScope = () => {
@@ -24155,7 +24154,7 @@ var useSequentialScope = () => {
     seq.push(void 0);
   }
   const set = (value) => {
-    if (qDev && qSerialize) {
+    if (qDev) {
       verifySerializable(value);
     }
     return seq[seqIdx] = value;
@@ -24237,7 +24236,7 @@ var useContextProvider = (context, newValue) => {
   if (qDev) {
     validateContext(context);
   }
-  if (qDev && qSerialize) {
+  if (qDev) {
     verifySerializable(newValue);
   }
   iCtx.$container$.setContext(iCtx.$hostElement$, context, newValue);
@@ -24288,7 +24287,7 @@ Object.freeze(EMPTY_ARRAY);
 Object.freeze(EMPTY_OBJ);
 
 // packages/qwik/src/core/shared/qrl/qrl-class.ts
-import { isBrowser as isBrowser3, isDev as isDev19 } from "@qwik.dev/core/build";
+import { isBrowser as isBrowser3, isDev as isDev20 } from "@qwik.dev/core/build";
 import { p as preload } from "@qwik.dev/core/preloader";
 
 // packages/qwik/src/core/shared/serdes/inflate.ts
@@ -24719,6 +24718,21 @@ function getEffects(effects, prop) {
 var directGetPropsProxyProp = (jsx2, prop) => {
   return jsx2.constProps && prop in jsx2.constProps ? jsx2.constProps[prop] : jsx2.varProps[prop];
 };
+var _getProps = (props, prop) => {
+  return _getVarProps(props)?.[prop] || _getConstProps(props)?.[prop] || null;
+};
+var _getVarProps = (props) => {
+  if (!props) {
+    return null;
+  }
+  return _VAR_PROPS in props ? "children" in props ? { ...props[_VAR_PROPS], children: props.children } : props[_VAR_PROPS] : props;
+};
+var _getConstProps = (props) => {
+  if (!props) {
+    return null;
+  }
+  return _CONST_PROPS in props ? props[_CONST_PROPS] : null;
+};
 var isPropsProxy = (obj) => {
   return obj && _VAR_PROPS in obj;
 };
@@ -24785,13 +24799,21 @@ var cleanupFn = (target, handleError) => {
         cleanupFns = [];
         target.$destroy$ = () => {
           target.$destroy$ = null;
+          let cleanupPromises = null;
           for (const fn2 of cleanupFns) {
             try {
-              fn2();
+              const result2 = fn2();
+              if (isPromise(result2)) {
+                (cleanupPromises || (cleanupPromises = [])).push(result2.catch(handleError));
+              }
             } catch (err) {
               handleError(err);
             }
           }
+          cleanupFns = null;
+          if (cleanupPromises?.length) {
+            return Promise.all(cleanupPromises).then(() => void 0);
+          }
         };
       }
       cleanupFns.push(fn);
@@ -25273,11 +25295,7 @@ var SerializerSignalImpl = class extends ComputedSignalImpl {
       return;
     }
     throwIfQRLNotResolved(this.$computeQrl$);
-    this.$flags$ &= ~1 /* INVALID */;
-    let arg = this.$computeQrl$.resolved;
-    if (typeof arg === "function") {
-      arg = arg();
-    }
+    const arg = untrack(this.$computeQrl$.resolved);
     const { deserialize, initial } = arg;
     const update = arg.update;
     const currentValue = this.$untrackedValue$ === NEEDS_COMPUTATION ? initial : this.$untrackedValue$;
@@ -25288,6 +25306,7 @@ var SerializerSignalImpl = class extends ComputedSignalImpl {
       this.$container$
     );
     this.$didInitialize$ = true;
+    this.$flags$ &= ~1 /* INVALID */;
     DEBUG4 && log4("SerializerSignal.$compute$", untrackedValue);
     const didChange = this.$didInitialize$ && untrackedValue !== "undefined" || untrackedValue !== this.$untrackedValue$;
     if (didChange) {
@@ -25447,8 +25466,8 @@ var componentQrl = (componentQrl3) => {
   function QwikComponent(props, key, flags = 0) {
     isDev11 && assertQrl(componentQrl3);
     isDev11 && assertNumber(flags, "The Qwik Component was not invoked correctly");
-    const hash3 = qTest ? "sX" : componentQrl3.$hash$.slice(0, 4);
-    const finalKey = hash3 + ":" + (key ? key : "");
+    const hash2 = qTest ? "sX" : componentQrl3.$hash$.slice(0, 4);
+    const finalKey = hash2 + ":" + (key ? key : "");
     const InnerCmp = () => {
     };
     InnerCmp[SERIALIZABLE_STATE] = [componentQrl3];
@@ -26521,11 +26540,53 @@ var cleanupDestroyable = (destroyable) => {
     destroyable.$destroy$ = null;
   }
 };
+var cleanupAsyncDestroyable = (destroyable, handleError) => {
+  const pendingCleanup = destroyable.$destroyPromise$;
+  if (pendingCleanup) {
+    return pendingCleanup;
+  }
+  const cleanup2 = destroyable.$destroy$;
+  if (!cleanup2) {
+    return;
+  }
+  destroyable.$destroy$ = null;
+  try {
+    const result2 = cleanup2();
+    if (isPromise(result2)) {
+      const cleanupPromise = Promise.resolve(result2).then(
+        () => void 0,
+        (err) => {
+          handleError(err);
+        }
+      ).finally(() => {
+        if (destroyable.$destroyPromise$ === cleanupPromise) {
+          destroyable.$destroyPromise$ = void 0;
+        }
+      });
+      destroyable.$destroyPromise$ = cleanupPromise;
+      return cleanupPromise;
+    }
+  } catch (err) {
+    handleError(err);
+  }
+  return;
+};
 
 // packages/qwik/src/core/client/vnode-diff.ts
 function peekNextSibling(vCurrent) {
   return vCurrent ? vCurrent.nextSibling : null;
 }
+function getLevelBoundary(diffContext) {
+  return diffContext.$vParent$ === diffContext.$vEndParent$ ? diffContext.$vEnd$ : null;
+}
+function getCurrentInsertBefore(diffContext) {
+  return diffContext.$vCurrent$ || getLevelBoundary(diffContext);
+}
+function peekNextSiblingWithinBoundary(diffContext, vCurrent) {
+  const nextSibling = peekNextSibling(vCurrent);
+  const boundary = getLevelBoundary(diffContext);
+  return nextSibling === boundary ? null : nextSibling;
+}
 var _hasOwnProperty2 = Object.prototype.hasOwnProperty;
 function setAttribute(journal, vnode, key, value, scopedStyleIdPrefix, originalValue) {
   import.meta.env.TEST && scopedStyleIdPrefix && vnode_setProp(vnode, debugStyleScopeIdPrefixAttr, scopedStyleIdPrefix);
@@ -26553,6 +26614,8 @@ function createDiffContext(container, journal, cursor, scopedStyleIdPrefix) {
     $vParent$: null,
     $vCurrent$: null,
     $vNewNode$: null,
+    $vEnd$: null,
+    $vEndParent$: null,
     $vSiblings$: null,
     $vSiblingsArray$: null,
     $vSideBuffer$: null,
@@ -26574,9 +26637,40 @@ function createDiffContext(container, journal, cursor, scopedStyleIdPrefix) {
     }
   };
 }
-var vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleIdPrefix) => {
-  const diffContext = createDiffContext(container, journal, cursor, scopedStyleIdPrefix);
-  diff(diffContext, jsxNode, vStartNode);
+function prepareDiffContext(diffContext, container, journal, cursor, scopedStyleIdPrefix) {
+  diffContext.$container$ = container;
+  diffContext.$journal$ = journal;
+  diffContext.$cursor$ = cursor;
+  diffContext.$scopedStyleIdPrefix$ = scopedStyleIdPrefix;
+  diffContext.$subscriptionData$.$const$.data.$scopedStyleIdPrefix$ = scopedStyleIdPrefix;
+  diffContext.$subscriptionData$.$var$.data.$scopedStyleIdPrefix$ = scopedStyleIdPrefix;
+  diffContext.$asyncQueue$.length = 0;
+  diffContext.$asyncAttributePromises$.length = 0;
+}
+function getPreparedDiffContext(diffContext, container, journal, cursor, scopedStyleIdPrefix) {
+  const reusableDiffContext = diffContext ?? createDiffContext(container, journal, cursor, scopedStyleIdPrefix);
+  prepareDiffContext(reusableDiffContext, container, journal, cursor, scopedStyleIdPrefix);
+  return reusableDiffContext;
+}
+var vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleIdPrefix, diffContext) => {
+  return runDiff(
+    getPreparedDiffContext(diffContext, container, journal, cursor, scopedStyleIdPrefix),
+    jsxNode,
+    vStartNode
+  );
+};
+var vnode_diff_range = (container, journal, jsxNode, vParent, vCurrent, vEnd, cursor, scopedStyleIdPrefix, forceCreationMode = false, diffContext) => {
+  return runDiff(
+    getPreparedDiffContext(diffContext, container, journal, cursor, scopedStyleIdPrefix),
+    jsxNode,
+    vParent,
+    vCurrent,
+    vEnd,
+    forceCreationMode
+  );
+};
+function runDiff(diffContext, jsxNode, vStartNode, vCurrent = vnode_getFirstChild(vStartNode), vEnd = null, forceCreationMode = false) {
+  diff(diffContext, jsxNode, vStartNode, vCurrent, vEnd, forceCreationMode);
   const result2 = drainAsyncQueue(diffContext);
   if (isPromise(result2)) {
     return result2.finally(() => {
@@ -26585,112 +26679,125 @@ var vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleId
   } else {
     cleanupDiffContext(diffContext);
   }
-};
-function diff(diffContext, jsxNode, vStartNode) {
+}
+function diff(diffContext, jsxNode, vStartNode, vCurrent = vnode_getFirstChild(vStartNode), vEnd = null, forceCreationMode = false) {
+  const previousCreationMode = diffContext.$isCreationMode$;
   isDev14 && assertFalse(vnode_isVNode(jsxNode), "JSXNode should not be a VNode");
   isDev14 && assertTrue(vnode_isVNode(vStartNode), "vStartNode should be a VNode");
+  diffContext.$isCreationMode$ = forceCreationMode || previousCreationMode;
   diffContext.$vParent$ = vStartNode;
   diffContext.$vNewNode$ = null;
-  diffContext.$vCurrent$ = vnode_getFirstChild(vStartNode);
+  diffContext.$vCurrent$ = vCurrent;
+  diffContext.$vEnd$ = vEnd;
+  diffContext.$vEndParent$ = vStartNode;
   stackPush(diffContext, jsxNode, true);
-  if (diffContext.$vParent$.flags & 32 /* Deleted */) {
-    return;
-  }
-  while (diffContext.$stack$.length) {
-    while (diffContext.$jsxIdx$ < diffContext.$jsxCount$) {
-      isDev14 && assertFalse(
-        diffContext.$vParent$ === diffContext.$vCurrent$,
-        "Parent and current can't be the same"
-      );
-      if (typeof diffContext.$jsxValue$ === "string") {
-        expectText(diffContext, diffContext.$jsxValue$);
-      } else if (typeof diffContext.$jsxValue$ === "number") {
-        expectText(diffContext, String(diffContext.$jsxValue$));
-      } else if (diffContext.$jsxValue$ && typeof diffContext.$jsxValue$ === "object") {
-        if (isJSXNode(diffContext.$jsxValue$)) {
-          const type = diffContext.$jsxValue$.type;
-          if (typeof type === "string") {
-            expectNoTextNode(diffContext);
-            expectElement(diffContext, diffContext.$jsxValue$, type);
-            const hasDangerousInnerHTML = diffContext.$jsxValue$.constProps && _hasOwnProperty2.call(diffContext.$jsxValue$.constProps, dangerouslySetInnerHTML) || _hasOwnProperty2.call(diffContext.$jsxValue$.varProps, dangerouslySetInnerHTML);
-            if (hasDangerousInnerHTML) {
-              expectNoChildren(diffContext, false);
-            } else {
-              descend(diffContext, diffContext.$jsxValue$.children, true);
-            }
-          } else if (typeof type === "function") {
-            if (type === Fragment) {
-              expectNoTextNode(diffContext);
-              expectVirtual(diffContext, "F" /* Fragment */, diffContext.$jsxValue$.key);
-              descend(diffContext, diffContext.$jsxValue$.children, true);
-            } else if (type === Slot) {
+  try {
+    if (diffContext.$vParent$.flags & 32 /* Deleted */) {
+      return;
+    }
+    while (diffContext.$stack$.length) {
+      while (diffContext.$jsxIdx$ < diffContext.$jsxCount$) {
+        isDev14 && assertFalse(
+          diffContext.$vParent$ === diffContext.$vCurrent$,
+          "Parent and current can't be the same"
+        );
+        if (typeof diffContext.$jsxValue$ === "string") {
+          expectText(diffContext, diffContext.$jsxValue$);
+        } else if (typeof diffContext.$jsxValue$ === "number") {
+          expectText(diffContext, String(diffContext.$jsxValue$));
+        } else if (diffContext.$jsxValue$ && typeof diffContext.$jsxValue$ === "object") {
+          if (isJSXNode(diffContext.$jsxValue$)) {
+            const type = diffContext.$jsxValue$.type;
+            if (typeof type === "string") {
               expectNoTextNode(diffContext);
-              if (!expectSlot(diffContext)) {
+              expectElement(diffContext, diffContext.$jsxValue$, type);
+              const hasDangerousInnerHTML = diffContext.$jsxValue$.constProps && _hasOwnProperty2.call(
+                diffContext.$jsxValue$.constProps,
+                dangerouslySetInnerHTML
+              ) || _hasOwnProperty2.call(diffContext.$jsxValue$.varProps, dangerouslySetInnerHTML);
+              if (hasDangerousInnerHTML) {
+                if (!diffContext.$vNewNode$) {
+                  expectNoChildren(diffContext, false);
+                }
+              } else {
+                descend(diffContext, diffContext.$jsxValue$.children, true);
+              }
+            } else if (typeof type === "function") {
+              if (type === Fragment) {
+                expectNoTextNode(diffContext);
+                expectVirtual(diffContext, "F" /* Fragment */, diffContext.$jsxValue$.key);
                 descend(diffContext, diffContext.$jsxValue$.children, true);
+              } else if (type === Slot) {
+                expectNoTextNode(diffContext);
+                if (!expectSlot(diffContext)) {
+                  descend(diffContext, diffContext.$jsxValue$.children, true);
+                }
+              } else if (type === Projection) {
+                expectProjection(diffContext);
+                descend(
+                  diffContext,
+                  diffContext.$jsxValue$.children,
+                  true,
+                  // special case for projection, we don't want to expect no children
+                  // because the projection's children are not removed
+                  false
+                );
+              } else if (type === SSRComment) {
+                expectNoMore(diffContext);
+              } else if (type === SSRRaw) {
+                expectNoMore(diffContext);
+              } else {
+                expectNoTextNode(diffContext);
+                expectComponent(diffContext, type);
               }
-            } else if (type === Projection) {
-              expectProjection(diffContext);
+            }
+          } else if (Array.isArray(diffContext.$jsxValue$)) {
+            descend(diffContext, diffContext.$jsxValue$, false);
+          } else if (isSignal(diffContext.$jsxValue$)) {
+            expectVirtual(diffContext, "S" /* WrappedSignal */, null);
+            const unwrappedSignal = diffContext.$jsxValue$ instanceof WrappedSignalImpl ? diffContext.$jsxValue$.$unwrapIfSignal$() : diffContext.$jsxValue$;
+            const signals = diffContext.$vCurrent$?.[_EFFECT_BACK_REF]?.get(
+              "." /* VNODE */
+            )?.backRef;
+            let hasUnwrappedSignal = signals?.has(unwrappedSignal);
+            if (signals && unwrappedSignal instanceof WrappedSignalImpl) {
+              hasUnwrappedSignal = containsWrappedSignal(signals, unwrappedSignal);
+            }
+            if (!hasUnwrappedSignal) {
+              const vHost = diffContext.$vNewNode$ || diffContext.$vCurrent$;
               descend(
                 diffContext,
-                diffContext.$jsxValue$.children,
-                true,
-                // special case for projection, we don't want to expect no children
-                // because the projection's children are not removed
-                false
+                resolveSignalAndDescend(
+                  diffContext,
+                  () => trackSignalAndAssignHost(
+                    unwrappedSignal,
+                    vHost,
+                    "." /* VNODE */,
+                    diffContext.$container$
+                  )
+                ),
+                true
               );
-            } else if (type === SSRComment) {
-              expectNoMore(diffContext);
-            } else if (type === SSRRaw) {
-              expectNoMore(diffContext);
-            } else {
-              expectNoTextNode(diffContext);
-              expectComponent(diffContext, type);
-            }
-          }
-        } else if (Array.isArray(diffContext.$jsxValue$)) {
-          descend(diffContext, diffContext.$jsxValue$, false);
-        } else if (isSignal(diffContext.$jsxValue$)) {
-          expectVirtual(diffContext, "S" /* WrappedSignal */, null);
-          const unwrappedSignal = diffContext.$jsxValue$ instanceof WrappedSignalImpl ? diffContext.$jsxValue$.$unwrapIfSignal$() : diffContext.$jsxValue$;
-          const signals = diffContext.$vCurrent$?.[_EFFECT_BACK_REF]?.get(
-            "." /* VNODE */
-          )?.backRef;
-          let hasUnwrappedSignal = signals?.has(unwrappedSignal);
-          if (signals && unwrappedSignal instanceof WrappedSignalImpl) {
-            hasUnwrappedSignal = containsWrappedSignal(signals, unwrappedSignal);
-          }
-          if (!hasUnwrappedSignal) {
-            const vHost = diffContext.$vNewNode$ || diffContext.$vCurrent$;
-            descend(
-              diffContext,
-              resolveSignalAndDescend(
-                diffContext,
-                () => trackSignalAndAssignHost(
-                  unwrappedSignal,
-                  vHost,
-                  "." /* VNODE */,
-                  diffContext.$container$
-                )
-              ),
-              true
+            }
+          } else if (isPromise(diffContext.$jsxValue$)) {
+            expectVirtual(diffContext, "A" /* Awaited */, null);
+            diffContext.$asyncQueue$.push(
+              diffContext.$jsxValue$,
+              diffContext.$vNewNode$ || diffContext.$vCurrent$
             );
           }
-        } else if (isPromise(diffContext.$jsxValue$)) {
-          expectVirtual(diffContext, "A" /* Awaited */, null);
-          diffContext.$asyncQueue$.push(
-            diffContext.$jsxValue$,
-            diffContext.$vNewNode$ || diffContext.$vCurrent$
-          );
+        } else if (diffContext.$jsxValue$ === SkipRender) {
+        } else {
+          expectText(diffContext, "");
         }
-      } else if (diffContext.$jsxValue$ === SkipRender) {
-      } else {
-        expectText(diffContext, "");
+        advance(diffContext);
       }
-      advance(diffContext);
+      expectNoMore(diffContext);
+      cleanupSideBuffer(diffContext);
+      ascend(diffContext);
     }
-    expectNoMore(diffContext);
-    cleanupSideBuffer(diffContext);
-    ascend(diffContext);
+  } finally {
+    diffContext.$isCreationMode$ = previousCreationMode;
   }
 }
 function resolveSignalAndDescend(diffContext, fn) {
@@ -26719,7 +26826,7 @@ function advance(diffContext) {
   if (diffContext.$vNewNode$ !== null) {
     diffContext.$vNewNode$ = null;
   } else {
-    diffContext.$vCurrent$ = peekNextSibling(diffContext.$vCurrent$);
+    diffContext.$vCurrent$ = peekNextSiblingWithinBoundary(diffContext, diffContext.$vCurrent$);
   }
 }
 function descend(diffContext, children, descendVNode, shouldExpectNoChildren = true) {
@@ -26799,10 +26906,9 @@ function stackPush(diffContext, children, descendVNode) {
 }
 function getInsertBefore(diffContext) {
   if (diffContext.$vNewNode$) {
-    return diffContext.$vCurrent$;
-  } else {
-    return peekNextSibling(diffContext.$vCurrent$);
+    return getCurrentInsertBefore(diffContext);
   }
+  return peekNextSiblingWithinBoundary(diffContext, diffContext.$vCurrent$) || getLevelBoundary(diffContext);
 }
 function descendContentToProject(diffContext, children, host) {
   const projectionChildren = Array.isArray(children) ? children : [children];
@@ -26884,7 +26990,7 @@ function expectSlot(diffContext) {
       diffContext.$journal$,
       diffContext.$vParent$,
       diffContext.$vNewNode$,
-      diffContext.$vCurrent$ && getInsertBefore(diffContext)
+      getInsertBefore(diffContext)
     );
     return false;
   } else if (vProjectedNode === diffContext.$vCurrent$) {
@@ -26902,7 +27008,7 @@ function expectSlot(diffContext) {
       diffContext.$journal$,
       diffContext.$vParent$,
       diffContext.$vNewNode$,
-      diffContext.$vCurrent$ && getInsertBefore(diffContext)
+      getInsertBefore(diffContext)
     );
     if (oldParent && vnode_isElementVNode(oldParent) && !oldParent.firstChild && vnode_getElementName(oldParent) === QTemplate) {
       vnode_remove(
@@ -26989,14 +27095,15 @@ function expectNoChildren(diffContext, removeDOM = true) {
   }
 }
 function expectNoMore(diffContext) {
+  const boundary = getLevelBoundary(diffContext);
   isDev14 && assertFalse(
     diffContext.$vParent$ === diffContext.$vCurrent$,
     "Parent and current can't be the same"
   );
-  if (diffContext.$vCurrent$ !== null) {
-    while (diffContext.$vCurrent$) {
+  if (diffContext.$vCurrent$ !== null && diffContext.$vCurrent$ !== boundary) {
+    while (diffContext.$vCurrent$ && diffContext.$vCurrent$ !== boundary) {
       const toRemove = diffContext.$vCurrent$;
-      diffContext.$vCurrent$ = peekNextSibling(diffContext.$vCurrent$);
+      diffContext.$vCurrent$ = peekNextSiblingWithinBoundary(diffContext, diffContext.$vCurrent$);
       if (diffContext.$vParent$ === toRemove.parent) {
         cleanup(diffContext.$container$, diffContext.$journal$, toRemove, diffContext.$cursor$);
         vnode_remove(diffContext.$journal$, diffContext.$vParent$, toRemove, true);
@@ -27007,87 +27114,97 @@ function expectNoMore(diffContext) {
 function expectNoTextNode(diffContext) {
   if (diffContext.$vCurrent$ !== null && vnode_isTextVNode(diffContext.$vCurrent$)) {
     const toRemove = diffContext.$vCurrent$;
-    diffContext.$vCurrent$ = peekNextSibling(diffContext.$vCurrent$);
+    diffContext.$vCurrent$ = peekNextSiblingWithinBoundary(diffContext, diffContext.$vCurrent$);
     vnode_remove(diffContext.$journal$, diffContext.$vParent$, toRemove, true);
   }
 }
+function applyRef(value, element, currentFile) {
+  if (isSignal(value)) {
+    value.value = element;
+    return true;
+  }
+  if (typeof value === "function") {
+    value(element);
+    return true;
+  }
+  if (value == null) {
+    return true;
+  }
+  throw qError(15 /* invalidRefValue */, [currentFile]);
+}
+function resolveSignalValue(container, vHost, key, signal, subscriptionData) {
+  return retryOnPromise(
+    () => trackSignalAndAssignHost(signal, vHost, key, container, subscriptionData)
+  );
+}
+function queueConstAttributePromise(diffContext, element, key, value, isSvg2) {
+  const scopedStyleIdPrefix = diffContext.$scopedStyleIdPrefix$;
+  const attributePromise = value.then(
+    (resolvedValue) => directSetAttribute(
+      element,
+      key,
+      serializeAttribute(key, resolvedValue, scopedStyleIdPrefix),
+      isSvg2
+    )
+  );
+  diffContext.$asyncAttributePromises$.push(attributePromise);
+}
+function applyConstInnerHtml(element, value) {
+  if (value) {
+    element.innerHTML = String(value);
+    element.setAttribute(QContainerAttr, "html" /* HTML */);
+  }
+}
+function applyConstTextareaValue(element, value, currentFile) {
+  if (value && typeof value !== "string") {
+    if (isDev14) {
+      throw qError(23 /* wrongTextareaValue */, [currentFile, value]);
+    }
+    return true;
+  }
+  element.value = escapeHTML(value || "");
+  return true;
+}
 function createNewElement(diffContext, jsx2, elementName, currentFile) {
   const element = createElementWithNamespace(diffContext, elementName);
+  const vHost = diffContext.$vNewNode$;
+  const isSvg2 = (vHost.flags & 512 /* NS_svg */) !== 0;
   const { constProps } = jsx2;
   if (constProps) {
     for (const key2 in constProps) {
       let value = constProps[key2];
       if (isHtmlAttributeAnEventName(key2)) {
-        registerEventHandlers(
-          key2,
-          value,
-          element,
-          diffContext.$vNewNode$,
-          diffContext
-        );
+        registerEventHandlers(key2, value, element, vHost, diffContext);
         continue;
       }
-      if (key2 === "ref") {
-        if (isSignal(value)) {
-          value.value = element;
-          continue;
-        } else if (typeof value === "function") {
-          value(element);
-          continue;
-        } else if (value == null) {
-          continue;
-        } else {
-          throw qError(15 /* invalidRefValue */, [currentFile]);
-        }
+      if (key2 === "ref" && applyRef(value, element, currentFile)) {
+        continue;
       }
       if (isSignal(value)) {
-        const vHost = diffContext.$vNewNode$;
-        const signal = value;
-        value = retryOnPromise(
-          () => trackSignalAndAssignHost(
-            signal,
-            vHost,
-            key2,
-            diffContext.$container$,
-            diffContext.$subscriptionData$.$const$
-          )
+        value = resolveSignalValue(
+          diffContext.$container$,
+          diffContext.$vNewNode$,
+          key2,
+          value,
+          diffContext.$subscriptionData$.$const$
         );
       }
       if (isPromise(value)) {
-        const vHost = diffContext.$vNewNode$;
-        const attributePromise = value.then(
-          (resolvedValue) => directSetAttribute(
-            element,
-            key2,
-            serializeAttribute(key2, resolvedValue, diffContext.$scopedStyleIdPrefix$),
-            (vHost.flags & 512 /* NS_svg */) !== 0
-          )
-        );
-        diffContext.$asyncAttributePromises$.push(attributePromise);
+        queueConstAttributePromise(diffContext, element, key2, value, isSvg2);
         continue;
       }
       if (key2 === dangerouslySetInnerHTML) {
-        if (value) {
-          element.innerHTML = String(value);
-          element.setAttribute(QContainerAttr, "html" /* HTML */);
-        }
+        applyConstInnerHtml(element, value);
         continue;
       }
-      if (elementName === "textarea" && key2 === "value") {
-        if (value && typeof value !== "string") {
-          if (isDev14) {
-            throw qError(23 /* wrongTextareaValue */, [currentFile, value]);
-          }
-          continue;
-        }
-        element.value = escapeHTML(value || "");
+      if (elementName === "textarea" && key2 === "value" && applyConstTextareaValue(element, value, currentFile)) {
         continue;
       }
       directSetAttribute(
         element,
         key2,
         serializeAttribute(key2, value, diffContext.$scopedStyleIdPrefix$),
-        (diffContext.$vNewNode$.flags & 512 /* NS_svg */) !== 0
+        isSvg2
       );
     }
   }
@@ -27105,7 +27222,7 @@ function createNewElement(diffContext, jsx2, elementName, currentFile) {
     diffContext.$journal$,
     diffContext.$vParent$,
     diffContext.$vNewNode$,
-    diffContext.$vCurrent$
+    getCurrentInsertBefore(diffContext)
   );
 }
 function registerEventHandlers(key, value, element, vnode, diffContext) {
@@ -27127,12 +27244,13 @@ function registerEventHandlers(key, value, element, vnode, diffContext) {
       }
     }
     if (handlers.length > 0) {
-      (element._qDispatch || (element._qDispatch = {}))[scopedKebabName] = handlers;
+      (element._qDispatch || (element._qDispatch = {}))[scopedKebabName] = handlers.length === 1 ? handlers[0] : handlers;
     }
   } else if (value) {
-    (element._qDispatch || (element._qDispatch = {}))[scopedKebabName] = [
-      runEventHandlerQRL.bind(null, value)
-    ];
+    (element._qDispatch || (element._qDispatch = {}))[scopedKebabName] = runEventHandlerQRL.bind(
+      null,
+      value
+    );
   }
   if (key.charAt(2) !== "e") {
     vnode_setAttr(diffContext.$journal$, vnode, key, "");
@@ -27222,14 +27340,8 @@ var patchProperty = (diffContext, vnode, key, value, currentFile) => {
   const originalValue = value;
   if (key === "ref") {
     const element = vnode.node;
-    if (isSignal(value)) {
-      value.value = element;
+    if (applyRef(value, element, currentFile)) {
       return;
-    } else if (typeof value === "function") {
-      value(element);
-      return;
-    } else {
-      throw qError(15 /* invalidRefValue */, [currentFile]);
     }
   }
   const currentEffect = vnode[_EFFECT_BACK_REF]?.get(key);
@@ -27242,14 +27354,12 @@ var patchProperty = (diffContext, vnode, key, value, currentFile) => {
       clearEffectSubscription(diffContext.$container$, currentEffect);
     }
     const vHost = vnode;
-    value = retryOnPromise(
-      () => trackSignalAndAssignHost(
-        unwrappedSignal,
-        vHost,
-        key,
-        diffContext.$container$,
-        diffContext.$subscriptionData$.$var$
-      )
+    value = resolveSignalValue(
+      diffContext.$container$,
+      vHost,
+      key,
+      unwrappedSignal,
+      diffContext.$subscriptionData$.$var$
     );
   } else {
     if (currentEffect) {
@@ -27299,8 +27409,9 @@ function retrieveChildWithKey(diffContext, nodeName, key) {
     }
     diffContext.$vSiblings$ = /* @__PURE__ */ new Map();
     diffContext.$vSiblingsArray$ = [];
+    const boundary = getLevelBoundary(diffContext);
     let vNode = diffContext.$vCurrent$;
-    while (vNode) {
+    while (vNode && vNode !== boundary) {
       const name = vnode_isElementVNode(vNode) ? vnode_getElementName(vNode) : null;
       const vKey = getKey(vNode) || getComponentHash(vNode, diffContext.$container$.$getObjectById$);
       if (vNodeWithKey === null && vKey == key && name == nodeName) {
@@ -27349,8 +27460,9 @@ function collectSideBufferSiblings(diffContext, targetNode) {
     }
     return;
   }
+  const boundary = getLevelBoundary(diffContext);
   let vNode = diffContext.$vCurrent$;
-  while (vNode && vNode !== targetNode) {
+  while (vNode && vNode !== targetNode && vNode !== boundary) {
     const name = vnode_isElementVNode(vNode) ? vnode_getElementName(vNode) : null;
     const vKey = getKey(vNode) || getComponentHash(vNode, diffContext.$container$.$getObjectById$);
     if (vKey != null) {
@@ -27384,7 +27496,7 @@ function moveOrCreateKeyedNode(diffContext, nodeName, lookupKey, sideBufferKey,
         diffContext.$journal$,
         parentForInsert,
         diffContext.$vNewNode$,
-        diffContext.$vCurrent$
+        getCurrentInsertBefore(diffContext)
       );
     }
     diffContext.$vCurrent$ = diffContext.$vNewNode$;
@@ -27411,7 +27523,7 @@ function moveOrCreateKeyedNode(diffContext, nodeName, lookupKey, sideBufferKey,
           diffContext.$journal$,
           parentForInsert,
           buffered,
-          diffContext.$vCurrent$
+          getCurrentInsertBefore(diffContext)
         );
       }
       diffContext.$vCurrent$ = buffered;
@@ -27437,7 +27549,7 @@ function expectVirtual(diffContext, type, jsxKey) {
       diffContext.$journal$,
       diffContext.$vParent$,
       diffContext.$vNewNode$ = vnode_newVirtual(),
-      diffContext.$vCurrent$ && getInsertBefore(diffContext)
+      getInsertBefore(diffContext)
     );
     diffContext.$vNewNode$.key = jsxKey;
     isDev14 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, type);
@@ -27455,7 +27567,7 @@ function expectVirtual(diffContext, type, jsxKey) {
       diffContext.$journal$,
       diffContext.$vParent$,
       diffContext.$vNewNode$ = vnode_newVirtual(),
-      diffContext.$vCurrent$ && getInsertBefore(diffContext)
+      getInsertBefore(diffContext)
     );
     diffContext.$vNewNode$.key = jsxKey;
     isDev14 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, type);
@@ -27568,7 +27680,7 @@ function insertNewComponent(diffContext, host, componentQRL, jsxProps) {
     diffContext.$journal$,
     diffContext.$vParent$,
     diffContext.$vNewNode$ = vnode_newVirtual(),
-    diffContext.$vCurrent$ && getInsertBefore(diffContext)
+    getInsertBefore(diffContext)
   );
   const jsxNode = diffContext.$jsxValue$;
   isDev14 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "C" /* Component */);
@@ -27581,7 +27693,7 @@ function insertNewInlineComponent(diffContext) {
     diffContext.$journal$,
     diffContext.$vParent$,
     diffContext.$vNewNode$ = vnode_newVirtual(),
-    diffContext.$vCurrent$ && getInsertBefore(diffContext)
+    getInsertBefore(diffContext)
   );
   const jsxNode = diffContext.$jsxValue$;
   isDev14 && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "I" /* InlineComponent */);
@@ -27608,7 +27720,7 @@ function expectText(diffContext, text) {
       (import.meta.env.TEST ? diffContext.$container$.document : document).createTextNode(text),
       text
     ),
-    diffContext.$vCurrent$
+    getCurrentInsertBefore(diffContext)
   );
 }
 function getKey(vNode) {
@@ -27844,6 +27956,260 @@ function containsWrappedSignal(data, signal) {
   return false;
 }
 
+// packages/qwik/src/core/client/reconcile-keyed-loop.ts
+import { isDev as isDev15 } from "@qwik.dev/core/build";
+function collectChildren(first, last = null) {
+  const children = [];
+  let child = first;
+  while (child) {
+    children.push(child);
+    if (child === last) {
+      break;
+    }
+    child = child.nextSibling;
+  }
+  return children;
+}
+function renderKeyedRow(item, index, key, renderItem) {
+  const jsx2 = renderItem(item, index);
+  if (isDev15 && !isJSXNode(jsx2)) {
+    throw new Error("Each item$ must return a single JSX node");
+  }
+  jsx2.key = key;
+  return jsx2;
+}
+function buildJsxRange(items, nextKeys, keyOf, renderItem, start, end) {
+  const jsxItems = new Array(end - start + 1);
+  for (let i = start; i <= end; i++) {
+    const key = nextKeys[i] ?? (nextKeys[i] = keyOf(items[i], i));
+    jsxItems[i - start] = renderKeyedRow(items[i], i, key, renderItem);
+  }
+  return jsxItems;
+}
+function firstInsertedBeforeAnchor(parent, anchor, count) {
+  let inserted = anchor ? anchor.previousSibling : parent.lastChild;
+  for (let i = 1; i < count && inserted; i++) {
+    inserted = inserted.previousSibling;
+  }
+  return inserted;
+}
+function longestIncreasingSubsequencePositions(arr) {
+  const n = arr.length;
+  if (n === 0) {
+    return [];
+  }
+  const tails = [];
+  const prev = new Array(n).fill(-1);
+  for (let i = 0; i < n; i++) {
+    const x = arr[i];
+    let low = 0;
+    let high = tails.length;
+    while (low < high) {
+      const mid = low + high >> 1;
+      if (arr[tails[mid]] < x) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    }
+    if (low > 0) {
+      prev[i] = tails[low - 1];
+    }
+    if (low === tails.length) {
+      tails.push(i);
+    } else {
+      tails[low] = i;
+    }
+  }
+  const lis = [];
+  let current = tails[tails.length - 1];
+  while (current !== -1) {
+    lis.push(current);
+    current = prev[current];
+  }
+  lis.reverse();
+  return lis;
+}
+function reconcileKeyedLoopToParent(container, journal, parent, cursor, items, keyOf, renderItem) {
+  const clientContainer = container;
+  const nextLength = items.length;
+  const firstLoopChild = vnode_getFirstChild(parent);
+  const diffContext = createDiffContext(clientContainer, journal, cursor, null);
+  const nextKeys = new Array(nextLength);
+  if (firstLoopChild === null) {
+    if (nextLength > 0) {
+      return vnode_diff_range(
+        clientContainer,
+        journal,
+        buildJsxRange(items, nextKeys, keyOf, renderItem, 0, nextLength - 1),
+        parent,
+        null,
+        null,
+        cursor,
+        null,
+        true,
+        diffContext
+      );
+    }
+    return;
+  }
+  if (nextLength === 0) {
+    vnode_truncate(journal, parent, firstLoopChild, true);
+    return;
+  }
+  let start = 0;
+  let nextEnd = nextLength - 1;
+  let oldStart = firstLoopChild;
+  while (oldStart && start <= nextEnd && oldStart.key === (nextKeys[start] ?? (nextKeys[start] = keyOf(items[start], start)))) {
+    oldStart = oldStart.nextSibling;
+    start++;
+  }
+  if (oldStart === null) {
+    if (start > nextEnd) {
+      return;
+    }
+    return vnode_diff_range(
+      clientContainer,
+      journal,
+      buildJsxRange(items, nextKeys, keyOf, renderItem, start, nextEnd),
+      parent,
+      null,
+      null,
+      cursor,
+      null,
+      true,
+      diffContext
+    );
+  }
+  if (start > nextEnd) {
+    vnode_truncate(journal, parent, oldStart, true);
+    return;
+  }
+  const oldStartBoundary = oldStart.previousSibling;
+  let oldEnd = parent.lastChild;
+  while (oldEnd !== oldStartBoundary && nextEnd >= start && oldEnd.key === (nextKeys[nextEnd] ?? (nextKeys[nextEnd] = keyOf(items[nextEnd], nextEnd)))) {
+    oldEnd = oldEnd.previousSibling;
+    nextEnd--;
+  }
+  const suffixAnchor = oldEnd ? oldEnd.nextSibling : oldStart;
+  if (start > nextEnd) {
+    let child = oldStart;
+    while (child && child !== suffixAnchor) {
+      const nextChild = child.nextSibling;
+      vnode_remove(journal, parent, child, true);
+      child = nextChild;
+    }
+    return;
+  }
+  if (oldEnd === oldStartBoundary) {
+    const anchor2 = suffixAnchor;
+    return vnode_diff_range(
+      clientContainer,
+      journal,
+      buildJsxRange(items, nextKeys, keyOf, renderItem, start, nextEnd),
+      parent,
+      anchor2,
+      anchor2,
+      cursor,
+      null,
+      true,
+      diffContext
+    );
+  }
+  for (let i = start; i <= nextEnd; i++) {
+    nextKeys[i] ?? (nextKeys[i] = keyOf(items[i], i));
+  }
+  const middleLength = nextEnd - start + 1;
+  const nextIndexByKey = /* @__PURE__ */ new Map();
+  for (let i = start; i <= nextEnd; i++) {
+    nextIndexByKey.set(nextKeys[i], i - start);
+  }
+  const prev = collectChildren(oldStart, oldEnd);
+  const survivors = [];
+  const prevRelIndexByKey = /* @__PURE__ */ new Map();
+  for (let i = 0; i < prev.length; i++) {
+    const prevNode = prev[i];
+    const prevKey = prevNode.key;
+    if (nextIndexByKey.has(prevKey)) {
+      prevRelIndexByKey.set(prevKey, survivors.length);
+      survivors.push(prevNode);
+    } else {
+      vnode_remove(journal, parent, prevNode, true);
+    }
+  }
+  const nextRefs = new Int32Array(middleLength);
+  nextRefs.fill(-1);
+  const seq = [];
+  const seqOffsets = [];
+  for (let offset = 0; offset < middleLength; offset++) {
+    const relIndex = prevRelIndexByKey.get(nextKeys[start + offset]);
+    if (relIndex !== void 0) {
+      nextRefs[offset] = relIndex;
+      seqOffsets.push(offset);
+      seq.push(relIndex);
+    }
+  }
+  const keepMask = new Uint8Array(middleLength);
+  const lisPositions = longestIncreasingSubsequencePositions(seq);
+  for (let i = 0; i < lisPositions.length; i++) {
+    keepMask[seqOffsets[lisPositions[i]]] = 1;
+  }
+  let index = nextEnd;
+  let anchor = suffixAnchor;
+  const resume = () => {
+    while (index >= start) {
+      const offset = index - start;
+      if (keepMask[offset] === 1) {
+        anchor = survivors[nextRefs[offset]];
+        index--;
+        continue;
+      }
+      const existingRelIndex = nextRefs[offset];
+      if (existingRelIndex !== -1) {
+        const node = survivors[existingRelIndex];
+        const alreadyPlaced = anchor === null ? parent.lastChild === node : node.nextSibling === anchor;
+        if (!alreadyPlaced) {
+          vnode_insertBefore(journal, parent, node, anchor);
+        }
+        anchor = node;
+        index--;
+        continue;
+      }
+      let blockStart = index;
+      while (blockStart > start) {
+        const prevOffset = blockStart - 1 - start;
+        if (keepMask[prevOffset] === 1 || nextRefs[prevOffset] !== -1) {
+          break;
+        }
+        blockStart--;
+      }
+      const blockLength = index - blockStart + 1;
+      const result2 = vnode_diff_range(
+        clientContainer,
+        journal,
+        buildJsxRange(items, nextKeys, null, renderItem, blockStart, index),
+        parent,
+        anchor,
+        anchor,
+        cursor,
+        null,
+        true,
+        diffContext
+      );
+      return maybeThen(result2, () => {
+        const firstInserted = firstInsertedBeforeAnchor(parent, anchor, blockLength);
+        if (isDev15 && !firstInserted) {
+          throw new Error("Failed to insert keyed loop block");
+        }
+        anchor = firstInserted;
+        index = blockStart - 1;
+        return resume();
+      });
+    }
+  };
+  return resume();
+}
+
 // packages/qwik/src/core/shared/cursor/chore-execution.ts
 function executeTasks(vNode, container, cursorData) {
   vNode.dirty &= ~1 /* TASKS */;
@@ -27890,6 +28256,7 @@ function executeNodeDiff(vNode, container, journal, cursor) {
   if (!jsx2) {
     return;
   }
+  setNodeDiffPayload(vNode, null);
   if (isSignal(jsx2)) {
     jsx2 = jsx2.value;
   }
@@ -28022,6 +28389,40 @@ function executeCompute(vNode, container) {
     }
   );
 }
+function executeReconcile(vNode, container, journal, cursor) {
+  vNode.dirty &= ~128 /* RECONCILE */;
+  const host = vNode;
+  const props = container.getHostProp(host, ELEMENT_PROPS) || null;
+  if (!props) {
+    return;
+  }
+  let items = _getProps(props, "items");
+  if (isSignal(items)) {
+    items = untrack(items);
+  }
+  const keyQrl = _getProps(props, "key$");
+  const itemQrl = _getProps(props, "item$");
+  const keyOf = keyQrl.resolved;
+  const itemFn = itemQrl.resolved;
+  if (keyOf !== void 0 && itemFn !== void 0) {
+    return reconcileKeyedLoopToParent(container, journal, host, cursor, items, keyOf, itemFn);
+  }
+  return maybeThen(
+    keyQrl.resolve(),
+    (resolvedKeyOf) => maybeThen(
+      itemQrl.resolve(),
+      (resolvedItemFn) => reconcileKeyedLoopToParent(
+        container,
+        journal,
+        host,
+        cursor,
+        items,
+        resolvedKeyOf,
+        resolvedItemFn
+      )
+    )
+  );
+}
 
 // packages/qwik/src/core/shared/cursor/cursor-flush.ts
 var DEBUG5 = false;
@@ -28196,7 +28597,7 @@ var createMacroTask = (fn) => {
 };
 
 // packages/qwik/src/core/shared/cursor/cursor-walker.ts
-import { isBrowser as isBrowser2, isDev as isDev15, isServer as isServer7 } from "@qwik.dev/core/build";
+import { isBrowser as isBrowser2, isDev as isDev16, isServer as isServer7 } from "@qwik.dev/core/build";
 var DEBUG6 = false;
 var nextMicroTask = createMicroTask(processCursorQueue);
 var nextMacroTask = createMacroTask(processCursorQueue);
@@ -28233,7 +28634,7 @@ function walkCursor(cursor, options) {
     return;
   }
   const container = cursorData.container;
-  isDev15 && assertDefined(container, "Cursor container not found");
+  isDev16 && assertDefined(container, "Cursor container not found");
   if (!cursor.dirty) {
     finishWalk(container, cursor, cursorData, isRunningOnServer);
     return;
@@ -28249,7 +28650,7 @@ function walkCursor(cursor, options) {
     if (cursorData.promise) {
       return;
     }
-    if (!(currentVNode.dirty & 127 /* DIRTY_MASK */)) {
+    if (!(currentVNode.dirty & 255 /* DIRTY_MASK */)) {
       setCursorPosition(container, cursorData, getNextVNode(currentVNode, cursor));
       continue;
     }
@@ -28263,7 +28664,7 @@ function walkCursor(cursor, options) {
           continue;
         }
       }
-      currentVNode.dirty &= ~127 /* DIRTY_MASK */;
+      currentVNode.dirty &= ~255 /* DIRTY_MASK */;
       setCursorPosition(container, cursorData, getNextVNode(currentVNode, cursor));
       continue;
     }
@@ -28275,6 +28676,8 @@ function walkCursor(cursor, options) {
         result2 = executeNodeDiff(currentVNode, container, journal, cursor);
       } else if (currentVNode.dirty & 4 /* COMPONENT */) {
         result2 = executeComponentChore(currentVNode, container, journal, cursor);
+      } else if (currentVNode.dirty & 128 /* RECONCILE */) {
+        result2 = executeReconcile(currentVNode, container, journal, cursor);
       } else if (currentVNode.dirty & 8 /* NODE_PROPS */) {
         executeNodeProps(currentVNode, journal);
       } else if (currentVNode.dirty & 16 /* COMPUTE */) {
@@ -28311,14 +28714,14 @@ function walkCursor(cursor, options) {
       }
     }
   }
-  isDev15 && assertFalse(
-    !!(cursor.dirty & 127 /* DIRTY_MASK */ && !cursorData.position),
+  isDev16 && assertFalse(
+    !!(cursor.dirty & 255 /* DIRTY_MASK */ && !cursorData.position),
     "Cursor is still dirty and position is not set after walking"
   );
   finishWalk(container, cursor, cursorData, isRunningOnServer);
 }
 function finishWalk(container, cursor, cursorData, isServer13) {
-  if (!(cursor.dirty & 127 /* DIRTY_MASK */)) {
+  if (!(cursor.dirty & 255 /* DIRTY_MASK */)) {
     removeCursorFromQueue(cursor, container);
     DEBUG6 && console.warn("walkCursor: cursor done", cursor.toString());
     if (!isServer13) {
@@ -28365,7 +28768,7 @@ function partitionDirtyChildren(dirtyChildren, parent) {
 }
 function getNextVNode(vNode, cursor) {
   if (vNode === cursor) {
-    if (cursor.dirty & 127 /* DIRTY_MASK */) {
+    if (cursor.dirty & 255 /* DIRTY_MASK */) {
       return cursor;
     }
     return null;
@@ -28377,7 +28780,7 @@ function getNextVNode(vNode, cursor) {
     parent = vNode.parent;
   }
   if (!parent) {
-    if (cursor.dirty & 127 /* DIRTY_MASK */) {
+    if (cursor.dirty & 255 /* DIRTY_MASK */) {
       return cursor;
     }
     return null;
@@ -28388,7 +28791,7 @@ function getNextVNode(vNode, cursor) {
   let count = len;
   while (count-- > 0) {
     const nextVNode = dirtyChildren[index];
-    if (nextVNode.dirty & 127 /* DIRTY_MASK */) {
+    if (nextVNode.dirty & 255 /* DIRTY_MASK */) {
       parent.nextDirtyChildIndex = (index + 1) % len;
       return nextVNode;
     }
@@ -28451,7 +28854,7 @@ function propagateToCursorRoot(vNode, cursorRoot) {
   reusablePath.push(vNode);
   let current = vNode.slotParent || vNode.parent;
   while (current) {
-    const isDirty = current.dirty & 127 /* DIRTY_MASK */;
+    const isDirty = current.dirty & 255 /* DIRTY_MASK */;
     const currentIsCursor = isCursor(current);
     if (current === cursorRoot || isDirty) {
       propagatePath(current);
@@ -28505,8 +28908,8 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     }
     return;
   }
-  const isRealDirty = bits & 127 /* DIRTY_MASK */;
-  if ((isRealDirty ? prevDirty & 127 /* DIRTY_MASK */ : prevDirty) || vNode === cursorRoot) {
+  const isRealDirty = bits & 255 /* DIRTY_MASK */;
+  if ((isRealDirty ? prevDirty & 255 /* DIRTY_MASK */ : prevDirty) || vNode === cursorRoot) {
     return;
   }
   const parent = vNode.slotParent || vNode.parent;
@@ -28514,7 +28917,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     propagateToCursorRoot(vNode, cursorRoot);
     return;
   }
-  if (parent && parent.dirty & 127 /* DIRTY_MASK */) {
+  if (parent && parent.dirty & 255 /* DIRTY_MASK */) {
     if (isRealDirty) {
       parent.dirty |= 32 /* CHILDREN */;
     }
@@ -28549,7 +28952,7 @@ function addVNodeOperation(journal, operation) {
 }
 
 // packages/qwik/src/core/reactive-primitives/impl/wrapped-signal-impl.ts
-import { isDev as isDev16 } from "@qwik.dev/core/build";
+import { isDev as isDev17 } from "@qwik.dev/core/build";
 var _a4, _b3;
 var WrappedSignalImpl = class extends (_b3 = SignalImpl, _a4 = _EFFECT_BACK_REF, _b3) {
   constructor(container, fn, args, fnStr, flags = 1 /* INVALID */ | 4 /* UNWRAP */) {
@@ -28584,7 +28987,7 @@ var WrappedSignalImpl = class extends (_b3 = SignalImpl, _a4 = _EFFECT_BACK_REF,
   }
   get untrackedValue() {
     this.$computeIfNeeded$();
-    isDev16 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
+    isDev17 && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state");
     return this.$untrackedValue$;
   }
   $computeIfNeeded$() {
@@ -28693,25 +29096,47 @@ function clearStoreOrProps(producer, effect) {
 
 // packages/qwik/src/core/use/use-task.ts
 var runTask = (task, container, host) => {
+  const pendingTask = task.$taskPromise$;
+  if (pendingTask) {
+    return pendingTask;
+  }
   task.$flags$ &= ~4 /* DIRTY */;
-  cleanupDestroyable(task);
-  const iCtx = newInvokeContext(container.$locale$, host, TaskEvent);
-  iCtx.$container$ = container;
-  const taskFn = task.$qrl$.getFn(iCtx, () => clearAllEffects(container, task));
-  const track = trackFn(task, container);
-  const [cleanup2] = cleanupFn(task, (reason) => container.handleError(reason, host));
-  const taskApi = { track, cleanup: cleanup2 };
-  return safeCall(
-    () => taskFn(taskApi),
-    cleanup2,
-    (err) => {
-      if (isPromise(err)) {
-        return err.then(() => runTask(task, container, host));
-      } else {
-        container.handleError(err, host);
+  const handleError = (reason) => container.handleError(reason, host);
+  let taskPromise = null;
+  const result2 = maybeThen(cleanupAsyncDestroyable(task, handleError), () => {
+    const iCtx = newInvokeContext(container.$locale$, host, TaskEvent);
+    iCtx.$container$ = container;
+    const taskFn = task.$qrl$.getFn(iCtx, () => clearAllEffects(container, task));
+    const track = trackFn(task, container);
+    const [cleanup2] = cleanupFn(task, handleError);
+    const taskApi = { track, cleanup: cleanup2 };
+    return safeCall(
+      () => taskFn(taskApi),
+      cleanup2,
+      (err) => {
+        if (isPromise(err)) {
+          return err.then(() => {
+            if (task.$taskPromise$ === taskPromise) {
+              task.$taskPromise$ = null;
+            }
+            return runTask(task, container, host);
+          });
+        } else {
+          handleError(err);
+        }
       }
-    }
-  );
+    );
+  });
+  if (isPromise(result2)) {
+    taskPromise = result2.finally(() => {
+      if (task.$taskPromise$ === taskPromise) {
+        task.$taskPromise$ = null;
+      }
+    });
+    task.$taskPromise$ = taskPromise;
+    return taskPromise;
+  }
+  return result2;
 };
 var Task = class extends BackRef {
   constructor($flags$, $index$, $el$, $qrl$, $state$, $destroy$) {
@@ -28722,6 +29147,8 @@ var Task = class extends BackRef {
     this.$qrl$ = $qrl$;
     this.$state$ = $state$;
     this.$destroy$ = $destroy$;
+    __publicField(this, "$destroyPromise$");
+    __publicField(this, "$taskPromise$", null);
   }
 };
 var isTask = (value) => {
@@ -28737,7 +29164,7 @@ function _executeSsrChores(container, ssrNode) {
     if (ssrNode.dirty & 16 /* COMPUTE */) {
       executeCompute(ssrNode, container);
     }
-    if (ssrNode.dirty & 127 /* DIRTY_MASK */) {
+    if (ssrNode.dirty & 255 /* DIRTY_MASK */) {
       const warningMessage = `A chore was scheduled on a host element that has already been streamed to the client.
         This can lead to inconsistencies between Server-Side Rendering (SSR) and Client-Side Rendering (CSR).
         
@@ -28748,7 +29175,7 @@ function _executeSsrChores(container, ssrNode) {
         This is often caused by modifying a signal in an already rendered component during SSR.`;
       logWarn(warningMessage);
     }
-    ssrNode.dirty &= ~127 /* DIRTY_MASK */;
+    ssrNode.dirty &= ~255 /* DIRTY_MASK */;
     return;
   }
   let promise = null;
@@ -28758,7 +29185,11 @@ function _executeSsrChores(container, ssrNode) {
       promise = result2;
     }
   }
-  ssrNode.dirty &= ~(127 /* DIRTY_MASK */ & ~4 /* COMPONENT */);
+  if (ssrNode.dirty & 128 /* RECONCILE */) {
+    const result2 = executeReconcileChore(container, ssrNode);
+    promise = promise ? promise.then(() => result2) : result2;
+  }
+  ssrNode.dirty &= ~(255 /* DIRTY_MASK */ & ~4 /* COMPONENT */);
   if (promise) {
     return promise;
   }
@@ -28797,6 +29228,32 @@ function executeNodePropChore(container, ssrNode) {
     container.addBackpatchEntry(ssrNode.id, property, serializedValue);
   }
 }
+async function executeReconcileChore(container, ssrNode) {
+  ssrNode.dirty &= ~128 /* RECONCILE */;
+  const host = ssrNode;
+  const props = container.getHostProp(host, ELEMENT_PROPS) || null;
+  if (!props) {
+    return;
+  }
+  let items = _getProps(props, "items");
+  if (isSignal(items)) {
+    items = untrack(items);
+  }
+  const keyOf = await _getProps(props, "key$").resolve();
+  const itemFn = await _getProps(props, "item$").resolve();
+  const children = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const jsx2 = itemFn(item, i);
+    const key = keyOf(item, i);
+    jsx2.key = key;
+    children.push(jsx2);
+  }
+  await container.renderJSX(children, {
+    currentStyleScoped: null,
+    parentComponentFrame: container.getComponentFrame(0)
+  });
+}
 
 // packages/qwik/src/core/shared/jsx/bind-handlers.ts
 var maybeScopeFromQL = (captureIds, element) => {
@@ -28821,7 +29278,7 @@ function _chk(_, element) {
 var version = globalThis.QWIK_VERSION;
 
 // packages/qwik/src/core/shared/serdes/serialize.ts
-import { isDev as isDev17 } from "@qwik.dev/core/build";
+import { isDev as isDev18 } from "@qwik.dev/core/build";
 
 // packages/qwik/src/core/shared/ssr-const.ts
 var LT = "<";
@@ -29205,7 +29662,7 @@ var Serializer = class {
     } else if (value instanceof Error) {
       const out = [value.message];
       out.push(...Object.entries(value).flat());
-      if (isDev17) {
+      if (isDev18) {
         out.push("stack", value.stack);
       }
       this.output(15 /* Error */, out);
@@ -30056,7 +30513,7 @@ function restoreEffectBackRefForEffectsMap(effectsMap, consumer) {
 }
 
 // packages/qwik/src/core/shared/vnode/vnode.ts
-import { isDev as isDev18 } from "@qwik.dev/core/build";
+import { isDev as isDev19 } from "@qwik.dev/core/build";
 var _a5;
 _a5 = _EFFECT_BACK_REF;
 var VNode = class {
@@ -30074,7 +30531,7 @@ var VNode = class {
   }
   // TODO: this creates debug issues
   toString() {
-    if (isDev18) {
+    if (isDev19) {
       return vnode_toString.call(this);
     }
     return Object.prototype.toString.call(this);
@@ -30145,10 +30602,10 @@ var LazyRef = class {
       return this.$ref$;
     }
     if (this.$chunk$ === "") {
-      isDev19 && assertDefined(this.$container$, "Sync QRL must have container element");
-      const hash3 = this.$container$.$instanceHash$;
+      isDev20 && assertDefined(this.$container$, "Sync QRL must have container element");
+      const hash2 = this.$container$.$instanceHash$;
       const doc2 = this.$container$.element?.ownerDocument || document;
-      const qFuncs2 = getQFuncs(doc2, hash3);
+      const qFuncs2 = getQFuncs(doc2, hash2);
       return this.$ref$ = qFuncs2[Number(this.$symbol$)];
     }
     if (isBrowser3 && this.$chunk$) {
@@ -30164,12 +30621,12 @@ var LazyRef = class {
     return this.$ref$;
   }
 };
+var QRL_STATE = /* @__PURE__ */ Symbol("qrl-state");
 var getInstance = (instance) => {
-  return Object.prototype.hasOwnProperty.call(instance, "resolved") ? instance : Object.getPrototypeOf(instance);
+  return instance?.[QRL_STATE] ?? instance;
 };
-var QRLClass = class _QRLClass extends Function {
+var QRLClass = class {
   constructor($lazy$, $captures$, container) {
-    super();
     this.$lazy$ = $lazy$;
     __publicField(this, "resolved");
     // This is defined or undefined for the lifetime of the QRL, so we set it lazily
@@ -30192,75 +30649,137 @@ var QRLClass = class _QRLClass extends Function {
       this.resolved = bindCaptures(this, $lazy$.$ref$);
     }
   }
-  w(captures) {
-    const newQrl = new _QRLClass(
-      this.$lazy$,
-      captures,
-      this.$captures$ ? this.$container$ : void 0
-    );
-    return makeQrlFn(newQrl);
-  }
-  s(ref) {
-    const qrl = getInstance(this);
-    qrl.$lazy$.$setRef$(ref);
-    qrl.resolved = bindCaptures(qrl, ref);
-  }
-  // --- Getter proxies for backward compat ---
-  get $chunk$() {
-    return this.$lazy$.$chunk$;
-  }
-  get $symbol$() {
-    return this.$lazy$.$symbol$;
-  }
-  get $hash$() {
-    return this.$lazy$.$hash$;
-  }
-  get dev() {
-    return this.$lazy$.dev;
+};
+var qrlCallFn = function(withThis, ...args) {
+  const qrl = getInstance(this);
+  if (qrl.resolved) {
+    return qrl.resolved.apply(withThis, args);
   }
-  $callFn$(withThis, ...args) {
-    if (this.resolved) {
-      return this.resolved.apply(withThis, args);
+  const ctx = tryGetInvokeContext();
+  return qrlResolve.call(qrl, ctx?.$container$).then(() => invokeApply.call(withThis, ctx, qrl.resolved, args));
+};
+var qrlWithCaptures = function(captures) {
+  const qrl = getInstance(this);
+  const newQrl = new QRLClass(
+    qrl.$lazy$,
+    captures,
+    qrl.$captures$ ? qrl.$container$ : void 0
+  );
+  return makeQrlFn(newQrl);
+};
+var qrlSetRef = function(ref) {
+  const qrl = getInstance(this);
+  qrl.$lazy$.$setRef$(ref);
+  qrl.resolved = bindCaptures(qrl, ref);
+};
+var qrlResolve = async function(container) {
+  const qrl = getInstance(this);
+  return maybeThen($resolve$(qrl, container), () => qrl.resolved);
+};
+var qrlGetSymbol = function() {
+  return getInstance(this).$lazy$.$symbol$;
+};
+var qrlGetHash = function() {
+  return getInstance(this).$lazy$.$hash$;
+};
+var qrlGetCaptured = function() {
+  const qrl = getInstance(this);
+  ensureQrlCaptures(qrl);
+  return qrl.$captures$;
+};
+var qrlGetFn = function(currentCtx, beforeFn) {
+  const qrl = getInstance(this);
+  const bound = (...args) => {
+    if (!qrl.resolved) {
+      return qrlResolve.call(qrl).then((fn) => {
+        if (qDev && !isFunction(fn)) {
+          throw qError(5 /* qrlIsNotFunction */);
+        }
+        return bound(...args);
+      });
     }
-    const ctx = tryGetInvokeContext();
-    return this.resolve(ctx?.$container$).then(
-      () => invokeApply.call(withThis, ctx, this.resolved, args)
-    );
-  }
-  async resolve(container) {
-    const qrl = getInstance(this);
-    return maybeThen($resolve$(qrl, container), () => qrl.resolved);
-  }
-  getSymbol() {
-    return this.$symbol$;
-  }
-  getHash() {
-    return this.$hash$;
-  }
-  getCaptured() {
-    const qrl = getInstance(this);
-    ensureQrlCaptures(qrl);
-    return qrl.$captures$;
-  }
-  getFn(currentCtx, beforeFn) {
-    const qrl = getInstance(this);
-    const bound = (...args) => {
-      if (!qrl.resolved) {
-        return qrl.resolve().then((fn) => {
-          if (qDev && !isFunction(fn)) {
-            throw qError(5 /* qrlIsNotFunction */);
-          }
-          return bound(...args);
-        });
-      }
-      if (beforeFn && beforeFn() === false) {
-        return void 0;
-      }
-      return invokeApply(currentCtx, qrl.resolved, args);
-    };
-    return bound;
-  }
+    if (beforeFn && beforeFn() === false) {
+      return void 0;
+    }
+    return invokeApply(currentCtx, qrl.resolved, args);
+  };
+  return bound;
 };
+var QRL_FUNCTION_PROTO = Object.create(Function.prototype, {
+  resolved: {
+    get() {
+      return this[QRL_STATE].resolved;
+    },
+    set(value) {
+      this[QRL_STATE].resolved = value;
+    }
+  },
+  $captures$: {
+    get() {
+      return this[QRL_STATE].$captures$;
+    },
+    set(value) {
+      this[QRL_STATE].$captures$ = value;
+    }
+  },
+  $container$: {
+    get() {
+      return this[QRL_STATE].$container$;
+    },
+    set(value) {
+      this[QRL_STATE].$container$ = value;
+    }
+  },
+  $lazy$: {
+    get() {
+      return this[QRL_STATE].$lazy$;
+    }
+  },
+  $chunk$: {
+    get() {
+      return this[QRL_STATE].$lazy$.$chunk$;
+    }
+  },
+  $symbol$: {
+    get() {
+      return this[QRL_STATE].$lazy$.$symbol$;
+    }
+  },
+  $hash$: {
+    get() {
+      return this[QRL_STATE].$lazy$.$hash$;
+    }
+  },
+  dev: {
+    get() {
+      return this[QRL_STATE].$lazy$.dev;
+    }
+  },
+  $callFn$: {
+    value: qrlCallFn
+  },
+  w: {
+    value: qrlWithCaptures
+  },
+  s: {
+    value: qrlSetRef
+  },
+  resolve: {
+    value: qrlResolve
+  },
+  getSymbol: {
+    value: qrlGetSymbol
+  },
+  getHash: {
+    value: qrlGetHash
+  },
+  getCaptured: {
+    value: qrlGetCaptured
+  },
+  getFn: {
+    value: qrlGetFn
+  }
+});
 var _captures = null;
 var setCaptures = (captures) => {
   _captures = captures;
@@ -30335,9 +30854,10 @@ var createQRL = (chunk, symbol, symbolRef, symbolFn, captures, container) => {
 };
 var makeQrlFn = (qrl) => {
   const qrlFn = async function(...args) {
-    return qrl.$callFn$(this, ...args);
+    return qrlCallFn.call(qrlFn, this, ...args);
   };
-  Object.setPrototypeOf(qrlFn, qrl);
+  qrlFn[QRL_STATE] = qrl;
+  Object.setPrototypeOf(qrlFn, QRL_FUNCTION_PROTO);
   return qrlFn;
 };
 var EMITTED = /* @__PURE__ */ new Set();
@@ -31005,6 +31525,7 @@ var DomContainer = class extends _SharedContainer {
     this.$setServerData$();
     element.setAttribute(QContainerAttr, "resumed" /* RESUMED */);
     element.qContainer = this;
+    element.qDestroy = () => this.$destroy$();
     const qwikStates = element.querySelectorAll('script[type="qwik/state"]');
     if (qwikStates.length !== 0) {
       const lastState = qwikStates[qwikStates.length - 1];
@@ -31017,6 +31538,19 @@ var DomContainer = class extends _SharedContainer {
       element.dispatchEvent(new CustomEvent("qresume", { bubbles: true }));
     }
   }
+  /** Tear down this container so stale references fail gracefully. */
+  $destroy$() {
+    this.vNodeLocate = () => null;
+    this.$rawStateData$.length = 0;
+    this.$stateData$.length = 0;
+    this.$getObjectById$ = () => void 0;
+    const el = this.element;
+    el.qContainer = void 0;
+    el.qVnodeData = void 0;
+    el.qVNodeRefs = void 0;
+    el.removeAttribute(QContainerAttr);
+    el.ownerDocument.qVNodeData = void 0;
+  }
   /**
    * The first time we render we need to hoist the styles. (Meaning we need to move all styles from
    * component inline to <head>)
@@ -31153,7 +31687,7 @@ var DomContainer = class extends _SharedContainer {
   }
   getSyncFn(id) {
     const fn = this.$qFuncs$[id];
-    isDev20 && assertTrue(typeof fn === "function", "Invalid reference: " + id);
+    isDev21 && assertTrue(typeof fn === "function", "Invalid reference: " + id);
     return fn;
   }
   $appendStyle$(content, styleId, host, scoped) {
@@ -31195,278 +31729,6 @@ var DomContainer = class extends _SharedContainer {
   }
 };
 
-// packages/qwik/src/core/preloader/queue.ts
-import { isBrowser as isBrowser5 } from "@qwik.dev/core/build";
-
-// packages/qwik/src/core/preloader/constants.ts
-import { isBrowser as isBrowser4 } from "@qwik.dev/core/build";
-var doc = isBrowser4 ? document : void 0;
-var config = {
-  $DEBUG$: false,
-  $maxIdlePreloads$: 25,
-  $invPreloadProbability$: 0.65
-};
-var rel = isBrowser4 && doc.createElement("link").relList.supports("modulepreload") ? "modulePreload" : "preload";
-var loadStart = Date.now();
-var isJSRegex = /\.[mc]?js$/;
-
-// packages/qwik/src/core/preloader/types.ts
-var BundleImportState_None = 0;
-var BundleImportState_Queued = 1;
-var BundleImportState_Preload = 2;
-var BundleImportState_Alias = 3;
-var BundleImportState_Loaded = 4;
-
-// packages/qwik/src/core/preloader/bundle-graph.ts
-var base;
-var graph;
-var makeBundle = (name, deps) => {
-  return {
-    $name$: name,
-    $state$: isJSRegex.test(name) ? BundleImportState_None : BundleImportState_Alias,
-    $deps$: shouldResetFactor ? deps?.map((d) => ({ ...d, $factor$: 1 })) : deps,
-    $inverseProbability$: 1,
-    $createdTs$: Date.now(),
-    $waitedMs$: 0,
-    $loadedMs$: 0
-  };
-};
-var parseBundleGraph = (serialized) => {
-  const graph2 = /* @__PURE__ */ new Map();
-  let i = 0;
-  while (i < serialized.length) {
-    const name = serialized[i++];
-    const deps = [];
-    let idx;
-    let probability = 1;
-    while (idx = serialized[i], typeof idx === "number") {
-      if (idx < 0) {
-        probability = -idx / 10;
-      } else {
-        deps.push({
-          $name$: serialized[idx],
-          $importProbability$: probability,
-          $factor$: 1
-        });
-      }
-      i++;
-    }
-    graph2.set(name, deps);
-  }
-  return graph2;
-};
-var getBundle = (name) => {
-  let bundle = bundles.get(name);
-  if (!bundle) {
-    let deps;
-    if (graph) {
-      deps = graph.get(name);
-      if (!deps) {
-        return;
-      }
-      if (!deps.length) {
-        deps = void 0;
-      }
-    }
-    bundle = makeBundle(name, deps);
-    bundles.set(name, bundle);
-  }
-  return bundle;
-};
-var initPreloader = (serializedBundleGraph, opts) => {
-  if (opts) {
-    if ("debug" in opts) {
-      config.$DEBUG$ = !!opts.debug;
-    }
-    if (typeof opts.preloadProbability === "number") {
-      config.$invPreloadProbability$ = 1 - opts.preloadProbability;
-    }
-  }
-  if (base != null || !serializedBundleGraph) {
-    return;
-  }
-  base = "";
-  graph = parseBundleGraph(serializedBundleGraph);
-};
-
-// packages/qwik/src/core/preloader/queue.ts
-var bundles = /* @__PURE__ */ new Map();
-var shouldResetFactor;
-var queueDirty;
-var preloadCount = 0;
-var queue = [];
-var log5 = (...args) => {
-  console.log(
-    `Preloader ${Date.now() - loadStart}ms ${preloadCount}/${queue.length} queued>`,
-    ...args
-  );
-};
-var resetQueue = () => {
-  bundles.clear();
-  queueDirty = false;
-  shouldResetFactor = true;
-  preloadCount = 0;
-  queue.length = 0;
-};
-var sortQueue = () => {
-  if (queueDirty) {
-    queue.sort((a, b) => a.$inverseProbability$ - b.$inverseProbability$);
-    queueDirty = false;
-  }
-};
-var getQueue = () => {
-  sortQueue();
-  let probability = 0.4;
-  const result2 = [];
-  for (const b of queue) {
-    const nextProbability = Math.round((1 - b.$inverseProbability$) * 10);
-    if (nextProbability !== probability) {
-      probability = nextProbability;
-      result2.push(probability);
-    }
-    result2.push(b.$name$);
-  }
-  return result2;
-};
-var trigger = () => {
-  if (!queue.length) {
-    return;
-  }
-  sortQueue();
-  while (queue.length) {
-    const bundle = queue[0];
-    const inverseProbability = bundle.$inverseProbability$;
-    const probability = 1 - inverseProbability;
-    const allowedPreloads = graph ? config.$maxIdlePreloads$ : (
-      // While the graph is not available, we limit to 5 preloads
-      5
-    );
-    if (probability >= 0.99 || preloadCount < allowedPreloads) {
-      queue.shift();
-      preloadOne(bundle);
-    } else {
-      break;
-    }
-  }
-  if (config.$DEBUG$ && !queue.length) {
-    const loaded = [...bundles.values()].filter((b) => b.$state$ > BundleImportState_None);
-    const waitTime = loaded.reduce((acc, b) => acc + b.$waitedMs$, 0);
-    const loadTime = loaded.reduce((acc, b) => acc + b.$loadedMs$, 0);
-    log5(
-      `>>>> done ${loaded.length}/${bundles.size} total: ${waitTime}ms waited, ${loadTime}ms loaded`
-    );
-  }
-};
-var preloadOne = (bundle) => {
-  if (bundle.$state$ >= BundleImportState_Preload) {
-    return;
-  }
-  preloadCount++;
-  const start = Date.now();
-  bundle.$waitedMs$ = start - bundle.$createdTs$;
-  bundle.$state$ = BundleImportState_Preload;
-  config.$DEBUG$ && log5(
-    `<< load ${Math.round((1 - bundle.$inverseProbability$) * 100)}% after ${`${bundle.$waitedMs$}ms`}`,
-    bundle.$name$
-  );
-  const link = doc.createElement("link");
-  link.href = new URL(`${base}${bundle.$name$}`, doc.baseURI).toString();
-  link.rel = rel;
-  link.as = "script";
-  link.onload = link.onerror = () => {
-    preloadCount--;
-    const end = Date.now();
-    bundle.$loadedMs$ = end - start;
-    bundle.$state$ = BundleImportState_Loaded;
-    config.$DEBUG$ && log5(`>> done after ${bundle.$loadedMs$}ms`, bundle.$name$);
-    link.remove();
-    trigger();
-  };
-  doc.head.appendChild(link);
-};
-var adjustProbabilities = (bundle, newInverseProbability, seen) => {
-  if (seen?.has(bundle)) {
-    return;
-  }
-  const previousInverseProbability = bundle.$inverseProbability$;
-  bundle.$inverseProbability$ = newInverseProbability;
-  if (previousInverseProbability - bundle.$inverseProbability$ < 0.01) {
-    return;
-  }
-  if (
-    // don't queue until we have initialized the preloader
-    base != null && bundle.$state$ < BundleImportState_Preload
-  ) {
-    if (bundle.$state$ === BundleImportState_None) {
-      bundle.$state$ = BundleImportState_Queued;
-      queue.push(bundle);
-      config.$DEBUG$ && log5(`queued ${Math.round((1 - bundle.$inverseProbability$) * 100)}%`, bundle.$name$);
-    }
-    queueDirty = true;
-  }
-  if (bundle.$deps$) {
-    seen || (seen = /* @__PURE__ */ new Set());
-    seen.add(bundle);
-    const probability = 1 - bundle.$inverseProbability$;
-    for (const dep of bundle.$deps$) {
-      const depBundle = getBundle(dep.$name$);
-      if (depBundle.$inverseProbability$ === 0) {
-        continue;
-      }
-      let newInverseProbability2;
-      if (probability === 1 || probability >= 0.99 && depsCount < 100) {
-        depsCount++;
-        newInverseProbability2 = Math.min(0.01, 1 - dep.$importProbability$);
-      } else {
-        const newInverseImportProbability = 1 - dep.$importProbability$ * probability;
-        const prevAdjust = dep.$factor$;
-        const factor = newInverseImportProbability / prevAdjust;
-        newInverseProbability2 = Math.max(0.02, depBundle.$inverseProbability$ * factor);
-        dep.$factor$ = factor;
-      }
-      adjustProbabilities(depBundle, newInverseProbability2, seen);
-    }
-  }
-};
-var handleBundle = (name, inverseProbability) => {
-  const bundle = getBundle(name);
-  if (bundle && bundle.$inverseProbability$ > inverseProbability) {
-    adjustProbabilities(bundle, inverseProbability);
-  }
-};
-var depsCount;
-var preload2 = (name, probability) => {
-  if (!name?.length) {
-    return;
-  }
-  depsCount = 0;
-  let inverseProbability = probability ? 1 - probability : 0.4;
-  if (Array.isArray(name)) {
-    for (let i = name.length - 1; i >= 0; i--) {
-      const item = name[i];
-      if (typeof item === "number") {
-        inverseProbability = 1 - item / 10;
-      } else {
-        handleBundle(item, inverseProbability);
-      }
-    }
-  } else {
-    handleBundle(name, inverseProbability);
-  }
-  if (isBrowser5) {
-    trigger();
-  }
-};
-if (isBrowser5) {
-  document.addEventListener("qsymbol", (ev) => {
-    const { symbol, href } = ev.detail;
-    if (href) {
-      const hash3 = symbol.slice(symbol.lastIndexOf("_") + 1);
-      preload2(hash3, 1);
-    }
-  });
-}
-
 // packages/qwik/src/core/use/use-locale.ts
 import { isServer as isServer10 } from "@qwik.dev/core/build";
 var _locale = void 0;
@@ -31485,17 +31747,6 @@ function setLocale(locale) {
   _locale = locale;
 }
 
-// packages/qwik/src/core/index.ts
-if (globalThis.__qwik) {
-  qError(30 /* duplicateQwik */, [globalThis.__qwik, version]);
-}
-globalThis.__qwik = version;
-if (import.meta.hot) {
-  import.meta.hot.dispose(() => {
-    globalThis.__qwik = void 0;
-  });
-}
-
 // packages/qwik/src/core/use/use-core.ts
 var _context;
 var tryGetInvokeContext = () => {
@@ -31506,8 +31757,8 @@ var useInvokeContext = () => {
   if (!ctx || ctx.$event$ !== RenderEvent) {
     throw qError(10 /* useInvokeContext */);
   }
-  isDev21 && assertDefined(ctx.$hostElement$, `invoke: $hostElement$ must be defined`, ctx);
-  isDev21 && assertDefined(ctx.$effectSubscriber$, `invoke: $effectSubscriber$ must be defined`, ctx);
+  isDev22 && assertDefined(ctx.$hostElement$, `invoke: $hostElement$ must be defined`, ctx);
+  isDev22 && assertDefined(ctx.$effectSubscriber$, `invoke: $effectSubscriber$ must be defined`, ctx);
   return ctx;
 };
 function invoke(context, fn, ...args) {
@@ -31595,9 +31846,9 @@ var trackSignalAndAssignHost = (value, host, property, container, data) => {
 };
 
 // packages/qwik/src/core/reactive-primitives/impl/store.ts
-import { isDev as isDev22, isServer as isServer11 } from "@qwik.dev/core/build";
+import { isDev as isDev23, isServer as isServer11 } from "@qwik.dev/core/build";
 var DEBUG7 = false;
-var log6 = (...args) => console.log("STORE", ...args.map(qwikDebugToString));
+var log5 = (...args) => console.log("STORE", ...args.map(qwikDebugToString));
 var getStoreHandler = (value) => {
   return value[STORE_HANDLER];
 };
@@ -31656,7 +31907,7 @@ var StoreHandler2 = class {
         }
         this.$container$ = ctx.$container$;
       } else {
-        isDev22 && assertTrue(
+        isDev23 && assertTrue(
           !ctx.$container$ || ctx.$container$ === this.$container$,
           "Do not use signals across containers"
         );
@@ -31690,11 +31941,11 @@ var StoreHandler2 = class {
     if (prop in target) {
       const oldValue = target[prop];
       if (newValue !== oldValue) {
-        DEBUG7 && log6("Store.set", oldValue, "->", newValue, pad("\n" + this.toString(), "  "));
+        DEBUG7 && log5("Store.set", oldValue, "->", newValue, pad("\n" + this.toString(), "  "));
         setNewValueAndTriggerEffects(prop, newValue, target, this);
       }
     } else {
-      DEBUG7 && log6("Store.set", "create property", newValue, pad("\n" + this.toString(), "  "));
+      DEBUG7 && log5("Store.set", "create property", newValue, pad("\n" + this.toString(), "  "));
       setNewValueAndTriggerEffects(prop, newValue, target, this);
     }
     return true;
@@ -31760,7 +32011,7 @@ function addStoreEffect(target, prop, store, effectSubscription) {
   ensureContainsSubscription(effects, effectSubscription);
   ensureContainsBackRef(effectSubscription, target);
   (import.meta.env.TEST ? !isDomContainer(store.$container$) : isServer11) && addQrlToSerializationCtx(effectSubscription, store.$container$);
-  DEBUG7 && log6(
+  DEBUG7 && log5(
     "sub",
     pad(
       "\n" + [...store.$effects$?.entries() || []].map(([key, value]) => `${String(key)}: ${String(value)}`).join(","),
@@ -31997,13 +32248,13 @@ function preprocessState(data, container) {
 }
 
 // packages/qwik/src/core/shared/serdes/serdes.public.ts
-import { isDev as isDev23 } from "@qwik.dev/core/build";
+import { isDev as isDev24 } from "@qwik.dev/core/build";
 function getObjectById(id, stateData) {
   if (typeof id === "string") {
     id = parseInt(id, 10);
     return stateData[id];
   }
-  isDev23 && assertTrue(id < stateData.length, `Invalid reference ${id} >= ${stateData.length}`);
+  isDev24 && assertTrue(id < stateData.length, `Invalid reference ${id} >= ${stateData.length}`);
   return stateData[id];
 }
 
@@ -32100,9 +32351,9 @@ var NoSerializeSymbol = /* @__PURE__ */ Symbol("noSerialize");
 var SerializerSymbol = /* @__PURE__ */ Symbol("serialize");
 
 // packages/qwik/src/core/reactive-primitives/utils.ts
-import { isDev as isDev24, isServer as isServer12 } from "@qwik.dev/core/build";
+import { isDev as isDev25, isServer as isServer12 } from "@qwik.dev/core/build";
 var DEBUG8 = false;
-var log7 = (...args) => console.log("SIGNAL", ...args.map(qwikDebugToString));
+var log6 = (...args) => console.log("SIGNAL", ...args.map(qwikDebugToString));
 var throwIfQRLNotResolved = (qrl) => {
   const resolved = qrl.resolved;
   if (!resolved) {
@@ -32141,7 +32392,7 @@ var scheduleEffects = (container, signal, effects) => {
     const scheduleEffect = (effectSubscription) => {
       const consumer = effectSubscription.consumer;
       const property = effectSubscription.property;
-      isDev24 && assertDefined(container, "Container must be defined.");
+      isDev25 && assertDefined(container, "Container must be defined.");
       if (isTask(consumer)) {
         consumer.$flags$ |= 4 /* DIRTY */;
         markVNodeDirty(container, consumer.$el$, 1 /* TASKS */);
@@ -32179,11 +32430,11 @@ var scheduleEffects = (container, signal, effects) => {
       }
     };
     const effectsSnapshot = Array.from(effects);
-    for (const effect of effectsSnapshot) {
-      scheduleEffect(effect);
+    for (let i = 0; i < effectsSnapshot.length; i++) {
+      scheduleEffect(effectsSnapshot[i]);
     }
   }
-  DEBUG8 && log7("done scheduling");
+  DEBUG8 && log6("done scheduling");
 };
 var isSerializerObj = (obj) => {
   return isObject(obj) && typeof obj[SerializerSymbol] === "function";
@@ -32322,7 +32573,7 @@ var createFastGetter = (propName) => {
 
 // packages/qwik/src/core/client/vnode-utils.ts
 var vnode_newElement = (element, elementName, key = null) => {
-  isDev25 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
+  isDev26 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
   const vnode = new ElementVNode(
     key,
     1 /* Element */ | 8 /* Inflated */ | -1 << 12 /* shift */,
@@ -32340,7 +32591,7 @@ var vnode_newElement = (element, elementName, key = null) => {
   return vnode;
 };
 var vnode_newUnMaterializedElement = (element) => {
-  isDev25 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
+  isDev26 && assertEqual(fastNodeType(element), 1, "Expecting element node.");
   const vnode = new ElementVNode(
     null,
     1 /* Element */ | -1 << 12 /* shift */,
@@ -32358,7 +32609,7 @@ var vnode_newUnMaterializedElement = (element) => {
   return vnode;
 };
 var vnode_newSharedText = (previousTextNode, sharedTextNode, textContent) => {
-  isDev25 && sharedTextNode && assertEqual(fastNodeType(sharedTextNode), 3, "Expecting text node.");
+  isDev26 && sharedTextNode && assertEqual(fastNodeType(sharedTextNode), 3, "Expecting text node.");
   const vnode = new TextVNode(
     4 /* Text */ | -1 << 12 /* shift */,
     // Flag
@@ -32390,10 +32641,10 @@ var vnode_newText = (textNode, textContent) => {
     textContent
     // Text Content
   );
-  isDev25 && assertEqual(fastNodeType(textNode), 3, "Expecting text node.");
-  isDev25 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
-  isDev25 && assertTrue(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
-  isDev25 && assertFalse(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
+  isDev26 && assertEqual(fastNodeType(textNode), 3, "Expecting text node.");
+  isDev26 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
+  isDev26 && assertTrue(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
+  isDev26 && assertFalse(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
   return vnode;
 };
 var vnode_newVirtual = () => {
@@ -32408,9 +32659,9 @@ var vnode_newVirtual = () => {
     null,
     null
   );
-  isDev25 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
-  isDev25 && assertFalse(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
-  isDev25 && assertTrue(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
+  isDev26 && assertFalse(vnode_isElementVNode(vnode), "Incorrect format of TextVNode.");
+  isDev26 && assertFalse(vnode_isTextVNode(vnode), "Incorrect format of TextVNode.");
+  isDev26 && assertTrue(vnode_isVirtualVNode(vnode), "Incorrect format of TextVNode.");
   return vnode;
 };
 var vnode_isVNode = (vNode) => {
@@ -32420,12 +32671,12 @@ var vnode_isElementVNode = (vNode) => {
   return (vNode.flags & 1 /* Element */) === 1 /* Element */;
 };
 var vnode_isElementOrTextVNode = (vNode) => {
-  isDev25 && assertDefined(vNode, "Missing vNode");
+  isDev26 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 5 /* ELEMENT_OR_TEXT_MASK */) !== 0;
 };
 var vnode_isMaterialized = (vNode) => {
-  isDev25 && assertDefined(vNode, "Missing vNode");
+  isDev26 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 1 /* Element */) === 1 /* Element */ && vNode.firstChild !== void 0 && vNode.lastChild !== void 0;
 };
@@ -32436,26 +32687,26 @@ var vnode_isVirtualVNode = (vNode) => {
   return (vNode.flags & 2 /* Virtual */) === 2 /* Virtual */;
 };
 var vnode_isProjection = (vNode) => {
-  isDev25 && assertDefined(vNode, "Missing vNode");
+  isDev26 && assertDefined(vNode, "Missing vNode");
   const flag = vNode.flags;
   return (flag & 2 /* Virtual */) === 2 /* Virtual */ && vnode_getProp(vNode, QSlot, null) !== null;
 };
 var ensureTextVNode = (vNode) => {
-  isDev25 && assertTrue(
+  isDev26 && assertTrue(
     vnode_isTextVNode(vNode),
     "Expecting TextVNode was: " + vnode_getNodeTypeName(vNode)
   );
   return vNode;
 };
 var ensureElementOrVirtualVNode = (vNode) => {
-  isDev25 && assertDefined(vNode, "Missing vNode");
-  isDev25 && assertTrue(
+  isDev26 && assertDefined(vNode, "Missing vNode");
+  isDev26 && assertTrue(
     (vNode.flags & 3 /* ELEMENT_OR_VIRTUAL_MASK */) !== 0,
     "Expecting ElementVNode or VirtualVNode was: " + vnode_getNodeTypeName(vNode)
   );
 };
 var ensureElementVNode = (vNode) => {
-  isDev25 && assertTrue(
+  isDev26 && assertTrue(
     vnode_isElementVNode(vNode),
     "Expecting ElementVNode was: " + vnode_getNodeTypeName(vNode)
   );
@@ -32558,15 +32809,25 @@ var vnode_ensureElementInflated = (container, vnode) => {
     }
   }
 };
+var unwrapEventHandlerQrl = (handler) => {
+  if (handler.$symbol$ === "_run") {
+    const innerHandler = handler.getCaptured()?.[0];
+    if (isQrl(innerHandler)) {
+      return innerHandler;
+    }
+  }
+  return handler;
+};
 function registerQrlHandlers(attr, key, container, element) {
   const value = attr.value;
   const scopedKebabName = key.slice(2);
   const qrls = value.split("|");
-  const handlers = qrls.map((qrl) => {
-    const handler = parseQRL(qrl, container);
-    return handler;
-  });
-  (element._qDispatch || (element._qDispatch = {}))[scopedKebabName] = handlers;
+  const handlers = [];
+  for (let i = 0; i < qrls.length; i++) {
+    const handler = unwrapEventHandlerQrl(parseQRL(qrls[i], container));
+    handlers.push(runEventHandlerQRL.bind(null, handler));
+  }
+  (element._qDispatch || (element._qDispatch = {}))[scopedKebabName] = handlers.length === 1 ? handlers[0] : handlers;
 }
 function vnode_walkDirectChildren(journal, vParent, callback) {
   let vNode = vnode_getFirstChild(vParent);
@@ -32686,7 +32947,7 @@ var vnode_ensureTextInflated = (journal, vnode) => {
   const flags = textVNode.flags;
   if ((flags & 8 /* Inflated */) === 0) {
     const parentNode = vnode_getDomParent(vnode, true);
-    isDev25 && assertDefined(parentNode, "Missing parent node.");
+    isDev26 && assertDefined(parentNode, "Missing parent node.");
     const sharedTextNode = textVNode.node;
     const doc2 = fastOwnerDocument(parentNode);
     let vCursor = vnode_getDomSibling(vnode, false, true);
@@ -32735,7 +32996,7 @@ var vnode_locate = (rootVNode, id) => {
   let elementOffset = -1;
   let refElement;
   if (typeof id === "string") {
-    isDev25 && assertDefined(qVNodeRefs, "Missing qVNodeRefs.");
+    isDev26 && assertDefined(qVNodeRefs, "Missing qVNodeRefs.");
     elementOffset = parseInt(id);
     refElement = qVNodeRefs.get(elementOffset);
   } else {
@@ -32745,9 +33006,9 @@ var vnode_locate = (rootVNode, id) => {
       return vNode2;
     }
   }
-  isDev25 && assertDefined(refElement, "Missing refElement.");
+  isDev26 && assertDefined(refElement, "Missing refElement.");
   if (!vnode_isVNode(refElement)) {
-    isDev25 && assertTrue(
+    isDev26 && assertTrue(
       containerElement2.contains(refElement),
       `Couldn't find the element inside the container while locating the VNode.`
     );
@@ -32791,10 +33052,10 @@ var vnode_locate = (rootVNode, id) => {
 };
 var vnode_getChildWithIdx = (vNode, childIdx) => {
   let child = vnode_getFirstChild(vNode);
-  isDev25 && assertDefined(child, "Missing child.");
+  isDev26 && assertDefined(child, "Missing child.");
   while (child.flags >>> 12 /* shift */ !== childIdx) {
     child = child.nextSibling;
-    isDev25 && assertDefined(child, "Missing child.");
+    isDev26 && assertDefined(child, "Missing child.");
   }
   return child;
 };
@@ -32802,7 +33063,7 @@ var vNodeStack = [];
 var vnode_getVNodeForChildNode = (vNode, childElement) => {
   ensureElementVNode(vNode);
   let child = vnode_getFirstChild(vNode);
-  isDev25 && assertDefined(child, "Missing child.");
+  isDev26 && assertDefined(child, "Missing child.");
   while (child && (child instanceof ElementVNode ? child.node !== childElement : true)) {
     if (vnode_isVirtualVNode(child)) {
       const next = child.nextSibling;
@@ -32821,13 +33082,13 @@ var vnode_getVNodeForChildNode = (vNode, childElement) => {
         child = next || vNodeStack.pop();
       }
     }
-    isDev25 && assertDefined(child, "Missing child.");
+    isDev26 && assertDefined(child, "Missing child.");
   }
   while (vNodeStack.length) {
     vNodeStack.pop();
   }
   ensureElementVNode(child);
-  isDev25 && assertEqual(child.node, childElement, "Child not found.");
+  isDev26 && assertEqual(child.node, childElement, "Child not found.");
   return child;
 };
 var indexOfAlphanumeric = (id, length) => {
@@ -33084,7 +33345,7 @@ var vnode_getDomParentVNode = (vnode, includeProjection) => {
   return vnode;
 };
 var vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
-  isDev25 && assertEqual(vParent, vToRemove.parent, "Parent mismatch.");
+  isDev26 && assertEqual(vParent, vToRemove.parent, "Parent mismatch.");
   if (vnode_isTextVNode(vToRemove)) {
     vnode_ensureTextInflated(journal, vToRemove);
   }
@@ -33117,15 +33378,20 @@ var vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
   vToRemove.nextSibling = null;
 };
 var vnode_truncate = (journal, vParent, vDelete, removeDOM = true) => {
-  isDev25 && assertDefined(vDelete, "Missing vDelete.");
+  isDev26 && assertDefined(vDelete, "Missing vDelete.");
   const parent = vnode_getDomParent(vParent, true);
   if (parent && removeDOM) {
     if (vnode_isElementOrTextVNode(vParent)) {
       addVNodeOperation(journal, createRemoveAllChildrenOperation(vParent.node));
     } else {
-      vnode_walkDirectChildren(journal, vParent, (vNode) => {
-        addVNodeOperation(journal, createDeleteOperation(vNode.node));
-      });
+      const domParentVNode = vnode_getDomParentVNode(vParent, false);
+      if (domParentVNode && domParentVNode.firstChild === vParent && domParentVNode.lastChild === vParent) {
+        addVNodeOperation(journal, createRemoveAllChildrenOperation(parent));
+      } else {
+        vnode_walkDirectChildren(journal, vParent, (vNode) => {
+          addVNodeOperation(journal, createDeleteOperation(vNode.node));
+        });
+      }
     }
   }
   const vPrevious = vDelete.previousSibling;
@@ -33211,8 +33477,8 @@ var ensureMaterialized = (vnode) => {
       vFirstChild = vnode_materialize(vParent);
     }
   }
-  isDev25 && assertTrue(vParent.firstChild !== void 0, "Did not materialize.");
-  isDev25 && assertTrue(vParent.lastChild !== void 0, "Did not materialize.");
+  isDev26 && assertTrue(vParent.firstChild !== void 0, "Did not materialize.");
+  isDev26 && assertTrue(vParent.lastChild !== void 0, "Did not materialize.");
   return vFirstChild;
 };
 var _fastHasAttribute = null;
@@ -33379,7 +33645,7 @@ var materializeFromDOM = (vParent, firstChild, vData) => {
         }
         const id = consumeValue();
         container.$setRawState$(parseInt(id), vParent);
-        isDev25 && vnode_setProp(vParent, ELEMENT_ID, id);
+        isDev26 && vnode_setProp(vParent, ELEMENT_ID, id);
       } else if (peek() === VNodeDataChar.BACK_REFS) {
         if (!container) {
           container = getDomContainer(vParent.node);
@@ -33657,7 +33923,7 @@ function materializeFromVNodeData(vParent, vData, element, child) {
       }
       const id = consumeValue();
       container.$setRawState$(parseInt(id), vParent);
-      isDev25 && vnode_setProp(vParent, ELEMENT_ID, id);
+      isDev26 && vnode_setProp(vParent, ELEMENT_ID, id);
     } else if (peek() === VNodeDataChar.PROPS) {
       vnode_setProp(vParent, ELEMENT_PROPS, consumeValue());
     } else if (peek() === VNodeDataChar.KEY) {
@@ -34211,7 +34477,9 @@ function prettyHtml(element, prefix = "") {
   const lines = [];
   lines.push(prefix, "<", element.localName);
   const attrs = Array.from(element.attributes).map((attr) => ({ name: attr.name, value: attr.value })).filter(
-    (attr) => [Q_PROPS_SEPARATOR, ELEMENT_KEY].indexOf(attr.name) == -1 && !attr.name.startsWith("q-e:" /* on */)
+    (attr) => [Q_PROPS_SEPARATOR, ELEMENT_KEY, ITERATION_ITEM_MULTI, ITERATION_ITEM_SINGLE].indexOf(
+      attr.name
+    ) == -1 && !attr.name.startsWith("q-e:" /* on */)
   ).sort((a, b) => a.name.localeCompare(b.name));
   for (let i = 0; i < attrs.length; i++) {
     const attr = attrs[i];
@@ -34728,8 +34996,8 @@ var ElementFixture = class {
           const equal = code2.indexOf("=");
           const qFuncs2 = (0, eval)(code2.substring(equal + 1));
           const container = this.host.closest(QContainerSelector2);
-          const hash3 = container.getAttribute(QInstanceAttr);
-          document[QFuncsPrefix + hash3] = qFuncs2;
+          const hash2 = container.getAttribute(QInstanceAttr);
+          document[QFuncsPrefix + hash2] = qFuncs2;
         }
       });
       this.child = null;
@@ -34741,7 +35009,7 @@ var ElementFixture = class {
     }
   }
 };
-async function trigger2(root, queryOrElement, eventName, eventPayload = {}, options) {
+async function trigger(root, queryOrElement, eventName, eventPayload = {}, options) {
   const waitForIdle = options?.waitForIdle ?? true;
   let scope;
   let kebabName;
@@ -34804,7 +35072,9 @@ var dispatch = async (element, event, scopedKebabName, kebabName) => {
     if ("_qDispatch" in element) {
       const handlers = element._qDispatch?.[scopedKebabName];
       if (handlers) {
-        if (handlers.length) {
+        if (typeof handlers === "function") {
+          await handlers(event, element);
+        } else if (handlers.length) {
           for (const handler of handlers) {
             if (handler) {
               await handler(event, element);
@@ -34849,8 +35119,8 @@ function createPlatform2() {
   const testPlatform2 = {
     isServer: false,
     importSymbol(containerEl, url, symbolName) {
-      const hash3 = getSymbolHash(symbolName);
-      const regSym = globalThis.__qwik_reg_symbols?.get(hash3);
+      const hash2 = getSymbolHash(symbolName);
+      const regSym = globalThis.__qwik_reg_symbols?.get(hash2);
       if (regSym) {
         return regSym;
       }
@@ -34934,7 +35204,7 @@ var createDOM = async function({ html } = {}) {
     },
     screen: host,
     userEvent: async function(queryOrElement, eventNameCamel, eventPayload = {}) {
-      return trigger2(host, queryOrElement, eventNameCamel, eventPayload);
+      return trigger(host, queryOrElement, eventNameCamel, eventPayload);
     }
   };
 };
@@ -34963,11 +35233,283 @@ import { join } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { expect as expect2 } from "vitest";
 
+// packages/qwik/src/core/preloader/queue.ts
+import { isBrowser as isBrowser5 } from "@qwik.dev/core/build";
+
+// packages/qwik/src/core/preloader/constants.ts
+import { isBrowser as isBrowser4 } from "@qwik.dev/core/build";
+var doc = isBrowser4 ? document : void 0;
+var config = {
+  $DEBUG$: false,
+  $maxIdlePreloads$: 25,
+  $invPreloadProbability$: 0.65
+};
+var rel = isBrowser4 && doc.createElement("link").relList.supports("modulepreload") ? "modulePreload" : "preload";
+var loadStart = Date.now();
+var isJSRegex = /\.[mc]?js$/;
+
+// packages/qwik/src/core/preloader/types.ts
+var BundleImportState_None = 0;
+var BundleImportState_Queued = 1;
+var BundleImportState_Preload = 2;
+var BundleImportState_Alias = 3;
+var BundleImportState_Loaded = 4;
+
+// packages/qwik/src/core/preloader/bundle-graph.ts
+var base;
+var graph;
+var makeBundle = (name, deps) => {
+  return {
+    $name$: name,
+    $state$: isJSRegex.test(name) ? BundleImportState_None : BundleImportState_Alias,
+    $deps$: shouldResetFactor ? deps?.map((d) => ({ ...d, $factor$: 1 })) : deps,
+    $inverseProbability$: 1,
+    $createdTs$: Date.now(),
+    $waitedMs$: 0,
+    $loadedMs$: 0
+  };
+};
+var parseBundleGraph = (serialized) => {
+  const graph2 = /* @__PURE__ */ new Map();
+  let i = 0;
+  while (i < serialized.length) {
+    const name = serialized[i++];
+    const deps = [];
+    let idx;
+    let probability = 1;
+    while (idx = serialized[i], typeof idx === "number") {
+      if (idx < 0) {
+        probability = -idx / 10;
+      } else {
+        deps.push({
+          $name$: serialized[idx],
+          $importProbability$: probability,
+          $factor$: 1
+        });
+      }
+      i++;
+    }
+    graph2.set(name, deps);
+  }
+  return graph2;
+};
+var getBundle = (name) => {
+  let bundle = bundles.get(name);
+  if (!bundle) {
+    let deps;
+    if (graph) {
+      deps = graph.get(name);
+      if (!deps) {
+        return;
+      }
+      if (!deps.length) {
+        deps = void 0;
+      }
+    }
+    bundle = makeBundle(name, deps);
+    bundles.set(name, bundle);
+  }
+  return bundle;
+};
+var initPreloader = (serializedBundleGraph, opts) => {
+  if (opts) {
+    if ("debug" in opts) {
+      config.$DEBUG$ = !!opts.debug;
+    }
+    if (typeof opts.preloadProbability === "number") {
+      config.$invPreloadProbability$ = 1 - opts.preloadProbability;
+    }
+  }
+  if (base != null || !serializedBundleGraph) {
+    return;
+  }
+  base = "";
+  graph = parseBundleGraph(serializedBundleGraph);
+};
+
+// packages/qwik/src/core/preloader/queue.ts
+var bundles = /* @__PURE__ */ new Map();
+var shouldResetFactor;
+var queueDirty;
+var preloadCount = 0;
+var queue = [];
+var log7 = (...args) => {
+  console.log(
+    `Preloader ${Date.now() - loadStart}ms ${preloadCount}/${queue.length} queued>`,
+    ...args
+  );
+};
+var resetQueue = () => {
+  bundles.clear();
+  queueDirty = false;
+  shouldResetFactor = true;
+  preloadCount = 0;
+  queue.length = 0;
+};
+var sortQueue = () => {
+  if (queueDirty) {
+    queue.sort((a, b) => a.$inverseProbability$ - b.$inverseProbability$);
+    queueDirty = false;
+  }
+};
+var getQueue = () => {
+  sortQueue();
+  let probability = 0.4;
+  const result2 = [];
+  for (const b of queue) {
+    const nextProbability = Math.round((1 - b.$inverseProbability$) * 10);
+    if (nextProbability !== probability) {
+      probability = nextProbability;
+      result2.push(probability);
+    }
+    result2.push(b.$name$);
+  }
+  return result2;
+};
+var trigger2 = () => {
+  if (!queue.length) {
+    return;
+  }
+  sortQueue();
+  while (queue.length) {
+    const bundle = queue[0];
+    const inverseProbability = bundle.$inverseProbability$;
+    const probability = 1 - inverseProbability;
+    const allowedPreloads = graph ? config.$maxIdlePreloads$ : (
+      // While the graph is not available, we limit to 5 preloads
+      5
+    );
+    if (probability >= 0.99 || preloadCount < allowedPreloads) {
+      queue.shift();
+      preloadOne(bundle);
+    } else {
+      break;
+    }
+  }
+  if (config.$DEBUG$ && !queue.length) {
+    const loaded = [...bundles.values()].filter((b) => b.$state$ > BundleImportState_None);
+    const waitTime = loaded.reduce((acc, b) => acc + b.$waitedMs$, 0);
+    const loadTime = loaded.reduce((acc, b) => acc + b.$loadedMs$, 0);
+    log7(
+      `>>>> done ${loaded.length}/${bundles.size} total: ${waitTime}ms waited, ${loadTime}ms loaded`
+    );
+  }
+};
+var preloadOne = (bundle) => {
+  if (bundle.$state$ >= BundleImportState_Preload) {
+    return;
+  }
+  preloadCount++;
+  const start = Date.now();
+  bundle.$waitedMs$ = start - bundle.$createdTs$;
+  bundle.$state$ = BundleImportState_Preload;
+  config.$DEBUG$ && log7(
+    `<< load ${Math.round((1 - bundle.$inverseProbability$) * 100)}% after ${`${bundle.$waitedMs$}ms`}`,
+    bundle.$name$
+  );
+  const link = doc.createElement("link");
+  link.href = new URL(`${base}${bundle.$name$}`, doc.baseURI).toString();
+  link.rel = rel;
+  link.as = "script";
+  link.onload = link.onerror = () => {
+    preloadCount--;
+    const end = Date.now();
+    bundle.$loadedMs$ = end - start;
+    bundle.$state$ = BundleImportState_Loaded;
+    config.$DEBUG$ && log7(`>> done after ${bundle.$loadedMs$}ms`, bundle.$name$);
+    link.remove();
+    trigger2();
+  };
+  doc.head.appendChild(link);
+};
+var adjustProbabilities = (bundle, newInverseProbability, seen) => {
+  if (seen?.has(bundle)) {
+    return;
+  }
+  const previousInverseProbability = bundle.$inverseProbability$;
+  bundle.$inverseProbability$ = newInverseProbability;
+  if (previousInverseProbability - bundle.$inverseProbability$ < 0.01) {
+    return;
+  }
+  if (
+    // don't queue until we have initialized the preloader
+    base != null && bundle.$state$ < BundleImportState_Preload
+  ) {
+    if (bundle.$state$ === BundleImportState_None) {
+      bundle.$state$ = BundleImportState_Queued;
+      queue.push(bundle);
+      config.$DEBUG$ && log7(`queued ${Math.round((1 - bundle.$inverseProbability$) * 100)}%`, bundle.$name$);
+    }
+    queueDirty = true;
+  }
+  if (bundle.$deps$) {
+    seen || (seen = /* @__PURE__ */ new Set());
+    seen.add(bundle);
+    const probability = 1 - bundle.$inverseProbability$;
+    for (const dep of bundle.$deps$) {
+      const depBundle = getBundle(dep.$name$);
+      if (depBundle.$inverseProbability$ === 0) {
+        continue;
+      }
+      let newInverseProbability2;
+      if (probability === 1 || probability >= 0.99 && depsCount < 100) {
+        depsCount++;
+        newInverseProbability2 = Math.min(0.01, 1 - dep.$importProbability$);
+      } else {
+        const newInverseImportProbability = 1 - dep.$importProbability$ * probability;
+        const prevAdjust = dep.$factor$;
+        const factor = newInverseImportProbability / prevAdjust;
+        newInverseProbability2 = Math.max(0.02, depBundle.$inverseProbability$ * factor);
+        dep.$factor$ = factor;
+      }
+      adjustProbabilities(depBundle, newInverseProbability2, seen);
+    }
+  }
+};
+var handleBundle = (name, inverseProbability) => {
+  const bundle = getBundle(name);
+  if (bundle && bundle.$inverseProbability$ > inverseProbability) {
+    adjustProbabilities(bundle, inverseProbability);
+  }
+};
+var depsCount;
+var preload2 = (name, probability) => {
+  if (!name?.length) {
+    return;
+  }
+  depsCount = 0;
+  let inverseProbability = probability ? 1 - probability : 0.4;
+  if (Array.isArray(name)) {
+    for (let i = name.length - 1; i >= 0; i--) {
+      const item = name[i];
+      if (typeof item === "number") {
+        inverseProbability = 1 - item / 10;
+      } else {
+        handleBundle(item, inverseProbability);
+      }
+    }
+  } else {
+    handleBundle(name, inverseProbability);
+  }
+  if (isBrowser5) {
+    trigger2();
+  }
+};
+if (isBrowser5) {
+  document.addEventListener("qsymbol", (ev) => {
+    const { symbol, href } = ev.detail;
+    if (href) {
+      const hash2 = symbol.slice(symbol.lastIndexOf("_") + 1);
+      preload2(hash2, 1);
+    }
+  });
+}
+
 // packages/qwik/src/server/platform.ts
 import { setPlatform as setPlatform2 } from "../core.mjs";
-import { isDev as isDev26 } from "@qwik.dev/core/build";
-var getDevSegmentPath = (mapper, hash3, symbolName, parent) => {
-  const existing = mapper?.[hash3];
+import { isDev as isDev27 } from "@qwik.dev/core/build";
+var getDevSegmentPath = (mapper, hash2, symbolName, parent) => {
+  const existing = mapper?.[hash2];
   if (existing) {
     return existing;
   }
@@ -34987,14 +35529,14 @@ var getDevSegmentPath = (mapper, hash3, symbolName, parent) => {
 function createPlatform3(opts, resolvedManifest) {
   const mapper = resolvedManifest?.mapper;
   const mapperFn = opts.symbolMapper ? opts.symbolMapper : (symbolName, _chunk, parent) => {
-    if (mapper || isDev26 && import.meta.env.MODE !== "test") {
-      const hash3 = getSymbolHash2(symbolName);
-      const result2 = !isDev26 ? mapper[hash3] : getDevSegmentPath(mapper, hash3, symbolName, parent);
+    if (mapper || isDev27 && import.meta.env.MODE !== "test") {
+      const hash2 = getSymbolHash2(symbolName);
+      const result2 = !isDev27 ? mapper[hash2] : getDevSegmentPath(mapper, hash2, symbolName, parent);
       if (!result2) {
-        if (hash3 === SYNC_QRL) {
-          return [hash3, ""];
+        if (hash2 === SYNC_QRL) {
+          return [hash2, ""];
         }
-        const isRegistered = globalThis.__qwik_reg_symbols?.has(hash3);
+        const isRegistered = globalThis.__qwik_reg_symbols?.has(hash2);
         if (isRegistered) {
           return [symbolName, "_"];
         }
@@ -35006,8 +35548,8 @@ function createPlatform3(opts, resolvedManifest) {
   const serverPlatform = {
     isServer: true,
     async importSymbol(_containerEl, url, symbolName) {
-      const hash3 = getSymbolHash2(symbolName);
-      const regSym = globalThis.__qwik_reg_symbols?.get(hash3);
+      const hash2 = getSymbolHash2(symbolName);
+      const regSym = globalThis.__qwik_reg_symbols?.get(hash2);
       if (regSym) {
         return regSym;
       }
@@ -35066,7 +35608,7 @@ var versions = {
 };
 
 // packages/qwik/src/server/ssr-container.ts
-import { isDev as isDev28 } from "@qwik.dev/core/build";
+import { isDev as isDev29 } from "@qwik.dev/core/build";
 import {
   _SubscriptionData as SubscriptionData2,
   _SharedContainer as _SharedContainer2,
@@ -35346,7 +35888,7 @@ import {
   _EMPTY_OBJ,
   _EFFECT_BACK_REF as _EFFECT_BACK_REF2
 } from "@qwik.dev/core/internal";
-import { isDev as isDev27 } from "@qwik.dev/core/build";
+import { isDev as isDev28 } from "@qwik.dev/core/build";
 var SsrNode = class {
   constructor(parentComponent, id, attributesIndex, cleanupQueue, vnodeData, currentFile) {
     this.parentComponent = parentComponent;
@@ -35371,7 +35913,7 @@ var SsrNode = class {
     this.flags = 1 /* Updatable */;
     this.attrs = this.attributesIndex >= 0 ? this.vnodeData[this.attributesIndex] : _EMPTY_OBJ;
     this.parentComponent?.addChild(this);
-    if (isDev27 && id.indexOf("undefined") != -1) {
+    if (isDev28 && id.indexOf("undefined") != -1) {
       throw new Error(`Invalid SSR node id: ${id}`);
     }
   }
@@ -35435,7 +35977,7 @@ var SsrNode = class {
     }
   }
   toString() {
-    if (isDev27) {
+    if (isDev28) {
       let stringifiedAttrs = "";
       for (const key in this.attrs) {
         const value = this.attrs[key];
@@ -35697,7 +36239,7 @@ var SSRContainer = class extends _SharedContainer2 {
     __publicField(this, "componentStack", []);
     __publicField(this, "cleanupQueue", []);
     __publicField(this, "emitContainerDataFrame", null);
-    __publicField(this, "$instanceHash$", hash2());
+    __publicField(this, "$instanceHash$", randomStr());
     // Temporary flag to find missing roots after the state was serialized
     __publicField(this, "$noMoreRoots$", false);
     __publicField(this, "qlInclude");
@@ -35751,12 +36293,15 @@ var SSRContainer = class extends _SharedContainer2 {
   }
   async render(jsx2) {
     this.openContainer();
-    await _walkJSX(this, jsx2, {
+    await this.renderJSX(jsx2, {
       currentStyleScoped: null,
       parentComponentFrame: this.getComponentFrame()
     });
     await this.closeContainer();
   }
+  async renderJSX(jsx2, options) {
+    await _walkJSX(this, jsx2, options);
+  }
   setContext(host, context, value) {
     const ssrNode = host;
     let ctx = ssrNode.getProp(QCtxAttr);
@@ -35802,7 +36347,7 @@ var SSRContainer = class extends _SharedContainer2 {
     containerAttributes[QContainerAttr] = "paused" /* PAUSED */;
     containerAttributes[QRuntimeAttr] = "2";
     containerAttributes[QVersionAttr] = this.$version$ ?? "dev";
-    containerAttributes[QRenderAttr] = (qRender ? qRender + "-" : "") + (isDev28 ? "ssr-dev" : "ssr");
+    containerAttributes[QRenderAttr] = (qRender ? qRender + "-" : "") + (isDev29 ? "ssr-dev" : "ssr");
     containerAttributes[QBaseAttr] = this.$buildBase$ || "";
     containerAttributes[QLocaleAttr] = this.$locale$;
     containerAttributes[QManifestHashAttr] = this.resolvedManifest.manifest.manifestHash;
@@ -35991,14 +36536,14 @@ var SSRContainer = class extends _SharedContainer2 {
       const slotName = componentFrame.slots[i];
       const children = componentFrame.slots[i + 1];
       this.openFragment(
-        isDev28 ? { [DEBUG_TYPE]: "P" /* Projection */, [QSlotParent]: componentFrame.componentNode.id } : { [QSlotParent]: componentFrame.componentNode.id }
+        isDev29 ? { [DEBUG_TYPE]: "P" /* Projection */, [QSlotParent]: componentFrame.componentNode.id } : { [QSlotParent]: componentFrame.componentNode.id }
       );
       const lastNode = this.getOrCreateLastNode();
       if (lastNode.vnodeData) {
         lastNode.vnodeData[0] |= 16 /* SERIALIZE */;
       }
       componentFrame.componentNode.setProp(slotName, lastNode.id);
-      await _walkJSX(this, children, {
+      await this.renderJSX(children, {
         currentStyleScoped: scopedStyleId,
         parentComponentFrame: componentFrame.projectionComponentFrame
       });
@@ -36312,7 +36857,7 @@ var SSRContainer = class extends _SharedContainer2 {
       scriptAttrs["nonce"] = this.renderOptions.serverData.nonce;
     }
     this.openElement("script", null, scriptAttrs);
-    const backpatchScript = getQwikBackpatchExecutorScript({ debug: isDev28 });
+    const backpatchScript = getQwikBackpatchExecutorScript({ debug: isDev29 });
     this.write(backpatchScript);
     this.closeElement();
   }
@@ -36410,7 +36955,7 @@ var SSRContainer = class extends _SharedContainer2 {
   }
   createAndPushFrame(elementName, depthFirstElementIdx, currentFile) {
     let tagNesting = 10 /* ANYTHING */;
-    if (isDev28) {
+    if (isDev29) {
       if (!this.currentElementFrame) {
         tagNesting = initialTag(elementName);
       } else {
@@ -36456,7 +37001,7 @@ var SSRContainer = class extends _SharedContainer2 {
       elementName,
       depthFirstElementIdx,
       vNodeData: [0 /* NONE */],
-      currentFile: isDev28 ? currentFile || null : null
+      currentFile: isDev29 ? currentFile || null : null
     };
     this.currentElementFrame = frame;
     this.vNodeDatas.push(frame.vNodeData);
@@ -36485,7 +37030,7 @@ var SSRContainer = class extends _SharedContainer2 {
     for (let key in attrs) {
       let value = attrs[key];
       if (isSSRUnsafeAttr(key)) {
-        if (isDev28) {
+        if (isDev29) {
           throw qError(32 /* unsafeAttr */, [key]);
         }
         continue;
@@ -36540,7 +37085,7 @@ var SSRContainer = class extends _SharedContainer2 {
       }
       if (tag === "textarea" && key === "value") {
         if (value && typeof value !== "string") {
-          if (isDev28) {
+          if (isDev29) {
             throw qError(23 /* wrongTextareaValue */, [currentFile, value]);
           }
           continue;
@@ -36595,8 +37140,8 @@ function isSSRUnsafeAttr(name) {
   }
   return false;
 }
-function hash2() {
-  return Math.random().toString(36).slice(2);
+function randomStr() {
+  return (Math.random().toString(36) + "000000").slice(2, 8);
 }
 function addPreventDefaultEventToSerializationContext(serializationCtx, key) {
   const eventName = "e" + key.substring(14);
@@ -37030,7 +37575,7 @@ export {
   expectDOM,
   getTestPlatform,
   ssrRenderToDom,
-  trigger2 as trigger,
+  trigger,
   vnode_fromJSX,
   waitForDrain,
   walkJSX