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

package/dist/core.prod.mjs

@@ -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
@@ -104,10 +104,9 @@ var QError;
     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 = []) => {
@@ -115,117 +114,6 @@ const qError = (code, errorMessageArgs = []) => {
     return logErrorAndStop(text, ...errorMessageArgs);
 };
 
-const createPlatform = () => ({
-    isServer,
-    importSymbol(containerEl, url, symbolName) {
-        if (isServer) {
-            const hash = getSymbolHash(symbolName);
-            const regSym = globalThis.__qwik_reg_symbols?.get(hash);
-            if (regSym) {
-                return regSym;
-            }
-        }
-        if (!url) {
-            throw qError(QError.qrlMissingChunk, [ symbolName ]);
-        }
-        if (!containerEl) {
-            throw qError(QError.qrlMissingContainer, [ url, symbolName ]);
-        }
-        const urlDoc = toUrl(containerEl.ownerDocument, containerEl, url).toString();
-        const urlCopy = new URL(urlDoc);
-        urlCopy.hash = "";
-        return import(urlCopy.href).then((mod => mod[symbolName]));
-    },
-    raf: fn => new Promise((resolve => {
-        requestAnimationFrame((() => {
-            resolve(fn());
-        }));
-    })),
-    nextTick: fn => new Promise((resolve => {
-        setTimeout((() => {
-            resolve(fn());
-        }));
-    })),
-    chunkForSymbol: (symbolName, chunk) => [ symbolName, chunk ?? "_" ]
-});
-
-const toUrl = (doc, containerEl, url) => {
-    const baseURI = doc.baseURI;
-    const base = new URL(containerEl.getAttribute("q:base") ?? baseURI, baseURI);
-    return new URL(url, base);
-};
-
-let _platform = /*#__PURE__ */ createPlatform();
-
-const setPlatform = plt => _platform = plt;
-
-const getPlatform = () => _platform;
-
-const isServerPlatform = () => _platform.isServer;
-
-const isNode = value => value && "number" == typeof value.nodeType;
-
-const isDocument = value => 9 === value.nodeType;
-
-const isElement$1 = value => 1 === value.nodeType;
-
-const MAX_RETRY_ON_PROMISE_COUNT = 100;
-
-const isPromise = value => !!value && "object" == typeof value && "function" == typeof value.then;
-
-const safeCall = (call, thenFn, rejectFn) => {
-    try {
-        const result = call();
-        return isPromise(result) ? result.then(thenFn, rejectFn) : thenFn(result);
-    } catch (e) {
-        return rejectFn(e);
-    }
-};
-
-const maybeThen = (valueOrPromise, thenFn) => isPromise(valueOrPromise) ? valueOrPromise.then(thenFn, shouldNotError) : thenFn(valueOrPromise);
-
-const maybeThenPassError = (valueOrPromise, thenFn) => isPromise(valueOrPromise) ? valueOrPromise.then(thenFn) : thenFn(valueOrPromise);
-
-const shouldNotError = reason => {
-    throwErrorAndStop(reason);
-};
-
-const delay = timeout => new Promise((resolve => {
-    setTimeout(resolve, timeout);
-}));
-
-function retryOnPromise(fn, retryCount = 0) {
-    try {
-        return fn();
-    } catch (e) {
-        if (isPromise(e) && retryCount < 100) {
-            return e.then(retryOnPromise.bind(null, fn, retryCount++));
-        }
-        throw e;
-    }
-}
-
-const isSerializableObject = v => {
-    const proto = Object.getPrototypeOf(v);
-    return proto === Object.prototype || proto === Array.prototype || null === proto;
-};
-
-const isObject = v => !!v && "object" == typeof v;
-
-const isArray = v => Array.isArray(v);
-
-const isString = v => "string" == typeof v;
-
-const isFunction = v => "function" == typeof v;
-
-var VNodeDataFlag;
-
-!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 = {}));
-
 const DEBUG_TYPE = "q:type";
 
 var VirtualType;
@@ -357,6 +245,115 @@ const dangerouslySetInnerHTML = "dangerouslySetInnerHTML";
 
 const qwikInspectorAttr = "data-qwik-inspector";
 
+const createPlatform = () => ({
+    isServer,
+    importSymbol(containerEl, url, symbolName) {
+        if (isServer) {
+            const hash = getSymbolHash(symbolName);
+            const regSym = globalThis.__qwik_reg_symbols?.get(hash);
+            if (regSym) {
+                return regSym;
+            }
+        }
+        if (!url) {
+            throw qError(QError.qrlMissingChunk, [ symbolName ]);
+        }
+        if (!containerEl) {
+            throw qError(QError.qrlMissingContainer, [ url, symbolName ]);
+        }
+        const urlDoc = toUrl(containerEl.ownerDocument, containerEl, url).toString();
+        const urlCopy = new URL(urlDoc);
+        urlCopy.hash = "";
+        return import(urlCopy.href).then((mod => mod[symbolName]));
+    },
+    raf: fn => new Promise((resolve => {
+        requestAnimationFrame((() => {
+            resolve(fn());
+        }));
+    })),
+    nextTick: fn => new Promise((resolve => {
+        setTimeout((() => {
+            resolve(fn());
+        }));
+    })),
+    chunkForSymbol: (symbolName, chunk) => [ symbolName, chunk ?? "_" ]
+});
+
+const toUrl = (doc, containerEl, url) => {
+    const baseURI = doc.baseURI;
+    const base = new URL(containerEl.getAttribute("q:base") ?? baseURI, baseURI);
+    return new URL(url, base);
+};
+
+let _platform = /*#__PURE__ */ createPlatform();
+
+const setPlatform = plt => _platform = plt;
+
+const getPlatform = () => _platform;
+
+const isServerPlatform = () => _platform.isServer;
+
+const isNode = value => value && "number" == typeof value.nodeType;
+
+const isDocument = value => 9 === value.nodeType;
+
+const isElement$1 = value => 1 === value.nodeType;
+
+const MAX_RETRY_ON_PROMISE_COUNT = 100;
+
+const isPromise = value => !!value && "object" == typeof value && "function" == typeof value.then;
+
+const safeCall = (call, thenFn, rejectFn) => {
+    try {
+        const result = call();
+        return isPromise(result) ? result.then(thenFn, rejectFn) : thenFn(result);
+    } catch (e) {
+        return rejectFn(e);
+    }
+};
+
+const maybeThen = (valueOrPromise, thenFn) => isPromise(valueOrPromise) ? valueOrPromise.then(thenFn, shouldNotError) : thenFn(valueOrPromise);
+
+const maybeThenPassError = (valueOrPromise, thenFn) => isPromise(valueOrPromise) ? valueOrPromise.then(thenFn) : thenFn(valueOrPromise);
+
+const shouldNotError = reason => {
+    throwErrorAndStop(reason);
+};
+
+const delay = timeout => new Promise((resolve => {
+    setTimeout(resolve, timeout);
+}));
+
+function retryOnPromise(fn, retryCount = 0) {
+    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 => {
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === Array.prototype || null === proto;
+};
+
+const isObject = v => !!v && "object" == typeof v;
+
+const isArray = v => Array.isArray(v);
+
+const isString = v => "string" == typeof v;
+
+const isFunction = v => "function" == typeof v;
+
+var VNodeDataFlag;
+
 let _locale;
 
 function getLocale(defaultLocale) {
@@ -386,6 +383,12 @@ function setLocale(locale) {
     _locale = 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 = {}));
+
 const isQrl$1 = value => "function" == typeof value && "function" == typeof value.getSymbol;
 
 const EMPTY_ARRAY = [];
@@ -717,7 +720,7 @@ class StoreHandler {
         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;
@@ -762,7 +765,8 @@ class StoreHandler {
 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) {
@@ -806,26 +810,35 @@ function clearVNodeEffectDependencies(container, value) {
     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--) {
@@ -833,15 +846,66 @@ function clearEffects(subscriber, value) {
             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) {
@@ -861,7 +925,18 @@ function getResourceValueAsPromise(props) {
     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));
     }
@@ -890,7 +965,7 @@ const runResource = (task, container, host) => {
     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(resource, 'useResource: when running a resource, "task.resource" must be a defined.', task);
     const cleanups = [];
@@ -1299,6 +1374,14 @@ function escapeHTML(html) {
     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 = [];
@@ -1459,7 +1542,7 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
             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);
@@ -1487,6 +1570,7 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                             value(element);
                             continue;
                         }
+                        throw qError(QError.invalidRefValue, [ currentFile ]);
                     }
                     if (isSignal(value)) {
                         const signalData = new EffectPropData({
@@ -1499,13 +1583,13 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                         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 (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);
@@ -1522,17 +1606,19 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
         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;
@@ -1554,8 +1640,16 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                         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);
                 }
             };
@@ -1576,7 +1670,7 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                     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, 
@@ -1589,7 +1683,7 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                 }
             }
             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;
@@ -1633,7 +1727,7 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
     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), isDev && vnode_setProp(vNewNode || vCurrent, "q:type", type)) : vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore()));
+        vnode_setProp(vNewNode, "q:key", jsxKey), isDev && vnode_setProp(vNewNode || vCurrent, "q:type", type)) : vnode_insertBefore(journal, vParent, vNewNode, vCurrent && getInsertBefore()));
     }
     function expectComponent(component) {
         const componentMeta = component[SERIALIZABLE_STATE];
@@ -1775,7 +1869,7 @@ function cleanup(container, vNode) {
                         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);
                         }
                     }
                 }
@@ -1875,6 +1969,68 @@ const createComputedQrl = createComputedSignal;
 
 const createComputed$ = /*#__PURE__*/ implicit$FirstArg(createComputedQrl);
 
+const aVNodePath = [];
+
+const bVNodePath = [];
+
+const vnode_documentPosition = (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;
+};
+
+const aSsrNodePath = [];
+
+const bSsrNodePath = [];
+
+const ssrNodeDocumentPosition = (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;
+};
+
 var ChoreType;
 
 !function(ChoreType) {
@@ -1906,12 +2062,12 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
             $returnValue$: null,
             $executed$: !1
         };
-        chore.$promise$ = new Promise((resolve => chore.$resolve$ = resolve)), chore = sortedInsert(choreQueue, chore), 
+        chore.$promise$ = new Promise((resolve => chore.$resolve$ = resolve)), chore = sortedInsert(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$;
         }
@@ -1920,7 +2076,7 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
         }
         for (;choreQueue.length; ) {
             const nextChore = choreQueue.shift();
-            const order = choreComparator(nextChore, runUptoChore, !1);
+            const order = choreComparator(nextChore, runUptoChore, rootVNode);
             if (null === order) {
                 continue;
             }
@@ -1932,7 +2088,7 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
             }
             const returnValue = executeChore(nextChore);
             if (isPromise(returnValue)) {
-                return returnValue.then((() => drainUpTo(runUptoChore)));
+                return returnValue.then((() => drainUpTo(runUptoChore, rootVNode)));
             }
         }
         return runUptoChore.$returnValue$;
@@ -1951,7 +2107,7 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
             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)));
@@ -1974,7 +2130,7 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
           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:
@@ -2028,7 +2184,7 @@ function vNodeAlreadyDeleted(chore) {
     return !!(chore.$host$ && vnode_isVNode(chore.$host$) && chore.$host$[VNodeProps.flags] & VNodeFlags.Deleted);
 }
 
-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;
@@ -2037,15 +2193,15 @@ function choreComparator(a, b, shouldThrowOnHostMismatch) {
         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 = vnode_documentPosition(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 = ssrNodeDocumentPosition(aHost, bHost);
                 if (0 !== hostDiff) {
                     return hostDiff;
                 }
@@ -2066,12 +2222,12 @@ function choreComparator(a, b, shouldThrowOnHostMismatch) {
     return 0;
 }
 
-function sortedFindIndex(sortedArray, value) {
+function sortedFindIndex(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 {
@@ -2084,8 +2240,8 @@ function sortedFindIndex(sortedArray, value) {
     return ~bottom;
 }
 
-function sortedInsert(sortedArray, value) {
-    const idx = sortedFindIndex(sortedArray, value);
+function sortedInsert(sortedArray, value, rootVNode) {
+    const idx = sortedFindIndex(sortedArray, value, rootVNode);
     if (idx < 0) {
         return sortedArray.splice(~idx, 0, value), value;
     }
@@ -2135,7 +2291,7 @@ const runTask = (task, container, host) => {
     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 => {
@@ -2552,7 +2708,7 @@ function processJSXNode(ssr, enqueue, value, options) {
             if ("string" == typeof type) {
                 appendClassIfScopedStyleExists(jsx, options.styleScoped);
                 let qwikInspectorAttrValue = null;
-                isDev && jsx.dev && "head" !== jsx.type && (qwikInspectorAttrValue = getQwikInspectorAttributeValue(jsx.dev));
+                isDev && jsx.dev && "head" !== jsx.type && (qwikInspectorAttrValue = getFileLocationFromJsx(jsx.dev));
                 const innerHTML = ssr.openElement(type, varPropsToSsrAttrs(jsx.varProps, jsx.constProps, ssr.serializationCtx, options.styleScoped, jsx.key), constPropsToSsrAttrs(jsx.constProps, jsx.varProps, ssr.serializationCtx, options.styleScoped), qwikInspectorAttrValue);
                 innerHTML && ssr.htmlNode(innerHTML), enqueue(ssr.closeElement), "head" === type ? (enqueue(ssr.additionalHeadNodes), 
                 enqueue(ssr.emitQwikLoaderAtTopIfNeeded)) : "body" === type && enqueue(ssr.additionalBodyNodes);
@@ -2716,11 +2872,6 @@ function getSlotName(host, jsx, ssr) {
     return directGetPropsProxyProp(jsx, "name") || "";
 }
 
-function getQwikInspectorAttributeValue(jsxDev) {
-    const sanitizedFileName = jsxDev.fileName?.replace(/\\/g, "/");
-    return sanitizedFileName ? `${sanitizedFileName}:${jsxDev.lineNumber}:${jsxDev.columnNumber}` : null;
-}
-
 function appendQwikInspectorAttribute(jsx, qwikInspectorAttrValue) {
     !qwikInspectorAttrValue || jsx.constProps && qwikInspectorAttr in jsx.constProps || ((jsx.constProps ||= {})[qwikInspectorAttr] = qwikInspectorAttrValue);
 }
@@ -2730,7 +2881,7 @@ function appendClassIfScopedStyleExists(jsx, styleScoped) {
     jsx.constProps.class = "");
 }
 
-const version = "2.0.0-alpha.4-dev+374e0d6";
+const version = "2.0.0-alpha.6-dev+d848ba5";
 
 class _SharedContainer {
     $version$;
@@ -3827,7 +3978,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), "Expecting Text Node."), 
 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 "...";
@@ -3989,49 +4140,11 @@ const vnode_getType = vnode => {
 
 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 = vnode_getPreviousSibling(cursor), 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);
         }
@@ -4497,13 +4610,10 @@ class DomContainer extends _SharedContainer {
                 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;
     }
@@ -4581,11 +4691,6 @@ class DomContainer extends _SharedContainer {
 
 const deserializedProxyMap = new WeakMap;
 
-const unwrapDeserializerProxy = value => {
-    const unwrapped = "object" == typeof value && null !== value && value[SERIALIZER_PROXY_UNWRAP];
-    return unwrapped || value;
-};
-
 const isDeserializerProxy = value => "object" == typeof value && null !== value && SERIALIZER_PROXY_UNWRAP in value;
 
 const SERIALIZER_PROXY_UNWRAP = Symbol("UNWRAP");
@@ -4624,9 +4729,10 @@ class DeserializationHandler {
             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);
@@ -4656,181 +4762,184 @@ const _eagerDeserializeArray = (container, data) => {
 const resolvers = new WeakMap;
 
 const inflate = (container, target, typeId, data) => {
-    if (void 0 !== typeId) {
-        switch (typeId !== TypeIds.Object && Array.isArray(data) && (data = _eagerDeserializeArray(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 = _eagerDeserializeArray(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;
 
-          default:
-            throw qError(QError.serializeErrorNotImplemented, [ typeId ]);
+      case TypeIds.PropsProxy:
+        const propsProxy = target;
+        propsProxy[_VAR_PROPS] = 0 === data ? {} : data[0], propsProxy[_CONST_PROPS] = data[1];
+        break;
+
+      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 ];
@@ -4893,10 +5002,8 @@ const allocate = (container, typeId, value) => {
         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);
@@ -5424,13 +5531,13 @@ function _deserialize(rawStateData, element) {
     return output;
 }
 
-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 getObjectById(id, stateData) {