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

package/dist/core.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.29-dev+bc61b71
+ * @qwik.dev/core 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
@@ -13,7 +13,6 @@ import { p } from '@qwik.dev/core/preloader';
 const g = globalThis;
 const qDev = g.qDev !== false;
 const qInspector = g.qInspector === true;
-const qSerialize = g.qSerialize !== false;
 const qDynamicPlatform = g.qDynamicPlatform !== false;
 const qTest = g.qTest === true;
 const qRuntimeQrl = g.qRuntimeQrl === true;
@@ -1007,7 +1006,7 @@ const COMMA = ',';
  *
  * @public
  */
-const version = "2.0.0-beta.29-dev+bc61b71";
+const version = "2.0.0-beta.30-dev+5421ed4";
 
 // keep this import from core/build so the cjs build works
 const createPlatform = () => {
@@ -1876,6 +1875,9 @@ function getEffects$1(effects, prop) {
 const directGetPropsProxyProp = (jsx, prop) => {
     return (jsx.constProps && prop in jsx.constProps ? jsx.constProps[prop] : jsx.varProps[prop]);
 };
+const _getProps = (props, prop) => {
+    return _getVarProps(props)?.[prop] || _getConstProps(props)?.[prop] || null;
+};
 /** Used by the optimizer for spread props operations @internal */
 const _getVarProps = (props) => {
     if (!props) {
@@ -2030,15 +2032,22 @@ const cleanupFn = (target, handleError) => {
                 cleanupFns = [];
                 target.$destroy$ = () => {
                     target.$destroy$ = null;
-                    // TODO handle promises
+                    let cleanupPromises = null;
                     for (const fn of cleanupFns) {
                         try {
-                            fn();
+                            const result = fn();
+                            if (isPromise(result)) {
+                                (cleanupPromises ||= []).push(result.catch(handleError));
+                            }
                         }
                         catch (err) {
                             handleError(err);
                         }
                     }
+                    cleanupFns = null;
+                    if (cleanupPromises?.length) {
+                        return Promise.all(cleanupPromises).then(() => undefined);
+                    }
                 };
             }
             cleanupFns.push(fn);
@@ -2574,11 +2583,7 @@ class SerializerSignalImpl extends ComputedSignalImpl {
             return;
         }
         throwIfQRLNotResolved(this.$computeQrl$);
-        this.$flags$ &= -2 /* SignalFlags.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$;
@@ -2586,6 +2591,8 @@ class SerializerSignalImpl extends ComputedSignalImpl {
             ? update?.(currentValue) || currentValue
             : deserialize(currentValue), this, "." /* EffectProperty.VNODE */, this.$container$);
         this.$didInitialize$ = true;
+        // Needs to invalidate only after all possible Promise throws happened
+        this.$flags$ &= -2 /* SignalFlags.INVALID */;
         // We allow forcing the update of the signal without changing the value, for example when the deserialized value is the same reference as the old value but its internals have changed. In that case we want to trigger effects that depend on this signal, even though the value is the same.
         const didChange = (this.$didInitialize$ && untrackedValue !== 'undefined') ||
             untrackedValue !== this.$untrackedValue$;
@@ -3709,6 +3716,37 @@ const cleanupDestroyable = (destroyable) => {
         destroyable.$destroy$ = null;
     }
 };
+const cleanupAsyncDestroyable = (destroyable, handleError) => {
+    const pendingCleanup = destroyable.$destroyPromise$;
+    if (pendingCleanup) {
+        return pendingCleanup;
+    }
+    const cleanup = destroyable.$destroy$;
+    if (!cleanup) {
+        return;
+    }
+    destroyable.$destroy$ = null;
+    try {
+        const result = cleanup();
+        if (isPromise(result)) {
+            const cleanupPromise = Promise.resolve(result)
+                .then(() => undefined, (err) => {
+                handleError(err);
+            })
+                .finally(() => {
+                if (destroyable.$destroyPromise$ === cleanupPromise) {
+                    destroyable.$destroyPromise$ = undefined;
+                }
+            });
+            destroyable.$destroyPromise$ = cleanupPromise;
+            return cleanupPromise;
+        }
+    }
+    catch (err) {
+        handleError(err);
+    }
+    return;
+};
 
 /**
  * This safely calls an event handler, handling errors and retrying on thrown Promises, and
@@ -3770,13 +3808,20 @@ function _run(event, element) {
     return runEventHandlerQRL(qrlToRun, event, element, ctx);
 }
 
-/**
- * Helper to get the next sibling of a VNode. Extracted to module scope to help V8 inline it
- * reliably.
- */
 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;
+}
 const _hasOwnProperty = Object.prototype.hasOwnProperty;
 /** Helper to set an attribute on a vnode. Extracted to module scope to avoid closure allocation. */
 function setAttribute(journal, vnode, key, value, scopedStyleIdPrefix, originalValue) {
@@ -3798,6 +3843,8 @@ function createDiffContext(container, journal, cursor, scopedStyleIdPrefix) {
         $vParent$: null,
         $vCurrent$: null,
         $vNewNode$: null,
+        $vEnd$: null,
+        $vEndParent$: null,
         $vSiblings$: null,
         $vSiblingsArray$: null,
         $vSideBuffer$: null,
@@ -3819,10 +3866,34 @@ function createDiffContext(container, journal, cursor, scopedStyleIdPrefix) {
         },
     };
 }
-const 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;
+}
+const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleIdPrefix, diffContext) => {
+    return runDiff(getPreparedDiffContext(diffContext, container, journal, cursor, scopedStyleIdPrefix), jsxNode, vStartNode);
+};
+const vnode_diff_range = (container, journal, jsxNode, vParent, vCurrent, vEnd, cursor, scopedStyleIdPrefix, 
+// Allows callers diffing into an empty known-new range to skip keyed-sibling materialization.
+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 result = drainAsyncQueue(diffContext);
     // Cleanup diffContext after completion
     if (isPromise(result)) {
@@ -3833,112 +3904,123 @@ const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyle
     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$;
     isDev && assertFalse(vnode_isVNode(jsxNode), 'JSXNode should not be a VNode');
     isDev && 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 /* VNodeFlags.Deleted */) {
-        // Ignore diff if the parent is deleted.
-        return;
-    }
-    while (diffContext.$stack$.length) {
-        while (diffContext.$jsxIdx$ < diffContext.$jsxCount$) {
-            isDev &&
-                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 &&
-                            _hasOwnProperty.call(diffContext.$jsxValue$.constProps, dangerouslySetInnerHTML)) ||
-                            _hasOwnProperty.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" /* VirtualType.Fragment */, diffContext.$jsxValue$.key);
-                            descend(diffContext, diffContext.$jsxValue$.children, true);
-                        }
-                        else if (type === Slot) {
+    try {
+        if (diffContext.$vParent$.flags & 32 /* VNodeFlags.Deleted */) {
+            // Ignore diff if the parent is deleted.
+            return;
+        }
+        while (diffContext.$stack$.length) {
+            while (diffContext.$jsxIdx$ < diffContext.$jsxCount$) {
+                isDev &&
+                    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)) {
-                                // nothing to project, so try to render the Slot default content.
+                            expectElement(diffContext, diffContext.$jsxValue$, type);
+                            const hasDangerousInnerHTML = (diffContext.$jsxValue$.constProps &&
+                                _hasOwnProperty.call(diffContext.$jsxValue$.constProps, dangerouslySetInnerHTML)) ||
+                                _hasOwnProperty.call(diffContext.$jsxValue$.varProps, dangerouslySetInnerHTML);
+                            if (hasDangerousInnerHTML) {
+                                // Only clean up children for existing nodes; new nodes have no children yet
+                                if (!diffContext.$vNewNode$) {
+                                    expectNoChildren(diffContext, false);
+                                }
+                            }
+                            else {
                                 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 (typeof type === 'function') {
+                            if (type === Fragment) {
+                                expectNoTextNode(diffContext);
+                                expectVirtual(diffContext, "F" /* VirtualType.Fragment */, diffContext.$jsxValue$.key);
+                                descend(diffContext, diffContext.$jsxValue$.children, true);
+                            }
+                            else if (type === Slot) {
+                                expectNoTextNode(diffContext);
+                                if (!expectSlot(diffContext)) {
+                                    // nothing to project, so try to render the Slot default content.
+                                    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 {
+                                // Must be a component
+                                expectNoTextNode(diffContext);
+                                expectComponent(diffContext, type);
+                            }
                         }
-                        else if (type === SSRRaw) {
-                            expectNoMore(diffContext);
+                    }
+                    else if (Array.isArray(diffContext.$jsxValue$)) {
+                        descend(diffContext, diffContext.$jsxValue$, false);
+                    }
+                    else if (isSignal(diffContext.$jsxValue$)) {
+                        expectVirtual(diffContext, "S" /* VirtualType.WrappedSignal */, null);
+                        const unwrappedSignal = diffContext.$jsxValue$ instanceof WrappedSignalImpl
+                            ? diffContext.$jsxValue$.$unwrapIfSignal$()
+                            : diffContext.$jsxValue$;
+                        const signals = diffContext.$vCurrent$?.[_EFFECT_BACK_REF]?.get("." /* EffectProperty.VNODE */)?.backRef;
+                        let hasUnwrappedSignal = signals?.has(unwrappedSignal);
+                        if (signals && unwrappedSignal instanceof WrappedSignalImpl) {
+                            hasUnwrappedSignal = containsWrappedSignal(signals, unwrappedSignal);
                         }
-                        else {
-                            // Must be a component
-                            expectNoTextNode(diffContext);
-                            expectComponent(diffContext, type);
+                        if (!hasUnwrappedSignal) {
+                            const vHost = (diffContext.$vNewNode$ || diffContext.$vCurrent$);
+                            descend(diffContext, resolveSignalAndDescend(diffContext, () => trackSignalAndAssignHost(unwrappedSignal, vHost, "." /* EffectProperty.VNODE */, diffContext.$container$)), true);
                         }
                     }
-                }
-                else if (Array.isArray(diffContext.$jsxValue$)) {
-                    descend(diffContext, diffContext.$jsxValue$, false);
-                }
-                else if (isSignal(diffContext.$jsxValue$)) {
-                    expectVirtual(diffContext, "S" /* VirtualType.WrappedSignal */, null);
-                    const unwrappedSignal = diffContext.$jsxValue$ instanceof WrappedSignalImpl
-                        ? diffContext.$jsxValue$.$unwrapIfSignal$()
-                        : diffContext.$jsxValue$;
-                    const signals = diffContext.$vCurrent$?.[_EFFECT_BACK_REF]?.get("." /* EffectProperty.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, "." /* EffectProperty.VNODE */, diffContext.$container$)), true);
+                    else if (isPromise(diffContext.$jsxValue$)) {
+                        expectVirtual(diffContext, "A" /* VirtualType.Awaited */, null);
+                        diffContext.$asyncQueue$.push(diffContext.$jsxValue$, diffContext.$vNewNode$ || diffContext.$vCurrent$);
                     }
                 }
-                else if (isPromise(diffContext.$jsxValue$)) {
-                    expectVirtual(diffContext, "A" /* VirtualType.Awaited */, null);
-                    diffContext.$asyncQueue$.push(diffContext.$jsxValue$, diffContext.$vNewNode$ || diffContext.$vCurrent$);
+                else if (diffContext.$jsxValue$ === SkipRender) {
+                    // do nothing, we are skipping this node
                 }
+                else {
+                    expectText(diffContext, '');
+                }
+                advance(diffContext);
             }
-            else if (diffContext.$jsxValue$ === SkipRender) ;
-            else {
-                expectText(diffContext, '');
-            }
-            advance(diffContext);
+            expectNoMore(diffContext);
+            cleanupSideBuffer(diffContext);
+            ascend(diffContext);
         }
-        expectNoMore(diffContext);
-        cleanupSideBuffer(diffContext);
-        ascend(diffContext);
+    }
+    finally {
+        diffContext.$isCreationMode$ = previousCreationMode;
     }
 }
 function resolveSignalAndDescend(diffContext, fn) {
@@ -3978,7 +4060,7 @@ function advance(diffContext) {
         diffContext.$vNewNode$ = null;
     }
     else {
-        diffContext.$vCurrent$ = peekNextSibling(diffContext.$vCurrent$);
+        diffContext.$vCurrent$ = peekNextSiblingWithinBoundary(diffContext, diffContext.$vCurrent$);
     }
 }
 /**
@@ -4068,11 +4150,10 @@ 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));
 }
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
@@ -4163,7 +4244,7 @@ function expectSlot(diffContext) {
         vHost && vnode_setProp(vHost, slotNameKey, diffContext.$vNewNode$);
         isDev &&
             vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* VirtualType.Projection */); // Nothing to project, so render content of the slot.
-        vnode_insertBefore(diffContext.$journal$, diffContext.$vParent$, diffContext.$vNewNode$, diffContext.$vCurrent$ && getInsertBefore(diffContext));
+        vnode_insertBefore(diffContext.$journal$, diffContext.$vParent$, diffContext.$vNewNode$, getInsertBefore(diffContext));
         return false;
     }
     else if (vProjectedNode === diffContext.$vCurrent$) ;
@@ -4176,7 +4257,7 @@ function expectSlot(diffContext) {
         isDev &&
             vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* VirtualType.Projection */);
         vnode_inflateProjectionTrailingText(diffContext.$journal$, diffContext.$vNewNode$);
-        vnode_insertBefore(diffContext.$journal$, diffContext.$vParent$, diffContext.$vNewNode$, diffContext.$vCurrent$ && getInsertBefore(diffContext));
+        vnode_insertBefore(diffContext.$journal$, diffContext.$vParent$, diffContext.$vNewNode$, getInsertBefore(diffContext));
         // If we moved from a q:template and it's now empty, remove it
         if (oldParent &&
             vnode_isElementVNode(oldParent) &&
@@ -4258,12 +4339,13 @@ function expectNoChildren(diffContext, removeDOM = true) {
 }
 /** Expect no more nodes - Any nodes which are still at cursor, need to be removed. */
 function expectNoMore(diffContext) {
+    const boundary = getLevelBoundary(diffContext);
     isDev &&
         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$);
                 // If we are diffing projection than the parent is not the parent of the node.
@@ -4276,12 +4358,52 @@ 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 /* QError.invalidRefValue */, [currentFile]);
+}
+function resolveSignalValue(container, vHost, key, signal, subscriptionData) {
+    return retryOnPromise(() => trackSignalAndAssignHost(signal, vHost, key, container, subscriptionData));
+}
+function queueConstAttributePromise(diffContext, element, key, value, isSvg) {
+    const scopedStyleIdPrefix = diffContext.$scopedStyleIdPrefix$;
+    const attributePromise = value.then((resolvedValue) => directSetAttribute(element, key, serializeAttribute(key, resolvedValue, scopedStyleIdPrefix), isSvg));
+    diffContext.$asyncAttributePromises$.push(attributePromise);
+}
+function applyConstInnerHtml(element, value) {
+    if (value) {
+        element.innerHTML = String(value);
+        element.setAttribute(QContainerAttr, "html" /* QContainerValue.HTML */);
+    }
+}
+function applyConstTextareaValue(element, value, currentFile) {
+    if (value && typeof value !== 'string') {
+        if (isDev) {
+            throw qError(23 /* QError.wrongTextareaValue */, [currentFile, value]);
+        }
+        return true;
+    }
+    element.value = escapeHTML(value || '');
+    return true;
+}
 function createNewElement(diffContext, jsx, elementName, currentFile) {
     const element = createElementWithNamespace(diffContext, elementName);
+    const vHost = diffContext.$vNewNode$;
+    const isSvg = (vHost.flags & 512 /* VNodeFlags.NS_svg */) !== 0;
     const { constProps } = jsx;
     if (constProps) {
         // Const props are, well, constant, they will never change!
@@ -4290,54 +4412,29 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
         for (const key in constProps) {
             let value = constProps[key];
             if (isHtmlAttributeAnEventName(key)) {
-                registerEventHandlers(key, value, element, diffContext.$vNewNode$, diffContext);
+                registerEventHandlers(key, value, element, vHost, diffContext);
                 continue;
             }
-            if (key === '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 /* QError.invalidRefValue */, [currentFile]);
-                }
+            if (key === 'ref' && applyRef(value, element, currentFile)) {
+                continue;
             }
             if (isSignal(value)) {
-                const vHost = diffContext.$vNewNode$;
-                const signal = value;
-                value = retryOnPromise(() => trackSignalAndAssignHost(signal, vHost, key, diffContext.$container$, diffContext.$subscriptionData$.$const$));
+                value = resolveSignalValue(diffContext.$container$, diffContext.$vNewNode$, key, value, diffContext.$subscriptionData$.$const$);
             }
             if (isPromise(value)) {
-                const vHost = diffContext.$vNewNode$;
-                const attributePromise = value.then((resolvedValue) => directSetAttribute(element, key, serializeAttribute(key, resolvedValue, diffContext.$scopedStyleIdPrefix$), (vHost.flags & 512 /* VNodeFlags.NS_svg */) !== 0));
-                diffContext.$asyncAttributePromises$.push(attributePromise);
+                queueConstAttributePromise(diffContext, element, key, value, isSvg);
                 continue;
             }
             if (key === dangerouslySetInnerHTML) {
-                if (value) {
-                    element.innerHTML = String(value);
-                    element.setAttribute(QContainerAttr, "html" /* QContainerValue.HTML */);
-                }
+                applyConstInnerHtml(element, value);
                 continue;
             }
-            if (elementName === 'textarea' && key === 'value') {
-                if (value && typeof value !== 'string') {
-                    if (isDev) {
-                        throw qError(23 /* QError.wrongTextareaValue */, [currentFile, value]);
-                    }
-                    continue;
-                }
-                element.value = escapeHTML(value || '');
+            if (elementName === 'textarea' &&
+                key === 'value' &&
+                applyConstTextareaValue(element, value, currentFile)) {
                 continue;
             }
-            directSetAttribute(element, key, serializeAttribute(key, value, diffContext.$scopedStyleIdPrefix$), (diffContext.$vNewNode$.flags & 512 /* VNodeFlags.NS_svg */) !== 0);
+            directSetAttribute(element, key, serializeAttribute(key, value, diffContext.$scopedStyleIdPrefix$), isSvg);
         }
     }
     const key = jsx.key;
@@ -4352,7 +4449,7 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
             element.setAttribute('class', diffContext.$scopedStyleIdPrefix$);
         }
     }
-    vnode_insertElementBefore(diffContext.$journal$, diffContext.$vParent$, diffContext.$vNewNode$, diffContext.$vCurrent$);
+    vnode_insertElementBefore(diffContext.$journal$, diffContext.$vParent$, diffContext.$vNewNode$, getCurrentInsertBefore(diffContext));
 }
 function registerEventHandlers(key, value, element, vnode, diffContext) {
     const scopedKebabName = key.slice(2);
@@ -4374,13 +4471,11 @@ function registerEventHandlers(key, value, element, vnode, diffContext) {
             }
         }
         if (handlers.length > 0) {
-            (element._qDispatch ||= {})[scopedKebabName] = handlers;
+            (element._qDispatch ||= {})[scopedKebabName] = handlers.length === 1 ? handlers[0] : handlers;
         }
     }
     else if (value) {
-        (element._qDispatch ||= {})[scopedKebabName] = [
-            runEventHandlerQRL.bind(null, value),
-        ];
+        (element._qDispatch ||= {})[scopedKebabName] = runEventHandlerQRL.bind(null, value);
     }
     // window and document events need attrs so qwik loader can find them
     // TODO only do these when not already present
@@ -4485,17 +4580,9 @@ const 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 /* QError.invalidRefValue */, [currentFile]);
-        }
     }
     const currentEffect = vnode[_EFFECT_BACK_REF]?.get(key);
     if (isSignal(value)) {
@@ -4507,7 +4594,7 @@ const 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) {
@@ -4548,8 +4635,9 @@ function retrieveChildWithKey(diffContext, nodeName, key) {
         // it is not materialized; so materialize it.
         diffContext.$vSiblings$ = 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$);
@@ -4608,8 +4696,9 @@ function collectSideBufferSiblings(diffContext, targetNode) {
         return;
     }
     // Walk from vCurrent up to the target node and collect all keyed siblings
+    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$);
@@ -4652,7 +4741,7 @@ function moveOrCreateKeyedNode(diffContext, nodeName, lookupKey, sideBufferKey,
     diffContext.$vNewNode$ = retrieveChildWithKey(diffContext, nodeName, lookupKey);
     if (diffContext.$vNewNode$) {
         if (!sideBufferKey) {
-            vnode_insertBefore(diffContext.$journal$, parentForInsert, diffContext.$vNewNode$, diffContext.$vCurrent$);
+            vnode_insertBefore(diffContext.$journal$, parentForInsert, diffContext.$vNewNode$, getCurrentInsertBefore(diffContext));
         }
         diffContext.$vCurrent$ = diffContext.$vNewNode$;
         diffContext.$vNewNode$ = null;
@@ -4679,7 +4768,7 @@ function moveOrCreateKeyedNode(diffContext, nodeName, lookupKey, sideBufferKey,
             }
             // Only move if the node is not already in the correct position
             if (buffered !== diffContext.$vCurrent$) {
-                vnode_insertBefore(diffContext.$journal$, parentForInsert, buffered, diffContext.$vCurrent$);
+                vnode_insertBefore(diffContext.$journal$, parentForInsert, buffered, getCurrentInsertBefore(diffContext));
             }
             diffContext.$vCurrent$ = buffered;
             diffContext.$vNewNode$ = null;
@@ -4701,13 +4790,13 @@ function expectVirtual(diffContext, type, jsxKey) {
     }
     // For fragments without a key, always create a new virtual node (ensures rerender semantics)
     if (jsxKey === null || diffContext.$isCreationMode$) {
-        vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), diffContext.$vCurrent$ && getInsertBefore(diffContext));
+        vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), getInsertBefore(diffContext));
         diffContext.$vNewNode$.key = jsxKey;
         isDev && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, type);
         return;
     }
     if (moveOrCreateKeyedNode(diffContext, null, jsxKey, getSideBufferKey(null, jsxKey), diffContext.$vParent$, true)) {
-        vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), diffContext.$vCurrent$ && getInsertBefore(diffContext));
+        vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), getInsertBefore(diffContext));
         diffContext.$vNewNode$.key = jsxKey;
         isDev && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, type);
     }
@@ -4809,7 +4898,7 @@ function insertNewComponent(diffContext, host, componentQRL, jsxProps) {
     if (host) {
         clearAllEffects(diffContext.$container$, host);
     }
-    vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), diffContext.$vCurrent$ && getInsertBefore(diffContext));
+    vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), getInsertBefore(diffContext));
     const jsxNode = diffContext.$jsxValue$;
     isDev && vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "C" /* VirtualType.Component */);
     vnode_setProp(diffContext.$vNewNode$, OnRenderProp, componentQRL);
@@ -4817,7 +4906,7 @@ function insertNewComponent(diffContext, host, componentQRL, jsxProps) {
     diffContext.$vNewNode$.key = jsxNode.key;
 }
 function insertNewInlineComponent(diffContext) {
-    vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), diffContext.$vCurrent$ && getInsertBefore(diffContext));
+    vnode_insertVirtualBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newVirtual()), getInsertBefore(diffContext));
     const jsxNode = diffContext.$jsxValue$;
     isDev &&
         vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "I" /* VirtualType.InlineComponent */);
@@ -4837,7 +4926,7 @@ function expectText(diffContext, text) {
             return;
         }
     }
-    vnode_insertElementBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newText((import.meta.env.TEST ? diffContext.$container$.document : document).createTextNode(text), text)), diffContext.$vCurrent$);
+    vnode_insertElementBefore(diffContext.$journal$, diffContext.$vParent$, (diffContext.$vNewNode$ = vnode_newText((import.meta.env.TEST ? diffContext.$container$.document : document).createTextNode(text), text)), getCurrentInsertBefore(diffContext));
 }
 /**
  * Retrieve the key from the VNode.
@@ -5160,6 +5249,221 @@ function containsWrappedSignal(data, signal) {
     return false;
 }
 
+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 jsx = renderItem(item, index);
+    if (isDev && !isJSXNode(jsx)) {
+        throw new Error('Each item$ must return a single JSX node');
+    }
+    jsx.key = key;
+    return jsx;
+}
+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] ??= 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] ??= 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 anchor = suffixAnchor;
+        return vnode_diff_range(clientContainer, journal, buildJsxRange(items, nextKeys, keyOf, renderItem, start, nextEnd), parent, anchor, anchor, cursor, null, true, diffContext);
+    }
+    for (let i = start; i <= nextEnd; i++) {
+        nextKeys[i] ??= keyOf(items[i], i);
+    }
+    const middleLength = nextEnd - start + 1;
+    const nextIndexByKey = new Map();
+    for (let i = start; i <= nextEnd; i++) {
+        nextIndexByKey.set(nextKeys[i], i - start);
+    }
+    const prev = collectChildren(oldStart, oldEnd);
+    const survivors = [];
+    const prevRelIndexByKey = 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 !== undefined) {
+            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 result = vnode_diff_range(clientContainer, journal, buildJsxRange(items, nextKeys, null, renderItem, blockStart, index), parent, anchor, anchor, cursor, null, true, diffContext);
+            return maybeThen(result, () => {
+                const firstInserted = firstInsertedBeforeAnchor(parent, anchor, blockLength);
+                if (isDev && !firstInserted) {
+                    throw new Error('Failed to insert keyed loop block');
+                }
+                anchor = firstInserted;
+                index = blockStart - 1;
+                return resume();
+            });
+        }
+    };
+    return resume();
+}
+
 /**
  * Executes tasks for a vNode if the TASKS dirty bit is set. Tasks are stored in the ELEMENT_SEQ
  * property and executed in order.
@@ -5232,6 +5536,8 @@ function executeNodeDiff(vNode, container, journal, cursor) {
     if (!jsx) {
         return;
     }
+    // cleanup payload
+    setNodeDiffPayload(vNode, null);
     if (isSignal(jsx)) {
         jsx = jsx.value;
     }
@@ -5392,6 +5698,35 @@ function executeCompute(vNode, container) {
         }
     });
 }
+/**
+ * Executes a reconcile chore for a vNode if the RECONCILE dirty bit is set. This handles the
+ * reconciliation of a keyed loop.
+ *
+ * @param container - The container
+ * @param journal - The journal
+ * @param vNode - The vNode
+ * @returns Promise if reconcile is async, void otherwise
+ */
+function executeReconcile(vNode, container, journal, cursor) {
+    vNode.dirty &= -129 /* ChoreBits.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 !== undefined && itemFn !== undefined) {
+        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)));
+}
 
 /**
  * Executes the flush phase for a cursor.
@@ -5698,7 +6033,7 @@ function walkCursor(cursor, options) {
             return;
         }
         // Skip if the vNode is not dirty
-        if (!(currentVNode.dirty & 127 /* ChoreBits.DIRTY_MASK */)) {
+        if (!(currentVNode.dirty & 255 /* ChoreBits.DIRTY_MASK */)) {
             // Move to next node
             setCursorPosition(container, cursorData, getNextVNode(currentVNode, cursor));
             continue;
@@ -5717,7 +6052,7 @@ function walkCursor(cursor, options) {
                 }
             }
             // Clear dirty bits and move to next node
-            currentVNode.dirty &= -128 /* ChoreBits.DIRTY_MASK */;
+            currentVNode.dirty &= -256 /* ChoreBits.DIRTY_MASK */;
             setCursorPosition(container, cursorData, getNextVNode(currentVNode, cursor));
             continue;
         }
@@ -5733,6 +6068,9 @@ function walkCursor(cursor, options) {
             else if (currentVNode.dirty & 4 /* ChoreBits.COMPONENT */) {
                 result = executeComponentChore(currentVNode, container, journal, cursor);
             }
+            else if (currentVNode.dirty & 128 /* ChoreBits.RECONCILE */) {
+                result = executeReconcile(currentVNode, container, journal, cursor);
+            }
             else if (currentVNode.dirty & 8 /* ChoreBits.NODE_PROPS */) {
                 executeNodeProps(currentVNode, journal);
             }
@@ -5778,11 +6116,11 @@ function walkCursor(cursor, options) {
         }
     }
     isDev &&
-        assertFalse(!!(cursor.dirty & 127 /* ChoreBits.DIRTY_MASK */ && !cursorData.position), 'Cursor is still dirty and position is not set after walking');
+        assertFalse(!!(cursor.dirty & 255 /* ChoreBits.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, isServer) {
-    if (!(cursor.dirty & 127 /* ChoreBits.DIRTY_MASK */)) {
+    if (!(cursor.dirty & 255 /* ChoreBits.DIRTY_MASK */)) {
         removeCursorFromQueue(cursor, container);
         if (!isServer) {
             executeFlushPhase(cursor, container);
@@ -5854,7 +6192,7 @@ function partitionDirtyChildren(dirtyChildren, parent) {
 /** @returns Next vNode to process, or null if traversal is complete */
 function getNextVNode(vNode, cursor) {
     if (vNode === cursor) {
-        if (cursor.dirty & 127 /* ChoreBits.DIRTY_MASK */) {
+        if (cursor.dirty & 255 /* ChoreBits.DIRTY_MASK */) {
             return cursor;
         }
         return null;
@@ -5868,7 +6206,7 @@ function getNextVNode(vNode, cursor) {
         parent = vNode.parent;
     }
     if (!parent) {
-        if (cursor.dirty & 127 /* ChoreBits.DIRTY_MASK */) {
+        if (cursor.dirty & 255 /* ChoreBits.DIRTY_MASK */) {
             return cursor;
         }
         return null;
@@ -5879,7 +6217,7 @@ function getNextVNode(vNode, cursor) {
     let count = len;
     while (count-- > 0) {
         const nextVNode = dirtyChildren[index];
-        if (nextVNode.dirty & 127 /* ChoreBits.DIRTY_MASK */) {
+        if (nextVNode.dirty & 255 /* ChoreBits.DIRTY_MASK */) {
             parent.nextDirtyChildIndex = (index + 1) % len;
             return nextVNode;
         }
@@ -5955,7 +6293,7 @@ function _executeSsrChores(container, ssrNode) {
         if (ssrNode.dirty & 16 /* ChoreBits.COMPUTE */) {
             executeCompute(ssrNode, container);
         }
-        if (ssrNode.dirty & 127 /* ChoreBits.DIRTY_MASK */) {
+        if (ssrNode.dirty & 255 /* ChoreBits.DIRTY_MASK */) {
             // We are running on the server.
             // On server we can't schedule task for a different host!
             // Server is SSR, and therefore scheduling for anything but the current host
@@ -5970,7 +6308,7 @@ function _executeSsrChores(container, ssrNode) {
         This is often caused by modifying a signal in an already rendered component during SSR.`;
             logWarn(warningMessage);
         }
-        ssrNode.dirty &= -128 /* ChoreBits.DIRTY_MASK */;
+        ssrNode.dirty &= -256 /* ChoreBits.DIRTY_MASK */;
         return;
     }
     let promise = null;
@@ -5980,13 +6318,17 @@ function _executeSsrChores(container, ssrNode) {
             promise = result;
         }
     }
+    if (ssrNode.dirty & 128 /* ChoreBits.RECONCILE */) {
+        const result = executeReconcileChore(container, ssrNode);
+        promise = promise ? promise.then(() => result) : result;
+    }
     // In SSR, we don't handle the COMPONENT bit here.
     // During initial render, if a task completes and marks the component dirty,
     // we want to leave the COMPONENT bit set so that executeComponent can detect
     // it after $waitOn$ completes and re-execute the component function.
     // executeComponent will clear the bit after re-executing.
     // Clear all dirty bits EXCEPT COMPONENT
-    ssrNode.dirty &= -124;
+    ssrNode.dirty &= -252;
     if (promise) {
         return promise;
     }
@@ -6028,6 +6370,32 @@ function executeNodePropChore(container, ssrNode) {
         container.addBackpatchEntry(ssrNode.id, property, serializedValue);
     }
 }
+async function executeReconcileChore(container, ssrNode) {
+    ssrNode.dirty &= -129 /* ChoreBits.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 jsx = itemFn(item, i);
+        const key = keyOf(item, i);
+        jsx.key = key;
+        children.push(jsx);
+    }
+    await container.renderJSX(children, {
+        currentStyleScoped: null,
+        parentComponentFrame: container.getComponentFrame(0),
+    });
+}
 
 /** Reusable path array to avoid allocations */
 const reusablePath = [];
@@ -6051,7 +6419,7 @@ function propagateToCursorRoot(vNode, cursorRoot) {
     reusablePath.push(vNode);
     let current = vNode.slotParent || vNode.parent;
     while (current) {
-        const isDirty = current.dirty & 127 /* ChoreBits.DIRTY_MASK */;
+        const isDirty = current.dirty & 255 /* ChoreBits.DIRTY_MASK */;
         const currentIsCursor = isCursor(current);
         // Stop when we reach the cursor root or a dirty ancestor
         if (current === cursorRoot || isDirty) {
@@ -6123,9 +6491,9 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
         }
         return;
     }
-    const isRealDirty = bits & 127 /* ChoreBits.DIRTY_MASK */;
+    const isRealDirty = bits & 255 /* ChoreBits.DIRTY_MASK */;
     // If already dirty, no need to propagate again
-    if ((isRealDirty ? prevDirty & 127 /* ChoreBits.DIRTY_MASK */ : prevDirty) || vNode === cursorRoot) {
+    if ((isRealDirty ? prevDirty & 255 /* ChoreBits.DIRTY_MASK */ : prevDirty) || vNode === cursorRoot) {
         return;
     }
     const parent = vNode.slotParent || vNode.parent;
@@ -6135,7 +6503,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
         return;
     }
     // We must attach to a cursor subtree if it exists
-    if (parent && parent.dirty & 127 /* ChoreBits.DIRTY_MASK */) {
+    if (parent && parent.dirty & 255 /* ChoreBits.DIRTY_MASK */) {
         if (isRealDirty) {
             parent.dirty |= 32 /* ChoreBits.CHILDREN */;
         }
@@ -6516,16 +6884,26 @@ const vnode_ensureElementInflated = (container, vnode) => {
         }
     }
 };
+const 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);
+    const handlers = [];
+    for (let i = 0; i < qrls.length; i++) {
+        const handler = unwrapEventHandlerQrl(parseQRL(qrls[i], container));
         // These QRLs are mostly _run and _task and don't need wrapping with retryOnPromise
-        return handler;
-    });
-    (element._qDispatch ||= {})[scopedKebabName] = handlers;
+        handlers.push(runEventHandlerQRL.bind(null, handler));
+    }
+    (element._qDispatch ||= {})[scopedKebabName] = handlers.length === 1 ? handlers[0] : handlers;
 }
 /** Walks the direct children of a parent node and calls the callback for each child. */
 function vnode_walkDirectChildren(journal, vParent, callback) {
@@ -7204,9 +7582,17 @@ const vnode_truncate = (journal, vParent, vDelete, removeDOM = true) => {
             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;
@@ -8198,7 +8584,7 @@ const useSequentialScope = () => {
         seq.push(undefined);
     }
     const set = (value) => {
-        if (qDev && qSerialize) {
+        if (qDev) {
             verifySerializable(value);
         }
         return (seq[seqIdx] = value);
@@ -8335,7 +8721,7 @@ const useContextProvider = (context, newValue) => {
     if (qDev) {
         validateContext(context);
     }
-    if (qDev && qSerialize) {
+    if (qDev) {
         verifySerializable(newValue);
     }
     iCtx.$container$.setContext(iCtx.$hostElement$, context, newValue);
@@ -8756,13 +9142,6 @@ function retrieveVNodeOrDocument(container, value) {
         : container.element?.ownerDocument;
 }
 
-// https://regexr.com/68v72
-// @ts-expect-error this is a valid regex
-const EXTRACT_IMPORT_PATH = /\(\s*(['"])([^\1]+)\1\s*\)/;
-// https://regexr.com/690ds
-const EXTRACT_SELF_IMPORT = /Promise\s*\.\s*resolve/;
-// https://regexr.com/6a83h
-const EXTRACT_FILE_NAME = /[\\/(]([\w\d.\-_]+\.(js|ts)x?):/;
 // <docs markdown="../../readme.md#qrl">
 // !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
 // (edit ../../readme.md#qrl instead and run `pnpm docs.sync`)
@@ -8784,29 +9163,6 @@ const qrl = (chunkOrFn, symbol, lexicalScopeCapture, stackOffset = 0) => {
     let symbolFn = null;
     if (isFunction(chunkOrFn)) {
         symbolFn = chunkOrFn;
-        if (qSerialize) {
-            let match;
-            const srcCode = String(chunkOrFn);
-            if ((match = srcCode.match(EXTRACT_IMPORT_PATH)) && match[2]) {
-                chunk = match[2];
-            }
-            else if ((match = srcCode.match(EXTRACT_SELF_IMPORT))) {
-                const ref = 'QWIK-SELF';
-                const frames = new Error(ref).stack.split('\n');
-                const start = frames.findIndex((f) => f.includes(ref));
-                const frame = frames[start + 2 + stackOffset];
-                match = frame.match(EXTRACT_FILE_NAME);
-                if (!match) {
-                    chunk = 'main';
-                }
-                else {
-                    chunk = match[1];
-                }
-            }
-            else {
-                throw qError(6 /* QError.dynamicImportFailed */, [srcCode]);
-            }
-        }
     }
     else if (isString(chunkOrFn)) {
         chunk = chunkOrFn;
@@ -10450,9 +10806,7 @@ const _hmr = (event, element) => {
     // Maybe we should use a qrl registry to invalidate all QRLs from a parent?
     const qrl = container.getHostProp(host, OnRenderProp);
     if (qrl) {
-        // This code is highly coupled to the internal implementation of QRL
-        const instance = qrl.__proto__;
-        const lazy = instance.$lazy$;
+        const lazy = qrl.$lazy$;
         const chunk = lazy.$chunk$;
         if (chunk) {
             /**
@@ -10462,7 +10816,7 @@ const _hmr = (event, element) => {
             const bustUrl = chunk.split('?')[0] + '?t=' + Date.now();
             lazy.$chunk$ = bustUrl;
             lazy.$ref$ = undefined;
-            instance.resolved = undefined;
+            qrl.resolved = undefined;
             // Force rerender
             markVNodeDirty(container, host, 4 /* ChoreBits.COMPONENT */);
         }
@@ -11345,6 +11699,7 @@ class DomContainer extends _SharedContainer {
         this.$setServerData$();
         element.setAttribute(QContainerAttr, "resumed" /* QContainerValue.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];
@@ -11357,6 +11712,19 @@ class DomContainer 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$ = () => undefined;
+        const el = this.element;
+        el.qContainer = undefined;
+        el.qVnodeData = undefined;
+        el.qVNodeRefs = undefined;
+        el.removeAttribute(QContainerAttr);
+        el.ownerDocument.qVNodeData = undefined;
+    }
     /**
      * The first time we render we need to hoist the styles. (Meaning we need to move all styles from
      * component inline to <head>)
@@ -11562,23 +11930,45 @@ const useTaskQrl = (qrl, opts) => {
     }
 };
 const runTask = (task, container, host) => {
+    const pendingTask = task.$taskPromise$;
+    if (pendingTask) {
+        return pendingTask;
+    }
     task.$flags$ &= -5 /* TaskFlags.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 [cleanup] = cleanupFn(task, (reason) => container.handleError(reason, host));
-    const taskApi = { track, cleanup };
-    return safeCall(() => taskFn(taskApi), cleanup, (err) => {
-        // If a Promise is thrown, that means we need to re-run the task.
-        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 result = 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 [cleanup] = cleanupFn(task, handleError);
+        const taskApi = { track, cleanup };
+        return safeCall(() => taskFn(taskApi), cleanup, (err) => {
+            // If a Promise is thrown, that means we need to re-run the task.
+            if (isPromise(err)) {
+                return err.then(() => {
+                    if (task.$taskPromise$ === taskPromise) {
+                        task.$taskPromise$ = null;
+                    }
+                    return runTask(task, container, host);
+                });
+            }
+            else {
+                handleError(err);
+            }
+        });
     });
+    if (isPromise(result)) {
+        taskPromise = result.finally(() => {
+            if (task.$taskPromise$ === taskPromise) {
+                task.$taskPromise$ = null;
+            }
+        });
+        task.$taskPromise$ = taskPromise;
+        return taskPromise;
+    }
+    return result;
 };
 class Task extends BackRef {
     $flags$;
@@ -11587,6 +11977,8 @@ class Task extends BackRef {
     $qrl$;
     $state$;
     $destroy$;
+    $destroyPromise$;
+    $taskPromise$ = null;
     constructor($flags$, $index$, $el$, $qrl$, $state$, $destroy$) {
         super();
         this.$flags$ = $flags$;
@@ -11707,8 +12099,8 @@ const 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]);
         }
     }
 };
@@ -12613,37 +13005,26 @@ class LazyRef {
         return this.$ref$;
     }
 }
+const QRL_STATE = Symbol('qrl-state');
 /**
- * When a method is called on the qrlFn wrapper function, `this` is the function, not the QRLClass
- * instance that holds the data. This helper returns the actual instance by checking whether `this`
- * owns `resolved` (always set on the instance).
+ * QRL methods may run with `this` set either to the callable wrapper or directly to the backing
+ * state object. This helper normalizes both cases to the shared backing state.
  */
 const getInstance = (instance) => {
-    return Object.prototype.hasOwnProperty.call(instance, 'resolved')
-        ? instance
-        : Object.getPrototypeOf(instance);
+    return instance?.[QRL_STATE] ?? instance;
 };
 /**
- * We use a class here to avoid copying all the methods for every QRL instance. The QRL itself is a
- * function that calls the internal $callFn$ method, and we set the prototype to the class instance
- * so it has access to all the properties and methods. That's why we need to extend Function, so
- * that `.apply()` etc work.
- *
- * So a QRL is a function that has a prototype of a QRLClass instance. This is unconventional, but
- * it allows us to have a callable QRL that is also a class.
- *
- * Note the use of getInstance everywhere when writing to `this`. If you write to `this` directly,
- * it will be stored on the function itself, and we don't want that because the QRLClass instance
- * doesn't have access to it, and it uses more memory.
+ * QRL state lives in a plain object. The callable wrapper stores that state under a symbol and uses
+ * a shared prototype derived from Function.prototype for methods/getters. This keeps QRLs callable
+ * without using a unique state object as each function's prototype.
  */
-class QRLClass extends Function {
+class QRLClass {
     $lazy$;
     resolved = undefined;
     // This is defined or undefined for the lifetime of the QRL, so we set it lazily
     $captures$;
     $container$;
     constructor($lazy$, $captures$, container) {
-        super();
         this.$lazy$ = $lazy$;
         if ($captures$) {
             this.$captures$ = $captures$;
@@ -12662,76 +13043,140 @@ class QRLClass extends Function {
         // If it is plain value with deserialized or missing captures, resolve it immediately
         // Otherwise we keep using the async path so we can wait for qrls to load
         if ($lazy$.$ref$ != null && typeof this.$captures$ !== 'string' && !isPromise($lazy$.$ref$)) {
-            // we can pass this instead of using getInstance because we know we are not the qrlFn
             this.resolved = bindCaptures(this, $lazy$.$ref$);
         }
     }
-    w(captures) {
-        const newQrl = new QRLClass(this.$lazy$, captures, this.$captures$ ? this.$container$ : undefined);
-        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;
+}
+const 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);
+    // Not resolved yet: we'll return a promise
+    // grab the context while we are sync
+    const ctx = tryGetInvokeContext();
+    return qrlResolve
+        .call(qrl, ctx?.$container$)
+        .then(() => invokeApply.call(withThis, ctx, qrl.resolved, args));
+};
+const qrlWithCaptures = function (captures) {
+    const qrl = getInstance(this);
+    const newQrl = new QRLClass(qrl.$lazy$, captures, qrl.$captures$ ? qrl.$container$ : undefined);
+    return makeQrlFn(newQrl);
+};
+const qrlSetRef = function (ref) {
+    const qrl = getInstance(this);
+    qrl.$lazy$.$setRef$(ref);
+    qrl.resolved = bindCaptures(qrl, ref);
+};
+const qrlResolve = async function (container) {
+    const qrl = getInstance(this);
+    return maybeThen($resolve$(qrl, container), () => qrl.resolved);
+};
+const qrlGetSymbol = function () {
+    return getInstance(this).$lazy$.$symbol$;
+};
+const qrlGetHash = function () {
+    return getInstance(this).$lazy$.$hash$;
+};
+const qrlGetCaptured = function () {
+    const qrl = getInstance(this);
+    ensureQrlCaptures(qrl);
+    return qrl.$captures$;
+};
+const 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 /* QError.qrlIsNotFunction */);
+                }
+                return bound(...args);
+            });
         }
-        // Not resolved yet: we'll return a promise
-        // grab the context while we are sync
-        const ctx = tryGetInvokeContext();
-        return this.resolve(ctx?.$container$).then(() => invokeApply.call(withThis, ctx, this.resolved, args));
-    }
-    async resolve(container) {
-        // We need to write to the QRLClass instance, not the function
-        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 /* QError.qrlIsNotFunction */);
-                    }
-                    return bound(...args);
-                });
-            }
-            if (beforeFn && beforeFn() === false) {
-                return undefined;
-            }
-            return invokeApply(currentCtx, qrl.resolved, args);
-        };
-        return bound;
-    }
-}
+        if (beforeFn && beforeFn() === false) {
+            return undefined;
+        }
+        return invokeApply(currentCtx, qrl.resolved, args);
+    };
+    return bound;
+};
+const 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,
+    },
+});
 /**
  * The current captured scope during QRL invocation. This is used to provide the lexical scope for
  * QRL functions. It is used one time per invocation, synchronously, so it is safe to store it in
@@ -12829,12 +13274,12 @@ const createQRL = (chunk, symbol, symbolRef, symbolFn, captures, container) => {
     return makeQrlFn(qrl);
 };
 const makeQrlFn = (qrl) => {
-    // The QRL has to be callable, so we create a function that calls the internal $callFn$
+    // The QRL has to be callable, so we create a function and attach the per-instance state to it.
     const qrlFn = async function (...args) {
-        return qrl.$callFn$(this, ...args);
+        return qrlCallFn.call(qrlFn, this, ...args);
     };
-    // ...and set the prototype to the QRL instance so it has all the properties and methods without copying them
-    Object.setPrototypeOf(qrlFn, qrl);
+    qrlFn[QRL_STATE] = qrl;
+    Object.setPrototypeOf(qrlFn, QRL_FUNCTION_PROTO);
     return qrlFn;
 };
 const EMITTED = /*#__PURE__*/ new Set();
@@ -14046,6 +14491,31 @@ const useErrorBoundary = () => {
     return error;
 };
 
+/** @internal */
+const eachCmpTask = async ({ track }) => {
+    const props = _captures[0];
+    track(() => props.items);
+    const context = tryGetInvokeContext();
+    const host = context.$hostElement$;
+    const container = context.$container$;
+    markVNodeDirty(container, host, 128 /* ChoreBits.RECONCILE */);
+    const isSsr = import.meta.env.TEST ? isServerPlatform() : isServer;
+    if (isSsr) {
+        await container.$renderPromise$;
+    }
+};
+/** @internal */
+const eachCmp = (props) => {
+    if (!__EXPERIMENTAL__.each) {
+        throw new Error('Each is experimental and must be enabled with `experimental: ["each"]` in the `qwikVite` plugin.');
+    }
+    useTaskQrl(/*#__PURE__*/ inlinedQrl(eachCmpTask, '_eaT', [props]));
+    return SkipRender;
+};
+/** @public @experimental */
+const Each = /*#__PURE__*/ componentQrl(
+/*#__PURE__*/ inlinedQrl(eachCmp, '_eaC'));
+
 // keep this import from core/build so the cjs build works
 /**
  * @deprecated This is no longer needed as the preloading happens automatically in qrl-class.ts.
@@ -14140,5 +14610,5 @@ if (import.meta.hot) {
     });
 }
 
-export { $, Fragment, NoSerializeSymbol, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SerializerSymbol, SkipRender, Slot, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, EMPTY_ARRAY as _EMPTY_ARRAY, EMPTY_OBJ as _EMPTY_OBJ, _IMMUTABLE, _SharedContainer, SubscriptionData as _SubscriptionData, _UNINITIALIZED, _VAR_PROPS, _addProjection, _captures, _chk, createQRL as _createQRL, _deserialize, _dumpState, _executeSsrChores, _fnSignal, _getConstProps, _getContextContainer, _getContextEvent, _getContextHostElement, getDomContainer as _getDomContainer, _getQContainerElement, _getVarProps, _hasStoreEffects, _hmr, isJSXNode as _isJSXNode, isStore as _isStore, isStringifiable as _isStringifiable, isTask as _isTask, _jsxBranch, _jsxC, _jsxQ, _jsxS, _jsxSorted, _jsxSplit, mapApp_findIndx as _mapApp_findIndx, mapArray_get as _mapArray_get, mapArray_set as _mapArray_set, _noopQrl, _noopQrlDEV, preprocessState as _preprocessState, _qrlSync, qrlToString as _qrlToString, _regSymbol, _removeProjection, _res, _resolveContextWithoutSequentialScope, _restProps, _rsc, _run, _serialize, setEvent as _setEvent, _setProjectionTarget, scheduleTask as _task, _updateProjectionProps, _useHmr, _val, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getFirstChild as _vnode_getFirstChild, vnode_isMaterialized as _vnode_isMaterialized, vnode_isTextVNode as _vnode_isTextVNode, vnode_isVirtualVNode as _vnode_isVirtualVNode, vnode_toString as _vnode_toString, _waitUntilRendered, _walkJSX, _wrapProp, _wrapSignal, component$, componentQrl, createAsync$, createAsyncSignal as createAsyncQrl, createComputed$, createComputedSignal as createComputedQrl, createContextId, h as createElement, createSerializer$, createSerializerSignal as createSerializerQrl, createSignal, event$, eventQrl, forceStoreEffects, getDomContainer, getLocale, getPlatform, h, implicit$FirstArg, inlinedQrl, inlinedQrlDEV, isSignal, jsx, jsxDEV, jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useAsync$, useAsyncQrl, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, useErrorBoundary, useId, useLexicalScope, useOn, useOnDocument, useOnWindow, useResource$, useResourceQrl, useSerializer$, useSerializerQrl, useServerData, useSignal, useStore, useStyles$, useStylesQrl, useStylesScoped$, useStylesScopedQrl, useTask$, useTaskQrl, useVisibleTask$, useVisibleTaskQrl, version, withLocale };
+export { $, Each, Fragment, NoSerializeSymbol, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SerializerSymbol, SkipRender, Slot, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, EMPTY_ARRAY as _EMPTY_ARRAY, EMPTY_OBJ as _EMPTY_OBJ, _IMMUTABLE, _SharedContainer, SubscriptionData as _SubscriptionData, _UNINITIALIZED, _VAR_PROPS, _addProjection, _captures, _chk, createQRL as _createQRL, _deserialize, _dumpState, eachCmp as _eaC, eachCmpTask as _eaT, _executeSsrChores, _fnSignal, _getConstProps, _getContextContainer, _getContextEvent, _getContextHostElement, getDomContainer as _getDomContainer, _getQContainerElement, _getVarProps, _hasStoreEffects, _hmr, isJSXNode as _isJSXNode, isStore as _isStore, isStringifiable as _isStringifiable, isTask as _isTask, _jsxBranch, _jsxC, _jsxQ, _jsxS, _jsxSorted, _jsxSplit, mapApp_findIndx as _mapApp_findIndx, mapArray_get as _mapArray_get, mapArray_set as _mapArray_set, _noopQrl, _noopQrlDEV, preprocessState as _preprocessState, _qrlSync, qrlToString as _qrlToString, _regSymbol, _removeProjection, _res, _resolveContextWithoutSequentialScope, _restProps, _rsc, _run, _serialize, setEvent as _setEvent, _setProjectionTarget, scheduleTask as _task, _updateProjectionProps, _useHmr, _val, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getFirstChild as _vnode_getFirstChild, vnode_isMaterialized as _vnode_isMaterialized, vnode_isTextVNode as _vnode_isTextVNode, vnode_isVirtualVNode as _vnode_isVirtualVNode, vnode_toString as _vnode_toString, _waitUntilRendered, _walkJSX, _wrapProp, _wrapSignal, component$, componentQrl, createAsync$, createAsyncSignal as createAsyncQrl, createComputed$, createComputedSignal as createComputedQrl, createContextId, h as createElement, createSerializer$, createSerializerSignal as createSerializerQrl, createSignal, event$, eventQrl, forceStoreEffects, getDomContainer, getLocale, getPlatform, h, implicit$FirstArg, inlinedQrl, inlinedQrlDEV, isSignal, jsx, jsxDEV, jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useAsync$, useAsyncQrl, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, useErrorBoundary, useId, useLexicalScope, useOn, useOnDocument, useOnWindow, useResource$, useResourceQrl, useSerializer$, useSerializerQrl, useServerData, useSignal, useStore, useStyles$, useStylesQrl, useStylesScoped$, useStylesScopedQrl, useTask$, useTaskQrl, useVisibleTask$, useVisibleTaskQrl, version, withLocale };
 //# sourceMappingURL=core.mjs.map