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

package/dist/core.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
@@ -1007,7 +1007,7 @@ const COMMA = ',';
  *
  * @public
  */
-const version = "2.0.0-beta.24-dev+314726b";
+const version = "2.0.0-beta.26-dev+c693cf5";
 
 // keep this import from core/build so the cjs build works
 const createPlatform = () => {
@@ -1020,6 +1020,8 @@ const createPlatform = () => {
                 if (regSym) {
                     return regSym;
                 }
+                // we never lazy import on the server
+                throw qError(6 /* QError.dynamicImportFailed */, [symbolName]);
             }
             if (!url) {
                 throw qError(14 /* QError.qrlMissingChunk */, [symbolName]);
@@ -3068,6 +3070,14 @@ const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
                     }
                     delete constProps[k];
                 }
+                else if (k === BIND_CHECKED) {
+                    // Set flag, will process after walk
+                    bindCheckedSignal = constProps[k];
+                }
+                else if (k === BIND_VALUE) {
+                    // Set flag, will process after walk
+                    bindValueSignal = constProps[k];
+                }
                 processedKeys.add(k);
             }
         }
@@ -3097,44 +3107,65 @@ const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
                 }
                 processedKeys.add(k);
             }
-            // Handle bind:* - only in varProps, bind:* should be moved to varProps
-            if (bindCheckedSignal || bindValueSignal) {
-                if (!varPropsCopied) {
-                    varProps = { ...varProps };
-                    varPropsCopied = true;
-                }
-                if (bindCheckedSignal) {
+        }
+        // Handle bind:* - only in varProps, bind:* should be moved to varProps
+        if (bindCheckedSignal || bindValueSignal) {
+            if (!varPropsCopied) {
+                varProps = { ...varProps };
+                varPropsCopied = true;
+            }
+            varProps ||= {};
+            if (bindCheckedSignal) {
+                // Delete from both varProps and constProps if present
+                if (varProps && _hasOwnProperty$1.call(varProps, BIND_CHECKED)) {
                     delete varProps[BIND_CHECKED];
-                    varProps.checked = bindCheckedSignal;
-                    const handler = createQRL(null, '_chk', _chk, null, [bindCheckedSignal]);
-                    // Move q-e:input from constProps if it exists
-                    if (constProps && _hasOwnProperty$1.call(constProps, 'q-e:input')) {
-                        if (!constPropsCopied) {
-                            constProps = { ...constProps };
-                            constPropsCopied = true;
-                        }
-                        const existingHandler = constProps['q-e:input'];
-                        delete constProps['q-e:input'];
-                        toSort = mergeHandlers(varProps, 'q-e:input', existingHandler) || toSort;
+                }
+                if (constProps && _hasOwnProperty$1.call(constProps, BIND_CHECKED)) {
+                    if (!constPropsCopied) {
+                        constProps = { ...constProps };
+                        constPropsCopied = true;
+                    }
+                    delete constProps[BIND_CHECKED];
+                }
+                varProps.checked = bindCheckedSignal;
+                const handler = createQRL(null, '_chk', _chk, null, [bindCheckedSignal]);
+                // Move q-e:input from constProps if it exists
+                if (constProps && _hasOwnProperty$1.call(constProps, 'q-e:input')) {
+                    if (!constPropsCopied) {
+                        constProps = { ...constProps };
+                        constPropsCopied = true;
                     }
-                    toSort = mergeHandlers(varProps, 'q-e:input', handler) || toSort;
+                    const existingHandler = constProps['q-e:input'];
+                    delete constProps['q-e:input'];
+                    toSort = mergeHandlers(varProps, 'q-e:input', existingHandler) || toSort;
                 }
-                else if (bindValueSignal) {
+                toSort = mergeHandlers(varProps, 'q-e:input', handler) || toSort;
+            }
+            else if (bindValueSignal) {
+                // Delete from both varProps and constProps if present
+                if (varProps && _hasOwnProperty$1.call(varProps, BIND_VALUE)) {
                     delete varProps[BIND_VALUE];
-                    varProps.value = bindValueSignal;
-                    const handler = createQRL(null, '_val', _val, null, [bindValueSignal]);
-                    // Move q-e:input from constProps if it exists
-                    if (constProps && _hasOwnProperty$1.call(constProps, 'q-e:input')) {
-                        if (!constPropsCopied) {
-                            constProps = { ...constProps };
-                            constPropsCopied = true;
-                        }
-                        const existingHandler = constProps['q-e:input'];
-                        delete constProps['q-e:input'];
-                        toSort = mergeHandlers(varProps, 'q-e:input', existingHandler) || toSort;
+                }
+                if (constProps && _hasOwnProperty$1.call(constProps, BIND_VALUE)) {
+                    if (!constPropsCopied) {
+                        constProps = { ...constProps };
+                        constPropsCopied = true;
                     }
-                    toSort = mergeHandlers(varProps, 'q-e:input', handler) || toSort;
+                    delete constProps[BIND_VALUE];
                 }
+                varProps.value = bindValueSignal;
+                const handler = createQRL(null, '_val', _val, null, [bindValueSignal]);
+                // Move q-e:input from constProps if it exists
+                if (constProps && _hasOwnProperty$1.call(constProps, 'q-e:input')) {
+                    if (!constPropsCopied) {
+                        constProps = { ...constProps };
+                        constPropsCopied = true;
+                    }
+                    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;
             }
         }
         // Transform className -> class
@@ -3676,7 +3707,14 @@ const cleanupDestroyable = (destroyable) => {
  * This safely calls an event handler, handling errors and retrying on thrown Promises, and
  * providing extra parameters defined on the elements as arguments (used for loop optimization)
  */
-function runEventHandlerQRL(handler, event, element, ctx = newInvokeContextFromDOM(event, element)) {
+function runEventHandlerQRL(handler, event, element, ctx) {
+    if (!element.isConnected) {
+        // ignore events on disconnected elements, this can happen when the event is triggered while the element is being removed
+        return;
+    }
+    if (!ctx) {
+        ctx = newInvokeContextFromDOM(event, element);
+    }
     const container = ctx.$container$;
     const hostElement = ctx.$hostElement$;
     vnode_ensureElementInflated(container, hostElement);
@@ -3712,6 +3750,10 @@ function runEventHandlerQRL(handler, event, element, ctx = newInvokeContextFromD
  * @internal
  */
 function _run(event, element) {
+    if (!element.isConnected) {
+        // ignore events on disconnected elements, this can happen when the event is triggered while the element is being removed
+        return;
+    }
     const ctx = newInvokeContextFromDOM(event, element);
     if (typeof this === 'string') {
         setCaptures(deserializeCaptures(ctx.$container$, this));
@@ -3737,8 +3779,8 @@ function setAttribute(journal, vnode, key, value, scopedStyleIdPrefix, originalV
     vnode_setProp(vnode, key, originalValue);
     addVNodeOperation(journal, createSetAttributeOperation(vnode.node, key, value, scopedStyleIdPrefix, (vnode.flags & 512 /* VNodeFlags.NS_svg */) !== 0));
 }
-const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleIdPrefix) => {
-    const diffContext = {
+function createDiffContext(container, journal, cursor, scopedStyleIdPrefix) {
+    return {
         container,
         journal,
         cursor,
@@ -3769,6 +3811,9 @@ const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyle
             }),
         },
     };
+}
+const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleIdPrefix) => {
+    const diffContext = createDiffContext(container, journal, cursor, scopedStyleIdPrefix);
     ////////////////////////////////
     diff(diffContext, jsxNode, vStartNode);
     const result = drainAsyncQueue(diffContext);
@@ -4123,6 +4168,7 @@ function expectSlot(diffContext) {
         vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
         isDev &&
             vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* VirtualType.Projection */);
+        vnode_inflateProjectionTrailingText(diffContext.journal, diffContext.vNewNode);
         vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent && getInsertBefore(diffContext));
         // If we moved from a q:template and it's now empty, remove it
         if (oldParent &&
@@ -4673,26 +4719,34 @@ function expectComponent(diffContext, component) {
         const vNodeLookupKey = getKey(host) || vNodeComponentHash;
         const lookupKeysAreEqual = lookupKey === vNodeLookupKey;
         const hashesAreEqual = componentHash === vNodeComponentHash;
-        if (!lookupKeysAreEqual) {
-            if (moveOrCreateKeyedNode(diffContext, null, lookupKey, lookupKey, diffContext.vParent)) {
+        if (lookupKeysAreEqual) {
+            if (hashesAreEqual) {
+                deleteFromSideBuffer(diffContext, null, lookupKey);
+            }
+            else {
                 insertNewComponent(diffContext, host, componentQRL, jsxProps);
+                host = diffContext.vNewNode;
                 shouldRender = true;
             }
-            host = (diffContext.vNewNode || diffContext.vCurrent);
-        }
-        else if (!hashesAreEqual || !jsxNode.key) {
-            insertNewComponent(diffContext, host, componentQRL, jsxProps);
-            host = diffContext.vNewNode;
-            shouldRender = true;
         }
         else {
-            // delete the key from the side buffer if it is the same component
-            deleteFromSideBuffer(diffContext, null, lookupKey);
+            if (moveOrCreateKeyedNode(diffContext, null, lookupKey, lookupKey, diffContext.vParent)) {
+                insertNewComponent(diffContext, host, componentQRL, jsxProps);
+                shouldRender = true;
+            }
+            host = (diffContext.vNewNode || diffContext.vCurrent);
         }
         if (host) {
             const vNodeProps = vnode_getProp(host, ELEMENT_PROPS, diffContext.container.$getObjectById$);
             if (!shouldRender) {
-                shouldRender ||= handleProps(host, jsxProps, vNodeProps, diffContext.container);
+                const propsChanged = handleProps(host, jsxProps, vNodeProps, diffContext.container);
+                // if props changed but key is null we need to insert a new component, because we need to execute hooks etc
+                if (propsChanged && jsxNode.key == null) {
+                    insertNewComponent(diffContext, host, componentQRL, jsxProps);
+                    host = diffContext.vNewNode;
+                    shouldRender = true;
+                }
+                shouldRender ||= propsChanged;
             }
             if (shouldRender) {
                 // Assign the new QRL instance to the host.
@@ -4714,7 +4768,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;
         }
@@ -5706,7 +5760,7 @@ function walkCursor(cursor, options) {
             return;
         }
         // Check time budget (only for DOM, not SSR)
-        if (!isRunningOnServer && !import.meta.env.TEST) {
+        if (isBrowser) {
             const elapsed = performance.now() - startTime;
             if (elapsed >= timeBudget) {
                 // Schedule continuation as macrotask to actually yield to browser
@@ -5748,10 +5802,27 @@ function tryDescendDirtyChildren(container, cursorData, currentVNode, cursor) {
         return null;
     }
     partitionDirtyChildren(dirtyChildren, currentVNode);
+    // Scan dirtyChildren directly instead of going through getNextVNode.
+    // getNextVNode follows the child's parent/slotParent pointer, which for Projection nodes
+    // points to the DOM insertion location rather than currentVNode — that would scan the
+    // wrong dirtyChildren array and potentially cause infinite loops.
+    // const len = dirtyChildren.length;
+    // for (let i = 0; i < len; i++) {
+    //   const child = dirtyChildren[i];
+    //   if (child.dirty & ChoreBits.DIRTY_MASK) {
+    //     currentVNode.nextDirtyChildIndex = (i + 1) % len;
+    //     setCursorPosition(container, cursorData, child);
+    //     return child;
+    //   }
+    // }
+    // // No dirty child found — clean up
+    // currentVNode.dirty &= ~ChoreBits.CHILDREN;
+    // currentVNode.dirtyChildren = null;
     currentVNode.nextDirtyChildIndex = 0;
     const next = getNextVNode(dirtyChildren[0], cursor);
     setCursorPosition(container, cursorData, next);
     return next;
+    // return null;
 }
 /**
  * Partitions dirtyChildren array so non-projections come first, projections last. Uses in-place
@@ -5780,14 +5851,14 @@ function getNextVNode(vNode, cursor) {
         }
         return null;
     }
-    // Prefer parent if it's dirty, otherwise try slotParent
+    // Prefer slotParent (logical owner) for Projections, fall back to parent
     let parent = null;
-    if (vNode.parent && vNode.parent.dirty & 32 /* ChoreBits.CHILDREN */) {
-        parent = vNode.parent;
-    }
-    else if (vNode.slotParent && vNode.slotParent.dirty & 32 /* ChoreBits.CHILDREN */) {
+    if (vNode.slotParent && vNode.slotParent.dirty & 32 /* ChoreBits.CHILDREN */) {
         parent = vNode.slotParent;
     }
+    else if (vNode.parent && vNode.parent.dirty & 32 /* ChoreBits.CHILDREN */) {
+        parent = vNode.parent;
+    }
     if (!parent) {
         if (cursor.dirty & 127 /* ChoreBits.DIRTY_MASK */) {
             return cursor;
@@ -5959,7 +6030,9 @@ function propagatePath(target) {
         const parent = reusablePath[i + 1] || target;
         parent.dirty |= 32 /* ChoreBits.CHILDREN */;
         parent.dirtyChildren ||= [];
-        parent.dirtyChildren.push(child);
+        if (!parent.dirtyChildren.includes(child)) {
+            parent.dirtyChildren.push(child);
+        }
     }
 }
 /**
@@ -5968,7 +6041,7 @@ function propagatePath(target) {
  */
 function propagateToCursorRoot(vNode, cursorRoot) {
     reusablePath.push(vNode);
-    let current = vNode.parent || vNode.slotParent;
+    let current = vNode.slotParent || vNode.parent;
     while (current) {
         const isDirty = current.dirty & 127 /* ChoreBits.DIRTY_MASK */;
         const currentIsCursor = isCursor(current);
@@ -5993,7 +6066,7 @@ function propagateToCursorRoot(vNode, cursorRoot) {
             }
         }
         reusablePath.push(current);
-        current = current.parent || current.slotParent;
+        current = current.slotParent || current.parent;
     }
     reusablePath.length = 0;
     throwErrorAndStop('Cursor root not found in current path!');
@@ -6004,7 +6077,7 @@ function propagateToCursorRoot(vNode, cursorRoot) {
  */
 function findAndPropagateToBlockingCursor(vNode) {
     reusablePath.push(vNode);
-    let current = vNode.parent || vNode.slotParent;
+    let current = vNode.slotParent || vNode.parent;
     while (current) {
         const currentIsCursor = isCursor(current);
         if (currentIsCursor) {
@@ -6013,7 +6086,7 @@ function findAndPropagateToBlockingCursor(vNode) {
             return true;
         }
         reusablePath.push(current);
-        current = current.parent || current.slotParent;
+        current = current.slotParent || current.parent;
     }
     reusablePath.length = 0;
     return false;
@@ -6047,7 +6120,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     if ((isRealDirty ? prevDirty & 127 /* ChoreBits.DIRTY_MASK */ : prevDirty) || vNode === cursorRoot) {
         return;
     }
-    const parent = vNode.parent || vNode.slotParent;
+    const parent = vNode.slotParent || vNode.parent;
     // If cursorRoot is provided, propagate up to it
     if (cursorRoot && isRealDirty && parent && !parent.dirty) {
         propagateToCursorRoot(vNode, cursorRoot);
@@ -6059,7 +6132,9 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
             parent.dirty |= 32 /* ChoreBits.CHILDREN */;
         }
         parent.dirtyChildren ||= [];
-        parent.dirtyChildren.push(vNode);
+        if (!parent.dirtyChildren.includes(vNode)) {
+            parent.dirtyChildren.push(vNode);
+        }
         if (isRealDirty && vNode.dirtyChildren) {
             // this node is maybe an ancestor of the current cursor position
             // if so we must restart from here
@@ -6070,7 +6145,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
                 if (cursorPosition) {
                     // find the ancestor of the cursor position that is current vNode
                     while (cursorPosition !== cursor) {
-                        cursorPosition = cursorPosition.parent || cursorPosition.slotParent;
+                        cursorPosition = cursorPosition.slotParent || cursorPosition.parent;
                         if (cursorPosition === vNode) {
                             // set cursor position to this node
                             cursorData.position = vNode;
@@ -6454,7 +6529,7 @@ function vnode_walkVNode(vNode, callback) {
     let vCursor = vNode;
     // Depth first traversal
     if (vnode_isTextVNode(vNode)) {
-        // Text nodes don't have subscriptions or children;
+        callback?.(vNode, null);
         return;
     }
     let vParent = null;
@@ -6602,11 +6677,6 @@ const vnode_getDomSibling = (vNode, nextDirection, descend) => {
     }
     return null;
 };
-const vnode_ensureInflatedIfText = (journal, vNode) => {
-    if (vnode_isTextVNode(vNode)) {
-        vnode_ensureTextInflated(journal, vNode);
-    }
-};
 const vnode_ensureTextInflated = (journal, vnode) => {
     const textVNode = ensureTextVNode(vnode);
     const flags = textVNode.flags;
@@ -6932,7 +7002,9 @@ const vnode_findInsertBefore = (journal, parent, insertBefore) => {
     else {
         adjustedInsertBefore = insertBefore;
     }
-    adjustedInsertBefore && vnode_ensureInflatedIfText(journal, adjustedInsertBefore);
+    adjustedInsertBefore &&
+        vnode_isTextVNode(adjustedInsertBefore) &&
+        vnode_ensureTextInflated(journal, adjustedInsertBefore);
     return adjustedInsertBefore;
 };
 const vnode_connectSiblings = (parent, vNode, vNext) => {
@@ -6996,6 +7068,45 @@ const vnode_unlinkFromOldParent = (journal, currentParent, newParent, newChild)
         vnode_remove(journal, currentParent, newChild, false);
     }
 };
+/**
+ * When a projection vnode is about to be repositioned (moved in the vnode tree), its trailing text
+ * node must be inflated before the projection is unlinked from its current sibling chain.
+ * `vnode_ensureTextInflated` relies on `vnode_getDomSibling` to locate adjacent text nodes and
+ * decide which one is "last" (i.e. the one that gets to reuse the shared SSR DOM `Text` node). Once
+ * the projection is unlinked, its `nextSibling` becomes `null`, so `getDomSibling` can no longer
+ * cross the boundary to find a trailing sibling such as an empty-string text node — causing
+ * `isLastNode` to be `true` prematurely and corrupting the shared DOM text node. Inflating the
+ * trailing text node while the siblings are still connected gives it its own fresh DOM node and
+ * avoids the corruption.
+ *
+ * Example:
+ *
+ * ```
+ * <Component>
+ *   <button>
+ *     <InlineComponent>
+ *       <span>
+ *         "*"
+ *       </span>
+ *     </InlineComponent>
+ *     <Projection> // <-- this projection when unlinked from the siblings will cause the "test" text node to be considered the last node without inflating it
+ *       "test" // <-- this text node is sharing the same DOM node with the ""
+ *     </Projection>
+ *     "" <-- this text node is sharing the same DOM node with the "test"
+ *   </button>
+ * </Component>
+ * ```
+ */
+const vnode_inflateProjectionTrailingText = (journal, projection) => {
+    // Follow lastChild through any inner virtual wrappers to reach the actual trailing text node.
+    let last = projection;
+    while (last && vnode_isVirtualVNode(last)) {
+        last = last.lastChild;
+    }
+    if (last && vnode_isTextVNode(last) && (last.flags & 8 /* VNodeFlags.Inflated */) === 0) {
+        vnode_ensureTextInflated(journal, last);
+    }
+};
 const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
     if (vnode_isElementOrTextVNode(newChild)) {
         vnode_insertElementBefore(journal, parent, newChild, insertBefore);
@@ -7619,6 +7730,15 @@ function materializeFromVNodeData(vParent, vData, element, child) {
                 vnode_ensureElementKeyInflated(elementVNode);
                 addVNode(elementVNode);
                 child = fastNextSibling(child);
+                while (
+                // skip only elements, not text nodes
+                isElement(child) &&
+                    shouldSkipElement(child)) {
+                    child = fastNextSibling(child);
+                    if (!child && value > 0) {
+                        throw qError(27 /* QError.materializeVNodeDataError */, [vData, peek(), nextToConsumeIdx]);
+                    }
+                }
             }
             // collect the elements;
         }
@@ -9010,12 +9130,7 @@ class Serializer {
             ]);
         }
         else if (value instanceof EffectSubscription) {
-            this.output(32 /* TypeIds.EffectSubscription */, [
-                value.consumer,
-                value.property,
-                value.backRef,
-                value.data,
-            ]);
+            this.output(32 /* TypeIds.EffectSubscription */, [value.consumer, value.property, value.data]);
         }
         else if (isStore(value)) {
             const storeHandler = getStoreHandler(value);
@@ -9083,19 +9198,13 @@ class Serializer {
                     this.output(2 /* TypeIds.ForwardRef */, forwardRefId);
                 }
                 else {
-                    this.output(26 /* TypeIds.SerializerSignal */, [
-                        value.$computeQrl$,
-                        filterEffectBackRefs(value[_EFFECT_BACK_REF]),
-                        value.$effects$,
-                        maybeValue,
-                    ]);
+                    this.output(26 /* TypeIds.SerializerSignal */, [value.$computeQrl$, value.$effects$, maybeValue]);
                 }
                 return;
             }
             if (value instanceof WrappedSignalImpl) {
                 this.output(23 /* TypeIds.WrappedSignal */, [
                     ...serializeWrappingFn(this.$serializationContext$, value),
-                    filterEffectBackRefs(value[_EFFECT_BACK_REF]),
                     value.$flags$,
                     value.$hostElement$,
                     ...(value.$effects$ || []),
@@ -9123,11 +9232,7 @@ class Serializer {
                 else if (shouldNeverSerialize) {
                     v = NEEDS_COMPUTATION;
                 }
-                const out = [
-                    value.$computeQrl$,
-                    filterEffectBackRefs(value[_EFFECT_BACK_REF]),
-                    value.$effects$,
-                ];
+                const out = [value.$computeQrl$, value.$effects$];
                 if (isAsync) {
                     // After SSR, the signal is never loading, so no need to send it
                     out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedError$);
@@ -9254,14 +9359,7 @@ class Serializer {
             this.output(29 /* TypeIds.JSXNode */, 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$];
             while (out[out.length - 1] === undefined) {
                 out.pop();
             }
@@ -9460,18 +9558,6 @@ function serializeWrappingFn(serializationContext, value) {
     const syncFnId = serializationContext.$addSyncFn$(value.$funcStr$, value.$args$.length, value.$func$);
     return [syncFnId, value.$args$];
 }
-function filterEffectBackRefs(effectBackRef) {
-    let effectBackRefToSerialize = undefined;
-    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, QBackRefs)
         ? props[QBackRefs]
@@ -10195,8 +10281,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 /* TypeIds.Component */:
             target[SERIALIZABLE_STATE][0] = data[0];
@@ -10217,6 +10302,7 @@ const inflate = (container, target, typeId, data) => {
             const storeHandler = getStoreHandler(target);
             storeHandler.$flags$ = flags;
             storeHandler.$effects$ = effects;
+            restoreEffectBackRefForEffectsMap(storeHandler.$effects$, store);
             break;
         }
         case 22 /* TypeIds.Signal */: {
@@ -10224,6 +10310,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;
         }
         case 23 /* TypeIds.WrappedSignal */: {
@@ -10231,41 +10318,43 @@ 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 /* SignalFlags.INVALID */;
-            signal.$hostElement$ = d[4];
-            signal.$effects$ = new Set(d.slice(5));
+            signal.$hostElement$ = d[3];
+            signal.$effects$ = new Set(d.slice(4));
             inflateWrappedSignalValue(signal);
+            restoreEffectBackRefForEffects(signal.$effects$, signal);
             break;
         }
         case 25 /* TypeIds.AsyncSignal */: {
             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;
             if (asyncSignal.$flags$ & 64 /* AsyncSignalFlags.CLIENT_ONLY */) {
                 // If it's client only, it was serialized because it pretended to be loading
                 asyncSignal.$untrackedLoading$ = true;
             }
-            const hasValue = d.length > 7;
+            const hasValue = d.length > 6;
             if (hasValue) {
-                asyncSignal.$untrackedValue$ = d[7];
+                asyncSignal.$untrackedValue$ = d[6];
             }
             // can happen when never serialize etc
             if (asyncSignal.$untrackedValue$ === NEEDS_COMPUTATION) {
                 asyncSignal.$flags$ |= 1 /* SignalFlags.INVALID */;
             }
             // Note, we use the setter so that it schedules polling if needed
-            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;
         }
         // Inflating a SerializerSignal is the same as inflating a ComputedSignal
@@ -10283,19 +10372,19 @@ const inflate = (container, target, typeId, data) => {
                 // ignore preload errors
             });
             loading = loading.finally(() => p);
-            computed[_EFFECT_BACK_REF] = d[1];
-            if (d[2]) {
-                computed.$effects$ = new Set(d[2]);
+            if (d[1]) {
+                computed.$effects$ = new Set(d[1]);
             }
-            const hasValue = d.length > 3;
+            const hasValue = d.length > 2;
             if (hasValue) {
-                computed.$untrackedValue$ = d[3];
+                computed.$untrackedValue$ = d[2];
             }
             if (typeId !== 26 /* TypeIds.SerializerSignal */ && computed.$untrackedValue$ !== NEEDS_COMPUTATION) {
                 // If we have a value after SSR, it will always be mean the signal was not invalid
                 // The serialized signal is always left invalid so it can recreate the custom object
                 computed.$flags$ &= -2 /* SignalFlags.INVALID */;
             }
+            restoreEffectBackRefForEffects(computed.$effects$, computed);
             break;
         }
         case 15 /* TypeIds.Error */: {
@@ -10370,7 +10459,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 /* TypeIds.SubscriptionData */: {
             const effectData = target;
@@ -10383,14 +10474,15 @@ 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];
+            restoreEffectBackRefForConsumer(effectSub);
             break;
         }
         default:
             throw qError(16 /* QError.serializeErrorNotImplemented */, [typeId]);
     }
-}; /**
+};
+/**
  * Restores an array eagerly. If you need it lazily, use `deserializeData(container, TypeIds.Array,
  * array)` instead
  */
@@ -10441,6 +10533,31 @@ function inflateWrappedSignalValue(signal) {
         }
     }
 }
+function restoreEffectBackRefForConsumer(effect) {
+    const isServerSide = import.meta.env.TEST ? isServerPlatform() : isServer;
+    const consumerBackRef = effect.consumer;
+    if (isServerSide && !consumerBackRef) {
+        // on browser, we don't serialize for example VNodes, so then on server side we don't have consumer
+        return;
+    }
+    consumerBackRef[_EFFECT_BACK_REF] ||= new Map();
+    consumerBackRef[_EFFECT_BACK_REF].set(effect.property, effect);
+}
+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);
+        }
+    }
+}
 
 /** Arrays/Objects are special-cased so their identifiers is a single digit. */
 const needsInflation = (typeId) => typeId >= 15 /* TypeIds.Error */ || typeId === 4 /* TypeIds.Array */ || typeId === 5 /* TypeIds.Object */;