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

package/dist/core.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-alpha.4-dev+374e0d6
+ * @qwik.dev/core 2.0.0-alpha.5-dev+cb53bbd
  * 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
@@ -149,7 +149,7 @@ const codeToText = (code, ...parts) => {
             'SsrError(tag): {{0}}', // 29
             'QRLs can not be resolved because it does not have an attached container. This means that the QRL does not know where it belongs inside the DOM, so it cant dynamically import() from a relative path.', // 30
             'QRLs can not be dynamically resolved, because it does not have a chunk path', // 31
-            'The JSX ref attribute must be a Signal', // 32
+            '{{0}}\nThe JSX ref attribute must be a Signal', // 32
             'Serialization Error: Deserialization of data type {{0}} is not implemented', // 33
             'Serialization Error: Expected vnode for ref prop, but got {{0}}', // 34
             'Serialization Error: Cannot allocate data type {{0}}', // 35
@@ -157,7 +157,7 @@ const codeToText = (code, ...parts) => {
             'Serialization Error: Serialization of data type {{0}} is not implemented', // 37
             'Serialization Error: Unvisited {{0}}', // 38
             'Serialization Error: Missing QRL chunk for {{0}}', // 39
-            'The value of the textarea must be a string', // 40
+            '{{0}}\nThe value of the textarea must be a string found {{1}}', // 40
             'Unable to find q:container', // 41
             "Element must have 'q:container' attribute.", // 42
             'Unknown vnode type {{0}}.', // 43
@@ -1135,7 +1135,6 @@ class StoreHandler {
     }
     /** In the case of oldValue and value are the same, the effects are not triggered. */
     set(target, prop, value) {
-        target = unwrapDeserializerProxy(target);
         if (typeof prop === 'symbol') {
             target[prop] = value;
             return true;
@@ -1204,6 +1203,8 @@ function addEffect(target, prop, store, effectSubscriber) {
     // to unsubscribe from. So we need to store the reference from the effect back
     // to this signal.
     ensureContains(effectSubscriber, target);
+    // We need to add the subscriber to the effect so that we can clean it up later
+    ensureEffectContainsSubscriber(effectSubscriber[EffectSubscriptionsProp.EFFECT], target, store.$container$);
 }
 function setNewValueAndTriggerEffects(prop, value, target, currentStore) {
     target[prop] = value;
@@ -1274,32 +1275,40 @@ function clearVNodeEffectDependencies(container, value) {
     }
     for (let i = effects.length - 1; i >= 0; i--) {
         const subscriber = effects[i];
-        const subscriptionRemoved = clearEffects(subscriber, value);
-        if (subscriptionRemoved) {
-            effects.splice(i, 1);
-        }
+        clearEffects(subscriber, value, effects, i, container);
+    }
+    if (effects.length === 0) {
+        vnode_setProp(value, QSubscribers, null);
     }
 }
-function clearSubscriberEffectDependencies(value) {
+function clearSubscriberEffectDependencies(container, value) {
     if (value.$effectDependencies$) {
         for (let i = value.$effectDependencies$.length - 1; i >= 0; i--) {
             const subscriber = value.$effectDependencies$[i];
-            const subscriptionRemoved = clearEffects(subscriber, value);
-            if (subscriptionRemoved) {
-                value.$effectDependencies$.splice(i, 1);
-            }
+            clearEffects(subscriber, value, value.$effectDependencies$, i, container);
+        }
+        if (value.$effectDependencies$.length === 0) {
+            value.$effectDependencies$ = null;
         }
     }
 }
-function clearEffects(subscriber, value) {
-    if (!isSignal(subscriber)) {
-        return false;
+function clearEffects(subscriber, value, effectArray, indexToRemove, container) {
+    let subscriptionRemoved = false;
+    const seenSet = new Set();
+    if (subscriber instanceof WrappedSignal) {
+        subscriptionRemoved = clearSignalEffects(subscriber, value, seenSet);
     }
-    const effectSubscriptions = subscriber.$effects$;
-    const hostElement = subscriber.$hostElement$;
-    if (hostElement && hostElement === value) {
-        subscriber.$hostElement$ = null;
+    else if (container.$storeProxyMap$.has(subscriber)) {
+        const store = container.$storeProxyMap$.get(subscriber);
+        const handler = getStoreHandler(store);
+        subscriptionRemoved = clearStoreEffects(handler, value);
+    }
+    if (subscriptionRemoved) {
+        effectArray.splice(indexToRemove, 1);
     }
+}
+function clearSignalEffects(subscriber, value, seenSet) {
+    const effectSubscriptions = subscriber.$effects$;
     let subscriptionRemoved = false;
     if (effectSubscriptions) {
         for (let i = effectSubscriptions.length - 1; i >= 0; i--) {
@@ -1310,15 +1319,69 @@ function clearEffects(subscriber, value) {
             }
         }
     }
-    // clear the effects of the arguments
-    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$;
+        if (hostElement && hostElement === value) {
+            subscriber.$hostElement$ = null;
+        }
+        // clear the effects of the arguments
+        const args = subscriber.$args$;
+        if (args) {
+            clearArgsEffects(args, subscriber, seenSet);
         }
     }
     return subscriptionRemoved;
 }
+function clearStoreEffects(storeHandler, value) {
+    const effectSubscriptions = storeHandler.$effects$;
+    if (!effectSubscriptions) {
+        return false;
+    }
+    let subscriptionRemoved = false;
+    for (const key in effectSubscriptions) {
+        const effects = effectSubscriptions[key];
+        for (let i = effects.length - 1; i >= 0; i--) {
+            const effect = effects[i];
+            if (effect[EffectSubscriptionsProp.EFFECT] === value) {
+                effects.splice(i, 1);
+                subscriptionRemoved = true;
+            }
+        }
+        if (effects.length === 0) {
+            delete effectSubscriptions[key];
+        }
+    }
+    return subscriptionRemoved;
+}
+function clearArgsEffects(args, subscriber, seenSet) {
+    for (let i = args.length - 1; i >= 0; i--) {
+        const arg = args[i];
+        clearArgEffect(arg, subscriber, seenSet);
+    }
+}
+function clearArgEffect(arg, subscriber, seenSet) {
+    if (seenSet.has(arg)) {
+        return;
+    }
+    seenSet.add(arg);
+    if (isSignal(arg)) {
+        clearSignalEffects(arg, subscriber, seenSet);
+    }
+    else if (typeof arg === 'object' && arg !== null) {
+        if (isStore(arg)) {
+            clearStoreEffects(getStoreHandler(arg), subscriber);
+        }
+        else {
+            for (const key in arg) {
+                clearArgEffect(arg[key], subscriber, seenSet);
+            }
+        }
+    }
+    else if (Array.isArray(arg)) {
+        clearArgsEffects(arg, subscriber, seenSet);
+    }
+    else ;
+}
 
 /** @internal */
 const useResourceQrl = (qrl, opts) => {
@@ -1405,14 +1468,17 @@ function getResourceValueAsPromise(props) {
             // create a subscription for the resource._state changes
             const state = resource._state;
             if (state === 'pending' && props.onPending) {
-                return Promise.resolve(props.onPending());
+                return Promise.resolve().then(useBindInvokeContext(props.onPending));
             }
             else if (state === 'rejected' && props.onRejected) {
-                return Promise.resolve(resource._error).then(props.onRejected);
+                return Promise.resolve(resource._error).then(useBindInvokeContext(props.onRejected));
             }
             else {
-                // resolved, pending without onPending prop or rejected with onRejected prop
-                return Promise.resolve(untrack(() => resource._resolved)).then(props.onResolved);
+                const resolvedValue = untrack(() => resource._resolved);
+                if (resolvedValue !== undefined) {
+                    // resolved, pending without onPending prop or rejected without onRejected prop
+                    return Promise.resolve(resolvedValue).then(useBindInvokeContext(props.onResolved));
+                }
             }
         }
         return resource.value.then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
@@ -1453,7 +1519,7 @@ const runResource = (task, container, host) => {
     cleanupTask(task);
     const iCtx = newInvokeContext(container.$locale$, host, undefined, ResourceEvent);
     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 track = (obj, prop) => {
@@ -2254,6 +2320,17 @@ function escapeHTML(html) {
     }
 }
 
+function getFileLocationFromJsx(jsxDev) {
+    if (!jsxDev) {
+        return null;
+    }
+    const sanitizedFileName = jsxDev.fileName?.replace(/\\/g, '/');
+    if (sanitizedFileName) {
+        return `${sanitizedFileName}:${jsxDev.lineNumber}:${jsxDev.columnNumber}`;
+    }
+    return null;
+}
+
 const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
     let journal = container.$journal$;
     /**
@@ -2697,7 +2774,7 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
      *
      * @returns {boolean}
      */
-    function createNewElement(jsx, elementName) {
+    function createNewElement(jsx, elementName, currentFile) {
         const element = createElementWithNamespace(elementName);
         const { constProps } = jsx;
         let needsQDispatchEventPatch = false;
@@ -2728,6 +2805,9 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                         value(element);
                         continue;
                     }
+                    else {
+                        throw qError(QError.invalidRefValue, [currentFile]);
+                    }
                 }
                 if (isSignal(value)) {
                     const signalData = new EffectPropData({
@@ -2742,13 +2822,13 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                     continue;
                 }
                 if (elementName === 'textarea' && key === 'value') {
-                    if (typeof value !== 'string') {
+                    if (value && typeof value !== 'string') {
                         if (isDev) {
-                            throw qError(QError.wrongTextareaValue);
+                            throw qError(QError.wrongTextareaValue, [currentFile, value]);
                         }
                         continue;
                     }
-                    element.value = escapeHTML(value);
+                    element.value = escapeHTML(value || '');
                     continue;
                 }
                 value = serializeAttribute(key, value, scopedStyleIdPrefix);
@@ -2782,6 +2862,7 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
         const isSameElementName = vCurrent && vnode_isElementVNode(vCurrent) && elementName === vnode_getElementName(vCurrent);
         const jsxKey = jsx.key;
         let needsQDispatchEventPatch = false;
+        const currentFile = getFileLocationFromJsx(jsx.dev);
         if (!isSameElementName || jsxKey !== getKey(vCurrent)) {
             // So we have a key and it does not match the current node.
             // We need to do a forward search to find it.
@@ -2794,14 +2875,21 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
             else {
                 // Existing keyed node
                 vnode_insertBefore(journal, vParent, vNewNode, vCurrent);
+                // We are here, so jsx is different from the vCurrent, so now we want to point to the moved node.
+                vCurrent = vNewNode;
+                // We need to clean up the vNewNode, because we don't want to skip advance to next sibling (see `advance` function).
+                vNewNode = null;
+                // We need also to go back to the previous sibling, because we assigned previous sibling to the vCurrent.
+                if (vSiblings !== null) {
+                    vSiblingsIdx -= SiblingsArray.Size;
+                }
             }
         }
         // reconcile attributes
         const jsxAttrs = [];
         const props = jsx.varProps;
         for (const key in props) {
-            let value = props[key];
-            value = serializeAttribute(key, value, scopedStyleIdPrefix);
+            const value = props[key];
             if (value != null) {
                 mapArray_set(jsxAttrs, key, value, 0);
             }
@@ -2810,7 +2898,8 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
             mapArray_set(jsxAttrs, ELEMENT_KEY, jsxKey, 0);
         }
         const vNode = (vNewNode || vCurrent);
-        needsQDispatchEventPatch = setBulkProps(vNode, jsxAttrs) || needsQDispatchEventPatch;
+        needsQDispatchEventPatch =
+            setBulkProps(vNode, jsxAttrs, currentFile) || needsQDispatchEventPatch;
         if (needsQDispatchEventPatch) {
             // Event handler needs to be patched onto the element.
             const element = vnode_getNode(vNode);
@@ -2835,7 +2924,7 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
         }
     }
     /** @param tag Returns true if `qDispatchEvent` needs patching */
-    function setBulkProps(vnode, srcAttrs) {
+    function setBulkProps(vnode, srcAttrs, currentFile) {
         vnode_ensureElementInflated(vnode);
         const dstAttrs = vnode;
         let srcIdx = 0;
@@ -2860,11 +2949,18 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                     value(element);
                     return;
                 }
+                else {
+                    throw qError(QError.invalidRefValue, [currentFile]);
+                }
             }
             if (isSignal(value)) {
-                value = untrack(() => value.value);
+                const signalData = new EffectPropData({
+                    $scopedStyleIdPrefix$: scopedStyleIdPrefix,
+                    $isConst$: false,
+                });
+                value = trackSignalAndAssignHost(value, vnode, key, container, signalData);
             }
-            vnode_setAttr(journal, vnode, key, value);
+            vnode_setAttr(journal, vnode, key, serializeAttribute(key, value, scopedStyleIdPrefix));
             if (value === null) {
                 // if we set `null` than attribute was removed and we need to shorten the dstLength
                 dstLength = dstAttrs.length;
@@ -2920,6 +3016,10 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                 }
                 srcIdx++;
                 srcKey = srcIdx < srcLength ? srcAttrs[srcIdx++] : null;
+                // we need to increment dstIdx too, because we added destination key and value to the VNode
+                // and dstAttrs is a reference to the VNode
+                dstIdx++;
+                dstKey = dstIdx < dstLength ? dstAttrs[dstIdx++] : null;
             }
             else if (srcKey == dstKey) {
                 const srcValue = srcAttrs[srcIdx++];
@@ -3037,7 +3137,7 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
             vNewNode = retrieveChildWithKey(null, jsxKey);
             if (vNewNode != null) {
                 // We found it, move it up.
-                vnode_insertBefore(journal, vParent, (vNewNode = vnode_newVirtual()), vCurrent && getInsertBefore());
+                vnode_insertBefore(journal, vParent, vNewNode, vCurrent && getInsertBefore());
                 return;
             }
         }
@@ -3279,7 +3379,7 @@ function cleanup(container, vNode) {
                         const obj = seq[i];
                         if (isTask(obj)) {
                             const task = obj;
-                            clearSubscriberEffectDependencies(task);
+                            clearSubscriberEffectDependencies(container, task);
                             if (task.$flags$ & TaskFlags.VISIBLE_TASK) {
                                 container.$scheduler$(ChoreType.CLEANUP_VISIBLE, task);
                             }
@@ -3612,7 +3712,7 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
             $executed$: false,
         };
         chore.$promise$ = new Promise((resolve) => (chore.$resolve$ = resolve));
-        chore = sortedInsert(choreQueue, chore);
+        chore = sortedInsert(choreQueue, chore, container.rootVNode || null);
         if (!journalFlushScheduled && runLater) {
             // If we are not currently draining, we need to schedule a drain.
             journalFlushScheduled = true;
@@ -3623,7 +3723,7 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
             return chore.$promise$;
         }
         else {
-            return drainUpTo(chore);
+            return drainUpTo(chore, container.rootVNode || null);
         }
     }
     /**
@@ -3631,7 +3731,7 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
      *
      * @param runUptoChore
      */
-    function drainUpTo(runUptoChore) {
+    function drainUpTo(runUptoChore, rootVNode) {
         // If it already ran, it's not in the queue
         if (runUptoChore.$executed$) {
             return runUptoChore.$returnValue$;
@@ -3642,7 +3742,7 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
         }
         while (choreQueue.length) {
             const nextChore = choreQueue.shift();
-            const order = choreComparator(nextChore, runUptoChore, false);
+            const order = choreComparator(nextChore, runUptoChore, rootVNode, false);
             if (order === null) {
                 continue;
             }
@@ -3658,7 +3758,7 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
             }
             const returnValue = executeChore(nextChore);
             if (isPromise(returnValue)) {
-                const promise = returnValue.then(() => drainUpTo(runUptoChore));
+                const promise = returnValue.then(() => drainUpTo(runUptoChore, rootVNode));
                 return promise;
             }
         }
@@ -3779,7 +3879,7 @@ function vNodeAlreadyDeleted(chore) {
         vnode_isVNode(chore.$host$) &&
         chore.$host$[VNodeProps.flags] & VNodeFlags.Deleted);
 }
-function choreComparator(a, b, shouldThrowOnHostMismatch) {
+function choreComparator(a, b, rootVNode, shouldThrowOnHostMismatch) {
     const macroTypeDiff = (a.$type$ & ChoreType.MACRO) - (b.$type$ & ChoreType.MACRO);
     if (macroTypeDiff !== 0) {
         return macroTypeDiff;
@@ -3792,7 +3892,7 @@ function choreComparator(a, b, shouldThrowOnHostMismatch) {
         if (aHost !== bHost && aHost !== null && bHost !== null) {
             if (vnode_isVNode(aHost) && vnode_isVNode(bHost)) {
                 // we are running on the client.
-                const hostDiff = vnode_documentPosition(aHost, bHost);
+                const hostDiff = vnode_documentPosition(aHost, bHost, rootVNode);
                 if (hostDiff !== 0) {
                     return hostDiff;
                 }
@@ -3833,7 +3933,7 @@ function choreComparator(a, b, shouldThrowOnHostMismatch) {
     }
     return 0;
 }
-function sortedFindIndex(sortedArray, value) {
+function sortedFindIndex(sortedArray, value, rootVNode) {
     /// We need to ensure that the `queue` is sorted by priority.
     /// 1. Find a place where to insert into.
     let bottom = 0;
@@ -3841,7 +3941,7 @@ function sortedFindIndex(sortedArray, value) {
     while (bottom < top) {
         const middle = bottom + ((top - bottom) >> 1);
         const midChore = sortedArray[middle];
-        const comp = choreComparator(value, midChore, true);
+        const comp = choreComparator(value, midChore, rootVNode, true);
         if (comp < 0) {
             top = middle;
         }
@@ -3855,10 +3955,10 @@ function sortedFindIndex(sortedArray, value) {
     }
     return ~bottom;
 }
-function sortedInsert(sortedArray, value) {
+function sortedInsert(sortedArray, value, rootVNode) {
     /// We need to ensure that the `queue` is sorted by priority.
     /// 1. Find a place where to insert into.
-    const idx = sortedFindIndex(sortedArray, value);
+    const idx = sortedFindIndex(sortedArray, value, rootVNode);
     if (idx < 0) {
         /// 2. Insert the chore into the queue.
         sortedArray.splice(~idx, 0, value);
@@ -3936,7 +4036,7 @@ const runTask = (task, container, host) => {
     cleanupTask(task);
     const iCtx = newInvokeContext(container.$locale$, host, undefined, TaskEvent);
     iCtx.$container$ = container;
-    const taskFn = task.$qrl$.getFn(iCtx, () => clearSubscriberEffectDependencies(task));
+    const taskFn = task.$qrl$.getFn(iCtx, () => clearSubscriberEffectDependencies(container, task));
     const track = (obj, prop) => {
         const ctx = newInvokeContext();
         ctx.$effectSubscriber$ = [task, EffectProperty.COMPONENT];
@@ -4568,7 +4668,7 @@ function processJSXNode(ssr, enqueue, value, options) {
                 appendClassIfScopedStyleExists(jsx, options.styleScoped);
                 let qwikInspectorAttrValue = null;
                 if (isDev && jsx.dev && jsx.type !== 'head') {
-                    qwikInspectorAttrValue = getQwikInspectorAttributeValue(jsx.dev);
+                    qwikInspectorAttrValue = getFileLocationFromJsx(jsx.dev);
                     if (qInspector) {
                         appendQwikInspectorAttribute(jsx, qwikInspectorAttrValue);
                     }
@@ -4842,13 +4942,6 @@ function getSlotName(host, jsx, ssr) {
     }
     return directGetPropsProxyProp(jsx, 'name') || QDefaultSlot;
 }
-function getQwikInspectorAttributeValue(jsxDev) {
-    const sanitizedFileName = jsxDev.fileName?.replace(/\\/g, '/');
-    if (sanitizedFileName) {
-        return `${sanitizedFileName}:${jsxDev.lineNumber}:${jsxDev.columnNumber}`;
-    }
-    return null;
-}
 function appendQwikInspectorAttribute(jsx, qwikInspectorAttrValue) {
     if (qwikInspectorAttrValue && (!jsx.constProps || !(qwikInspectorAttr in jsx.constProps))) {
         (jsx.constProps ||= {})[qwikInspectorAttr] = qwikInspectorAttrValue;
@@ -4870,7 +4963,7 @@ function appendClassIfScopedStyleExists(jsx, styleScoped) {
  *
  * @public
  */
-const version = "2.0.0-alpha.4-dev+374e0d6";
+const version = "2.0.0-alpha.5-dev+cb53bbd";
 
 /** @internal */
 class _SharedContainer {
@@ -6761,7 +6854,7 @@ const vnode_getNode = (vnode) => {
     assertTrue(vnode_isTextVNode(vnode), 'Expecting Text Node.');
     return vnode[TextVNodeProps.node];
 };
-function vnode_toString(depth = 10, offset = '', materialize = false, siblings = false) {
+function vnode_toString(depth = 20, offset = '', materialize = false, siblings = false) {
     let vnode = this;
     if (depth === 0) {
         return '...';
@@ -6978,20 +7071,24 @@ const vnode_getType = (vnode) => {
     throw qError(QError.invalidVNodeType, [type]);
 };
 const isElement = (node) => node && typeof node == 'object' && fastNodeType(node) === /** Node.ELEMENT_NODE* */ 1;
-/// These global variables are used to avoid creating new arrays for each call to `vnode_getPathToClosestDomNode`.
+/// These global variables are used to avoid creating new arrays for each call to `vnode_documentPosition`.
 const aPath = [];
 const bPath = [];
-const vnode_documentPosition = (a, b) => {
+const vnode_documentPosition = (a, b, rootVNode) => {
     if (a === b) {
         return 0;
     }
     let aDepth = -1;
     let bDepth = -1;
     while (a) {
-        a = (aPath[++aDepth] = a)[VNodeProps.parent];
+        const vNode = (aPath[++aDepth] = a);
+        a = (vNode[VNodeProps.parent] ||
+            (rootVNode && vnode_getProp(a, QSlotParent, (id) => vnode_locate(rootVNode, id))));
     }
     while (b) {
-        b = (bPath[++bDepth] = b)[VNodeProps.parent];
+        const vNode = (bPath[++bDepth] = b);
+        b = (vNode[VNodeProps.parent] ||
+            (rootVNode && vnode_getProp(b, QSlotParent, (id) => vnode_locate(rootVNode, id))));
     }
     while (aDepth >= 0 && bDepth >= 0) {
         a = aPath[aDepth];
@@ -7017,6 +7114,11 @@ const vnode_documentPosition = (a, b) => {
                     return -1;
                 }
             } while (cursor);
+            if (rootVNode && vnode_getProp(b, QSlotParent, (id) => vnode_locate(rootVNode, id))) {
+                // The "b" node is a projection, so we need to set it after "a" node,
+                // because the "a" node could be a context provider.
+                return -1;
+            }
             // The node is not in the list of siblings, that means it must be disconnected.
             return 1;
         }
@@ -7049,11 +7151,7 @@ const vnode_getProjectionParentComponent = (vHost, rootVNode) => {
     while (projectionDepth--) {
         while (vHost &&
             (vnode_isVirtualVNode(vHost) ? vnode_getProp(vHost, OnRenderProp, null) === null : true)) {
-            const qSlotParentProp = vnode_getProp(vHost, QSlotParent, null);
-            const qSlotParent = qSlotParentProp &&
-                (typeof qSlotParentProp === 'string'
-                    ? vnode_locate(rootVNode, qSlotParentProp)
-                    : qSlotParentProp);
+            const qSlotParent = vnode_getProp(vHost, QSlotParent, (id) => vnode_locate(rootVNode, id));
             const vProjectionParent = vnode_isVirtualVNode(vHost) && qSlotParent;
             if (vProjectionParent) {
                 // We found a projection, so we need to go up one more level.
@@ -7962,14 +8060,14 @@ class DomContainer extends _SharedContainer {
                 if (vnode_getProp(vNode, OnRenderProp, null) !== null) {
                     return vNode;
                 }
-                // If virtual node, than it could be a slot so we need to read its parent.
-                const parent = vnode_getProp(vNode, QSlotParent, this.$vnodeLocate$);
-                if (parent) {
-                    vNode = parent;
-                    continue;
-                }
+                vNode =
+                    vnode_getParent(vNode) ||
+                        // If virtual node, than it could be a slot so we need to read its parent.
+                        vnode_getProp(vNode, QSlotParent, this.$vnodeLocate$);
+            }
+            else {
+                vNode = vnode_getParent(vNode);
             }
-            vNode = vnode_getParent(vNode);
         }
         return null;
     }
@@ -8069,12 +8167,6 @@ class DomContainer extends _SharedContainer {
 
 /** There's [documentation](./serialization.md) */
 const deserializedProxyMap = new WeakMap();
-const unwrapDeserializerProxy = (value) => {
-    const unwrapped = typeof value === 'object' &&
-        value !== null &&
-        value[SERIALIZER_PROXY_UNWRAP];
-    return unwrapped ? unwrapped : value;
-};
 const isDeserializerProxy = (value) => {
     return typeof value === 'object' && value !== null && SERIALIZER_PROXY_UNWRAP in value;
 };
@@ -8127,14 +8219,14 @@ class DeserializationHandler {
             return value;
         }
         const container = this.$container$;
-        const propValue = allocate(container, typeId, value);
-        Reflect.set(target, property, propValue);
-        this.$data$[idx] = undefined;
-        this.$data$[idx + 1] = propValue;
+        let propValue = allocate(container, typeId, value);
         /** We stored the reference, so now we can inflate, allowing cycles. */
         if (typeId >= TypeIds.Error) {
-            inflate(container, propValue, typeId, value);
+            propValue = inflate(container, propValue, typeId, value);
         }
+        Reflect.set(target, property, propValue);
+        this.$data$[idx] = undefined;
+        this.$data$[idx + 1] = propValue;
         return propValue;
     }
     has(target, property) {
@@ -8173,7 +8265,7 @@ const resolvers = new WeakMap();
 const inflate = (container, target, typeId, data) => {
     if (typeId === undefined) {
         // Already processed
-        return;
+        return target;
     }
     // restore the complex data, except for plain objects
     if (typeId !== TypeIds.Object && Array.isArray(data)) {
@@ -8245,16 +8337,13 @@ const inflate = (container, target, typeId, data) => {
         case TypeIds.Store:
         case TypeIds.StoreArray: {
             const [value, flags, effects, storeEffect] = data;
-            const handler = getStoreHandler(target);
-            handler.$flags$ = flags;
-            // First assign so it sets up the deep stores
-            Object.assign(getStoreTarget(target), value);
-            // Afterwards restore the effects so they don't get triggered
+            const store = getOrCreateStore(value, flags, container);
+            const storeHandler = getStoreHandler(store);
             if (storeEffect) {
                 effects[STORE_ARRAY_PROP] = storeEffect;
             }
-            handler.$effects$ = effects;
-            container.$storeProxyMap$.set(value, target);
+            storeHandler.$effects$ = effects;
+            target = store;
             break;
         }
         case TypeIds.Signal: {
@@ -8381,6 +8470,7 @@ const inflate = (container, target, typeId, data) => {
         default:
             throw qError(QError.serializeErrorNotImplemented, [typeId]);
     }
+    return target;
 };
 const _constants = [
     undefined,
@@ -8446,9 +8536,9 @@ const allocate = (container, typeId, value) => {
         case TypeIds.ComputedSignal:
             return new ComputedSignal(container, null);
         case TypeIds.Store:
-            return createStore(container, {}, 0);
         case TypeIds.StoreArray:
-            return createStore(container, [], 0);
+            // ignore allocate, we need to assign target while creating store
+            return null;
         case TypeIds.URLSearchParams:
             return new URLSearchParams(value);
         case TypeIds.FormData:
@@ -9310,15 +9400,15 @@ function _deserialize(rawStateData, element) {
     }
     return output;
 }
-function deserializeData(container, typeId, propValue) {
+function deserializeData(container, typeId, value) {
     if (typeId === undefined) {
-        return propValue;
+        return value;
     }
-    const value = allocate(container, typeId, propValue);
+    let propValue = allocate(container, typeId, value);
     if (typeId >= TypeIds.Error) {
-        inflate(container, value, typeId, propValue);
+        propValue = inflate(container, propValue, typeId, value);
     }
-    return value;
+    return propValue;
 }
 function getObjectById(id, stateData) {
     if (typeof id === 'string') {