@qwik.dev/core 2.0.0-beta.24 → 2.0.0-beta.26

package/dist/core.prod.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.24-dev+314726b
+ * @qwik.dev/core 2.0.0-beta.26-dev+c693cf5
  * 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
@@ -523,7 +523,7 @@ const isObjectEmpty = obj => {
     return !0;
 };
 
-const version = "2.0.0-beta.24-dev+314726b";
+const version = "2.0.0-beta.26-dev+c693cf5";
 
 const createPlatform = () => ({
     isServer,
@@ -534,6 +534,7 @@ const createPlatform = () => ({
             if (regSym) {
                 return regSym;
             }
+            throw qError(6, [ symbolName ]);
         }
         if (!url) {
             throw qError(14, [ symbolName ]);
@@ -1721,6 +1722,8 @@ const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
                     }
                     _hasOwnProperty$1.call(constProps, attr) && !processedKeys.has(attr) || (constProps[attr] = constProps[k]);
                     delete constProps[k];
+                } else {
+                    k === "bind:checked" ? bindCheckedSignal = constProps[k] : k === "bind:value" && (bindValueSignal = constProps[k]);
                 }
                 processedKeys.add(k);
             }
@@ -1744,46 +1747,65 @@ const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
                 }
                 processedKeys.add(k);
             }
-            if (bindCheckedSignal || bindValueSignal) {
-                if (!varPropsCopied) {
-                    varProps = {
-                        ...varProps
-                    };
-                    varPropsCopied = !0;
+        }
+        if (bindCheckedSignal || bindValueSignal) {
+            if (!varPropsCopied) {
+                varProps = {
+                    ...varProps
+                };
+                varPropsCopied = !0;
+            }
+            varProps ||= {};
+            if (bindCheckedSignal) {
+                varProps && _hasOwnProperty$1.call(varProps, "bind:checked") && delete varProps["bind:checked"];
+                if (constProps && _hasOwnProperty$1.call(constProps, "bind:checked")) {
+                    if (!constPropsCopied) {
+                        constProps = {
+                            ...constProps
+                        };
+                        constPropsCopied = !0;
+                    }
+                    delete constProps["bind:checked"];
                 }
-                if (bindCheckedSignal) {
-                    delete varProps["bind:checked"];
-                    varProps.checked = bindCheckedSignal;
-                    const handler = createQRL(null, "_chk", _chk, null, [ bindCheckedSignal ]);
-                    if (constProps && _hasOwnProperty$1.call(constProps, "q-e:input")) {
-                        if (!constPropsCopied) {
-                            constProps = {
-                                ...constProps
-                            };
-                            constPropsCopied = !0;
-                        }
-                        const existingHandler = constProps["q-e:input"];
-                        delete constProps["q-e:input"];
-                        toSort = mergeHandlers(varProps, "q-e:input", existingHandler) || toSort;
+                varProps.checked = bindCheckedSignal;
+                const handler = createQRL(null, "_chk", _chk, null, [ bindCheckedSignal ]);
+                if (constProps && _hasOwnProperty$1.call(constProps, "q-e:input")) {
+                    if (!constPropsCopied) {
+                        constProps = {
+                            ...constProps
+                        };
+                        constPropsCopied = !0;
                     }
-                    toSort = mergeHandlers(varProps, "q-e:input", handler) || toSort;
-                } else if (bindValueSignal) {
-                    delete varProps["bind:value"];
-                    varProps.value = bindValueSignal;
-                    const handler = createQRL(null, "_val", _val, null, [ bindValueSignal ]);
-                    if (constProps && _hasOwnProperty$1.call(constProps, "q-e:input")) {
-                        if (!constPropsCopied) {
-                            constProps = {
-                                ...constProps
-                            };
-                            constPropsCopied = !0;
-                        }
-                        const existingHandler = constProps["q-e:input"];
-                        delete constProps["q-e:input"];
-                        toSort = mergeHandlers(varProps, "q-e:input", existingHandler) || toSort;
+                    const existingHandler = constProps["q-e:input"];
+                    delete constProps["q-e:input"];
+                    toSort = mergeHandlers(varProps, "q-e:input", existingHandler) || toSort;
+                }
+                toSort = mergeHandlers(varProps, "q-e:input", handler) || toSort;
+            } else if (bindValueSignal) {
+                varProps && _hasOwnProperty$1.call(varProps, "bind:value") && delete varProps["bind:value"];
+                if (constProps && _hasOwnProperty$1.call(constProps, "bind:value")) {
+                    if (!constPropsCopied) {
+                        constProps = {
+                            ...constProps
+                        };
+                        constPropsCopied = !0;
                     }
-                    toSort = mergeHandlers(varProps, "q-e:input", handler) || toSort;
+                    delete constProps["bind:value"];
                 }
+                varProps.value = bindValueSignal;
+                const handler = createQRL(null, "_val", _val, null, [ bindValueSignal ]);
+                if (constProps && _hasOwnProperty$1.call(constProps, "q-e:input")) {
+                    if (!constPropsCopied) {
+                        constProps = {
+                            ...constProps
+                        };
+                        constPropsCopied = !0;
+                    }
+                    const existingHandler = constProps["q-e:input"];
+                    delete constProps["q-e:input"];
+                    toSort = mergeHandlers(varProps, "q-e:input", existingHandler) || toSort;
+                }
+                toSort = mergeHandlers(varProps, "q-e:input", handler) || toSort;
             }
         }
         if (varProps && _hasOwnProperty$1.call(varProps, "className")) {
@@ -2203,7 +2225,11 @@ const cleanupDestroyable = destroyable => {
     }
 };
 
-function runEventHandlerQRL(handler, event, element, ctx = newInvokeContextFromDOM(event, element)) {
+function runEventHandlerQRL(handler, event, element, ctx) {
+    if (!element.isConnected) {
+        return;
+    }
+    ctx || (ctx = newInvokeContextFromDOM(event, element));
     const container = ctx.$container$;
     const hostElement = ctx.$hostElement$;
     vnode_ensureElementInflated(container, hostElement);
@@ -2231,6 +2257,9 @@ function runEventHandlerQRL(handler, event, element, ctx = newInvokeContextFromD
 }
 
 function _run(event, element) {
+    if (!element.isConnected) {
+        return;
+    }
     const ctx = newInvokeContextFromDOM(event, element);
     typeof this === "string" && setCaptures(deserializeCaptures(ctx.$container$, this));
     const qrlToRun = _captures[0];
@@ -2251,37 +2280,39 @@ function setAttribute(journal, vnode, key, value, scopedStyleIdPrefix, originalV
 }
 
 const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleIdPrefix) => {
-    const diffContext = {
-        container,
-        journal,
-        cursor,
-        scopedStyleIdPrefix,
-        stack: [],
-        asyncQueue: [],
-        asyncAttributePromises: [],
-        vParent: null,
-        vCurrent: null,
-        vNewNode: null,
-        vSiblings: null,
-        vSiblingsArray: null,
-        vSideBuffer: null,
-        jsxChildren: null,
-        jsxValue: null,
-        jsxIdx: 0,
-        jsxCount: 0,
-        shouldAdvance: !0,
-        isCreationMode: !1,
-        subscriptionData: {
-            const: new SubscriptionData({
-                $scopedStyleIdPrefix$: scopedStyleIdPrefix,
-                $isConst$: !0
-            }),
-            var: new SubscriptionData({
-                $scopedStyleIdPrefix$: scopedStyleIdPrefix,
-                $isConst$: !1
-            })
-        }
-    };
+    const diffContext = function createDiffContext(container, journal, cursor, scopedStyleIdPrefix) {
+        return {
+            container,
+            journal,
+            cursor,
+            scopedStyleIdPrefix,
+            stack: [],
+            asyncQueue: [],
+            asyncAttributePromises: [],
+            vParent: null,
+            vCurrent: null,
+            vNewNode: null,
+            vSiblings: null,
+            vSiblingsArray: null,
+            vSideBuffer: null,
+            jsxChildren: null,
+            jsxValue: null,
+            jsxIdx: 0,
+            jsxCount: 0,
+            shouldAdvance: !0,
+            isCreationMode: !1,
+            subscriptionData: {
+                const: new SubscriptionData({
+                    $scopedStyleIdPrefix$: scopedStyleIdPrefix,
+                    $isConst$: !0
+                }),
+                var: new SubscriptionData({
+                    $scopedStyleIdPrefix$: scopedStyleIdPrefix,
+                    $isConst$: !1
+                })
+            }
+        };
+    }(container, journal, cursor, scopedStyleIdPrefix);
     diff(diffContext, jsxNode, vStartNode);
     const result = drainAsyncQueue(diffContext);
     if (isPromise(result)) {
@@ -2498,6 +2529,7 @@ function expectSlot(diffContext) {
         vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey);
         vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
         isDev && vnode_setProp(diffContext.vNewNode, "q:type", "P");
+        vnode_inflateProjectionTrailingText(diffContext.journal, diffContext.vNewNode);
         vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent && getInsertBefore(diffContext));
         oldParent && vnode_isElementVNode(oldParent) && !oldParent.firstChild && vnode_getElementName(oldParent) === "q:template" && vnode_remove(diffContext.journal, oldParent.parent, oldParent, !0);
     }
@@ -2915,7 +2947,7 @@ function expectComponent(diffContext, component) {
         const lookupKeysAreEqual = lookupKey === vNodeLookupKey;
         const hashesAreEqual = componentHash === vNodeComponentHash;
         if (lookupKeysAreEqual) {
-            if (hashesAreEqual && jsxNode.key) {
+            if (hashesAreEqual) {
                 deleteFromSideBuffer(diffContext, null, lookupKey);
             } else {
                 insertNewComponent(diffContext, host, componentQRL, jsxProps);
@@ -2931,20 +2963,28 @@ function expectComponent(diffContext, component) {
         }
         if (host) {
             const vNodeProps = vnode_getProp(host, "q:props", diffContext.container.$getObjectById$);
-            shouldRender || (shouldRender ||= function handleProps(host, jsxProps, vNodeProps, container) {
-                let shouldRender = !1;
-                if (vNodeProps) {
-                    const constPropsDifferent = handleChangedProps(jsxProps[_CONST_PROPS], vNodeProps[_CONST_PROPS], vNodeProps[_PROPS_HANDLER], container, !1);
-                    shouldRender ||= constPropsDifferent;
-                    const varPropsDifferent = handleChangedProps(jsxProps[_VAR_PROPS], vNodeProps[_VAR_PROPS], vNodeProps[_PROPS_HANDLER], container, !0);
-                    shouldRender ||= varPropsDifferent;
-                    vNodeProps[_OWNER] = jsxProps[_OWNER];
-                } else if (jsxProps) {
-                    vnode_setProp(host, "q:props", jsxProps);
-                    vNodeProps = jsxProps;
+            if (!shouldRender) {
+                const propsChanged = function handleProps(host, jsxProps, vNodeProps, container) {
+                    let shouldRender = !1;
+                    if (vNodeProps) {
+                        const constPropsDifferent = handleChangedProps(jsxProps[_CONST_PROPS], vNodeProps[_CONST_PROPS], vNodeProps[_PROPS_HANDLER], container, !1);
+                        shouldRender ||= constPropsDifferent;
+                        const varPropsDifferent = handleChangedProps(jsxProps[_VAR_PROPS], vNodeProps[_VAR_PROPS], vNodeProps[_PROPS_HANDLER], container, !0);
+                        shouldRender ||= varPropsDifferent;
+                        vNodeProps[_OWNER] = jsxProps[_OWNER];
+                    } else if (jsxProps) {
+                        vnode_setProp(host, "q:props", jsxProps);
+                        vNodeProps = jsxProps;
+                    }
+                    return shouldRender;
+                }(host, jsxProps, vNodeProps, diffContext.container);
+                if (propsChanged && jsxNode.key == null) {
+                    insertNewComponent(diffContext, host, componentQRL, jsxProps);
+                    host = diffContext.vNewNode;
+                    shouldRender = !0;
                 }
-                return shouldRender;
-            }(host, jsxProps, vNodeProps, diffContext.container));
+                shouldRender ||= propsChanged;
+            }
             if (shouldRender) {
                 vnode_setProp(host, "q:renderFn", componentQRL);
                 host.flags &= -33;
@@ -2989,7 +3029,7 @@ function expectComponent(diffContext, component) {
         const lookupKeysAreEqual = lookupKey === vNodeLookupKey;
         const vNodeComponentHash = getComponentHash(host, diffContext.container.$getObjectById$);
         const isInlineComponent = vNodeComponentHash == null;
-        if (host && !isInlineComponent || lookupKey == null) {
+        if (host && !isInlineComponent || !host) {
             insertNewInlineComponent(diffContext);
             host = diffContext.vNewNode;
         } else if (lookupKeysAreEqual) {
@@ -3495,7 +3535,7 @@ function walkCursor(cursor, options) {
             });
             return;
         }
-        if (!isRunningOnServer && !import.meta.env.TEST) {
+        if (isBrowser) {
             const elapsed = performance.now() - startTime;
             if (elapsed >= timeBudget) {
                 scheduleYield();
@@ -3670,7 +3710,7 @@ function getNextVNode(vNode, cursor) {
         return null;
     }
     let parent = null;
-    vNode.parent && vNode.parent.dirty & 32 ? parent = vNode.parent : vNode.slotParent && vNode.slotParent.dirty & 32 && (parent = vNode.slotParent);
+    vNode.slotParent && vNode.slotParent.dirty & 32 ? parent = vNode.slotParent : vNode.parent && vNode.parent.dirty & 32 && (parent = vNode.parent);
     if (!parent) {
         if (cursor.dirty & 127) {
             return cursor;
@@ -3756,7 +3796,7 @@ function propagatePath(target) {
         const parent = reusablePath[i + 1] || target;
         parent.dirty |= 32;
         parent.dirtyChildren ||= [];
-        parent.dirtyChildren.push(child);
+        parent.dirtyChildren.includes(child) || parent.dirtyChildren.push(child);
     }
 }
 
@@ -3774,11 +3814,11 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     if ((isRealDirty ? prevDirty & 127 : prevDirty) || vNode === cursorRoot) {
         return;
     }
-    const parent = vNode.parent || vNode.slotParent;
+    const parent = vNode.slotParent || vNode.parent;
     if (cursorRoot && isRealDirty && parent && !parent.dirty) {
         (function propagateToCursorRoot(vNode, cursorRoot) {
             reusablePath.push(vNode);
-            let current = vNode.parent || vNode.slotParent;
+            let current = vNode.slotParent || vNode.parent;
             for (;current; ) {
                 const isDirty = current.dirty & 127;
                 const currentIsCursor = isCursor(current);
@@ -3796,7 +3836,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
                     cursorData.position !== current && (cursorData.position = vNode);
                 }
                 reusablePath.push(current);
-                current = current.parent || current.slotParent;
+                current = current.slotParent || current.parent;
             }
             reusablePath.length = 0;
             throwErrorAndStop("Cursor root not found in current path!");
@@ -3806,7 +3846,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     if (parent && parent.dirty & 127) {
         isRealDirty && (parent.dirty |= 32);
         parent.dirtyChildren ||= [];
-        parent.dirtyChildren.push(vNode);
+        parent.dirtyChildren.includes(vNode) || parent.dirtyChildren.push(vNode);
         if (isRealDirty && vNode.dirtyChildren) {
             const cursor = function findCursor(vNode) {
                 for (;vNode; ) {
@@ -3822,7 +3862,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
                 let cursorPosition = cursorData.position;
                 if (cursorPosition) {
                     for (;cursorPosition !== cursor; ) {
-                        cursorPosition = cursorPosition.parent || cursorPosition.slotParent;
+                        cursorPosition = cursorPosition.slotParent || cursorPosition.parent;
                         if (cursorPosition === vNode) {
                             cursorData.position = vNode;
                             break;
@@ -3834,7 +3874,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     } else {
         isCursor(vNode) || function findAndPropagateToBlockingCursor(vNode) {
             reusablePath.push(vNode);
-            let current = vNode.parent || vNode.slotParent;
+            let current = vNode.slotParent || vNode.parent;
             for (;current; ) {
                 const currentIsCursor = isCursor(current);
                 if (currentIsCursor) {
@@ -3843,7 +3883,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
                     return !0;
                 }
                 reusablePath.push(current);
-                current = current.parent || current.slotParent;
+                current = current.slotParent || current.parent;
             }
             reusablePath.length = 0;
             return !1;
@@ -4064,6 +4104,7 @@ function vnode_walkDirectChildren(journal, vParent, callback) {
 function vnode_walkVNode(vNode, callback) {
     let vCursor = vNode;
     if (vnode_isTextVNode(vNode)) {
+        callback?.(vNode, null);
         return;
     }
     let vParent = null;
@@ -4435,9 +4476,7 @@ const vnode_insertVirtualBefore = (journal, parent, newChild, insertBefore) => {
 const vnode_findInsertBefore = (journal, parent, insertBefore) => {
     let adjustedInsertBefore = null;
     insertBefore == null ? vnode_isVirtualVNode(parent) && (adjustedInsertBefore = vnode_getDomSibling(parent, !0, !1)) : adjustedInsertBefore = vnode_isVirtualVNode(insertBefore) ? vnode_getDomSibling(insertBefore, !0, !0) : insertBefore;
-    adjustedInsertBefore && ((journal, vNode) => {
-        vnode_isTextVNode(vNode) && vnode_ensureTextInflated(journal, vNode);
-    })(journal, adjustedInsertBefore);
+    adjustedInsertBefore && vnode_isTextVNode(adjustedInsertBefore) && vnode_ensureTextInflated(journal, adjustedInsertBefore);
     return adjustedInsertBefore;
 };
 
@@ -4454,6 +4493,14 @@ const vnode_unlinkFromOldParent = (journal, currentParent, newParent, newChild)
     currentParent && (newChild.previousSibling || newChild.nextSibling || currentParent !== newParent) && vnode_remove(journal, currentParent, newChild, !1);
 };
 
+const vnode_inflateProjectionTrailingText = (journal, projection) => {
+    let last = projection;
+    for (;last && vnode_isVirtualVNode(last); ) {
+        last = last.lastChild;
+    }
+    last && vnode_isTextVNode(last) && (last.flags & 8) === 0 && vnode_ensureTextInflated(journal, last);
+};
+
 const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
     vnode_isElementOrTextVNode(newChild) ? vnode_insertElementBefore(journal, parent, newChild, insertBefore) : vnode_insertVirtualBefore(journal, parent, newChild, insertBefore);
 };
@@ -4617,6 +4664,12 @@ const ensureMaterialized = vnode => {
                                     vnode_ensureElementKeyInflated(elementVNode);
                                     addVNode(elementVNode);
                                     child = fastNextSibling(child);
+                                    for (;isElement(child) && shouldSkipElement(child); ) {
+                                        child = fastNextSibling(child);
+                                        if (!child && value > 0) {
+                                            throw qError(27, [ vData, peek(), nextToConsumeIdx ]);
+                                        }
+                                    }
                                 }
                             } else if (peek() === 59) {
                                 vnode_setProp(vParent, "q:sstyle", consumeValue());
@@ -5836,7 +5889,7 @@ class Serializer {
         } else if (value instanceof SubscriptionData) {
             this.output(31, [ value.data.$scopedStyleIdPrefix$, value.data.$isConst$ ]);
         } else if (value instanceof EffectSubscription) {
-            this.output(32, [ value.consumer, value.property, value.backRef, value.data ]);
+            this.output(32, [ value.consumer, value.property, value.data ]);
         } else if (isStore(value)) {
             const storeHandler = getStoreHandler(value);
             const storeTarget = getStoreTarget(value);
@@ -5900,12 +5953,12 @@ class Serializer {
                     const forwardRefId = this.resolvePromise(maybeValue, (resolved, resolvedValue) => new PromiseResult(26, resolved, resolvedValue, value.$effects$, value.$computeQrl$));
                     this.output(2, forwardRefId);
                 } else {
-                    this.output(26, [ value.$computeQrl$, filterEffectBackRefs(value[_EFFECT_BACK_REF]), value.$effects$, maybeValue ]);
+                    this.output(26, [ value.$computeQrl$, value.$effects$, maybeValue ]);
                 }
                 return;
             }
             if (value instanceof WrappedSignalImpl) {
-                this.output(23, [ ...serializeWrappingFn(this.$serializationContext$, value), filterEffectBackRefs(value[_EFFECT_BACK_REF]), value.$flags$, value.$hostElement$, ...value.$effects$ || [] ]);
+                this.output(23, [ ...serializeWrappingFn(this.$serializationContext$, value), value.$flags$, value.$hostElement$, ...value.$effects$ || [] ]);
             } else if (value instanceof ComputedSignalImpl) {
                 let v = value.$untrackedValue$;
                 const shouldAlwaysSerialize = value.$flags$ & 16;
@@ -5918,7 +5971,7 @@ class Serializer {
                 const timeout = isAsync && value.$timeoutMs$ !== 0 ? value.$timeoutMs$ : void 0;
                 const asyncFlags = isAsync && value.$flags$ & -25 || void 0;
                 isInvalid || isSkippable ? v = NEEDS_COMPUTATION : shouldAlwaysSerialize ? v = value.$untrackedValue$ : shouldNeverSerialize && (v = NEEDS_COMPUTATION);
-                const out = [ value.$computeQrl$, filterEffectBackRefs(value[_EFFECT_BACK_REF]), value.$effects$ ];
+                const out = [ value.$computeQrl$, value.$effects$ ];
                 if (isAsync) {
                     out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedError$);
                     out.push(asyncFlags || void 0);
@@ -6001,7 +6054,7 @@ class Serializer {
             }
             this.output(29, out);
         } else if (value instanceof Task) {
-            const out = [ value.$qrl$, value.$flags$, value.$index$, value.$el$, value[_EFFECT_BACK_REF], value.$state$ ];
+            const out = [ value.$qrl$, value.$flags$, value.$index$, value.$el$, value.$state$ ];
             for (;out[out.length - 1] === void 0; ) {
                 out.pop();
             }
@@ -6138,19 +6191,6 @@ function serializeWrappingFn(serializationContext, value) {
     return [ syncFnId, value.$args$ ];
 }
 
-function filterEffectBackRefs(effectBackRef) {
-    let effectBackRefToSerialize;
-    if (effectBackRef) {
-        for (const [effectProp, effect] of effectBackRef) {
-            if (effect.backRef) {
-                effectBackRefToSerialize ||= new Map;
-                effectBackRefToSerialize.set(effectProp, effect);
-            }
-        }
-    }
-    return effectBackRefToSerialize;
-}
-
 function tryGetBackRefs(props) {
     return Object.prototype.hasOwnProperty.call(props, "q:brefs") ? props["q:brefs"] : void 0;
 }
@@ -6682,8 +6722,7 @@ const inflate = (container, target, typeId, data) => {
         task.$flags$ = v[1];
         task.$index$ = v[2];
         task.$el$ = v[3];
-        task[_EFFECT_BACK_REF] = v[4];
-        task.$state$ = v[5];
+        task.$state$ = v[4];
         break;
 
       case 21:
@@ -6702,6 +6741,7 @@ const inflate = (container, target, typeId, data) => {
             const storeHandler = getStoreHandler(target);
             storeHandler.$flags$ = flags;
             storeHandler.$effects$ = effects;
+            restoreEffectBackRefForEffectsMap(storeHandler.$effects$, store);
             break;
         }
 
@@ -6711,6 +6751,7 @@ const inflate = (container, target, typeId, data) => {
             const d = data;
             signal.$untrackedValue$ = d[0];
             signal.$effects$ = new Set(d.slice(1));
+            restoreEffectBackRefForEffects(signal.$effects$, signal);
             break;
         }
 
@@ -6720,12 +6761,11 @@ const inflate = (container, target, typeId, data) => {
             const d = data;
             signal.$func$ = container.getSyncFn(d[0]);
             signal.$args$ = d[1];
-            signal[_EFFECT_BACK_REF] = d[2];
             signal.$untrackedValue$ = NEEDS_COMPUTATION;
-            signal.$flags$ = d[3];
+            signal.$flags$ = d[2];
             signal.$flags$ |= 1;
-            signal.$hostElement$ = d[4];
-            signal.$effects$ = new Set(d.slice(5));
+            signal.$hostElement$ = d[3];
+            signal.$effects$ = new Set(d.slice(4));
             (function inflateWrappedSignalValue(signal) {
                 if (signal.$hostElement$ !== null && vnode_isVNode(signal.$hostElement$)) {
                     const hostVNode = signal.$hostElement$;
@@ -6750,6 +6790,7 @@ const inflate = (container, target, typeId, data) => {
                     }
                 }
             })(signal);
+            restoreEffectBackRefForEffects(signal.$effects$, signal);
             break;
         }
 
@@ -6758,19 +6799,21 @@ const inflate = (container, target, typeId, data) => {
             const asyncSignal = target;
             const d = data;
             asyncSignal.$computeQrl$ = d[0];
-            asyncSignal[_EFFECT_BACK_REF] = d[1];
-            asyncSignal.$effects$ = new Set(d[2]);
-            asyncSignal.$loadingEffects$ = new Set(d[3]);
-            asyncSignal.$errorEffects$ = new Set(d[4]);
-            asyncSignal.$untrackedError$ = d[5];
-            asyncSignal.$flags$ = d[6] ?? 0;
+            asyncSignal.$effects$ = new Set(d[1]);
+            asyncSignal.$loadingEffects$ = new Set(d[2]);
+            asyncSignal.$errorEffects$ = new Set(d[3]);
+            asyncSignal.$untrackedError$ = d[4];
+            asyncSignal.$flags$ = d[5] ?? 0;
             asyncSignal.$flags$ & 64 && (asyncSignal.$untrackedLoading$ = !0);
-            const hasValue = d.length > 7;
-            hasValue && (asyncSignal.$untrackedValue$ = d[7]);
+            const hasValue = d.length > 6;
+            hasValue && (asyncSignal.$untrackedValue$ = d[6]);
             asyncSignal.$untrackedValue$ === NEEDS_COMPUTATION && (asyncSignal.$flags$ |= 1);
-            asyncSignal.interval = d[8] ?? 0;
-            asyncSignal.$concurrency$ = d[9] ?? 1;
-            asyncSignal.$timeoutMs$ = d[10] ?? 0;
+            asyncSignal.interval = d[7] ?? 0;
+            asyncSignal.$concurrency$ = d[8] ?? 1;
+            asyncSignal.$timeoutMs$ = d[9] ?? 0;
+            restoreEffectBackRefForEffects(asyncSignal.$effects$, asyncSignal);
+            restoreEffectBackRefForEffects(asyncSignal.$loadingEffects$, asyncSignal);
+            restoreEffectBackRefForEffects(asyncSignal.$errorEffects$, asyncSignal);
             break;
         }
 
@@ -6782,11 +6825,11 @@ const inflate = (container, target, typeId, data) => {
             computed.$computeQrl$ = d[0];
             const p = computed.$computeQrl$.resolve(container).catch(() => {});
             loading = loading.finally(() => p);
-            computed[_EFFECT_BACK_REF] = d[1];
-            d[2] && (computed.$effects$ = new Set(d[2]));
-            const hasValue = d.length > 3;
-            hasValue && (computed.$untrackedValue$ = d[3]);
+            d[1] && (computed.$effects$ = new Set(d[1]));
+            const hasValue = d.length > 2;
+            hasValue && (computed.$untrackedValue$ = d[2]);
             typeId !== 26 && computed.$untrackedValue$ !== NEEDS_COMPUTATION && (computed.$flags$ &= -2);
+            restoreEffectBackRefForEffects(computed.$effects$, computed);
             break;
         }
 
@@ -6870,7 +6913,9 @@ const inflate = (container, target, typeId, data) => {
             owner._proxy = propsProxy;
         }
         propsProxy[_OWNER] = owner;
-        propsProxy[_PROPS_HANDLER].$effects$ = d[3];
+        const propsHandler = propsProxy[_PROPS_HANDLER];
+        propsHandler.$effects$ = d[3];
+        restoreEffectBackRefForEffectsMap(propsHandler.$effects$, propsProxy);
         break;
 
       case 31:
@@ -6887,8 +6932,16 @@ const inflate = (container, target, typeId, data) => {
             const d = data;
             effectSub.consumer = d[0];
             effectSub.property = d[1];
-            effectSub.backRef = d[2];
-            effectSub.data = d[3];
+            effectSub.data = d[2];
+            (function restoreEffectBackRefForConsumer(effect) {
+                const isServerSide = import.meta.env.TEST ? isServerPlatform() : isServer;
+                const consumerBackRef = effect.consumer;
+                if (isServerSide && !consumerBackRef) {
+                    return;
+                }
+                consumerBackRef[_EFFECT_BACK_REF] ||= new Map;
+                consumerBackRef[_EFFECT_BACK_REF].set(effect.property, effect);
+            })(effectSub);
             break;
         }
 
@@ -6913,6 +6966,23 @@ function deserializeData(container, typeId, value) {
     return propValue;
 }
 
+function restoreEffectBackRefForEffects(effects, consumer) {
+    if (effects) {
+        for (const effect of effects) {
+            effect.backRef ||= new Set;
+            effect.backRef.add(consumer);
+        }
+    }
+}
+
+function restoreEffectBackRefForEffectsMap(effectsMap, consumer) {
+    if (effectsMap) {
+        for (const [, effects] of effectsMap) {
+            restoreEffectBackRefForEffects(effects, consumer);
+        }
+    }
+}
+
 const needsInflation = typeId => typeId >= 15 || typeId === 4 || typeId === 5;
 
 const deserializedProxyMap = new WeakMap;

package/dist/loader/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwik.dev/core/loader",
-  "version": "2.0.0-beta.24-dev+314726b",
+  "version": "2.0.0-beta.26-dev+c693cf5",
   "main": "index.mjs",
   "types": "index.d.ts",
   "private": true,