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

package/dist/core.prod.mjs

@@ -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
@@ -11,6 +11,8 @@ export { isBrowser, isDev, isServer } from "@qwik.dev/core/build";
 
 import { p } from "@qwik.dev/core/preloader";
 
+const version = "2.0.0-beta.9-dev+6b582c7";
+
 const qDev = !1;
 
 const qInspector = !1;
@@ -66,6 +68,8 @@ const isArray = v => Array.isArray(v);
 
 const isString = v => "string" == typeof v;
 
+const isNumber$1 = v => "number" == typeof v;
+
 const isFunction = v => "function" == typeof v;
 
 const isPrimitive = v => "object" != typeof v && "function" != typeof v && null != v;
@@ -222,11 +226,6 @@ const createPlatform = () => ({
             resolve(fn());
         });
     }),
-    nextTick: fn => new Promise(resolve => {
-        setTimeout(() => {
-            resolve(fn());
-        });
-    }),
     chunkForSymbol: (symbolName, chunk) => [ symbolName, chunk ?? "_" ]
 });
 
@@ -360,6 +359,9 @@ class SignalImpl {
     constructor(container, value) {
         this.$container$ = container, this.$untrackedValue$ = value;
     }
+    force() {
+        this.$container$?.$scheduler$(7, null, this, this.$effects$);
+    }
     get untrackedValue() {
         return this.$untrackedValue$;
     }
@@ -370,7 +372,7 @@ class SignalImpl {
         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;
@@ -413,30 +415,27 @@ class WrappedSignalImpl extends SignalImpl {
     $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$ === NEEDS_COMPUTATION, "Invalid state"), 
+        return this.$computeIfNeeded$(), assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state"), 
         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);
@@ -581,12 +580,17 @@ const _getContextContainer = () => {
 const _jsxBranch = input => input;
 
 const _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();
 };
 
 const useSequentialScope = () => {
@@ -717,8 +721,6 @@ const ERROR_CONTEXT = /*#__PURE__*/ createContextId("qk-error");
 
 const isRecoverable = err => !(err && err instanceof Error && "plugin" in err);
 
-const version = "2.0.0-beta.8-dev+434cd18";
-
 const EMPTY_ARRAY = [];
 
 const EMPTY_OBJ = {};
@@ -799,7 +801,7 @@ const useLexicalScope = () => {
     return qrl.$captureRef$;
 };
 
-const queueQRL = (...args) => {
+const _run = (...args) => {
     const [runQrl] = useLexicalScope();
     const context = getInvokeContext();
     const hostElement = context.$hostElement$;
@@ -810,7 +812,8 @@ const queueQRL = (...args) => {
     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) => {
@@ -859,25 +862,23 @@ const log = (...args) => console.log("COMPUTED SIGNAL", ...args.map(qwikDebugToS
 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$ === NEEDS_COMPUTATION, "Invalid state"), 
+        return this.$computeIfNeeded$(), assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state"), 
         this.$untrackedValue$;
     }
     $computeIfNeeded$() {
         if (!(1 & this.$flags$)) {
-            return !1;
+            return;
         }
         const computeQrl = this.$computeQrl$;
         throwIfQRLNotResolved(computeQrl);
@@ -890,8 +891,8 @@ class ComputedSignalImpl extends SignalImpl {
                 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);
         }
@@ -906,12 +907,12 @@ class ComputedSignalImpl extends SignalImpl {
 
 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;
@@ -921,8 +922,8 @@ class SerializerSignalImpl extends ComputedSignalImpl {
         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);
     }
 }
 
@@ -930,6 +931,16 @@ 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 _hasStoreEffects = (value, prop) => {
+    const handler = getStoreHandler(value);
+    return !!handler && (handler.$effects$?.get(prop)?.size ?? 0) > 0;
+};
+
 const unwrapStore = value => getStoreTarget(value) || value;
 
 const isStore = value => STORE_TARGET in value;
@@ -957,6 +968,10 @@ class StoreHandler {
     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];
@@ -993,7 +1008,7 @@ class StoreHandler {
         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) {
@@ -1032,7 +1047,9 @@ function addStoreEffect(target, prop, store, effectSubscription) {
 }
 
 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) {
@@ -1129,7 +1146,7 @@ class AsyncComputedSignalImpl extends ComputedSignalImpl {
     }
     $computeIfNeeded$() {
         if (!(1 & this.$flags$)) {
-            return !1;
+            return;
         }
         const computeQrl = this.$computeQrl$;
         throwIfQRLNotResolved(computeQrl);
@@ -1147,7 +1164,8 @@ class AsyncComputedSignalImpl extends ComputedSignalImpl {
         }
         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;
     }
 }
 
@@ -1181,7 +1199,7 @@ const _wrapProp = (...args) => {
     }
     if (isSignal(obj)) {
         return obj instanceof AsyncComputedSignalImpl || assertEqual(prop, "value", "Left side is a signal, prop must be value"), 
-        obj instanceof WrappedSignalImpl && 2 & obj.flags ? obj : getWrapped(args);
+        obj instanceof WrappedSignalImpl && 4 & obj.flags ? obj : getWrapped(args);
     }
     if (isPropsProxy(obj)) {
         const constProps = obj[_CONST_PROPS];
@@ -1220,7 +1238,7 @@ function isSlotProp(prop) {
     return !prop.startsWith("q:") && !prop.startsWith(":");
 }
 
-const _restProps = (props, omit, target = {}) => {
+const _restProps = (props, omit = [], target = {}) => {
     let constPropsTarget = null;
     const constProps = props[_CONST_PROPS];
     if (constProps) {
@@ -1500,8 +1518,8 @@ function addUseOnEvents(jsx, useOnEvents) {
                     }
                     targetElement = placeholderElement;
                 }
-                targetElement && ("script" === targetElement.type && "onQvisible$" === key && (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 && "onQvisible$" === key && (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]));
             }
         }
@@ -1573,10 +1591,10 @@ const applyQwikComponentBody = (ssr, jsx, component) => {
     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);
 };
 
 class ParentComponentData {
@@ -1658,7 +1676,14 @@ function processJSXNode(ssr, enqueue, value, options) {
                 appendClassIfScopedStyleExists(jsx, options.styleScoped);
                 let qwikInspectorAttrValue = null;
                 isDev && jsx.dev && "head" !== jsx.type && (qwikInspectorAttrValue = getFileLocationFromJsx(jsx.dev));
-                const innerHTML = ssr.openElement(type, varPropsToSsrAttrs(jsx.varProps, jsx.constProps, ssr.serializationCtx, options.styleScoped, jsx.key), constPropsToSsrAttrs(jsx.constProps, jsx.varProps, ssr.serializationCtx, options.styleScoped), qwikInspectorAttrValue);
+                const innerHTML = ssr.openElement(type, varPropsToSsrAttrs(jsx.varProps, jsx.constProps, {
+                    serializationCtx: ssr.serializationCtx,
+                    styleScopedId: options.styleScoped,
+                    key: jsx.key
+                }), constPropsToSsrAttrs(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);
@@ -1726,18 +1751,19 @@ function processJSXNode(ssr, enqueue, value, options) {
     }
 }
 
-function varPropsToSsrAttrs(varProps, constProps, serializationCtx, styleScopedId, key) {
-    return toSsrAttrs(varProps, constProps, serializationCtx, !0, styleScopedId, key);
+function varPropsToSsrAttrs(varProps, constProps, options) {
+    return toSsrAttrs(varProps, constProps, !1, options);
 }
 
-function constPropsToSsrAttrs(constProps, varProps, serializationCtx, styleScopedId) {
-    return toSsrAttrs(constProps, varProps, serializationCtx, !1, styleScopedId);
+function constPropsToSsrAttrs(constProps, varProps, options) {
+    return toSsrAttrs(constProps, varProps, !0, options);
 }
 
-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];
@@ -1751,14 +1777,14 @@ function toSsrAttrs(record, anotherRecord, serializationCtx, pushMergedEventProp
                     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) {
@@ -1783,7 +1809,7 @@ function setEvent(serializationCtx, key, rawValue) {
     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++) {
@@ -1839,8 +1865,10 @@ const useTaskQrl = qrl => {
     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) => {
@@ -1891,7 +1919,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);
 };
 
@@ -2012,7 +2040,7 @@ class PropsProxyHandler {
             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, 
@@ -2275,36 +2303,38 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
         }
     }();
     function diff(jsxNode, vStartNode) {
-        for (assertFalse(vnode_isVNode(jsxNode), "JSXNode should not be a VNode"), assertTrue(vnode_isVNode(vStartNode), "vStartNode should be a VNode"), 
+        if (assertFalse(vnode_isVNode(jsxNode), "JSXNode should not be a VNode"), assertTrue(vnode_isVNode(vStartNode), "vStartNode should be a VNode"), 
         vParent = vStartNode, vNewNode = null, vCurrent = vnode_getFirstChild(vStartNode), 
-        stackPush(jsxNode, !0); stack.length; ) {
-            for (;jsxIdx < jsxCount; ) {
-                if (assertFalse(vParent === vCurrent, "Parent and current can't be the same"), "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(vParent === vCurrent, "Parent and current can't be the same"), "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() {
@@ -2566,8 +2596,12 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
             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;
         }));
@@ -2762,7 +2796,7 @@ function cleanup(container, vNode) {
                         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);
                         }
                     }
                 }
@@ -2788,7 +2822,9 @@ function cleanup(container, vNode) {
                 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 {
@@ -2849,8 +2885,9 @@ const useResourceQrl = (qrl, opts) => {
     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 Resource = props => _jsxSorted(Fragment, null, null, getResourceValueAsPromise(props), 0, null);
@@ -2858,8 +2895,8 @@ const Resource = props => _jsxSorted(Fragment, null, null, getResourceValueAsPro
 function getResourceValueAsPromise(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));
             }
@@ -2873,8 +2910,7 @@ function getResourceValueAsPromise(props) {
                 }
             }
         }
-        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));
@@ -2927,21 +2963,21 @@ const runResource = (task, container, host) => {
     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)) {
@@ -2955,8 +2991,6 @@ const runResource = (task, container, host) => {
     }) ]) : promise;
 };
 
-const ignoreErrorToPreventNodeFromCrashing = () => {};
-
 const aVNodePath = [];
 
 const bVNodePath = [];
@@ -3005,10 +3039,10 @@ const ssrNodeDocumentPosition = (a, b) => {
     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])) {
@@ -3019,26 +3053,199 @@ const ssrNodeDocumentPosition = (a, b) => {
     return aDepth < bDepth ? -1 : 1;
 };
 
+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 (!isNumber$1(blockedIdx) || blockedIdx <= 0) {
+            return !1;
+        }
+        return findPreviousTaskInComponent(blocked.$host$, blockedIdx, container) === 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 findPreviousTaskInComponent(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;
+}
+
+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;
+}
+
+const createNextTick = 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;
+};
+
 const DEBUG = !1;
 
-const getPromise = chore => chore.$promise$ ||= new Promise(resolve => {
-    chore.$resolve$ = resolve;
-});
+var ChoreState;
 
-const createScheduler = (container, scheduleDrain, journalFlush) => {
-    const choreQueue = [];
-    const qrlRuns = [];
-    let currentChore = null;
+!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 = createNextTick(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,
@@ -3046,184 +3253,218 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
             $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;
-            }
-            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);
+        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 blockingChore = findBlockingChore(chore, choreQueue, blockedChores, runningChores, container);
+        if (blockingChore) {
+            return addBlockedChore(chore, blockingChore, blockedChores), chore;
+        }
+        chore = sortedInsert(choreQueue, chore, container.rootVNode || null);
+        const runImmediately = isServer && 6 === type || 2 === type;
+        runImmediately && !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, null, "Chore already running."), 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$);
@@ -3241,8 +3482,6 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
             } else {
                 assertFalse(vnode_isVNode(aHost), "expected aHost to be SSRNode but it is a VNode"), 
                 assertFalse(vnode_isVNode(bHost), "expected bHost to be SSRNode but it is a VNode");
-                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 = ssrNodeDocumentPosition(aHost, bHost);
                 if (0 !== hostDiff) {
                     return hostDiff;
@@ -3254,7 +3493,39 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
             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;
     }
 };
 
@@ -3264,6 +3535,26 @@ 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;
+}
+
 function debugChoreTypeToString(type) {
     return {
         1: "QRL_RESOLVE",
@@ -3273,26 +3564,53 @@ function debugChoreTypeToString(type) {
         5: "NODE_PROP",
         6: "COMPONENT",
         7: "RECOMPUTE_SIGNAL",
-        16: "JOURNAL_FLUSH",
-        32: "VISIBLE",
-        48: "CLEANUP_VISIBLE",
-        255: "WAIT_FOR_ALL"
+        16: "VISIBLE",
+        32: "CLEANUP_VISIBLE",
+        255: "WAIT_FOR_QUEUE"
     }[type] || "UNKNOWN: " + type;
 }
 
-function debugChoreToString(chore) {
-    const type = debugChoreTypeToString(chore.$type$);
-    const host = String(chore.$host$).replaceAll(/\n.*/gim, "");
-    const qrlTarget = chore.$target$?.$symbol$;
-    return `Chore(${type} ${1 === chore.$type$ || 2 === chore.$type$ ? qrlTarget : host} ${chore.$idx$})`;
-}
-
-function debugTrace(action, arg, currentChore, queue) {
-    const lines = [ "===========================\nScheduler: " + action ];
-    arg && !("$type$" in arg) && lines.push("      arg: " + String(arg).replaceAll(/\n.*/gim, "")), 
-    queue && queue.forEach(chore => {
-        lines.push(`     ${chore === arg ? ">>>" : "   "} > ` + (chore === currentChore ? "[running] " : "") + debugChoreToString(chore));
-    }), console.log(lines.join("\n") + "\n");
+function debugTrace(action, arg, queue, blockedChores) {
+    const lines = [];
+    if (lines.push(`Scheduler: ${action}`), arg) {
+        if (lines.push(""), arg && "$type$" in arg) {
+            const chore = arg;
+            const type = debugChoreTypeToString(chore.$type$);
+            const host = String(chore.$host$).replaceAll(/\n.*/gim, "");
+            const qrlTarget = chore.$target$?.$symbol$;
+            const targetOrHost = 1 === chore.$type$ || 2 === chore.$type$ ? qrlTarget : host;
+            if (lines.push("🎯 Current Chore:"), lines.push(`  Type: ${type}`), lines.push(`  Host: ${targetOrHost}`), 
+            chore.$startTime$ && chore.$endTime$) {
+                lines.push(`  Time: ${(chore.$endTime$ - chore.$startTime$).toFixed(2)}ms`);
+            } else if (chore.$startTime$) {
+                const elapsedTime = performance.now() - chore.$startTime$;
+                lines.push(`  Time: ${elapsedTime.toFixed(2)}ms (running)`);
+            }
+            chore.$blockedChores$ && chore.$blockedChores$.length > 0 && (lines.push("  ⛔ Blocked Chores:"), 
+            chore.$blockedChores$.forEach((blockedChore, index) => {
+                const blockedType = debugChoreTypeToString(blockedChore.$type$);
+                const blockedTarget = String(blockedChore.$host$).replaceAll(/\n.*/gim, "");
+                lines.push(`    ${index + 1}. ${blockedType} ${blockedTarget} ${blockedChore.$idx$}`);
+            }));
+        } else {
+            lines.push(`📝 Argument: ${String(arg).replaceAll(/\n.*/gim, "")}`);
+        }
+    }
+    queue && queue.length > 0 && (lines.push(""), lines.push(`📋 Queue (${queue.length} items):`), 
+    queue.forEach(chore => {
+        const activeMarker = chore === arg ? "▶ " : "  ";
+        const type = debugChoreTypeToString(chore.$type$);
+        const state = chore.$state$ ? `[${ChoreState[chore.$state$]}]` : "";
+        const host = String(chore.$host$).replaceAll(/\n.*/gim, "");
+        const qrlTarget = chore.$target$?.$symbol$;
+        lines.push(`${activeMarker}${state} ${type} ${1 === chore.$type$ || 2 === chore.$type$ ? qrlTarget : host} ${chore.$idx$}`);
+    })), blockedChores && blockedChores.size > 0 && (lines.push(""), lines.push(`🚫 Blocked Chores (${blockedChores.size} items):`), 
+    Array.from(blockedChores).forEach((chore, index) => {
+        const type = debugChoreTypeToString(chore.$type$);
+        const host = String(chore.$host$).replaceAll(/\n.*/gim, "");
+        const qrlTarget = chore.$target$?.$symbol$;
+        lines.push(`  ${index + 1}. ${type} ${1 === chore.$type$ || 2 === chore.$type$ ? qrlTarget : host} ${chore.$idx$}`);
+    })), lines.push(""), lines.push("─".repeat(60)), console.log(lines.join("\n") + "\n");
 }
 
 class _SharedContainer {
@@ -3305,11 +3623,12 @@ class _SharedContainer {
     $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);
@@ -3477,7 +3796,10 @@ function processVNodeData$1(document) {
                 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) {
@@ -3518,7 +3840,7 @@ function getDomContainerFromQContainerElement(qContainerElement) {
 }
 
 function _getQContainerElement(element) {
-    return (Array.isArray(element) ? vnode_getDomParent(element) : element).closest(QContainerSelector);
+    return (Array.isArray(element) ? vnode_getDomParent(element, !0) : element).closest(QContainerSelector);
 }
 
 const isDomContainer = container => container instanceof DomContainer;
@@ -3530,7 +3852,6 @@ class DomContainer extends _SharedContainer {
     rootVNode;
     document;
     $journal$;
-    renderDone=null;
     $rawStateData$;
     $storeProxyMap$=new WeakMap;
     $qFuncs$;
@@ -3540,10 +3861,11 @@ class DomContainer extends _SharedContainer {
     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, 
@@ -3621,26 +3943,6 @@ class DomContainer extends _SharedContainer {
         }
         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;
@@ -3648,7 +3950,10 @@ class DomContainer extends _SharedContainer {
             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));
+                    }
                 }
             }
         }
@@ -3723,7 +4028,7 @@ const addQrlToSerializationCtx = (effectSubscriber, container) => {
 };
 
 const triggerEffects = (container, signal, effects) => {
-    const isBrowser = isDomContainer(container);
+    const isBrowser = !isServerPlatform();
     if (effects) {
         const scheduleEffect = effectSubscription => {
             const consumer = effectSubscription[0];
@@ -3731,7 +4036,7 @@ const triggerEffects = (container, signal, effects) => {
             if (assertDefined(container, "Container must be defined."), 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();
@@ -3741,18 +4046,18 @@ const triggerEffects = (container, signal, effects) => {
                 assertDefined(qrl, "Component must have QRL");
                 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);
                 }
             }
         };
@@ -3768,11 +4073,11 @@ const getComputedSignalFlags = serializationStrategy => {
     let flags = 1;
     switch (serializationStrategy) {
       case "never":
-        flags |= 8;
+        flags |= 16;
         break;
 
       case "always":
-        flags |= 16;
+        flags |= 32;
     }
     return flags;
 };
@@ -3966,13 +4271,16 @@ const vnode_ensureElementInflated = vnode => {
     }
 };
 
-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;
@@ -4071,6 +4379,7 @@ const vnode_ensureTextInflated = (journal, vnode) => {
     const textVNode = ensureTextVNode(vnode);
     if (!(8 & textVNode[0])) {
         const parentNode = vnode_getDomParent(vnode);
+        assertDefined(parentNode, "Missing parent node.");
         const sharedTextNode = textVNode[4];
         const doc = parentNode.ownerDocument;
         let cursor = vnode_getDomSibling(vnode, !1, !0);
@@ -4187,6 +4496,17 @@ const indexOfAlphanumeric = (id, length) => {
     return length;
 };
 
+const vnode_createErrorDiv = (document, host, err, journal) => {
+    const errorDiv = document.createElement("errored-host");
+    err && err instanceof Error && (errorDiv.props = {
+        error: err
+    }), errorDiv.setAttribute("q:key", "_error_");
+    const vErrorDiv = vnode_newElement(errorDiv, "errored-host");
+    return vnode_getDOMChildNodes(journal, host, !0).forEach(child => {
+        vnode_insertBefore(journal, vErrorDiv, child, null);
+    }), vErrorDiv;
+};
+
 const parseBoolean = value => "false" !== value && Boolean(value);
 
 const isBooleanAttr = (element, key) => ("allowfullscreen" == key || "async" == key || "autofocus" == key || "autoplay" == key || "checked" == key || "controls" == key || "default" == key || "defer" == key || "disabled" == key || "formnovalidate" == key || "inert" == key || "ismap" == key || "itemscope" == key || "loop" == key || "multiple" == key || "muted" == key || "nomodule" == key || "novalidate" == key || "open" == key || "playsinline" == key || "readonly" == key || "required" == key || "reversed" == key || "selected" == key) && key in element;
@@ -4247,26 +4567,29 @@ const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
         }
         insertBefore = null;
     }
-    const domParentVNode = vnode_getDomParentVNode(parent);
+    const domParentVNode = vnode_getDomParentVNode(parent, !1);
     const parentNode = domParentVNode && domParentVNode[6];
     let domChildren = null;
     domParentVNode && (domChildren = vnode_getDomChildrenWithCorrectNamespacesToInsert(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 && vnode_ensureInflatedIfText(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 && vnode_ensureInflatedIfText(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_getDomParent = (vnode, includeProjection = !0) => (vnode = vnode_getDomParentVNode(vnode, includeProjection)) && vnode[6];
 
-const vnode_getDomParentVNode = vnode => {
+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;
 };
@@ -4274,7 +4597,7 @@ const vnode_getDomParentVNode = vnode => {
 const vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
     if (assertEqual(vParent, vnode_getParent(vToRemove), "Parent mismatch."), 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;
         }
@@ -4598,6 +4921,27 @@ 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), "Expecting Text Node."), 
 vnode[4]);
 
@@ -4832,9 +5176,9 @@ class DeserializationHandler {
         }
         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);
@@ -4962,7 +5306,7 @@ const inflate = (container, target, typeId, data) => {
             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;
         }
 
@@ -5529,8 +5873,8 @@ async function serialize(serializationContext) {
                     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), 
@@ -6190,7 +6534,7 @@ const render = async (parent, jsxNode, opts = {}) => {
     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);
@@ -6544,7 +6888,7 @@ const useVisibleTaskQrl = (qrl, opts) => {
     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) => {
@@ -6604,4 +6948,7 @@ const PREFETCH_CODE = /*#__PURE__*/ (c => {
 
 const PrefetchGraph = () => null;
 
-export { $, Fragment, NoSerializeSymbol, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SerializerSymbol, SkipRender, Slot, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, EMPTY_ARRAY as _EMPTY_ARRAY, _IMMUTABLE, _SharedContainer, SubscriptionData as _SubscriptionData, _UNINITIALIZED, _VAR_PROPS, _deserialize, dumpState as _dumpState, _fnSignal, _getConstProps, _getContextContainer, _getContextElement, _getContextEvent, getDomContainer as _getDomContainer, _getQContainerElement, _getVarProps, isJSXNode as _isJSXNode, isStore as _isStore, isStringifiable as _isStringifiable, isTask as _isTask, _jsxBranch, _jsxC, _jsxQ, _jsxS, _jsxSorted, _jsxSplit, mapApp_findIndx as _mapApp_findIndx, mapArray_get as _mapArray_get, mapArray_set as _mapArray_set, _noopQrl, _noopQrlDEV, preprocessState as _preprocessState, _qrlSync, _regSymbol, _resolveContextWithoutSequentialScope, _restProps, queueQRL as _run, _serializationWeakRef, _serialize, scheduleTask as _task, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttr as _vnode_getAttr, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getFirstChild as _vnode_getFirstChild, vnode_getNextSibling as _vnode_getNextSibling, vnode_getPropStartIndex as _vnode_getPropStartIndex, vnode_getProps as _vnode_getProps, vnode_isMaterialized as _vnode_isMaterialized, vnode_isTextVNode as _vnode_isTextVNode, vnode_isVirtualVNode as _vnode_isVirtualVNode, vnode_toString as _vnode_toString, _waitUntilRendered, _walkJSX, _wrapProp, _wrapSignal, component$, componentQrl, createAsyncComputed$, createAsyncComputedSignal as createAsyncComputedQrl, createComputed$, createComputedSignal as createComputedQrl, createContextId, h as createElement, createSerializer$, createSerializerSignal as createSerializerQrl, createSignal, event$, eventQrl, getDomContainer, getLocale, getPlatform, h, implicit$FirstArg, inlinedQrl, inlinedQrlDEV, isSignal, jsx, jsxDEV, jsx as jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useAsyncComputed$, useAsyncComputedQrl, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, useErrorBoundary, useId, useLexicalScope, useOn, useOnDocument, useOnWindow, useResource$, useResourceQrl, useSerializer$, useSerializerQrl, useServerData, useSignal, useStore, useStyles$, useStylesQrl, useStylesScoped$, useStylesScopedQrl, useTask$, useTaskQrl, useVisibleTask$, useVisibleTaskQrl, version, withLocale };
+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;
+
+export { $, Fragment, NoSerializeSymbol, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SerializerSymbol, SkipRender, Slot, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, EMPTY_ARRAY as _EMPTY_ARRAY, _IMMUTABLE, _SharedContainer, SubscriptionData as _SubscriptionData, _UNINITIALIZED, _VAR_PROPS, _deserialize, dumpState as _dumpState, _fnSignal, _getConstProps, _getContextContainer, _getContextElement, _getContextEvent, getDomContainer as _getDomContainer, _getQContainerElement, _getVarProps, _hasStoreEffects, isJSXNode as _isJSXNode, isStore as _isStore, isStringifiable as _isStringifiable, isTask as _isTask, _jsxBranch, _jsxC, _jsxQ, _jsxS, _jsxSorted, _jsxSplit, mapApp_findIndx as _mapApp_findIndx, mapArray_get as _mapArray_get, mapArray_set as _mapArray_set, _noopQrl, _noopQrlDEV, preprocessState as _preprocessState, _qrlSync, _regSymbol, _resolveContextWithoutSequentialScope, _restProps, _run, _serializationWeakRef, _serialize, scheduleTask as _task, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttr as _vnode_getAttr, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getFirstChild as _vnode_getFirstChild, vnode_getNextSibling as _vnode_getNextSibling, vnode_getPropStartIndex as _vnode_getPropStartIndex, vnode_getProps as _vnode_getProps, vnode_isMaterialized as _vnode_isMaterialized, vnode_isTextVNode as _vnode_isTextVNode, vnode_isVirtualVNode as _vnode_isVirtualVNode, vnode_toString as _vnode_toString, _waitUntilRendered, _walkJSX, _wrapProp, _wrapSignal, component$, componentQrl, createAsyncComputed$, createAsyncComputedSignal as createAsyncComputedQrl, createComputed$, createComputedSignal as createComputedQrl, createContextId, h as createElement, createSerializer$, createSerializerSignal as createSerializerQrl, createSignal, event$, eventQrl, forceStoreEffects, getDomContainer, getLocale, getPlatform, h, implicit$FirstArg, inlinedQrl, inlinedQrlDEV, isSignal, jsx, jsxDEV, jsx as jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useAsyncComputed$, useAsyncComputedQrl, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, useErrorBoundary, useId, useLexicalScope, useOn, useOnDocument, useOnWindow, useResource$, useResourceQrl, useSerializer$, useSerializerQrl, useServerData, useSignal, useStore, useStyles$, useStylesQrl, useStylesScoped$, useStylesScopedQrl, useTask$, useTaskQrl, useVisibleTask$, useVisibleTaskQrl, version, withLocale };