@qwik.dev/core 2.0.0-beta.8 → 2.0.0-beta.9

package/dist/core.prod.cjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.8-dev+434cd18
+ * @qwik.dev/core 2.0.0-beta.9-dev+6b582c7
  * 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
@@ -9,6 +9,7 @@
     "object" == typeof exports && "undefined" != typeof module ? factory(exports, require("@qwik.dev/core/build"), require("@qwik.dev/core/preloader")) : "function" == typeof define && define.amd ? define([ "exports", "@qwik.dev/core/build", "@qwik.dev/core/preloader" ], factory) : factory((global = "undefined" != typeof globalThis ? globalThis : global || self).qwikCore = {}, global.qwikBuild, global.qwikPreloader);
 }(this, function(exports, build, preloader) {
     "use strict";
+    const version = "2.0.0-beta.9-dev+6b582c7";
     const qDev = !1;
     const seal = () => {
         qDev;
@@ -38,6 +39,7 @@
         const text = (code => `Code(Q${code}) https://github.com/QwikDev/qwik/blob/main/packages/qwik/src/core/error/error.ts#L${8 + code}`)(code, ...errorMessageArgs);
         return ((message, ...optionalParams) => createAndLogError(qDev, message, ...optionalParams))(text, ...errorMessageArgs);
     };
+    const isSyncQrl = value => isQrl(value) && "<sync>" == value.$symbol$;
     const isQrl = value => "function" == typeof value && "function" == typeof value.getSymbol;
     function assertQrl(qrl) {
         if (build.isDev && !isQrl(qrl)) {
@@ -80,11 +82,6 @@
                 resolve(fn());
             });
         }),
-        nextTick: fn => new Promise(resolve => {
-            setTimeout(() => {
-                resolve(fn());
-            });
-        }),
         chunkForSymbol: (symbolName, chunk) => [ symbolName, chunk ?? "_" ]
     });
     const toUrl = (doc, containerEl, url) => {
@@ -156,6 +153,9 @@
         constructor(container, value) {
             this.$container$ = container, this.$untrackedValue$ = value;
         }
+        force() {
+            this.$container$?.$scheduler$(7, null, this, this.$effects$);
+        }
         get untrackedValue() {
             return this.$untrackedValue$;
         }
@@ -166,7 +166,7 @@
             return setupSignalValueAccess(this, () => this.$effects$ ||= new Set, () => this.untrackedValue);
         }
         set value(value) {
-            value !== this.$untrackedValue$ && (this.$untrackedValue$ = value, triggerEffects(this.$container$, this, this.$effects$));
+            value !== this.$untrackedValue$ && (this.$untrackedValue$ = value, this.$container$?.$scheduler$(7, null, this, this.$effects$));
         }
         valueOf() {
             qDev;
@@ -205,29 +205,26 @@
         $funcStr$;
         $flags$;
         $hostElement$=null;
-        $forceRunEffects$=!1;
         [_EFFECT_BACK_REF]=null;
-        constructor(container, fn, args, fnStr, flags = 3) {
+        constructor(container, fn, args, fnStr, flags = 5) {
             super(container, NEEDS_COMPUTATION), this.$args$ = args, this.$func$ = fn, this.$funcStr$ = fnStr, 
             this.$flags$ = flags;
         }
         invalidate() {
-            this.$flags$ |= 1, this.$forceRunEffects$ = !1, this.$container$?.$scheduler$(7, this.$hostElement$, this, this.$effects$);
+            this.$flags$ |= 1, this.$container$?.$scheduler$(7, this.$hostElement$, this, this.$effects$);
         }
         force() {
-            this.$forceRunEffects$ = !0, this.$container$?.$scheduler$(7, this.$hostElement$, this, this.$effects$);
+            this.$flags$ |= 2, this.$container$?.$scheduler$(7, this.$hostElement$, this, this.$effects$);
         }
         get untrackedValue() {
-            const didChange = this.$computeIfNeeded$();
-            return didChange && (this.$forceRunEffects$ = didChange), assertFalse(), this.$untrackedValue$;
+            return this.$computeIfNeeded$(), assertFalse(), this.$untrackedValue$;
         }
         $computeIfNeeded$() {
             if (!(1 & this.$flags$)) {
-                return !1;
+                return;
             }
             const untrackedValue = trackSignal(() => this.$func$(...this.$args$), this, ".", this.$container$);
-            const didChange = untrackedValue !== this.$untrackedValue$;
-            return didChange && (this.$untrackedValue$ = untrackedValue), didChange;
+            untrackedValue !== this.$untrackedValue$ && (this.$flags$ |= 2, this.$untrackedValue$ = untrackedValue);
         }
         set value(_) {
             throw qError(31);
@@ -237,13 +234,15 @@
         }
     }
     function getSubscriber(effect, prop, data) {
-        var value;
-        effect[_EFFECT_BACK_REF] || (build.isServer && ("__brand__" in (value = effect) && "SsrNode" === value.__brand__) ? effect.setProp("q:brefs", new Map) : effect[_EFFECT_BACK_REF] = new Map);
+        effect[_EFFECT_BACK_REF] || (build.isServer && isSsrNode(effect) ? effect.setProp("q:brefs", new Map) : effect[_EFFECT_BACK_REF] = new Map);
         const subMap = effect[_EFFECT_BACK_REF];
         let sub = subMap.get(prop);
         return sub || (sub = [ effect, prop ], subMap.set(prop, sub)), data && (sub[3] = data), 
         sub;
     }
+    function isSsrNode(value) {
+        return "__brand__" in value && "SsrNode" === value.__brand__;
+    }
     let _context;
     const tryGetInvokeContext = () => {
         if (!_context) {
@@ -400,7 +399,6 @@
         set(1));
     };
     const ERROR_CONTEXT = /*#__PURE__*/ createContextId("qk-error");
-    const version = "2.0.0-beta.8-dev+434cd18";
     const EMPTY_ARRAY = [];
     const EMPTY_OBJ = {};
     Object.freeze(EMPTY_ARRAY), Object.freeze(EMPTY_OBJ);
@@ -453,7 +451,7 @@
         }
         return qrl.$captureRef$;
     };
-    const queueQRL = (...args) => {
+    const _run = (...args) => {
         const [runQrl] = useLexicalScope();
         const context = getInvokeContext();
         const hostElement = context.$hostElement$;
@@ -464,7 +462,8 @@
         if (!scheduler) {
             throw qError(1);
         }
-        return scheduler(2, hostElement, runQrl, args);
+        const chore = scheduler(2, hostElement, runQrl, args);
+        return getChorePromise(chore);
     };
     const mapApp_findIndx = (array, key, start) => {
         assertTrue();
@@ -499,24 +498,22 @@
     class ComputedSignalImpl extends SignalImpl {
         $computeQrl$;
         $flags$;
-        $forceRunEffects$=!1;
         [_EFFECT_BACK_REF]=null;
-        constructor(container, fn, flags = 17) {
+        constructor(container, fn, flags = 33) {
             super(container, NEEDS_COMPUTATION), this.$computeQrl$ = fn, this.$flags$ = flags;
         }
         invalidate() {
-            this.$flags$ |= 1, this.$forceRunEffects$ = !1, this.$container$?.$scheduler$(7, null, this, this.$effects$);
+            this.$flags$ |= 1, this.$container$?.$scheduler$(7, null, this, this.$effects$);
         }
         force() {
-            this.$forceRunEffects$ = !0, this.$container$?.$scheduler$(7, null, this, this.$effects$);
+            this.$flags$ |= 2, super.force();
         }
         get untrackedValue() {
-            const didChange = this.$computeIfNeeded$();
-            return didChange && (this.$forceRunEffects$ = didChange), assertFalse(), this.$untrackedValue$;
+            return this.$computeIfNeeded$(), assertFalse(), this.$untrackedValue$;
         }
         $computeIfNeeded$() {
             if (!(1 & this.$flags$)) {
-                return !1;
+                return;
             }
             const computeQrl = this.$computeQrl$;
             throwIfQRLNotResolved(computeQrl);
@@ -529,8 +526,8 @@
                     throw qError(29, [ computeQrl.dev ? computeQrl.dev.file : "", computeQrl.$hash$ ]);
                 }
                 this.$flags$ &= -2;
-                const didChange = untrackedValue !== this.$untrackedValue$;
-                return didChange && (this.$untrackedValue$ = untrackedValue), didChange;
+                untrackedValue !== this.$untrackedValue$ && (this.$untrackedValue$ !== NEEDS_COMPUTATION && (this.$flags$ |= 2), 
+                this.$untrackedValue$ = untrackedValue);
             } finally {
                 ctx && (ctx.$effectSubscriber$ = previousEffectSubscription);
             }
@@ -544,12 +541,12 @@
     }
     class SerializerSignalImpl extends ComputedSignalImpl {
         constructor(container, argQrl) {
-            super(container, argQrl, 17);
+            super(container, argQrl, 33);
         }
         $didInitialize$=!1;
         $computeIfNeeded$() {
             if (!(1 & this.$flags$)) {
-                return !1;
+                return;
             }
             throwIfQRLNotResolved(this.$computeQrl$);
             let arg = this.$computeQrl$.resolved;
@@ -559,12 +556,16 @@
             const currentValue = this.$untrackedValue$ === NEEDS_COMPUTATION ? initial : this.$untrackedValue$;
             const untrackedValue = trackSignal(() => this.$didInitialize$ ? update?.(currentValue) || currentValue : deserialize(currentValue), this, ".", this.$container$);
             const didChange = this.$didInitialize$ && "undefined" !== untrackedValue || untrackedValue !== this.$untrackedValue$;
-            return this.$flags$ &= -2, this.$didInitialize$ = !0, didChange && (this.$untrackedValue$ = untrackedValue), 
-            didChange;
+            this.$flags$ &= -2, this.$didInitialize$ = !0, didChange && (this.$flags$ |= 2, 
+            this.$untrackedValue$ = untrackedValue);
         }
     }
     const getStoreHandler = value => value[STORE_HANDLER];
     const getStoreTarget = value => value?.[STORE_TARGET] || null;
+    const forceStoreEffects = (value, prop) => {
+        const handler = getStoreHandler(value);
+        handler && handler.force(prop);
+    };
     const unwrapStore = value => getStoreTarget(value) || value;
     const isStore = value => STORE_TARGET in value;
     function createStore(container, obj, flags) {
@@ -588,6 +589,10 @@
         toString() {
             return "[Store]";
         }
+        force(prop) {
+            const target = getStoreTarget(this);
+            this.$container$?.$scheduler$(7, null, this, getEffects(target, prop, this.$effects$));
+        }
         get(target, prop) {
             if ("symbol" == typeof prop) {
                 return prop === STORE_TARGET ? target : prop === STORE_HANDLER ? this : target[prop];
@@ -624,7 +629,7 @@
             return !0;
         }
         deleteProperty(target, prop) {
-            return "string" == typeof prop && delete target[prop] && (triggerEffects(this.$container$, this, getEffects(target, prop, this.$effects$)), 
+            return "string" == typeof prop && delete target[prop] && (Array.isArray(target) || this.$container$?.$scheduler$(7, null, this, getEffects(target, prop, this.$effects$)), 
             !0);
         }
         has(target, prop) {
@@ -661,7 +666,9 @@
         ensureContainsBackRef(effectSubscription, target), addQrlToSerializationCtx(effectSubscription, store.$container$);
     }
     function setNewValueAndTriggerEffects(prop, value, target, currentStore) {
-        target[prop] = value, triggerEffects(currentStore.$container$, currentStore, getEffects(target, prop, currentStore.$effects$));
+        target[prop] = value;
+        const effects = getEffects(target, prop, currentStore.$effects$);
+        effects && currentStore.$container$?.$scheduler$(7, null, currentStore, effects);
     }
     function getEffects(target, prop, storeEffects) {
         let effectsToTrigger;
@@ -754,7 +761,7 @@
         }
         $computeIfNeeded$() {
             if (!(1 & this.$flags$)) {
-                return !1;
+                return;
             }
             const computeQrl = this.$computeQrl$;
             throwIfQRLNotResolved(computeQrl);
@@ -772,7 +779,8 @@
             }
             this.$promiseValue$ = NEEDS_COMPUTATION, this.$flags$ &= -2;
             const didChange = untrackedValue !== this.$untrackedValue$;
-            return didChange && (this.$untrackedValue$ = untrackedValue), didChange;
+            return didChange && (this.$flags$ |= 2, this.$untrackedValue$ = untrackedValue), 
+            didChange;
         }
     }
     const createComputedSignal = (qrl, options) => new ComputedSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || "always"));
@@ -792,7 +800,7 @@
             return obj[prop];
         }
         if (isSignal(obj)) {
-            return obj instanceof AsyncComputedSignalImpl || assertEqual(), obj instanceof WrappedSignalImpl && 2 & obj.flags ? obj : getWrapped(args);
+            return obj instanceof AsyncComputedSignalImpl || assertEqual(), obj instanceof WrappedSignalImpl && 4 & obj.flags ? obj : getWrapped(args);
         }
         if (isPropsProxy(obj)) {
             const constProps = obj[_CONST_PROPS];
@@ -1014,8 +1022,8 @@
                                 }
                                 targetElement = placeholderElement;
                             }
-                            targetElement && ("script" === targetElement.type && key === qVisibleEvent && (eventKey = "document:onQinit$", 
-                            logWarn('You are trying to add an event "' + key + '" using `useVisibleTask$` hook, but a node to which you can add an event is not found. Using document:onQinit$ instead.')), 
+                            targetElement && ("script" === targetElement.type && key === qVisibleEvent && (eventKey = "document:onQInit$", 
+                            logWarn('You are trying to add an event "' + key + '" using `useVisibleTask$` hook, but a node to which you can add an event is not found. Using document:onQInit$ instead.')), 
                             addUseOnEvent(targetElement, eventKey, useOnEvents[key]));
                         }
                     }
@@ -1167,9 +1175,18 @@
                     }(jsx, options.styleScoped);
                     let qwikInspectorAttrValue = null;
                     build.isDev && jsx.dev && "head" !== jsx.type && (qwikInspectorAttrValue = getFileLocationFromJsx(jsx.dev));
-                    const innerHTML = ssr.openElement(type, toSsrAttrs(jsx.varProps, jsx.constProps, ssr.serializationCtx, !0, options.styleScoped, jsx.key), function(constProps, varProps, serializationCtx, styleScopedId) {
-                        return toSsrAttrs(constProps, varProps, serializationCtx, !1, styleScopedId);
-                    }(jsx.constProps, jsx.varProps, ssr.serializationCtx, options.styleScoped), qwikInspectorAttrValue);
+                    const innerHTML = ssr.openElement(type, function(varProps, constProps, options) {
+                        return toSsrAttrs(varProps, constProps, !1, options);
+                    }(jsx.varProps, jsx.constProps, {
+                        serializationCtx: ssr.serializationCtx,
+                        styleScopedId: options.styleScoped,
+                        key: jsx.key
+                    }), function(constProps, varProps, options) {
+                        return toSsrAttrs(constProps, varProps, !0, options);
+                    }(jsx.constProps, jsx.varProps, {
+                        serializationCtx: ssr.serializationCtx,
+                        styleScopedId: options.styleScoped
+                    }), qwikInspectorAttrValue);
                     innerHTML && ssr.htmlNode(innerHTML), enqueue(ssr.closeElement), "head" === type ? (ssr.emitQwikLoaderAtTopIfNeeded(), 
                     ssr.emitPreloaderPre(), enqueue(ssr.additionalHeadNodes)) : "body" === type ? enqueue(ssr.additionalBodyNodes) : ssr.isHtml || ssr._didAddQwikLoader || (ssr.emitQwikLoaderAtTopIfNeeded(), 
                     ssr.emitPreloaderPre(), ssr._didAddQwikLoader = !0);
@@ -1233,10 +1250,10 @@
                             const host = ssr.getOrCreateLastNode();
                             const [componentQrl] = component[SERIALIZABLE_STATE];
                             const srcProps = jsx.props;
-                            srcProps && srcProps.children && delete srcProps.children;
-                            const scheduler = ssr.$scheduler$;
-                            return host.setProp("q:renderFn", componentQrl), host.setProp("q:props", srcProps), 
-                            null !== jsx.key && host.setProp("q:key", jsx.key), scheduler(6, host, componentQrl, srcProps);
+                            srcProps && srcProps.children && delete srcProps.children, host.setProp("q:renderFn", componentQrl), 
+                            host.setProp("q:props", srcProps), null !== jsx.key && host.setProp("q:key", jsx.key);
+                            const componentChore = ssr.$scheduler$(6, host, componentQrl, srcProps);
+                            return getChorePromise(componentChore);
                         })(ssr, jsx, type);
                         const compStyleComponentId = addComponentStylePrefix(host.getProp("q:sstyle"));
                         enqueue(new ParentComponentData(options.styleScoped, options.parentComponentFrame)), 
@@ -1257,10 +1274,11 @@
             }
         }
     }
-    function toSsrAttrs(record, anotherRecord, serializationCtx, pushMergedEventProps, styleScopedId, key) {
+    function toSsrAttrs(record, anotherRecord, isConst, options) {
         if (null == record) {
             return null;
         }
+        const pushMergedEventProps = !isConst;
         const ssrAttrs = [];
         for (const key in record) {
             let value = record[key];
@@ -1274,14 +1292,14 @@
                         value = getMergedEventPropValues(value, anotherValue);
                     }
                 }
-                const eventValue = setEvent(serializationCtx, key, value);
+                const eventValue = setEvent(options.serializationCtx, key, value);
                 eventValue && ssrAttrs.push(jsxEventToHtmlAttribute(key), eventValue);
                 continue;
             }
-            isSignal(value) ? isClassAttr(key) ? ssrAttrs.push(key, [ value, styleScopedId ]) : ssrAttrs.push(key, value) : (isPreventDefault(key) && addPreventDefaultEventToSerializationContext(serializationCtx, key), 
-            value = serializeAttribute(key, value, styleScopedId), ssrAttrs.push(key, value));
+            isSignal(value) ? isClassAttr(key) ? ssrAttrs.push(key, [ value, options.styleScopedId ]) : ssrAttrs.push(key, value) : (isPreventDefault(key) && addPreventDefaultEventToSerializationContext(options.serializationCtx, key), 
+            value = serializeAttribute(key, value, options.styleScopedId), ssrAttrs.push(key, value));
         }
-        return null != key && ssrAttrs.push("q:key", key), ssrAttrs;
+        return null != options.key && ssrAttrs.push("q:key", options.key), ssrAttrs;
     }
     function getMergedEventPropValues(value, anotherValue) {
         let mergedValue = value;
@@ -1303,7 +1321,7 @@
         const appendToValue = valueToAppend => {
             value = (null == value ? "" : value + "\n") + valueToAppend;
         };
-        const getQrlString = qrl => (qrl.$symbol$.startsWith("_") || !qrl.$captureRef$ && !qrl.$capture$ || (qrl = createQRL(null, "_run", queueQRL, null, null, [ qrl ])), 
+        const getQrlString = qrl => (qrl.$symbol$.startsWith("_") || !qrl.$captureRef$ && !qrl.$capture$ || (qrl = createQRL(null, "_run", _run, null, null, [ qrl ])), 
         qrlToString(serializationCtx, qrl));
         if (Array.isArray(qrls)) {
             for (let i = 0; i <= qrls.length; i++) {
@@ -1336,8 +1354,10 @@
         assertQrl(qrl), set(1);
         const task = new Task(10, i, iCtx.$hostElement$, qrl, void 0, null);
         set(task);
-        const promise = iCtx.$container$.$scheduler$(3, task);
-        isPromise(promise) && promise.catch(() => {});
+        const result = runTask(task, iCtx.$container$, iCtx.$hostElement$);
+        if (isPromise(result)) {
+            throw result;
+        }
     };
     const runTask = (task, container, host) => {
         task.$flags$ &= -9, cleanupTask(task);
@@ -1385,7 +1405,7 @@
     const isTask = value => value instanceof Task;
     const scheduleTask = (_event, element) => {
         const [task] = useLexicalScope();
-        const type = 1 & task.$flags$ ? 32 : 3;
+        const type = 1 & task.$flags$ ? 16 : 3;
         getDomContainer(element).$scheduler$(type, task);
     };
     const _jsxSorted = (type, varProps, constProps, children, flags, key) => {
@@ -1466,7 +1486,7 @@
                 return this.$children$;
             }
             const value = this.$constProps$ && prop in this.$constProps$ ? this.$constProps$[prop] : this.$varProps$[prop];
-            return value instanceof WrappedSignalImpl && 2 & value.$flags$ ? value.value : value;
+            return value instanceof WrappedSignalImpl && 4 & value.$flags$ ? value.value : value;
         }
         set(_, prop, value) {
             return prop === _CONST_PROPS ? (this.$constProps$ = value, !0) : prop === _VAR_PROPS ? (this.$varProps$ = value, 
@@ -1671,36 +1691,38 @@
             }
         }();
         function diff(jsxNode, vStartNode) {
-            for (assertFalse(vnode_isVNode(jsxNode)), assertTrue(vnode_isVNode(vStartNode)), 
+            if (assertFalse(vnode_isVNode(jsxNode)), assertTrue(vnode_isVNode(vStartNode)), 
             vParent = vStartNode, vNewNode = null, vCurrent = vnode_getFirstChild(vStartNode), 
-            stackPush(jsxNode, !0); stack.length; ) {
-                for (;jsxIdx < jsxCount; ) {
-                    if (assertFalse(), "string" == typeof jsxValue) {
-                        expectText(jsxValue);
-                    } else if ("number" == typeof jsxValue) {
-                        expectText(String(jsxValue));
-                    } else if (jsxValue && "object" == typeof jsxValue) {
-                        if (Array.isArray(jsxValue)) {
-                            descend(jsxValue, !1);
-                        } else if (isSignal(jsxValue)) {
-                            vCurrent && clearAllEffects(container, vCurrent), expectVirtual("S", null), descend(trackSignalAndAssignHost(jsxValue, vNewNode || vCurrent, ".", container), !0);
-                        } else if (isPromise(jsxValue)) {
-                            expectVirtual("A", null), asyncQueue.push(jsxValue, vNewNode || vCurrent);
-                        } else if (isJSXNode(jsxValue)) {
-                            const type = jsxValue.type;
-                            "string" == typeof type ? (expectNoMoreTextNodes(), expectElement(jsxValue, type), 
-                            descend(jsxValue.children, !0)) : "function" == typeof type && (type === Fragment ? (expectNoMoreTextNodes(), 
-                            expectVirtual("F", jsxValue.key), descend(jsxValue.children, !0)) : type === Slot ? (expectNoMoreTextNodes(), 
-                            expectSlot() || descend(jsxValue.children, !0)) : type === Projection ? (expectProjection(), 
-                            descend(jsxValue.children, !0)) : type === SSRComment || type === SSRRaw ? expectNoMore() : (expectNoMoreTextNodes(), 
-                            expectComponent(type)));
+            stackPush(jsxNode, !0), !(32 & vParent[0])) {
+                for (;stack.length; ) {
+                    for (;jsxIdx < jsxCount; ) {
+                        if (assertFalse(), "string" == typeof jsxValue) {
+                            expectText(jsxValue);
+                        } else if ("number" == typeof jsxValue) {
+                            expectText(String(jsxValue));
+                        } else if (jsxValue && "object" == typeof jsxValue) {
+                            if (Array.isArray(jsxValue)) {
+                                descend(jsxValue, !1);
+                            } else if (isSignal(jsxValue)) {
+                                vCurrent && clearAllEffects(container, vCurrent), expectVirtual("S", null), descend(trackSignalAndAssignHost(jsxValue, vNewNode || vCurrent, ".", container), !0);
+                            } else if (isPromise(jsxValue)) {
+                                expectVirtual("A", null), asyncQueue.push(jsxValue, vNewNode || vCurrent);
+                            } else if (isJSXNode(jsxValue)) {
+                                const type = jsxValue.type;
+                                "string" == typeof type ? (expectNoMoreTextNodes(), expectElement(jsxValue, type), 
+                                descend(jsxValue.children, !0)) : "function" == typeof type && (type === Fragment ? (expectNoMoreTextNodes(), 
+                                expectVirtual("F", jsxValue.key), descend(jsxValue.children, !0)) : type === Slot ? (expectNoMoreTextNodes(), 
+                                expectSlot() || descend(jsxValue.children, !0)) : type === Projection ? (expectProjection(), 
+                                descend(jsxValue.children, !0)) : type === SSRComment || type === SSRRaw ? expectNoMore() : (expectNoMoreTextNodes(), 
+                                expectComponent(type)));
+                            }
+                        } else {
+                            jsxValue === SkipRender ? journal = [] : expectText("");
                         }
-                    } else {
-                        jsxValue === SkipRender ? journal = [] : expectText("");
+                        advance();
                     }
-                    advance();
+                    expectNoMore(), ascend();
                 }
-                expectNoMore(), ascend();
             }
         }
         function advance() {
@@ -1962,8 +1984,12 @@
                 let returnValue = !1;
                 return qrls.flat(2).forEach(qrl => {
                     if (qrl) {
-                        const value = container.$scheduler$(2, vNode, qrl, [ event, element ]);
-                        returnValue = returnValue || !0 === value;
+                        if (isSyncQrl(qrl)) {
+                            qrl(event, element);
+                        } else {
+                            const value = container.$scheduler$(2, vNode, qrl, [ event, element ]);
+                            returnValue = returnValue || !0 === value;
+                        }
                     }
                 }), returnValue;
             }));
@@ -2150,7 +2176,7 @@
                             const obj = seq[i];
                             if (isTask(obj)) {
                                 const task = obj;
-                                clearAllEffects(container, task), 1 & task.$flags$ ? container.$scheduler$(48, task) : cleanupTask(task);
+                                clearAllEffects(container, task), 1 & task.$flags$ ? container.$scheduler$(32, task) : cleanupTask(task);
                             }
                         }
                     }
@@ -2176,7 +2202,9 @@
                     if (vCursor === vNode) {
                         const vFirstChild = vnode_getFirstChild(vCursor);
                         if (vFirstChild) {
-                            return void vnode_walkVNode(vFirstChild);
+                            return void vnode_walkVNode(vFirstChild, vNode => {
+                                2 & vNode[0] && vnode_getProp(vNode, "q:sparent", id => vnode_locate(container.rootVNode, id));
+                            });
                         }
                     }
                 } else {
@@ -2232,8 +2260,9 @@
         assertQrl(qrl);
         const container = iCtx.$container$;
         const resource = createResourceReturn(container, opts);
-        const task = new Task(12, i, iCtx.$hostElement$, qrl, resource, null);
-        return container.$scheduler$(3, task), set(resource), resource;
+        const el = iCtx.$hostElement$;
+        const task = new Task(12, i, el, qrl, resource, null);
+        return set(resource), runResource(task, container, el), resource;
     };
     const createResourceReturn = (container, opts, initialPromise) => {
         const result = (opts => ({
@@ -2272,21 +2301,21 @@
         let reject;
         let done = !1;
         const setState = (resolved, value) => !done && (done = !0, resolved ? (done = !0, 
-        resource.loading = !1, resource._state = "resolved", resource._resolved = value, 
-        resource._error = void 0, resolve(value)) : (done = !0, resource.loading = !1, resource._state = "rejected", 
-        resource._error = value, reject(value)), !0);
+        resourceTarget.loading = !1, resourceTarget._state = "resolved", resourceTarget._resolved = value, 
+        resourceTarget._error = void 0, resolve(value)) : (done = !0, resourceTarget.loading = !1, 
+        resourceTarget._state = "rejected", resourceTarget._error = value, reject(value)), 
+        isServerPlatform() || forceStoreEffects(resource, "_state"), !0);
         cleanups.push(() => {
             if (!0 === untrack(() => resource.loading)) {
                 const value = untrack(() => resource._resolved);
                 setState(!0, value);
             }
         }), invoke(iCtx, () => {
-            resource._state = "pending", resource.loading = !isServerPlatform();
-            (resource.value = new Promise((r, re) => {
+            resource._state = "pending", resource.loading = !isServerPlatform(), resource.value = new Promise((r, re) => {
                 resolve = r, reject = re;
-            })).catch(ignoreErrorToPreventNodeFromCrashing);
+            });
         });
-        const promise = safeCall(() => Promise.resolve(taskFn(opts)), value => {
+        const promise = safeCall(() => taskFn(opts), value => {
             setState(!0, value);
         }, err => {
             if (isPromise(err)) {
@@ -2299,28 +2328,187 @@
             setState(!1, new Error("timeout")) && cleanupTask(task);
         }) ]) : promise;
     };
-    const ignoreErrorToPreventNodeFromCrashing = () => {};
     const aVNodePath = [];
     const bVNodePath = [];
     const aSsrNodePath = [];
     const bSsrNodePath = [];
-    const getPromise = chore => chore.$promise$ ||= new Promise(resolve => {
-        chore.$resolve$ = resolve;
-    });
-    const createScheduler = (container, scheduleDrain, journalFlush) => {
-        const choreQueue = [];
-        const qrlRuns = [];
-        let currentChore = null;
+    const VISIBLE_BLOCKING_RULES = [ {
+        blockedType: 16,
+        blockingType: 4,
+        match: (blocked, blocking, container) => isDescendant(blocked, blocking, container) || isDescendant(blocking, blocked, container)
+    }, {
+        blockedType: 16,
+        blockingType: 6,
+        match: (blocked, blocking, container) => isDescendant(blocked, blocking, container) || isDescendant(blocking, blocked, container)
+    } ];
+    const BLOCKING_RULES = [ {
+        blockedType: 2,
+        blockingType: 1,
+        match: (blocked, blocking) => {
+            const blockedQrl = blocked.$target$;
+            const blockingQrl = blocking.$target$;
+            return isSameHost(blocked, blocking) && isSameQrl(blockedQrl, blockingQrl);
+        }
+    }, {
+        blockedType: 3,
+        blockingType: 1,
+        match: (blocked, blocking) => {
+            const blockedTask = blocked.$payload$;
+            const blockingQrl = blocking.$target$;
+            return isSameHost(blocked, blocking) && isSameQrl(blockedTask.$qrl$, blockingQrl);
+        }
+    }, {
+        blockedType: 16,
+        blockingType: 1,
+        match: (blocked, blocking) => {
+            const blockedTask = blocked.$payload$;
+            const blockingQrl = blocking.$target$;
+            return isSameHost(blocked, blocking) && isSameQrl(blockedTask.$qrl$, blockingQrl);
+        }
+    }, {
+        blockedType: 4,
+        blockingType: 6,
+        match: (blocked, blocking) => blocked.$host$ === blocking.$host$
+    }, {
+        blockedType: 5,
+        blockingType: 6,
+        match: (blocked, blocking) => blocked.$host$ === blocking.$host$
+    }, ...VISIBLE_BLOCKING_RULES, {
+        blockedType: 3,
+        blockingType: 3,
+        match: (blocked, blocking, container) => {
+            if (blocked.$host$ !== blocking.$host$) {
+                return !1;
+            }
+            const blockedIdx = blocked.$idx$;
+            if ("number" != typeof blockedIdx || blockedIdx <= 0) {
+                return !1;
+            }
+            const previousTask = function(host, currentTaskIdx, container) {
+                const elementSeq = container.getHostProp(host, "q:seq");
+                if (!elementSeq || elementSeq.length <= currentTaskIdx) {
+                    return null;
+                }
+                for (let i = currentTaskIdx - 1; i >= 0; i--) {
+                    const candidate = elementSeq[i];
+                    if (candidate instanceof Task && 2 & candidate.$flags$) {
+                        return candidate;
+                    }
+                }
+                return null;
+            }(blocked.$host$, blockedIdx, container);
+            return previousTask === blocking.$payload$;
+        }
+    } ];
+    function isDescendant(descendantChore, ancestorChore, container) {
+        const descendantHost = descendantChore.$host$;
+        const ancestorHost = ancestorChore.$host$;
+        return !(!vnode_isVNode(descendantHost) || !vnode_isVNode(ancestorHost)) && vnode_isDescendantOf(descendantHost, ancestorHost, container.rootVNode);
+    }
+    function isSameHost(a, b) {
+        return a.$host$ === b.$host$;
+    }
+    function isSameQrl(a, b) {
+        return a.$symbol$ === b.$symbol$;
+    }
+    function findBlockingChoreInQueue(chore, choreQueue, container) {
+        for (const candidate of choreQueue) {
+            if (!(candidate.$type$ >= 16 || 3 === candidate.$type$) && isDescendant(chore, candidate, container)) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+    function findBlockingChore(chore, choreQueue, blockedChores, runningChores, container) {
+        const blockingChoreInChoreQueue = findBlockingChoreInQueue(chore, choreQueue, container);
+        if (blockingChoreInChoreQueue) {
+            return blockingChoreInChoreQueue;
+        }
+        const blockingChoreInBlockedChores = findBlockingChoreInQueue(chore, Array.from(blockedChores), container);
+        if (blockingChoreInBlockedChores) {
+            return blockingChoreInBlockedChores;
+        }
+        const blockingChoreInRunningChores = findBlockingChoreInQueue(chore, Array.from(runningChores), container);
+        if (blockingChoreInRunningChores) {
+            return blockingChoreInRunningChores;
+        }
+        for (const rule of BLOCKING_RULES) {
+            if (chore.$type$ === rule.blockedType) {
+                for (const candidate of choreQueue) {
+                    if (candidate.$type$ === rule.blockingType && rule.match(chore, candidate, container)) {
+                        return candidate;
+                    }
+                }
+                for (const candidate of blockedChores) {
+                    if (candidate.$type$ === rule.blockingType && rule.match(chore, candidate, container)) {
+                        return candidate;
+                    }
+                }
+                for (const candidate of runningChores) {
+                    if (candidate.$type$ === rule.blockingType && rule.match(chore, candidate, container)) {
+                        return candidate;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    function findBlockingChoreForVisible(chore, runningChores, container) {
+        for (const rule of VISIBLE_BLOCKING_RULES) {
+            if (chore.$type$ === rule.blockedType) {
+                for (const candidate of runningChores) {
+                    if (candidate.$type$ === rule.blockingType && rule.match(chore, candidate, container)) {
+                        return candidate;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    var ChoreState;
+    !function(ChoreState) {
+        ChoreState[ChoreState.NONE = 0] = "NONE", ChoreState[ChoreState.RUNNING = 1] = "RUNNING", 
+        ChoreState[ChoreState.FAILED = 2] = "FAILED", ChoreState[ChoreState.DONE = 3] = "DONE";
+    }(ChoreState || (ChoreState = {}));
+    const getChorePromise = chore => chore.$state$ === ChoreState.NONE ? chore.$returnValue$ ||= new Promise((resolve, reject) => {
+        chore.$resolve$ = resolve, chore.$reject$ = reject;
+    }) : chore.$returnValue$;
+    const createScheduler = (container, journalFlush, choreQueue = [], blockedChores = new Set, runningChores = new Set) => {
+        let drainChore = null;
         let drainScheduled = !1;
-        return function schedule(type, hostOrTask = null, targetOrQrl = null, payload = null) {
-            const isServer = !isDomContainer(container);
-            const isComponentSsr = isServer && 6 === type;
-            const runLater = 255 !== type && !isComponentSsr && 2 !== type;
-            const isTask = 3 === type || 32 === type || 48 === type;
-            const isClientOnly = 16 === type || 4 === type || 5 === type || 1 === type || 7 === type;
-            if (isServer && isClientOnly) {
-                return;
+        let isDraining = !1;
+        let isJournalFlushRunning = !1;
+        let flushBudgetStart = 0;
+        let currentTime = performance.now();
+        const nextTick = (fn => {
+            let nextTick;
+            if ("function" == typeof setImmediate) {
+                nextTick = () => {
+                    setImmediate(fn);
+                };
+            } else if ("undefined" != typeof MessageChannel) {
+                const channel = new MessageChannel;
+                channel.port1.onmessage = () => {
+                    fn();
+                }, nextTick = () => {
+                    channel.port2.postMessage(null);
+                };
+            } else {
+                nextTick = () => {
+                    setTimeout(fn);
+                };
+            }
+            return nextTick;
+        })(drainChoreQueue);
+        function drainInNextTick() {
+            drainScheduled || (drainScheduled = !0, nextTick());
+        }
+        const FREQUENCY_MS = Math.floor(1e3 / 60);
+        return function(type, hostOrTask = null, targetOrQrl = null, payload = null) {
+            if (255 === type && drainChore) {
+                return drainChore;
             }
+            const isTask = 3 === type || 16 === type || 32 === type;
             isTask && (hostOrTask.$flags$ |= 8);
             let chore = {
                 $type$: type,
@@ -2328,184 +2516,217 @@
                 $host$: isTask ? hostOrTask.$el$ : hostOrTask,
                 $target$: targetOrQrl,
                 $payload$: isTask ? hostOrTask : payload,
-                $resolve$: null,
-                $promise$: null,
-                $returnValue$: null,
-                $executed$: !1
+                $state$: ChoreState.NONE,
+                $blockedChores$: null,
+                $startTime$: void 0,
+                $endTime$: void 0,
+                $resolve$: void 0,
+                $reject$: void 0,
+                $returnValue$: null
             };
-            chore = function(sortedArray, value, rootVNode) {
-                const idx = function(sortedArray, value, rootVNode) {
-                    let bottom = 0;
-                    let top = sortedArray.length;
-                    for (;bottom < top; ) {
-                        const middle = bottom + (top - bottom >> 1);
-                        const comp = choreComparator(value, sortedArray[middle], rootVNode);
-                        if (comp < 0) {
-                            top = middle;
-                        } else {
-                            if (!(comp > 0)) {
-                                return middle;
-                            }
-                            bottom = middle + 1;
-                        }
-                    }
-                    return ~bottom;
-                }(sortedArray, value, rootVNode);
-                if (idx < 0) {
-                    return sortedArray.splice(~idx, 0, value), value;
+            if (255 === type) {
+                return getChorePromise(chore), drainChore = chore, drainInNextTick(), chore;
+            }
+            const isServer = isServerPlatform();
+            const isClientOnly = 4 === type || 1 === type;
+            if (isServer && isClientOnly) {
+                return finishChore(chore, void 0), chore;
+            }
+            if (isServer && chore.$host$ && isSsrNode(chore.$host$)) {
+                if (!!!(1 & chore.$host$.flags) && 5 !== chore.$type$ && 7 !== chore.$type$) {
+                    const warningMessage = `A '${choreTypeToName(chore.$type$)}' chore was scheduled on a host element that has already been streamed to the client.\nThis can lead to inconsistencies between Server-Side Rendering (SSR) and Client-Side Rendering (CSR).\n\nProblematic chore:\n  - Type: ${choreTypeToName(chore.$type$)}\n  - Host: ${chore.$host$.toString()}\n  - Nearest element location: ${chore.$host$.currentFile}\n\nThis is often caused by modifying a signal in an already rendered component during SSR.`;
+                    return logWarn(warningMessage), chore;
                 }
-                const existing = sortedArray[idx];
-                existing.$payload$ !== value.$payload$ && (existing.$payload$ = value.$payload$);
-                existing.$executed$ && (existing.$executed$ = !1);
-                return existing;
-            }(choreQueue, chore, container.rootVNode || null), !drainScheduled && runLater && (drainScheduled = !0, 
-            schedule(16), scheduleDrain()?.catch?.(() => {}));
-            return runLater ? getPromise(chore) : drainUpTo(chore, isServer);
+            }
+            const blockingChore = findBlockingChore(chore, choreQueue, blockedChores, runningChores, container);
+            if (blockingChore) {
+                return addBlockedChore(chore, blockingChore, blockedChores), chore;
+            }
+            chore = sortedInsert(choreQueue, chore, container.rootVNode || null);
+            (isServer && 6 === type || 2 === type) && !isDraining ? (drainScheduled = !0, drainChoreQueue()) : drainInNextTick();
+            return chore;
         };
-        function drainUpTo(runUptoChore, isServer) {
-            let maxRetries = 5e3;
-            for (;choreQueue.length; ) {
-                if (maxRetries-- < 0) {
-                    throw new Error("drainUpTo: max retries reached");
-                }
-                if (currentChore) {
-                    return getPromise(currentChore).then(() => drainUpTo(runUptoChore, isServer)).catch(e => {
-                        container.handleError(e, currentChore?.$host$);
-                    });
+        function applyJournalFlush() {
+            isJournalFlushRunning || (isJournalFlushRunning = !0, journalFlush(), isJournalFlushRunning = !1, 
+            flushBudgetStart = performance.now());
+        }
+        function shouldApplyJournalFlush(isServer) {
+            return !isServer && currentTime - flushBudgetStart >= FREQUENCY_MS;
+        }
+        function drainChoreQueue() {
+            const isServer = isServerPlatform();
+            if (drainScheduled = !1, isDraining) {
+                return;
+            }
+            if (!choreQueue.length) {
+                return applyJournalFlush(), void (drainChore && !runningChores.size && (drainChore.$resolve$(null), 
+                drainChore = null));
+            }
+            isDraining = !0, flushBudgetStart = performance.now();
+            const maybeFinishDrain = () => choreQueue.length ? (drainInNextTick(), !1) : drainChore && runningChores.size ? (shouldApplyJournalFlush(isServer) && applyJournalFlush(), 
+            !1) : (currentChore = null, applyJournalFlush(), drainChore?.$resolve$(null), drainChore = null, 
+            !0);
+            const scheduleBlockedChoresAndDrainIfNeeded = chore => {
+                let blockedChoresScheduled = !1;
+                if (chore.$blockedChores$) {
+                    for (const blockedChore of chore.$blockedChores$) {
+                        const blockingChore = findBlockingChore(blockedChore, choreQueue, blockedChores, runningChores, container);
+                        blockingChore ? addBlockedChore(blockedChore, blockingChore, blockedChores) : (blockedChores.delete(blockedChore), 
+                        sortedInsert(choreQueue, blockedChore, container.rootVNode || null), blockedChoresScheduled = !0);
+                    }
+                    chore.$blockedChores$ = null;
                 }
-                const nextChore = choreQueue[0];
-                if (nextChore.$executed$) {
-                    if (choreQueue.shift(), nextChore === runUptoChore) {
-                        break;
+                blockedChoresScheduled && !isDraining && drainInNextTick();
+            };
+            let currentChore = null;
+            try {
+                for (;choreQueue.length; ) {
+                    currentTime = performance.now();
+                    const chore = currentChore = choreQueue.shift();
+                    if (chore.$state$ !== ChoreState.NONE) {
+                        continue;
+                    }
+                    if (vNodeAlreadyDeleted(chore) && 32 !== chore.$type$) {
+                        continue;
+                    }
+                    if (16 === chore.$type$) {
+                        applyJournalFlush();
+                        const blockingChore = findBlockingChoreForVisible(chore, runningChores, container);
+                        if (blockingChore && blockingChore.$state$ === ChoreState.RUNNING) {
+                            addBlockedChore(chore, blockingChore, blockedChores);
+                            continue;
+                        }
+                    }
+                    chore.$startTime$ = performance.now();
+                    const result = executeChore(chore, isServer);
+                    if (chore.$returnValue$ = result, isPromise(result) ? (runningChores.add(chore), 
+                    chore.$state$ = ChoreState.RUNNING, result.then(value => {
+                        finishChore(chore, value);
+                    }).catch(e => {
+                        chore.$state$ === ChoreState.RUNNING && handleError(chore, e);
+                    }).finally(() => {
+                        if (runningChores.delete(chore), scheduleBlockedChoresAndDrainIfNeeded(chore), !runningChores.size) {
+                            let finished = !1;
+                            drainChore && (finished = maybeFinishDrain()), finished || isDraining || applyJournalFlush();
+                        }
+                    })) : (finishChore(chore, result), scheduleBlockedChoresAndDrainIfNeeded(chore)), 
+                    shouldApplyJournalFlush(isServer)) {
+                        return applyJournalFlush(), void drainInNextTick();
                     }
-                } else {
-                    vNodeAlreadyDeleted(nextChore) && 48 !== nextChore.$type$ ? choreQueue.shift() : executeChore(nextChore, isServer);
                 }
+            } catch (e) {
+                handleError(currentChore, e), scheduleBlockedChoresAndDrainIfNeeded(currentChore);
+            } finally {
+                isDraining = !1, maybeFinishDrain();
             }
-            return runUptoChore.$returnValue$;
+        }
+        function finishChore(chore, value) {
+            chore.$endTime$ = performance.now(), chore.$state$ = ChoreState.DONE, chore.$returnValue$ = value, 
+            chore.$resolve$?.(value);
+        }
+        function handleError(chore, e) {
+            chore.$endTime$ = performance.now(), chore.$state$ = ChoreState.FAILED, chore.$reject$?.(e), 
+            container.handleError(e, chore.$host$);
         }
         function executeChore(chore, isServer) {
             const host = chore.$host$;
-            assertEqual(), currentChore = chore;
-            let returnValue = null;
-            try {
-                switch (chore.$type$) {
-                  case 255:
-                    isServer && (drainScheduled = !1);
-                    break;
-
-                  case 16:
-                    returnValue = journalFlush(), drainScheduled = !1;
-                    break;
-
-                  case 6:
-                    returnValue = safeCall(() => executeComponent(container, host, host, chore.$target$, chore.$payload$), jsx => {
-                        if (isServer) {
-                            return jsx;
-                        }
-                        {
-                            const styleScopedId = container.getHostProp(host, "q:sstyle");
-                            return retryOnPromise(() => vnode_diff(container, jsx, host, addComponentStylePrefix(styleScopedId)));
-                        }
-                    }, err => container.handleError(err, host));
-                    break;
-
-                  case 2:
-                    {
-                        const fn = chore.$target$.getFn();
-                        const result = retryOnPromise(() => fn(...chore.$payload$));
-                        if (isPromise(result)) {
-                            const handled = result.finally(() => {
-                                qrlRuns.splice(qrlRuns.indexOf(handled), 1);
-                            }).catch(error => {
-                                container.handleError(error, chore.$host$);
-                            });
-                            return qrlRuns.push(handled), chore.$returnValue$ = handled, chore.$resolve$?.(handled), 
-                            currentChore = null, void (chore.$executed$ = !0);
-                        }
-                        returnValue = null;
+            let returnValue;
+            switch (chore.$type$) {
+              case 6:
+                returnValue = safeCall(() => executeComponent(container, host, host, chore.$target$, chore.$payload$), jsx => {
+                    if (isServer) {
+                        return jsx;
                     }
-                    break;
-
-                  case 3:
-                  case 32:
                     {
-                        const payload = chore.$payload$;
-                        if (4 & payload.$flags$) {
-                            const result = runResource(payload, container, host);
-                            returnValue = isServer ? result : null;
-                        } else {
-                            returnValue = runTask(payload, container, host);
-                        }
+                        const styleScopedId = container.getHostProp(host, "q:sstyle");
+                        return retryOnPromise(() => vnode_diff(container, jsx, host, addComponentStylePrefix(styleScopedId)));
                     }
-                    break;
+                }, err => {
+                    handleError(chore, err);
+                });
+                break;
 
-                  case 48:
-                    cleanupTask(chore.$payload$);
-                    break;
+              case 2:
+                {
+                    const fn = chore.$target$.getFn();
+                    returnValue = retryOnPromise(() => fn(...chore.$payload$));
+                }
+                break;
 
-                  case 4:
-                    {
-                        const parentVirtualNode = chore.$target$;
-                        let jsx = chore.$payload$;
-                        isSignal(jsx) && (jsx = jsx.value), returnValue = retryOnPromise(() => vnode_diff(container, jsx, parentVirtualNode, null));
-                    }
-                    break;
+              case 3:
+              case 16:
+                {
+                    const payload = chore.$payload$;
+                    returnValue = 4 & payload.$flags$ ? runResource(payload, container, host) : runTask(payload, container, host);
+                }
+                break;
 
-                  case 5:
-                    {
-                        const virtualNode = chore.$host$;
-                        const payload = chore.$payload$;
-                        let value = payload.$value$;
-                        isSignal(value) && (value = value.value);
-                        const isConst = payload.$isConst$;
-                        const journal = container.$journal$;
-                        const property = chore.$idx$;
-                        const serializedValue = serializeAttribute(property, value, payload.$scopedStyleIdPrefix$);
+              case 32:
+                cleanupTask(chore.$payload$);
+                break;
+
+              case 4:
+                {
+                    const parentVirtualNode = chore.$target$;
+                    let jsx = chore.$payload$;
+                    isSignal(jsx) && (jsx = jsx.value), returnValue = retryOnPromise(() => vnode_diff(container, jsx, parentVirtualNode, null));
+                }
+                break;
+
+              case 5:
+                {
+                    const virtualNode = chore.$host$;
+                    const payload = chore.$payload$;
+                    let value = payload.$value$;
+                    isSignal(value) && (value = value.value);
+                    const isConst = payload.$isConst$;
+                    const journal = container.$journal$;
+                    const property = chore.$idx$;
+                    const serializedValue = serializeAttribute(property, value, payload.$scopedStyleIdPrefix$);
+                    if (isServer) {
+                        container.addBackpatchEntry(chore.$host$.id, property, serializedValue), returnValue = null;
+                    } else {
                         if (isConst) {
                             journal.push(2, virtualNode[6], property, serializedValue);
                         } else {
                             vnode_setAttr(journal, virtualNode, property, serializedValue);
                         }
+                        returnValue = void 0;
                     }
-                    break;
+                }
+                break;
 
-                  case 1:
-                    {
-                        const target = chore.$target$;
-                        returnValue = target.resolved ? null : target.resolve();
-                    }
-                    break;
+              case 1:
+                {
+                    const target = chore.$target$;
+                    returnValue = target.resolved ? null : target.resolve();
+                }
+                break;
 
-                  case 7:
-                    {
-                        const target = chore.$target$;
-                        const effects = chore.$payload$;
+              case 7:
+                {
+                    const target = chore.$target$;
+                    const effects = chore.$payload$;
+                    if (!effects?.size) {
+                        break;
+                    }
+                    let shouldCompute = target instanceof ComputedSignalImpl || target instanceof WrappedSignalImpl;
+                    if (target instanceof AsyncComputedSignalImpl && effects !== target.$effects$ && (shouldCompute = !1), 
+                    shouldCompute) {
                         const ctx = newInvokeContext();
-                        if (ctx.$container$ = container, target instanceof ComputedSignalImpl || target instanceof WrappedSignalImpl) {
-                            const forceRunEffects = target.$forceRunEffects$;
-                            if (target.$forceRunEffects$ = !1, !effects?.size && !forceRunEffects) {
-                                break;
+                        ctx.$container$ = container, returnValue = maybeThen(retryOnPromise(() => invoke.call(target, ctx, target.$computeIfNeeded$)), () => {
+                            if (2 & target.$flags$) {
+                                return target.$flags$ &= -3, retryOnPromise(() => triggerEffects(container, target, effects));
                             }
-                            returnValue = maybeThen(retryOnPromise(() => invoke.call(target, ctx, target.$computeIfNeeded$)), didChange => {
-                                if (didChange || forceRunEffects) {
-                                    return retryOnPromise(() => triggerEffects(container, target, effects));
-                                }
-                            });
-                        } else {
-                            returnValue = retryOnPromise(() => triggerEffects(container, target, effects));
-                        }
+                        });
+                    } else {
+                        returnValue = retryOnPromise(() => {
+                            triggerEffects(container, target, effects);
+                        });
                     }
                 }
-            } catch (e) {
-                returnValue = Promise.reject(e);
             }
-            const after = (value, error) => {
-                currentChore = null, chore.$executed$ = !0, error ? container.handleError(error, host) : (chore.$returnValue$ = value, 
-                chore.$resolve$?.(value));
-            };
-            isPromise(returnValue) ? (chore.$promise$ = returnValue.then(after, error => after(void 0, error)), 
-            chore.$resolve$?.(chore.$promise$), chore.$resolve$ = void 0) : after(returnValue);
+            return returnValue;
         }
         function choreComparator(a, b, rootVNode) {
             const macroTypeDiff = (240 & a.$type$) - (240 & b.$type$);
@@ -2553,8 +2774,6 @@
                     }
                 } else {
                     assertFalse(vnode_isVNode(aHost)), assertFalse(vnode_isVNode(bHost));
-                    const errorMessage = `SERVER: during HTML streaming, re-running tasks on a different host is not allowed.\n          You are attempting to change a state that has already been streamed to the client.\n          This can lead to inconsistencies between Server-Side Rendering (SSR) and Client-Side Rendering (CSR).\n          Problematic Node: ${aHost.toString()}`;
-                    logWarn(errorMessage);
                     const hostDiff = ((a, b) => {
                         if (a === b) {
                             return 0;
@@ -2562,10 +2781,10 @@
                         let aDepth = -1;
                         let bDepth = -1;
                         for (;a; ) {
-                            a = (aSsrNodePath[++aDepth] = a).parentSsrNode;
+                            a = (aSsrNodePath[++aDepth] = a).parentComponent;
                         }
                         for (;b; ) {
-                            b = (bSsrNodePath[++bDepth] = b).parentSsrNode;
+                            b = (bSsrNodePath[++bDepth] = b).parentComponent;
                         }
                         for (;aDepth >= 0 && bDepth >= 0; ) {
                             if ((a = aSsrNodePath[aDepth]) !== (b = bSsrNodePath[bDepth])) {
@@ -2585,13 +2804,63 @@
                 return microTypeDiff;
             }
             const idxDiff = toNumber(a.$idx$) - toNumber(b.$idx$);
-            return 0 !== idxDiff ? idxDiff : a.$target$ !== b.$target$ ? isQrl(a.$target$) && isQrl(b.$target$) && a.$target$.$hash$ === b.$target$.$hash$ ? 0 : 1 : b === currentChore ? 1 : 0;
+            return 0 !== idxDiff ? idxDiff : a.$target$ !== b.$target$ ? isQrl(a.$target$) && isQrl(b.$target$) && a.$target$.$hash$ === b.$target$.$hash$ ? 0 : 1 : 7 === a.$type$ && 7 === b.$type$ && (a.$target$ instanceof StoreHandler && b.$target$ instanceof StoreHandler || a.$target$ instanceof AsyncComputedSignalImpl && b.$target$ instanceof AsyncComputedSignalImpl) && a.$payload$ !== b.$payload$ ? 1 : 0;
+        }
+        function sortedInsert(sortedArray, value, rootVNode) {
+            const idx = function(sortedArray, value, rootVNode) {
+                let bottom = 0;
+                let top = sortedArray.length;
+                for (;bottom < top; ) {
+                    const middle = bottom + (top - bottom >> 1);
+                    const comp = choreComparator(value, sortedArray[middle], rootVNode);
+                    if (comp < 0) {
+                        top = middle;
+                    } else {
+                        if (!(comp > 0)) {
+                            return middle;
+                        }
+                        bottom = middle + 1;
+                    }
+                }
+                return ~bottom;
+            }(sortedArray, value, rootVNode);
+            if (idx < 0 && runningChores.size) {
+                for (const chore of runningChores) {
+                    if (0 === choreComparator(value, chore, rootVNode)) {
+                        return chore;
+                    }
+                }
+            }
+            if (idx < 0) {
+                return sortedArray.splice(~idx, 0, value), value;
+            }
+            const existing = sortedArray[idx];
+            return existing.$payload$ !== value.$payload$ && (existing.$payload$ = value.$payload$), 
+            existing;
         }
     };
     const toNumber = value => "number" == typeof value ? value : -1;
     function vNodeAlreadyDeleted(chore) {
         return !!(chore.$host$ && vnode_isVNode(chore.$host$) && 32 & chore.$host$[0]);
     }
+    function addBlockedChore(blockedChore, blockingChore, blockedChores) {
+        blockingChore.$blockedChores$ ||= [], blockingChore.$blockedChores$.push(blockedChore), 
+        blockedChores.add(blockedChore);
+    }
+    function choreTypeToName(type) {
+        return {
+            1: "Resolve QRL",
+            2: "Run QRL",
+            3: "Task",
+            4: "Changes diffing",
+            5: "Updating node property",
+            6: "Component",
+            7: "Signal recompute",
+            16: "Visible",
+            32: "Cleanup visible",
+            255: "Wait for queue"
+        }[type] || "Unknown: " + type;
+    }
     class _SharedContainer {
         $version$;
         $scheduler$;
@@ -2602,11 +2871,12 @@
         $currentUniqueId$=0;
         $instanceHash$=null;
         $buildBase$=null;
-        constructor(scheduleDrain, journalFlush, serverData, locale) {
+        $flushEpoch$=0;
+        constructor(journalFlush, serverData, locale) {
             this.$serverData$ = serverData, this.$locale$ = locale, this.$version$ = version, 
             this.$storeProxyMap$ = new WeakMap, this.$getObjectById$ = () => {
                 throw Error("Not implemented");
-            }, this.$scheduler$ = createScheduler(this, scheduleDrain, journalFlush);
+            }, this.$scheduler$ = createScheduler(this, journalFlush);
         }
         trackSignalValue(signal, subscriber, property, data) {
             return trackSignalAndAssignHost(signal, subscriber, property, this, data);
@@ -2629,9 +2899,8 @@
         return container || (container = new DomContainer(qContainerElement)), container;
     }
     function _getQContainerElement(element) {
-        return (Array.isArray(element) ? vnode_getDomParent(element) : element).closest("[q\\:container]:not([q\\:container=html]):not([q\\:container=text])");
+        return (Array.isArray(element) ? vnode_getDomParent(element, !0) : element).closest("[q\\:container]:not([q\\:container=html]):not([q\\:container=text])");
     }
-    const isDomContainer = container => container instanceof DomContainer;
     class DomContainer extends _SharedContainer {
         element;
         qContainer;
@@ -2639,7 +2908,6 @@
         rootVNode;
         document;
         $journal$;
-        renderDone=null;
         $rawStateData$;
         $storeProxyMap$=new WeakMap;
         $qFuncs$;
@@ -2649,10 +2917,11 @@
         vNodeLocate=id => vnode_locate(this.rootVNode, id);
         $stateData$;
         $styleIds$=null;
-        $renderCount$=0;
         constructor(element) {
-            if (super(() => this.scheduleRender(), () => vnode_applyJournal(this.$journal$), {}, element.getAttribute("q:locale")), 
-            this.qContainer = element.getAttribute("q:container"), !this.qContainer) {
+            if (super(() => {
+                this.$flushEpoch$++, vnode_applyJournal(this.$journal$);
+            }, {}, element.getAttribute("q:locale")), this.qContainer = element.getAttribute("q:container"), 
+            !this.qContainer) {
                 throw qError(25);
             }
             this.$journal$ = [ 3, element.ownerDocument ], this.document = element.ownerDocument, 
@@ -2789,7 +3058,10 @@
                             nextNode = nextSibling(node);
                             const shadowRootContainer = node;
                             const shadowRoot = shadowRootContainer?.shadowRoot;
-                            shadowRoot && walkContainer(document.createTreeWalker(shadowRoot, 129), null, firstChild(shadowRoot), null, "", null);
+                            if (shadowRoot) {
+                                const firstShadowRootChild = firstChild(shadowRoot);
+                                walkContainer(document.createTreeWalker(firstShadowRootChild, 129), null, firstShadowRootChild, null, "", null);
+                            }
                         }
                         if (!(2 & ~nodeType)) {
                             if (vNodeElementIndex < elementIdx && (-1 === vNodeElementIndex && (vNodeElementIndex = 0), 
@@ -2878,26 +3150,6 @@
             }
             return vnode_getProp(vNode, name, getObjectById);
         }
-        scheduleRender() {
-            return this.$renderCount$++, this.renderDone ||= getPlatform().nextTick(() => this.processChores()), 
-            this.renderDone.finally(() => emitEvent("qrender", {
-                instanceHash: this.$instanceHash$,
-                renderCount: this.$renderCount$
-            }));
-        }
-        processChores() {
-            let renderCount = this.$renderCount$;
-            const result = this.$scheduler$(255);
-            if (isPromise(result)) {
-                return result.then(async () => {
-                    for (;renderCount !== this.$renderCount$; ) {
-                        renderCount = this.$renderCount$, await this.$scheduler$(255);
-                    }
-                    this.renderDone = null;
-                });
-            }
-            renderCount === this.$renderCount$ ? this.renderDone = null : this.processChores();
-        }
         ensureProjectionResolved(vNode) {
             if (!(16 & vNode[0])) {
                 vNode[0] |= 16;
@@ -2905,7 +3157,10 @@
                 for (let i = 0; i < props.length; i += 2) {
                     if (isSlotProp(props[i])) {
                         const value = props[i + 1];
-                        "string" == typeof value && (props[i + 1] = this.vNodeLocate(value));
+                        if ("string" == typeof value) {
+                            const projection = this.vNodeLocate(value);
+                            props[i + 1] = projection, vnode_getProp(projection, "q:sparent", id => this.vNodeLocate(id));
+                        }
                     }
                 }
             }
@@ -2969,7 +3224,7 @@
         array[2] ||= new Set, array[2].add(value);
     };
     const addQrlToSerializationCtx = (effectSubscriber, container) => {
-        if (container && !isDomContainer(container)) {
+        if (container && !(container => container instanceof DomContainer)(container)) {
             const effect = effectSubscriber[0];
             const property = effectSubscriber[1];
             let qrl = null;
@@ -2978,7 +3233,7 @@
         }
     };
     const triggerEffects = (container, signal, effects) => {
-        const isBrowser = isDomContainer(container);
+        const isBrowser = !isServerPlatform();
         if (effects) {
             const scheduleEffect = effectSubscription => {
                 const consumer = effectSubscription[0];
@@ -2986,7 +3241,7 @@
                 if (assertDefined(), isTask(consumer)) {
                     consumer.$flags$ |= 8;
                     let choreType = 3;
-                    1 & consumer.$flags$ && (choreType = 32), container.$scheduler$(choreType, consumer);
+                    1 & consumer.$flags$ && (choreType = 16), container.$scheduler$(choreType, consumer);
                 } else if (consumer instanceof SignalImpl) {
                     consumer instanceof ComputedSignalImpl && (consumer.$computeQrl$.resolved || container.$scheduler$(1, null, consumer.$computeQrl$)), 
                     consumer.invalidate();
@@ -2996,18 +3251,18 @@
                     assertDefined();
                     const props = container.getHostProp(host, "q:props");
                     container.$scheduler$(6, host, qrl, props);
-                } else if (isBrowser) {
-                    if ("." === property) {
+                } else if ("." === property) {
+                    if (isBrowser) {
                         container.$scheduler$(4, consumer, consumer, signal);
-                    } else {
-                        const effectData = effectSubscription[3];
-                        if (effectData instanceof SubscriptionData) {
-                            const payload = {
-                                ...effectData.data,
-                                $value$: signal
-                            };
-                            container.$scheduler$(5, consumer, property, payload);
-                        }
+                    }
+                } else {
+                    const effectData = effectSubscription[3];
+                    if (effectData instanceof SubscriptionData) {
+                        const payload = {
+                            ...effectData.data,
+                            $value$: signal
+                        };
+                        container.$scheduler$(5, consumer, property, payload);
                     }
                 }
             };
@@ -3020,11 +3275,11 @@
         let flags = 1;
         switch (serializationStrategy) {
           case "never":
-            flags |= 8;
+            flags |= 16;
             break;
 
           case "always":
-            flags |= 16;
+            flags |= 32;
         }
         return flags;
     };
@@ -3179,13 +3434,16 @@
             }
         }
     };
-    function vnode_walkVNode(vNode) {
+    function vnode_walkVNode(vNode, callback) {
         let vCursor = vNode;
         if (vnode_isTextVNode(vNode)) {
             return;
         }
         let vParent = null;
         for (;;) {
+            if (callback?.(vCursor, vParent)) {
+                return;
+            }
             const vFirstChild = vnode_getFirstChild(vCursor);
             if (vFirstChild) {
                 vCursor = vFirstChild;
@@ -3277,6 +3535,7 @@
         const textVNode = ensureTextVNode(vnode);
         if (!(8 & textVNode[0])) {
             const parentNode = vnode_getDomParent(vnode);
+            assertDefined();
             const sharedTextNode = textVNode[4];
             const doc = parentNode.ownerDocument;
             let cursor = vnode_getDomSibling(vnode, !1, !0);
@@ -3442,7 +3701,7 @@
             }
             insertBefore = null;
         }
-        const domParentVNode = vnode_getDomParentVNode(parent);
+        const domParentVNode = vnode_getDomParentVNode(parent, !1);
         const parentNode = domParentVNode && domParentVNode[6];
         let domChildren = null;
         domParentVNode && (domChildren = function(journal, domParentVNode, newChild) {
@@ -3468,27 +3727,30 @@
             }
             return domChildren;
         }(journal, domParentVNode, newChild)), newChildCurrentParent && (newChild[2] || newChild[3] || newChildCurrentParent !== parent) && vnode_remove(journal, newChildCurrentParent, newChild, !1);
-        let adjustedInsertBefore = null;
-        null == insertBefore ? 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), domChildren && domChildren.length && journal.push(5, parentNode, vnode_getNode(adjustedInsertBefore), ...domChildren);
+        const parentIsDeleted = 32 & parent[0];
+        if (!parentIsDeleted) {
+            let adjustedInsertBefore = null;
+            null == insertBefore ? 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), domChildren && domChildren.length && journal.push(5, parentNode, vnode_getNode(adjustedInsertBefore), ...domChildren);
+        }
         const vNext = insertBefore;
         const vPrevious = vNext ? vNext[2] : parent[5];
         vNext ? vNext[2] = newChild : parent[5] = newChild, vPrevious ? vPrevious[3] = newChild : parent[4] = newChild, 
-        newChild[2] = vPrevious, newChild[3] = vNext, newChild[1] = parent;
+        newChild[2] = vPrevious, newChild[3] = vNext, newChild[1] = parent, parentIsDeleted && (newChild[0] |= 32);
     };
-    const vnode_getDomParent = vnode => (vnode = vnode_getDomParentVNode(vnode)) && vnode[6];
-    const vnode_getDomParentVNode = vnode => {
+    const vnode_getDomParent = (vnode, includeProjection = !0) => (vnode = vnode_getDomParentVNode(vnode, includeProjection)) && vnode[6];
+    const vnode_getDomParentVNode = (vnode, includeProjection = !0) => {
         for (;vnode && !vnode_isElementVNode(vnode); ) {
-            vnode = vnode[1];
+            vnode = vnode[1] || (includeProjection ? vnode_getProp(vnode, "q:sparent", id => vnode_isVNode(id) ? id : null) : null);
         }
         return vnode;
     };
     const vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
         if (assertEqual(vnode_getParent(vToRemove)), vnode_isTextVNode(vToRemove) && vnode_ensureTextInflated(journal, vToRemove), 
         removeDOM) {
-            const domParent = vnode_getDomParent(vParent);
+            const domParent = vnode_getDomParent(vParent, !1);
             if (vnode_getAttr(vParent, "dangerouslySetInnerHTML")) {
                 return;
             }
@@ -3868,6 +4130,25 @@
     };
     const vnode_getProps = vnode => vnode[vnode_getPropStartIndex(vnode)];
     const vnode_getParent = vnode => vnode[1] || null;
+    const vnode_isDescendantOf = (vnode, ancestor, rootVNode) => {
+        let parent = vnode_getParentOrProjectionParent(vnode, rootVNode);
+        for (;parent; ) {
+            if (parent === ancestor) {
+                return !0;
+            }
+            parent = vnode_getParentOrProjectionParent(parent, rootVNode);
+        }
+        return !1;
+    };
+    const vnode_getParentOrProjectionParent = (vnode, rootVNode) => {
+        if (rootVNode) {
+            const parentProjection = vnode_getProp(vnode, "q:sparent", id => vnode_locate(rootVNode, id));
+            if (parentProjection) {
+                return parentProjection;
+            }
+        }
+        return vnode_getParent(vnode);
+    };
     const vnode_getNode = vnode => null === vnode || vnode_isVirtualVNode(vnode) ? null : vnode_isElementVNode(vnode) ? vnode[6] : (assertTrue(vnode_isTextVNode(vnode)), 
     vnode[4]);
     function vnode_toString(depth = 20, offset = "", materialize = !1, siblings = !1, colorize = !0) {
@@ -4008,9 +4289,9 @@
             }
             const container = this.$container$;
             let propValue = allocate(container, typeId, value);
-            return typeId >= 14 && (propValue = inflate(container, propValue, typeId, value)), 
-            Reflect.set(target, property, propValue), this.$data$[idx] = void 0, this.$data$[idx + 1] = propValue, 
-            propValue;
+            return Reflect.set(target, property, propValue), this.$data$[idx] = void 0, this.$data$[idx + 1] = propValue, 
+            typeId >= 14 && (propValue = inflate(container, propValue, typeId, value), Reflect.set(target, property, propValue), 
+            this.$data$[idx + 1] = propValue), propValue;
         }
         has(target, property) {
             return property === SERIALIZER_PROXY_UNWRAP || Object.prototype.hasOwnProperty.call(target, property);
@@ -4133,7 +4414,7 @@
                 const d = data;
                 computed.$computeQrl$ = d[0], computed.$effects$ = new Set(d[1]);
                 d.length > 2 ? (computed.$untrackedValue$ = d[2], 29 === typeId && (computed.$flags$ |= 1)) : (computed.$flags$ |= 1, 
-                computed.$computeQrl$.resolve(), container.$scheduler$?.(1, null, computed.$computeQrl$));
+                computed.$computeQrl$.resolve(), container.$scheduler$(1, null, computed.$computeQrl$));
                 break;
             }
 
@@ -4613,8 +4894,8 @@
                                     output(26, [ ...serializeWrappingFn(serializationContext, value), filterEffectBackRefs(value[_EFFECT_BACK_REF]), value.$flags$, value.$hostElement$, ...value.$effects$ || [] ]);
                                 } else if (value instanceof ComputedSignalImpl) {
                                     let v = value.$untrackedValue$;
-                                    const shouldAlwaysSerialize = 16 & value.$flags$;
-                                    const shouldNeverSerialize = 8 & value.$flags$;
+                                    const shouldAlwaysSerialize = 32 & value.$flags$;
+                                    const shouldNeverSerialize = 16 & value.$flags$;
                                     const isInvalid = 1 & value.$flags$;
                                     const isSkippable = fastSkipSerialize(value.$untrackedValue$);
                                     shouldAlwaysSerialize ? v = value.$untrackedValue$ : (shouldNeverSerialize || isInvalid || isSkippable) && (v = NEEDS_COMPUTATION), 
@@ -4851,8 +5132,7 @@
             const result = platform.chunkForSymbol(symbol, chunk, value.dev?.file);
             result && (chunk = result[1], symbol = result[0]);
         }
-        const isSync = (value => isQrl(value) && "<sync>" == value.$symbol$)(value);
-        if (isSync) {
+        if (isSyncQrl(value)) {
             chunk = "", symbol = String(serializationContext.$addSyncFn$(null, 0, value.resolved));
         } else {
             chunk || (chunk = serializationContext.$symbolToChunkResolver$(value.$hash$));
@@ -5471,7 +5751,7 @@
         assertQrl(qrl);
         const task = new Task(1, i, iCtx.$hostElement$, qrl, void 0, null);
         set(task), useRunTask(task, eagerness), isServerPlatform() || (qrl.resolve(iCtx.$element$), 
-        iCtx.$container$.$scheduler$(32, task));
+        iCtx.$container$.$scheduler$(16, task));
     };
     const useRunTask = (task, eagerness) => {
         "intersection-observer" === eagerness ? useOn("qvisible", getTaskHandlerQrl(task)) : "document-ready" === eagerness ? useOnDocument("qinit", getTaskHandlerQrl(task)) : "document-idle" === eagerness && useOnDocument("qidle", getTaskHandlerQrl(task));
@@ -5491,7 +5771,8 @@
             cacheName && caches.delete(cacheName).catch(console.error);
         }).catch(console.error);
     }).toString();
-    Object.defineProperty(exports, "isBrowser", {
+    globalThis.__qwik && console.error(`==============================================\nQwik version ${globalThis.__qwik} already imported while importing ${version}. Verify external vs bundled imports etc. This can lead to issues due to duplicated shared structures.\n==============================================\n`), 
+    globalThis.__qwik = version, Object.defineProperty(exports, "isBrowser", {
         enumerable: !0,
         get: function() {
             return build.isBrowser;
@@ -5530,8 +5811,8 @@
     }, exports.RenderOnce = RenderOnce, exports.Resource = props => _jsxSorted(Fragment, null, null, function(props) {
         const resource = props.value;
         if (isResourceReturn(resource)) {
+            const state = resource._state;
             if (!isServerPlatform()) {
-                const state = resource._state;
                 if ("pending" === state && props.onPending) {
                     return Promise.resolve().then(useBindInvokeContext(props.onPending));
                 }
@@ -5545,8 +5826,7 @@
                     }
                 }
             }
-            const value = resource.value;
-            return value ? value.then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected)) : Promise.resolve(void 0);
+            return untrack(() => resource.value).then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
         }
         if (isPromise(resource)) {
             return resource.then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
@@ -5604,8 +5884,10 @@
     exports._getVarProps = props => props ? _VAR_PROPS in props ? "children" in props ? {
         ...props[_VAR_PROPS],
         children: props.children
-    } : props[_VAR_PROPS] : props : null, exports._isJSXNode = isJSXNode, exports._isStore = isStore, 
-    exports._isStringifiable = function(value) {
+    } : props[_VAR_PROPS] : props : null, exports._hasStoreEffects = (value, prop) => {
+        const handler = getStoreHandler(value);
+        return !!handler && (handler.$effects$?.get(prop)?.size ?? 0) > 0;
+    }, exports._isJSXNode = isJSXNode, exports._isStore = isStore, exports._isStringifiable = function(value) {
         return null === value || "string" == typeof value || "number" == typeof value || "boolean" == typeof value;
     }, exports._isTask = isTask, exports._jsxBranch = input => input, exports._jsxC = (type, mutable, _flags, key) => jsx(type, mutable, key), 
     exports._jsxQ = (type, mutable, immutable, children, _flags, key) => jsx(type, {
@@ -5630,7 +5912,7 @@
         if (hostElement) {
             return iCtx.$container$?.resolveContext(hostElement, context);
         }
-    }, exports._restProps = (props, omit, target = {}) => {
+    }, exports._restProps = (props, omit = [], target = {}) => {
         let constPropsTarget = null;
         const constProps = props[_CONST_PROPS];
         if (constProps) {
@@ -5644,7 +5926,7 @@
             omit.includes(key) || (varPropsTarget[key] = varProps[key]);
         }
         return createPropsProxy(varPropsTarget, constPropsTarget);
-    }, exports._run = queueQRL, exports._serializationWeakRef = obj => new SerializationWeakRef(obj), 
+    }, exports._run = _run, exports._serializationWeakRef = obj => new SerializationWeakRef(obj), 
     exports._serialize = async function(data) {
         const serializationContext = createSerializationContext(null, null, () => "", () => "", () => {}, new WeakMap);
         for (const root of data) {
@@ -5658,12 +5940,17 @@
     exports._vnode_getProps = vnode_getProps, exports._vnode_isMaterialized = vnode_isMaterialized, 
     exports._vnode_isTextVNode = vnode_isTextVNode, exports._vnode_isVirtualVNode = vnode_isVirtualVNode, 
     exports._vnode_toString = vnode_toString, exports._waitUntilRendered = elm => {
-        const containerEl = _getQContainerElement(elm);
-        if (!containerEl) {
-            return Promise.resolve();
-        }
-        const container = containerEl.qContainer;
-        return container?.renderDone ?? Promise.resolve();
+        const container = _getQContainerElement(elm)?.qContainer;
+        return container ? (async () => {
+            for (;;) {
+                await container.$scheduler$(255).$returnValue$;
+                const firstEpoch = container.$flushEpoch$ || 0;
+                await Promise.resolve();
+                if (firstEpoch === (container.$flushEpoch$ || 0)) {
+                    return;
+                }
+            }
+        })() : Promise.resolve();
     }, exports._walkJSX = _walkJSX, exports._wrapProp = _wrapProp, exports._wrapSignal = (obj, prop) => {
         const r = _wrapProp(obj, prop);
         return r === _IMMUTABLE ? obj[prop] : r;
@@ -5672,8 +5959,8 @@
     exports.createComputed$ = createComputed$, exports.createComputedQrl = createComputedSignal, 
     exports.createContextId = createContextId, exports.createElement = h, exports.createSerializer$ = createSerializer$, 
     exports.createSerializerQrl = createSerializerSignal, exports.createSignal = createSignal, 
-    exports.event$ = event$, exports.eventQrl = eventQrl, exports.getDomContainer = getDomContainer, 
-    exports.getLocale = function(defaultLocale) {
+    exports.event$ = event$, exports.eventQrl = eventQrl, exports.forceStoreEffects = forceStoreEffects, 
+    exports.getDomContainer = getDomContainer, exports.getLocale = function(defaultLocale) {
         if (void 0 === _locale) {
             const ctx = tryGetInvokeContext();
             if (ctx && ctx.$locale$) {
@@ -5716,7 +6003,7 @@
         const container = getDomContainer(parent);
         container.$serverData$ = opts.serverData || {};
         const host = container.rootVNode;
-        return container.$scheduler$(4, host, host, jsxNode), await container.$scheduler$(255), 
+        return container.$scheduler$(4, host, host, jsxNode), await container.$scheduler$(255).$returnValue$, 
         {
             cleanup: () => {
                 cleanup(container, container.rootVNode);