@qwik.dev/core 2.0.0-alpha.4 → 2.0.0-alpha.6

package/dist/core.prod.cjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-alpha.4-dev+374e0d6
+ * @qwik.dev/core 2.0.0-alpha.6-dev+d848ba5
  * 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
@@ -64,15 +64,41 @@
         QError[QError.serializeErrorMissingChunk = 39] = "serializeErrorMissingChunk", QError[QError.wrongTextareaValue = 40] = "wrongTextareaValue", 
         QError[QError.containerNotFound = 41] = "containerNotFound", QError[QError.elementWithoutContainer = 42] = "elementWithoutContainer", 
         QError[QError.invalidVNodeType = 43] = "invalidVNodeType", QError[QError.materializeVNodeDataError = 44] = "materializeVNodeDataError", 
-        QError[QError.serverHostMismatch = 45] = "serverHostMismatch", QError[QError.cannotCoerceSignal = 46] = "cannotCoerceSignal", 
-        QError[QError.computedNotSync = 47] = "computedNotSync", QError[QError.computedReadOnly = 48] = "computedReadOnly", 
-        QError[QError.wrappedReadOnly = 49] = "wrappedReadOnly", QError[QError.promisesNotExpected = 50] = "promisesNotExpected", 
-        QError[QError.unsafeAttr = 51] = "unsafeAttr";
+        QError[QError.cannotCoerceSignal = 45] = "cannotCoerceSignal", QError[QError.computedNotSync = 46] = "computedNotSync", 
+        QError[QError.computedReadOnly = 47] = "computedReadOnly", QError[QError.wrappedReadOnly = 48] = "wrappedReadOnly", 
+        QError[QError.promisesNotExpected = 49] = "promisesNotExpected", QError[QError.unsafeAttr = 50] = "unsafeAttr";
     }(QError || (QError = {}));
     const qError = (code, errorMessageArgs = []) => {
         const text = (code => `Code(Q${code}) https://github.com/QwikDev/qwik/blob/main/packages/qwik/src/core/error/error.ts#L${8 + code}`)(code, ...errorMessageArgs);
         return ((message, ...optionalParams) => createAndLogError(!0, message, ...optionalParams))(text, ...errorMessageArgs);
     };
+    var VirtualType;
+    !function(VirtualType) {
+        VirtualType.Virtual = "V", VirtualType.Fragment = "F", VirtualType.WrappedSignal = "S", 
+        VirtualType.Awaited = "A", VirtualType.Component = "C", VirtualType.InlineComponent = "I", 
+        VirtualType.Projection = "P";
+    }(VirtualType || (VirtualType = {}));
+    const VirtualTypeName = {
+        [VirtualType.Virtual]: "Virtual",
+        [VirtualType.Fragment]: "Fragment",
+        [VirtualType.WrappedSignal]: "Signal",
+        [VirtualType.Awaited]: "Awaited",
+        [VirtualType.Component]: "Component",
+        [VirtualType.InlineComponent]: "InlineComponent",
+        [VirtualType.Projection]: "Projection"
+    };
+    var QContainerValue;
+    !function(QContainerValue) {
+        QContainerValue.PAUSED = "paused", QContainerValue.RESUMED = "resumed", QContainerValue.HTML = "html", 
+        QContainerValue.TEXT = "text";
+    }(QContainerValue || (QContainerValue = {}));
+    const QSlot = "q:slot";
+    const QSlotS = "q:s";
+    const getQFuncs = (document, hash) => document["qFuncs_" + hash] || [];
+    const QContainerSelector = "[q\\:container]:not([q\\:container=" + QContainerValue.HTML + "]):not([q\\:container=" + QContainerValue.TEXT + "])";
+    const HTML_NS = "http://www.w3.org/1999/xhtml";
+    const SVG_NS = "http://www.w3.org/2000/svg";
+    const MATH_NS = "http://www.w3.org/1998/Math/MathML";
     const createPlatform = () => ({
         isServer: build.isServer,
         importSymbol(containerEl, url, symbolName) {
@@ -133,13 +159,17 @@
         setTimeout(resolve, timeout);
     }));
     function retryOnPromise(fn, retryCount = 0) {
-        try {
-            return fn();
-        } catch (e) {
+        const retryOrThrow = e => {
             if (isPromise(e) && retryCount < 100) {
                 return e.then(retryOnPromise.bind(null, fn, retryCount++));
             }
             throw e;
+        };
+        try {
+            const result = fn();
+            return isPromise(result) ? result.catch((e => retryOrThrow(e))) : result;
+        } catch (e) {
+            return retryOrThrow(e);
         }
     }
     const isSerializableObject = v => {
@@ -151,39 +181,12 @@
     const isString = v => "string" == typeof v;
     const isFunction = v => "function" == typeof v;
     var VNodeDataFlag;
+    let _locale;
     !function(VNodeDataFlag) {
         VNodeDataFlag[VNodeDataFlag.NONE = 0] = "NONE", VNodeDataFlag[VNodeDataFlag.TEXT_DATA = 1] = "TEXT_DATA", 
         VNodeDataFlag[VNodeDataFlag.VIRTUAL_NODE = 2] = "VIRTUAL_NODE", VNodeDataFlag[VNodeDataFlag.ELEMENT_NODE = 4] = "ELEMENT_NODE", 
         VNodeDataFlag[VNodeDataFlag.REFERENCE = 8] = "REFERENCE", VNodeDataFlag[VNodeDataFlag.SERIALIZE = 16] = "SERIALIZE";
     }(VNodeDataFlag || (VNodeDataFlag = {}));
-    var VirtualType;
-    !function(VirtualType) {
-        VirtualType.Virtual = "V", VirtualType.Fragment = "F", VirtualType.WrappedSignal = "S", 
-        VirtualType.Awaited = "A", VirtualType.Component = "C", VirtualType.InlineComponent = "I", 
-        VirtualType.Projection = "P";
-    }(VirtualType || (VirtualType = {}));
-    const VirtualTypeName = {
-        [VirtualType.Virtual]: "Virtual",
-        [VirtualType.Fragment]: "Fragment",
-        [VirtualType.WrappedSignal]: "Signal",
-        [VirtualType.Awaited]: "Awaited",
-        [VirtualType.Component]: "Component",
-        [VirtualType.InlineComponent]: "InlineComponent",
-        [VirtualType.Projection]: "Projection"
-    };
-    var QContainerValue;
-    !function(QContainerValue) {
-        QContainerValue.PAUSED = "paused", QContainerValue.RESUMED = "resumed", QContainerValue.HTML = "html", 
-        QContainerValue.TEXT = "text";
-    }(QContainerValue || (QContainerValue = {}));
-    const QSlot = "q:slot";
-    const QSlotS = "q:s";
-    const getQFuncs = (document, hash) => document["qFuncs_" + hash] || [];
-    const QContainerSelector = "[q\\:container]:not([q\\:container=" + QContainerValue.HTML + "]):not([q\\:container=" + QContainerValue.TEXT + "])";
-    const HTML_NS = "http://www.w3.org/1999/xhtml";
-    const SVG_NS = "http://www.w3.org/2000/svg";
-    const MATH_NS = "http://www.w3.org/1998/Math/MathML";
-    let _locale;
     const EMPTY_ARRAY = [];
     const EMPTY_OBJ = {};
     Object.freeze(EMPTY_ARRAY), Object.freeze(EMPTY_OBJ);
@@ -418,7 +421,7 @@
             return this.$flags$ & StoreFlags.RECURSIVE && "object" == typeof value && null !== value && !Object.isFrozen(value) && !isStore(value) && !Object.isFrozen(target) ? getOrCreateStore(value, this.$flags$, this.$container$) : value;
         }
         set(target, prop, value) {
-            if (target = unwrapDeserializerProxy(target), "symbol" == typeof prop) {
+            if ("symbol" == typeof prop) {
                 return target[prop] = value, !0;
             }
             const newValue = this.$flags$ & StoreFlags.RECURSIVE ? unwrapStore(value) : value;
@@ -462,7 +465,8 @@
     function addEffect(target, prop, store, effectSubscriber) {
         const effectsMap = store.$effects$ ||= {};
         const effects = Object.prototype.hasOwnProperty.call(effectsMap, prop) && effectsMap[prop] || (effectsMap[prop] = []);
-        ensureContainsEffect(effects, effectSubscriber), ensureContains(effectSubscriber, target);
+        ensureContainsEffect(effects, effectSubscriber), ensureContains(effectSubscriber, target), 
+        ensureEffectContainsSubscriber(effectSubscriber[EffectSubscriptionsProp.EFFECT], target, store.$container$);
     }
     function setNewValueAndTriggerEffects(prop, value, target, currentStore) {
         target[prop] = value, triggerEffects(currentStore.$container$, currentStore, getEffects(target, prop, currentStore.$effects$));
@@ -500,24 +504,32 @@
         const effects = vnode_getProp(value, "q:subs", container.$getObjectById$);
         if (effects) {
             for (let i = effects.length - 1; i >= 0; i--) {
-                clearEffects(effects[i], value) && effects.splice(i, 1);
+                clearEffects(effects[i], value, effects, i, container);
             }
+            0 === effects.length && vnode_setProp(value, "q:subs", null);
         }
     }
-    function clearSubscriberEffectDependencies(value) {
+    function clearSubscriberEffectDependencies(container, value) {
         if (value.$effectDependencies$) {
             for (let i = value.$effectDependencies$.length - 1; i >= 0; i--) {
-                clearEffects(value.$effectDependencies$[i], value) && value.$effectDependencies$.splice(i, 1);
+                clearEffects(value.$effectDependencies$[i], value, value.$effectDependencies$, i, container);
             }
+            0 === value.$effectDependencies$.length && (value.$effectDependencies$ = null);
         }
     }
-    function clearEffects(subscriber, value) {
-        if (!isSignal(subscriber)) {
-            return !1;
-        }
+    function clearEffects(subscriber, value, effectArray, indexToRemove, container) {
+        let subscriptionRemoved = !1;
+        const seenSet = new Set;
+        if (subscriber instanceof WrappedSignal) {
+            subscriptionRemoved = clearSignalEffects(subscriber, value, seenSet);
+        } else if (container.$storeProxyMap$.has(subscriber)) {
+            const store = container.$storeProxyMap$.get(subscriber);
+            subscriptionRemoved = clearStoreEffects(getStoreHandler(store), value);
+        }
+        subscriptionRemoved && effectArray.splice(indexToRemove, 1);
+    }
+    function clearSignalEffects(subscriber, value, seenSet) {
         const effectSubscriptions = subscriber.$effects$;
-        const hostElement = subscriber.$hostElement$;
-        hostElement && hostElement === value && (subscriber.$hostElement$ = null);
         let subscriptionRemoved = !1;
         if (effectSubscriptions) {
             for (let i = effectSubscriptions.length - 1; i >= 0; i--) {
@@ -525,14 +537,62 @@
                 subscriptionRemoved = !0);
             }
         }
-        const args = subscriber.$args$;
-        if (args) {
-            for (let i = args.length - 1; i >= 0; i--) {
-                clearEffects(args[i], subscriber);
+        if (subscriber instanceof WrappedSignal) {
+            const hostElement = subscriber.$hostElement$;
+            hostElement && hostElement === value && (subscriber.$hostElement$ = null);
+            const args = subscriber.$args$;
+            args && clearArgsEffects(args, subscriber, seenSet);
+        }
+        return subscriptionRemoved;
+    }
+    function clearStoreEffects(storeHandler, value) {
+        const effectSubscriptions = storeHandler.$effects$;
+        if (!effectSubscriptions) {
+            return !1;
+        }
+        let subscriptionRemoved = !1;
+        for (const key in effectSubscriptions) {
+            const effects = effectSubscriptions[key];
+            for (let i = effects.length - 1; i >= 0; i--) {
+                effects[i][EffectSubscriptionsProp.EFFECT] === value && (effects.splice(i, 1), subscriptionRemoved = !0);
             }
+            0 === effects.length && delete effectSubscriptions[key];
         }
         return subscriptionRemoved;
     }
+    function clearArgsEffects(args, subscriber, seenSet) {
+        for (let i = args.length - 1; i >= 0; i--) {
+            clearArgEffect(args[i], subscriber, seenSet);
+        }
+    }
+    function clearArgEffect(arg, subscriber, seenSet) {
+        if (!seenSet.has(arg)) {
+            if (seenSet.add(arg), isSignal(arg)) {
+                clearSignalEffects(arg, subscriber, seenSet);
+            } else if ("object" == typeof arg && null !== arg) {
+                if (isStore(arg)) {
+                    clearStoreEffects(getStoreHandler(arg), subscriber);
+                } else if (isPropsProxy(arg)) {
+                    const constProps = arg[_CONST_PROPS];
+                    const varProps = arg[_VAR_PROPS];
+                    if (constProps) {
+                        for (const key in constProps) {
+                            clearArgEffect(constProps[key], subscriber, seenSet);
+                        }
+                    }
+                    for (const key in varProps) {
+                        clearArgEffect(varProps[key], subscriber, seenSet);
+                    }
+                } else {
+                    for (const key in arg) {
+                        clearArgEffect(arg[key], subscriber, seenSet);
+                    }
+                }
+            } else {
+                Array.isArray(arg) && clearArgsEffects(arg, subscriber, seenSet);
+            }
+        }
+    }
     const useResourceQrl = (qrl, opts) => {
         const {val, set, i, iCtx} = useSequentialScope();
         if (null != val) {
@@ -562,7 +622,7 @@
         task.$flags$ &= ~TaskFlags.DIRTY, cleanupTask(task);
         const iCtx = newInvokeContext(container.$locale$, host, void 0, "qResource");
         iCtx.$container$ = container;
-        const taskFn = task.$qrl$.getFn(iCtx, (() => clearSubscriberEffectDependencies(task)));
+        const taskFn = task.$qrl$.getFn(iCtx, (() => clearSubscriberEffectDependencies(container, task)));
         const resource = task.$state$;
         assertDefined();
         const cleanups = [];
@@ -898,6 +958,13 @@
         }
         return 0 === lastIdx ? html : escapedHTML + html.substring(lastIdx);
     }
+    function getFileLocationFromJsx(jsxDev) {
+        if (!jsxDev) {
+            return null;
+        }
+        const sanitizedFileName = jsxDev.fileName?.replace(/\\/g, "/");
+        return sanitizedFileName ? `${sanitizedFileName}:${jsxDev.lineNumber}:${jsxDev.columnNumber}` : null;
+    }
     const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
         let journal = container.$journal$;
         const stack = [];
@@ -1058,7 +1125,7 @@
                 advanceToNextSibling(), vnode_remove(journal, vParent, toRemove, !0);
             }
         }
-        function createNewElement(jsx, elementName) {
+        function createNewElement(jsx, elementName, currentFile) {
             const element = function(elementName) {
                 const domParentVNode = vnode_getDomParentVNode(vParent);
                 const {elementNamespace, elementNamespaceFlag} = getNewElementNamespaceData(domParentVNode, elementName);
@@ -1086,6 +1153,7 @@
                                 value(element);
                                 continue;
                             }
+                            throw qError(QError.invalidRefValue, [ currentFile ]);
                         }
                         if (isSignal(value)) {
                             const signalData = new EffectPropData({
@@ -1098,13 +1166,13 @@
                             if ("textarea" !== elementName || "value" !== key) {
                                 value = serializeAttribute(key, value, scopedStyleIdPrefix), null != value && element.setAttribute(key, String(value));
                             } else {
-                                if ("string" != typeof value) {
+                                if (value && "string" != typeof value) {
                                     if (build.isDev) {
-                                        throw qError(QError.wrongTextareaValue);
+                                        throw qError(QError.wrongTextareaValue, [ currentFile, value ]);
                                     }
                                     continue;
                                 }
-                                element.value = escapeHTML(value);
+                                element.value = escapeHTML(value || "");
                             }
                         } else {
                             element.innerHTML = value, element.setAttribute("q:container", QContainerValue.HTML);
@@ -1121,17 +1189,19 @@
             const isSameElementName = vCurrent && vnode_isElementVNode(vCurrent) && elementName === vnode_getElementName(vCurrent);
             const jsxKey = jsx.key;
             let needsQDispatchEventPatch = !1;
+            const currentFile = getFileLocationFromJsx(jsx.dev);
             isSameElementName && jsxKey === getKey(vCurrent) || (vNewNode = retrieveChildWithKey(elementName, jsxKey), 
-            null === vNewNode ? needsQDispatchEventPatch = createNewElement(jsx, elementName) : vnode_insertBefore(journal, vParent, vNewNode, vCurrent));
+            null === vNewNode ? needsQDispatchEventPatch = createNewElement(jsx, elementName) : (vnode_insertBefore(journal, vParent, vNewNode, vCurrent), 
+            vCurrent = vNewNode, vNewNode = null, null !== vSiblings && (vSiblingsIdx -= SiblingsArray.Size)));
             const jsxAttrs = [];
             const props = jsx.varProps;
             for (const key in props) {
-                let value = props[key];
-                value = serializeAttribute(key, value, scopedStyleIdPrefix), null != value && mapArray_set(jsxAttrs, key, value, 0);
+                const value = props[key];
+                null != value && mapArray_set(jsxAttrs, key, value, 0);
             }
             null !== jsxKey && mapArray_set(jsxAttrs, "q:key", jsxKey, 0);
             const vNode = vNewNode || vCurrent;
-            if (needsQDispatchEventPatch = function(vnode, srcAttrs) {
+            if (needsQDispatchEventPatch = function(vnode, srcAttrs, currentFile) {
                 vnode_ensureElementInflated(vnode);
                 const dstAttrs = vnode;
                 let srcIdx = 0;
@@ -1153,8 +1223,16 @@
                             if ("function" == typeof value) {
                                 return void value(element);
                             }
+                            throw qError(QError.invalidRefValue, [ currentFile ]);
+                        }
+                        if (isSignal(value)) {
+                            const signalData = new EffectPropData({
+                                $scopedStyleIdPrefix$: scopedStyleIdPrefix,
+                                $isConst$: !1
+                            });
+                            value = trackSignalAndAssignHost(value, vnode, key, container, signalData);
                         }
-                        isSignal(value) && (value = untrack((() => value.value))), vnode_setAttr(journal, vnode, key, value), 
+                        vnode_setAttr(journal, vnode, key, serializeAttribute(key, value, scopedStyleIdPrefix)), 
                         null === value && (dstLength = dstAttrs.length);
                     }
                 };
@@ -1175,7 +1253,7 @@
                         dstIdx--), dstKey = dstIdx < dstLength ? dstAttrs[dstIdx++] : null;
                     } else if (null == dstKey) {
                         isJsxPropertyAnEventName(srcKey) ? (patchEventDispatch = !0, recordJsxEvent(srcKey, srcAttrs[srcIdx])) : record(srcKey, srcAttrs[srcIdx]), 
-                        srcIdx++, srcKey = srcIdx < srcLength ? srcAttrs[srcIdx++] : null;
+                        srcIdx++, srcKey = srcIdx < srcLength ? srcAttrs[srcIdx++] : null, dstIdx++, dstKey = dstIdx < dstLength ? dstAttrs[dstIdx++] : null;
                     } else if (srcKey == dstKey) {
                         const srcValue = srcAttrs[srcIdx++];
                         srcValue !== dstAttrs[dstIdx++] && record(dstKey, srcValue), srcKey = srcIdx < srcLength ? srcAttrs[srcIdx++] : null, 
@@ -1188,7 +1266,7 @@
                     }
                 }
                 return patchEventDispatch;
-            }(vNode, jsxAttrs) || needsQDispatchEventPatch, needsQDispatchEventPatch) {
+            }(vNode, jsxAttrs, currentFile) || needsQDispatchEventPatch, needsQDispatchEventPatch) {
                 const element = vnode_getNode(vNode);
                 element.qDispatchEvent || (element.qDispatchEvent = (event, scope) => {
                     const eventName = event.type;
@@ -1232,7 +1310,7 @@
         function expectVirtual(type, jsxKey) {
             vCurrent && vnode_isVirtualVNode(vCurrent) && getKey(vCurrent) === jsxKey || (null === jsxKey || (vNewNode = retrieveChildWithKey(null, jsxKey), 
             null == vNewNode) ? (vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore()), 
-            vnode_setProp(vNewNode, "q:key", jsxKey), build.isDev && vnode_setProp(vNewNode || vCurrent, "q:type", type)) : vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore()));
+            vnode_setProp(vNewNode, "q:key", jsxKey), build.isDev && vnode_setProp(vNewNode || vCurrent, "q:type", type)) : vnode_insertBefore(journal, vParent, vNewNode, vCurrent && getInsertBefore()));
         }
         function expectComponent(component) {
             const componentMeta = component[SERIALIZABLE_STATE];
@@ -1367,7 +1445,7 @@
                             const obj = seq[i];
                             if (isTask(obj)) {
                                 const task = obj;
-                                clearSubscriberEffectDependencies(task), task.$flags$ & TaskFlags.VISIBLE_TASK ? container.$scheduler$(ChoreType.CLEANUP_VISIBLE, task) : cleanupTask(task);
+                                clearSubscriberEffectDependencies(container, task), task.$flags$ & TaskFlags.VISIBLE_TASK ? container.$scheduler$(ChoreType.CLEANUP_VISIBLE, task) : cleanupTask(task);
                             }
                         }
                     }
@@ -1452,6 +1530,10 @@
     const createSignal = value => new Signal(null, value);
     const createComputedQrl = qrl => (throwIfQRLNotResolved(qrl), new ComputedSignal(null, qrl));
     const createComputed$ = /*#__PURE__*/ implicit$FirstArg(createComputedQrl);
+    const aVNodePath = [];
+    const bVNodePath = [];
+    const aSsrNodePath = [];
+    const bSsrNodePath = [];
     var ChoreType;
     !function(ChoreType) {
         ChoreType[ChoreType.MACRO = 240] = "MACRO", ChoreType[ChoreType.MICRO = 15] = "MICRO", 
@@ -1481,13 +1563,13 @@
                 $returnValue$: null,
                 $executed$: !1
             };
-            chore.$promise$ = new Promise((resolve => chore.$resolve$ = resolve)), chore = function(sortedArray, value) {
-                const idx = function(sortedArray, value) {
+            chore.$promise$ = new Promise((resolve => chore.$resolve$ = resolve)), chore = function(sortedArray, value, rootVNode) {
+                const idx = function(sortedArray, value, rootVNode) {
                     let bottom = 0;
                     let top = sortedArray.length;
                     for (;bottom < top; ) {
                         const middle = bottom + (top - bottom >> 1);
-                        const comp = choreComparator(value, sortedArray[middle], !0);
+                        const comp = choreComparator(value, sortedArray[middle], rootVNode);
                         if (comp < 0) {
                             top = middle;
                         } else {
@@ -1498,17 +1580,17 @@
                         }
                     }
                     return ~bottom;
-                }(sortedArray, value);
+                }(sortedArray, value, rootVNode);
                 if (idx < 0) {
                     return sortedArray.splice(~idx, 0, value), value;
                 }
                 const existing = sortedArray[idx];
                 return choreUpdate(existing, value), existing;
-            }(choreQueue, chore), !journalFlushScheduled && runLater && (journalFlushScheduled = !0, 
+            }(choreQueue, chore, container.rootVNode || null), !journalFlushScheduled && runLater && (journalFlushScheduled = !0, 
             schedule(ChoreType.JOURNAL_FLUSH), scheduleDrain());
-            return runLater ? chore.$promise$ : drainUpTo(chore);
+            return runLater ? chore.$promise$ : drainUpTo(chore, container.rootVNode || null);
         };
-        function drainUpTo(runUptoChore) {
+        function drainUpTo(runUptoChore, rootVNode) {
             if (runUptoChore.$executed$) {
                 return runUptoChore.$returnValue$;
             }
@@ -1517,7 +1599,7 @@
             }
             for (;choreQueue.length; ) {
                 const nextChore = choreQueue.shift();
-                const order = choreComparator(nextChore, runUptoChore, !1);
+                const order = choreComparator(nextChore, runUptoChore, rootVNode);
                 if (null === order) {
                     continue;
                 }
@@ -1529,7 +1611,7 @@
                 }
                 const returnValue = executeChore(nextChore);
                 if (isPromise(returnValue)) {
-                    return returnValue.then((() => drainUpTo(runUptoChore)));
+                    return returnValue.then((() => drainUpTo(runUptoChore, rootVNode)));
                 }
             }
             var chore;
@@ -1549,7 +1631,7 @@
                 returnValue = safeCall((() => executeComponent(container, host, host, chore.$target$, chore.$payload$)), (jsx => {
                     if (chore.$type$ === ChoreType.COMPONENT) {
                         const styleScopedId = container.getHostProp(host, "q:sstyle");
-                        return vnode_diff(container, jsx, host, addComponentStylePrefix(styleScopedId));
+                        return retryOnPromise((() => vnode_diff(container, jsx, host, addComponentStylePrefix(styleScopedId))));
                     }
                     return jsx;
                 }), (err => container.handleError(err, host)));
@@ -1572,7 +1654,7 @@
               case ChoreType.NODE_DIFF:
                 const parentVirtualNode = chore.$target$;
                 let jsx = chore.$payload$;
-                isSignal(jsx) && (jsx = jsx.value), returnValue = vnode_diff(container, jsx, parentVirtualNode, null);
+                isSignal(jsx) && (jsx = jsx.value), returnValue = retryOnPromise((() => vnode_diff(container, jsx, parentVirtualNode, null)));
                 break;
 
               case ChoreType.NODE_PROP:
@@ -1620,7 +1702,7 @@
     const choreUpdate = (existing, newChore) => {
         existing.$type$ === ChoreType.NODE_DIFF && (existing.$payload$ = newChore.$payload$);
     };
-    function choreComparator(a, b, shouldThrowOnHostMismatch) {
+    function choreComparator(a, b, rootVNode) {
         const macroTypeDiff = (a.$type$ & ChoreType.MACRO) - (b.$type$ & ChoreType.MACRO);
         if (0 !== macroTypeDiff) {
             return macroTypeDiff;
@@ -1629,15 +1711,65 @@
             const aHost = a.$host$;
             const bHost = b.$host$;
             if (aHost !== bHost && null !== aHost && null !== bHost) {
-                if (!vnode_isVNode(aHost) || !vnode_isVNode(bHost)) {
-                    const errorMessage = `SERVER: during HTML streaming, re-running tasks on a different host is not allowed.\n          You are attempting to change a state that has already been streamed to the client.\n          This can lead to inconsistencies between Server-Side Rendering (SSR) and Client-Side Rendering (CSR).\n          Problematic Node: ${aHost.toString()}`;
-                    if (shouldThrowOnHostMismatch) {
-                        throw qError(QError.serverHostMismatch, [ errorMessage ]);
+                if (vnode_isVNode(aHost) && vnode_isVNode(bHost)) {
+                    const hostDiff = ((a, b, rootVNode) => {
+                        if (a === b) {
+                            return 0;
+                        }
+                        let aDepth = -1;
+                        let bDepth = -1;
+                        for (;a; ) {
+                            a = (aVNodePath[++aDepth] = a)[VNodeProps.parent] || rootVNode && vnode_getProp(a, ":", (id => vnode_locate(rootVNode, id)));
+                        }
+                        for (;b; ) {
+                            b = (bVNodePath[++bDepth] = b)[VNodeProps.parent] || rootVNode && vnode_getProp(b, ":", (id => vnode_locate(rootVNode, id)));
+                        }
+                        for (;aDepth >= 0 && bDepth >= 0; ) {
+                            if ((a = aVNodePath[aDepth]) !== (b = bVNodePath[bDepth])) {
+                                let cursor = b;
+                                do {
+                                    if (cursor = vnode_getNextSibling(cursor), cursor === a) {
+                                        return 1;
+                                    }
+                                } while (cursor);
+                                cursor = b;
+                                do {
+                                    if (cursor = vnode_getPreviousSibling(cursor), cursor === a) {
+                                        return -1;
+                                    }
+                                } while (cursor);
+                                return rootVNode && vnode_getProp(b, ":", (id => vnode_locate(rootVNode, id))) ? -1 : 1;
+                            }
+                            aDepth--, bDepth--;
+                        }
+                        return aDepth < bDepth ? -1 : 1;
+                    })(aHost, bHost, rootVNode);
+                    if (0 !== hostDiff) {
+                        return hostDiff;
                     }
-                    return logWarn(errorMessage), null;
-                }
-                {
-                    const hostDiff = vnode_documentPosition(aHost, bHost);
+                } else {
+                    const errorMessage = `SERVER: during HTML streaming, re-running tasks on a different host is not allowed.\n          You are attempting to change a state that has already been streamed to the client.\n          This can lead to inconsistencies between Server-Side Rendering (SSR) and Client-Side Rendering (CSR).\n          Problematic Node: ${aHost.toString()}`;
+                    logWarn(errorMessage);
+                    const hostDiff = ((a, b) => {
+                        if (a === b) {
+                            return 0;
+                        }
+                        let aDepth = -1;
+                        let bDepth = -1;
+                        for (;a; ) {
+                            a = (aSsrNodePath[++aDepth] = a).currentComponentNode;
+                        }
+                        for (;b; ) {
+                            b = (bSsrNodePath[++bDepth] = b).currentComponentNode;
+                        }
+                        for (;aDepth >= 0 && bDepth >= 0; ) {
+                            if ((a = aSsrNodePath[aDepth]) !== (b = bSsrNodePath[bDepth])) {
+                                return 1;
+                            }
+                            aDepth--, bDepth--;
+                        }
+                        return aDepth < bDepth ? -1 : 1;
+                    })(aHost, bHost);
                     if (0 !== hostDiff) {
                         return hostDiff;
                     }
@@ -1695,7 +1827,7 @@
         task.$flags$ &= ~TaskFlags.DIRTY, cleanupTask(task);
         const iCtx = newInvokeContext(container.$locale$, host, void 0, "qTask");
         iCtx.$container$ = container;
-        const taskFn = task.$qrl$.getFn(iCtx, (() => clearSubscriberEffectDependencies(task)));
+        const taskFn = task.$qrl$.getFn(iCtx, (() => clearSubscriberEffectDependencies(container, task)));
         const handleError = reason => container.handleError(reason, host);
         let cleanupFns = null;
         const cleanup = fn => {
@@ -2074,13 +2206,7 @@
                         jsx.constProps.class = "");
                     }(jsx, options.styleScoped);
                     let qwikInspectorAttrValue = null;
-                    build.isDev && jsx.dev && "head" !== jsx.type && (qwikInspectorAttrValue = function(jsxDev) {
-                        const sanitizedFileName = jsxDev.fileName?.replace(/\\/g, "/");
-                        if (sanitizedFileName) {
-                            return `${sanitizedFileName}:${jsxDev.lineNumber}:${jsxDev.columnNumber}`;
-                        }
-                        return null;
-                    }(jsx.dev));
+                    build.isDev && jsx.dev && "head" !== jsx.type && (qwikInspectorAttrValue = getFileLocationFromJsx(jsx.dev));
                     const innerHTML = ssr.openElement(type, toSsrAttrs(jsx.varProps, jsx.constProps, ssr.serializationCtx, !0, options.styleScoped, jsx.key), function(constProps, varProps, serializationCtx, styleScopedId) {
                         return toSsrAttrs(constProps, varProps, serializationCtx, !1, styleScopedId);
                     }(jsx.constProps, jsx.varProps, ssr.serializationCtx, options.styleScoped), qwikInspectorAttrValue);
@@ -2241,7 +2367,7 @@
         const eventName = key.substring(15);
         eventName && serializationCtx.$eventNames$.add(eventName);
     }
-    const version = "2.0.0-alpha.4-dev+374e0d6";
+    const version = "2.0.0-alpha.6-dev+d848ba5";
     class _SharedContainer {
         $version$;
         $scheduler$;
@@ -3164,6 +3290,7 @@
         }
     };
     const vnode_getNextSibling = vnode => vnode[VNodeProps.nextSibling];
+    const vnode_getPreviousSibling = vnode => vnode[VNodeProps.previousSibling];
     const vnode_getAttrKeys = vnode => {
         if (vnode[VNodeProps.flags] & VNodeFlags.ELEMENT_OR_VIRTUAL_MASK) {
             vnode_ensureElementInflated(vnode);
@@ -3224,7 +3351,7 @@
     const vnode_getParent = vnode => vnode[VNodeProps.parent] || null;
     const vnode_getNode = vnode => null === vnode || vnode_isVirtualVNode(vnode) ? null : vnode_isElementVNode(vnode) ? vnode[ElementVNodeProps.element] : (assertTrue(vnode_isTextVNode(vnode)), 
     vnode[TextVNodeProps.node]);
-    function vnode_toString(depth = 10, offset = "", materialize = !1, siblings = !1) {
+    function vnode_toString(depth = 20, offset = "", materialize = !1, siblings = !1) {
         let vnode = this;
         if (0 === depth) {
             return "...";
@@ -3299,46 +3426,11 @@
         throw qError(QError.invalidVNodeType, [ type ]);
     };
     const isElement = node => node && "object" == typeof node && 1 === fastNodeType(node);
-    const aPath = [];
-    const bPath = [];
-    const vnode_documentPosition = (a, b) => {
-        if (a === b) {
-            return 0;
-        }
-        let aDepth = -1;
-        let bDepth = -1;
-        for (;a; ) {
-            a = (aPath[++aDepth] = a)[VNodeProps.parent];
-        }
-        for (;b; ) {
-            b = (bPath[++bDepth] = b)[VNodeProps.parent];
-        }
-        for (;aDepth >= 0 && bDepth >= 0; ) {
-            if ((a = aPath[aDepth]) !== (b = bPath[bDepth])) {
-                let cursor = b;
-                do {
-                    if (cursor = vnode_getNextSibling(cursor), cursor === a) {
-                        return 1;
-                    }
-                } while (cursor);
-                cursor = b;
-                do {
-                    if (cursor = cursor[VNodeProps.previousSibling], cursor === a) {
-                        return -1;
-                    }
-                } while (cursor);
-                return 1;
-            }
-            aDepth--, bDepth--;
-        }
-        return aDepth < bDepth ? -1 : 1;
-    };
     const vnode_getProjectionParentComponent = (vHost, rootVNode) => {
         let projectionDepth = 1;
         for (;projectionDepth--; ) {
             for (;vHost && (!vnode_isVirtualVNode(vHost) || null === vnode_getProp(vHost, "q:renderFn", null)); ) {
-                const qSlotParentProp = vnode_getProp(vHost, ":", null);
-                const qSlotParent = qSlotParentProp && ("string" == typeof qSlotParentProp ? vnode_locate(rootVNode, qSlotParentProp) : qSlotParentProp);
+                const qSlotParent = vnode_getProp(vHost, ":", (id => vnode_locate(rootVNode, id)));
                 const vProjectionParent = vnode_isVirtualVNode(vHost) && qSlotParent;
                 vProjectionParent && projectionDepth++, vHost = vProjectionParent || vnode_getParent(vHost);
             }
@@ -3713,13 +3805,10 @@
                     if (null !== vnode_getProp(vNode, "q:renderFn", null)) {
                         return vNode;
                     }
-                    const parent = vnode_getProp(vNode, ":", this.$vnodeLocate$);
-                    if (parent) {
-                        vNode = parent;
-                        continue;
-                    }
+                    vNode = vnode_getParent(vNode) || vnode_getProp(vNode, ":", this.$vnodeLocate$);
+                } else {
+                    vNode = vnode_getParent(vNode);
                 }
-                vNode = vnode_getParent(vNode);
             }
             return null;
         }
@@ -3799,10 +3888,6 @@
         }
     }
     const deserializedProxyMap = new WeakMap;
-    const unwrapDeserializerProxy = value => {
-        const unwrapped = "object" == typeof value && null !== value && value[SERIALIZER_PROXY_UNWRAP];
-        return unwrapped || value;
-    };
     const SERIALIZER_PROXY_UNWRAP = Symbol("UNWRAP");
     const wrapDeserializerProxy = (container, data) => {
         if (!Array.isArray(data) || vnode_isVNode(data) || "object" == typeof (value = data) && null !== value && SERIALIZER_PROXY_UNWRAP in value) {
@@ -3838,9 +3923,10 @@
                 return value;
             }
             const container = this.$container$;
-            const propValue = allocate(container, typeId, value);
-            return Reflect.set(target, property, propValue), this.$data$[idx] = void 0, this.$data$[idx + 1] = propValue, 
-            typeId >= TypeIds.Error && inflate(container, propValue, typeId, value), propValue;
+            let propValue = allocate(container, typeId, value);
+            return typeId >= TypeIds.Error && (propValue = inflate(container, propValue, typeId, value)), 
+            Reflect.set(target, property, propValue), this.$data$[idx] = void 0, this.$data$[idx + 1] = propValue, 
+            propValue;
         }
         has(target, property) {
             return property === SERIALIZER_PROXY_UNWRAP || Object.prototype.hasOwnProperty.call(target, property);
@@ -3860,186 +3946,189 @@
     }
     const resolvers = new WeakMap;
     const inflate = (container, target, typeId, data) => {
-        if (void 0 !== typeId) {
-            switch (typeId !== TypeIds.Object && Array.isArray(data) && (data = ((container, data) => {
-                const out = Array(data.length / 2);
-                for (let i = 0; i < data.length; i += 2) {
-                    out[i / 2] = deserializeData(container, data[i], data[i + 1]);
-                }
-                return out;
-            })(container, data)), typeId) {
-              case TypeIds.Object:
-                for (let i = 0; i < data.length; i += 4) {
-                    const key = deserializeData(container, data[i], data[i + 1]);
-                    const valType = data[i + 2];
-                    const valData = data[i + 3];
-                    valType === TypeIds.RootRef || valType >= TypeIds.Error ? Object.defineProperty(target, key, {
-                        get() {
-                            const value = deserializeData(container, valType, valData);
-                            return target[key] = value, value;
-                        },
-                        set(value) {
-                            Object.defineProperty(target, key, {
-                                value,
-                                writable: !0,
-                                enumerable: !0,
-                                configurable: !0
-                            });
-                        },
-                        enumerable: !0,
-                        configurable: !0
-                    }) : target[key] = deserializeData(container, valType, valData);
-                }
-                break;
-
-              case TypeIds.QRL:
-                inflateQRL(container, target);
-                break;
+        if (void 0 === typeId) {
+            return target;
+        }
+        switch (typeId !== TypeIds.Object && Array.isArray(data) && (data = ((container, data) => {
+            const out = Array(data.length / 2);
+            for (let i = 0; i < data.length; i += 2) {
+                out[i / 2] = deserializeData(container, data[i], data[i + 1]);
+            }
+            return out;
+        })(container, data)), typeId) {
+          case TypeIds.Object:
+            for (let i = 0; i < data.length; i += 4) {
+                const key = deserializeData(container, data[i], data[i + 1]);
+                const valType = data[i + 2];
+                const valData = data[i + 3];
+                valType === TypeIds.RootRef || valType >= TypeIds.Error ? Object.defineProperty(target, key, {
+                    get() {
+                        const value = deserializeData(container, valType, valData);
+                        return target[key] = value, value;
+                    },
+                    set(value) {
+                        Object.defineProperty(target, key, {
+                            value,
+                            writable: !0,
+                            enumerable: !0,
+                            configurable: !0
+                        });
+                    },
+                    enumerable: !0,
+                    configurable: !0
+                }) : target[key] = deserializeData(container, valType, valData);
+            }
+            break;
 
-              case TypeIds.Task:
-                const task = target;
-                const v = data;
-                task.$qrl$ = inflateQRL(container, v[0]), task.$flags$ = v[1], task.$index$ = v[2], 
-                task.$el$ = v[3], task.$effectDependencies$ = v[4], task.$state$ = v[5];
-                break;
+          case TypeIds.QRL:
+            inflateQRL(container, target);
+            break;
 
-              case TypeIds.Resource:
-                const [resolved, result, effects] = data;
-                const resource = target;
-                resolved ? (resource.value = Promise.resolve(result), resource._resolved = result, 
-                resource._state = "resolved") : (resource.value = Promise.reject(result), resource._error = result, 
-                resource._state = "rejected"), getStoreHandler(target).$effects$ = effects;
-                break;
+          case TypeIds.Task:
+            const task = target;
+            const v = data;
+            task.$qrl$ = inflateQRL(container, v[0]), task.$flags$ = v[1], task.$index$ = v[2], 
+            task.$el$ = v[3], task.$effectDependencies$ = v[4], task.$state$ = v[5];
+            break;
 
-              case TypeIds.Component:
-                target[SERIALIZABLE_STATE][0] = data[0];
-                break;
+          case TypeIds.Resource:
+            const [resolved, result, effects] = data;
+            const resource = target;
+            resolved ? (resource.value = Promise.resolve(result), resource._resolved = result, 
+            resource._state = "resolved") : (resource.value = Promise.reject(result), resource._error = result, 
+            resource._state = "rejected"), getStoreHandler(target).$effects$ = effects;
+            break;
 
-              case TypeIds.Store:
-              case TypeIds.StoreArray:
-                {
-                    const [value, flags, effects, storeEffect] = data;
-                    const handler = getStoreHandler(target);
-                    handler.$flags$ = flags, Object.assign(getStoreTarget(target), value), storeEffect && (effects[STORE_ARRAY_PROP] = storeEffect), 
-                    handler.$effects$ = effects, container.$storeProxyMap$.set(value, target);
-                    break;
-                }
+          case TypeIds.Component:
+            target[SERIALIZABLE_STATE][0] = data[0];
+            break;
 
-              case TypeIds.Signal:
-                {
-                    const signal = target;
-                    const d = data;
-                    signal.$untrackedValue$ = d[0], signal.$effects$ = d.slice(1);
-                    break;
-                }
+          case TypeIds.Store:
+          case TypeIds.StoreArray:
+            {
+                const [value, flags, effects, storeEffect] = data;
+                const store = getOrCreateStore(value, flags, container);
+                const storeHandler = getStoreHandler(store);
+                storeEffect && (effects[STORE_ARRAY_PROP] = storeEffect), storeHandler.$effects$ = effects, 
+                target = store;
+                break;
+            }
 
-              case TypeIds.WrappedSignal:
-                {
-                    const signal = target;
-                    const d = data;
-                    signal.$func$ = container.getSyncFn(d[0]), signal.$args$ = d[1], signal.$effectDependencies$ = d[2], 
-                    signal.$untrackedValue$ = d[3], signal.$hostElement$ = d[4], signal.$effects$ = d.slice(5);
-                    break;
-                }
+          case TypeIds.Signal:
+            {
+                const signal = target;
+                const d = data;
+                signal.$untrackedValue$ = d[0], signal.$effects$ = d.slice(1);
+                break;
+            }
 
-              case TypeIds.ComputedSignal:
-                {
-                    const computed = target;
-                    const d = data;
-                    computed.$computeQrl$ = d[0], computed.$effects$ = d[1], 3 === d.length ? computed.$untrackedValue$ = d[2] : (computed.$invalid$ = !0, 
-                    computed.$computeQrl$.resolve(), container.$scheduler$?.(ChoreType.QRL_RESOLVE, null, computed.$computeQrl$));
-                    break;
-                }
+          case TypeIds.WrappedSignal:
+            {
+                const signal = target;
+                const d = data;
+                signal.$func$ = container.getSyncFn(d[0]), signal.$args$ = d[1], signal.$effectDependencies$ = d[2], 
+                signal.$untrackedValue$ = d[3], signal.$hostElement$ = d[4], signal.$effects$ = d.slice(5);
+                break;
+            }
 
-              case TypeIds.Error:
-                {
-                    const d = data;
-                    target.message = d[0];
-                    const second = d[1];
-                    if (second && Array.isArray(second)) {
-                        for (let i = 0; i < second.length; i++) {
-                            target[second[i++]] = d[i];
-                        }
-                        target.stack = d[2];
-                    } else {
-                        target.stack = second;
-                    }
-                    break;
-                }
+          case TypeIds.ComputedSignal:
+            {
+                const computed = target;
+                const d = data;
+                computed.$computeQrl$ = d[0], computed.$effects$ = d[1], 3 === d.length ? computed.$untrackedValue$ = d[2] : (computed.$invalid$ = !0, 
+                computed.$computeQrl$.resolve(), container.$scheduler$?.(ChoreType.QRL_RESOLVE, null, computed.$computeQrl$));
+                break;
+            }
 
-              case TypeIds.FormData:
-                {
-                    const formData = target;
-                    const d = data;
-                    for (let i = 0; i < d.length; i++) {
-                        formData.append(d[i++], d[i]);
+          case TypeIds.Error:
+            {
+                const d = data;
+                target.message = d[0];
+                const second = d[1];
+                if (second && Array.isArray(second)) {
+                    for (let i = 0; i < second.length; i++) {
+                        target[second[i++]] = d[i];
                     }
-                    break;
-                }
-
-              case TypeIds.JSXNode:
-                {
-                    const jsx = target;
-                    const [type, varProps, constProps, children, flags, key] = data;
-                    jsx.type = type, jsx.varProps = varProps, jsx.constProps = constProps, jsx.children = children, 
-                    jsx.flags = flags, jsx.key = key;
-                    break;
+                    target.stack = d[2];
+                } else {
+                    target.stack = second;
                 }
+                break;
+            }
 
-              case TypeIds.Set:
-                {
-                    const set = target;
-                    const d = data;
-                    for (let i = 0; i < d.length; i++) {
-                        set.add(d[i]);
-                    }
-                    break;
+          case TypeIds.FormData:
+            {
+                const formData = target;
+                const d = data;
+                for (let i = 0; i < d.length; i++) {
+                    formData.append(d[i++], d[i]);
                 }
+                break;
+            }
 
-              case TypeIds.Map:
-                {
-                    const map = target;
-                    const d = data;
-                    for (let i = 0; i < d.length; i++) {
-                        map.set(d[i++], d[i]);
-                    }
-                    break;
-                }
+          case TypeIds.JSXNode:
+            {
+                const jsx = target;
+                const [type, varProps, constProps, children, flags, key] = data;
+                jsx.type = type, jsx.varProps = varProps, jsx.constProps = constProps, jsx.children = children, 
+                jsx.flags = flags, jsx.key = key;
+                break;
+            }
 
-              case TypeIds.Promise:
-                {
-                    const promise = target;
-                    const [resolved, result] = data;
-                    const [resolve, reject] = resolvers.get(promise);
-                    resolved ? resolve(result) : reject(result);
-                    break;
+          case TypeIds.Set:
+            {
+                const set = target;
+                const d = data;
+                for (let i = 0; i < d.length; i++) {
+                    set.add(d[i]);
                 }
+                break;
+            }
 
-              case TypeIds.Uint8Array:
-                const bytes = target;
-                const buf = atob(data);
-                let i = 0;
-                for (const s of buf) {
-                    bytes[i++] = s.charCodeAt(0);
+          case TypeIds.Map:
+            {
+                const map = target;
+                const d = data;
+                for (let i = 0; i < d.length; i++) {
+                    map.set(d[i++], d[i]);
                 }
                 break;
+            }
 
-              case TypeIds.PropsProxy:
-                const propsProxy = target;
-                propsProxy[_VAR_PROPS] = 0 === data ? {} : data[0], propsProxy[_CONST_PROPS] = data[1];
+          case TypeIds.Promise:
+            {
+                const promise = target;
+                const [resolved, result] = data;
+                const [resolve, reject] = resolvers.get(promise);
+                resolved ? resolve(result) : reject(result);
                 break;
+            }
 
-              case TypeIds.EffectData:
-                {
-                    const effectData = target;
-                    effectData.data.$scopedStyleIdPrefix$ = data[0], effectData.data.$isConst$ = data[1];
-                    break;
-                }
+          case TypeIds.Uint8Array:
+            const bytes = target;
+            const buf = atob(data);
+            let i = 0;
+            for (const s of buf) {
+                bytes[i++] = s.charCodeAt(0);
+            }
+            break;
+
+          case TypeIds.PropsProxy:
+            const propsProxy = target;
+            propsProxy[_VAR_PROPS] = 0 === data ? {} : data[0], propsProxy[_CONST_PROPS] = data[1];
+            break;
 
-              default:
-                throw qError(QError.serializeErrorNotImplemented, [ typeId ]);
+          case TypeIds.EffectData:
+            {
+                const effectData = target;
+                effectData.data.$scopedStyleIdPrefix$ = data[0], effectData.data.$isConst$ = data[1];
+                break;
             }
+
+          default:
+            throw qError(QError.serializeErrorNotImplemented, [ typeId ]);
         }
+        return target;
     };
     const _constants = [ void 0, null, !0, !1, "", EMPTY_ARRAY, EMPTY_OBJ, NEEDS_COMPUTATION, Slot, Fragment, NaN, 1 / 0, -1 / 0, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER - 1, Number.MIN_SAFE_INTEGER ];
     const allocate = (container, typeId, value) => {
@@ -4100,10 +4189,8 @@
             return new ComputedSignal(container, null);
 
           case TypeIds.Store:
-            return createStore(container, {}, 0);
-
           case TypeIds.StoreArray:
-            return createStore(container, [], 0);
+            return null;
 
           case TypeIds.URLSearchParams:
             return new URLSearchParams(value);
@@ -4594,13 +4681,13 @@
         }
         return qrlStringInline;
     }
-    function deserializeData(container, typeId, propValue) {
+    function deserializeData(container, typeId, value) {
         if (void 0 === typeId) {
-            return propValue;
+            return value;
         }
-        const value = allocate(container, typeId, propValue);
-        return typeId >= TypeIds.Error && inflate(container, value, typeId, propValue), 
-        value;
+        let propValue = allocate(container, typeId, value);
+        return typeId >= TypeIds.Error && (propValue = inflate(container, propValue, typeId, value)), 
+        propValue;
     }
     function _createDeserializeContainer(stateData, element) {
         let state;
@@ -5166,7 +5253,18 @@
         if (isResourceReturn(resource)) {
             if (!isServerPlatform()) {
                 const state = resource._state;
-                return "pending" === state && props.onPending ? Promise.resolve(props.onPending()) : "rejected" === state && props.onRejected ? Promise.resolve(resource._error).then(props.onRejected) : Promise.resolve(untrack((() => resource._resolved))).then(props.onResolved);
+                if ("pending" === state && props.onPending) {
+                    return Promise.resolve().then(useBindInvokeContext(props.onPending));
+                }
+                if ("rejected" === state && props.onRejected) {
+                    return Promise.resolve(resource._error).then(useBindInvokeContext(props.onRejected));
+                }
+                {
+                    const resolvedValue = untrack((() => resource._resolved));
+                    if (void 0 !== resolvedValue) {
+                        return Promise.resolve(resolvedValue).then(useBindInvokeContext(props.onResolved));
+                    }
+                }
             }
             return resource.value.then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
         }