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

package/dist/core.cjs

@@ -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
@@ -152,7 +152,7 @@
                 '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
@@ -160,7 +160,7 @@
                 '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
@@ -1138,7 +1138,6 @@
         }
         /** 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;
@@ -1207,6 +1206,8 @@
         // 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;
@@ -1277,32 +1278,40 @@
         }
         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--) {
@@ -1313,15 +1322,69 @@
                 }
             }
         }
-        // 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) => {
@@ -1408,14 +1471,17 @@
                 // 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));
@@ -1456,7 +1522,7 @@
         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) => {
@@ -2257,6 +2323,17 @@
         }
     }
 
+    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$;
         /**
@@ -2700,7 +2777,7 @@
          *
          * @returns {boolean}
          */
-        function createNewElement(jsx, elementName) {
+        function createNewElement(jsx, elementName, currentFile) {
             const element = createElementWithNamespace(elementName);
             const { constProps } = jsx;
             let needsQDispatchEventPatch = false;
@@ -2731,6 +2808,9 @@
                             value(element);
                             continue;
                         }
+                        else {
+                            throw qError(QError.invalidRefValue, [currentFile]);
+                        }
                     }
                     if (isSignal(value)) {
                         const signalData = new EffectPropData({
@@ -2745,13 +2825,13 @@
                         continue;
                     }
                     if (elementName === 'textarea' && key === 'value') {
-                        if (typeof value !== 'string') {
+                        if (value && typeof value !== 'string') {
                             if (build.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);
@@ -2785,6 +2865,7 @@
             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.
@@ -2797,14 +2878,21 @@
                 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);
                 }
@@ -2813,7 +2901,8 @@
                 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);
@@ -2838,7 +2927,7 @@
             }
         }
         /** @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;
@@ -2863,11 +2952,18 @@
                         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;
@@ -2923,6 +3019,10 @@
                     }
                     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++];
@@ -3040,7 +3140,7 @@
                 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;
                 }
             }
@@ -3282,7 +3382,7 @@
                             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);
                                 }
@@ -3615,7 +3715,7 @@
                 $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;
@@ -3626,7 +3726,7 @@
                 return chore.$promise$;
             }
             else {
-                return drainUpTo(chore);
+                return drainUpTo(chore, container.rootVNode || null);
             }
         }
         /**
@@ -3634,7 +3734,7 @@
          *
          * @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$;
@@ -3645,7 +3745,7 @@
             }
             while (choreQueue.length) {
                 const nextChore = choreQueue.shift();
-                const order = choreComparator(nextChore, runUptoChore, false);
+                const order = choreComparator(nextChore, runUptoChore, rootVNode, false);
                 if (order === null) {
                     continue;
                 }
@@ -3661,7 +3761,7 @@
                 }
                 const returnValue = executeChore(nextChore);
                 if (isPromise(returnValue)) {
-                    const promise = returnValue.then(() => drainUpTo(runUptoChore));
+                    const promise = returnValue.then(() => drainUpTo(runUptoChore, rootVNode));
                     return promise;
                 }
             }
@@ -3782,7 +3882,7 @@
             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;
@@ -3795,7 +3895,7 @@
             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;
                     }
@@ -3836,7 +3936,7 @@
         }
         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;
@@ -3844,7 +3944,7 @@
         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;
             }
@@ -3858,10 +3958,10 @@
         }
         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);
@@ -3939,7 +4039,7 @@
         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];
@@ -4571,7 +4671,7 @@
                     appendClassIfScopedStyleExists(jsx, options.styleScoped);
                     let qwikInspectorAttrValue = null;
                     if (build.isDev && jsx.dev && jsx.type !== 'head') {
-                        qwikInspectorAttrValue = getQwikInspectorAttributeValue(jsx.dev);
+                        qwikInspectorAttrValue = getFileLocationFromJsx(jsx.dev);
                         if (qInspector) {
                             appendQwikInspectorAttribute(jsx, qwikInspectorAttrValue);
                         }
@@ -4845,13 +4945,6 @@
         }
         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;
@@ -4873,7 +4966,7 @@
      *
      * @public
      */
-    const version = "2.0.0-alpha.4-dev+374e0d6";
+    const version = "2.0.0-alpha.5-dev+cb53bbd";
 
     /** @internal */
     class _SharedContainer {
@@ -6764,7 +6857,7 @@
         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 '...';
@@ -6981,20 +7074,24 @@
         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];
@@ -7020,6 +7117,11 @@
                         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;
             }
@@ -7052,11 +7154,7 @@
         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.
@@ -7965,14 +8063,14 @@
                     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;
         }
@@ -8072,12 +8170,6 @@
 
     /** 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;
     };
@@ -8130,14 +8222,14 @@
                 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) {
@@ -8176,7 +8268,7 @@
     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)) {
@@ -8248,16 +8340,13 @@
             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: {
@@ -8384,6 +8473,7 @@
             default:
                 throw qError(QError.serializeErrorNotImplemented, [typeId]);
         }
+        return target;
     };
     const _constants = [
         undefined,
@@ -8449,9 +8539,9 @@
             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:
@@ -9313,15 +9403,15 @@
         }
         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') {