@qwik.dev/core 2.0.0-alpha.6 → 2.0.0-alpha.8

package/dist/core.prod.cjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-alpha.6-dev+d848ba5
+ * @qwik.dev/core 2.0.0-alpha.8-dev+66037b5
  * 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
@@ -40,8 +40,8 @@
     }
     var QError;
     !function(QError) {
-        QError[QError.stringifyClassOrStyle = 0] = "stringifyClassOrStyle", QError[QError.UNUSED_1 = 1] = "UNUSED_1", 
-        QError[QError.UNUSED_2 = 2] = "UNUSED_2", QError[QError.verifySerializable = 3] = "verifySerializable", 
+        QError[QError.stringifyClassOrStyle = 0] = "stringifyClassOrStyle", QError[QError.schedulerNotFound = 1] = "schedulerNotFound", 
+        QError[QError.trackObjectWithoutProp = 2] = "trackObjectWithoutProp", QError[QError.verifySerializable = 3] = "verifySerializable", 
         QError[QError.UNUSED_4 = 4] = "UNUSED_4", QError[QError.cannotRenderOverExistingContainer = 5] = "cannotRenderOverExistingContainer", 
         QError[QError.UNUSED_6 = 6] = "UNUSED_6", QError[QError.UNUSED_7 = 7] = "UNUSED_7", 
         QError[QError.UNUSED_8 = 8] = "UNUSED_8", QError[QError.UNUSED_9 = 9] = "UNUSED_9", 
@@ -66,12 +66,22 @@
         QError[QError.invalidVNodeType = 43] = "invalidVNodeType", QError[QError.materializeVNodeDataError = 44] = "materializeVNodeDataError", 
         QError[QError.cannotCoerceSignal = 45] = "cannotCoerceSignal", QError[QError.computedNotSync = 46] = "computedNotSync", 
         QError[QError.computedReadOnly = 47] = "computedReadOnly", QError[QError.wrappedReadOnly = 48] = "wrappedReadOnly", 
-        QError[QError.promisesNotExpected = 49] = "promisesNotExpected", QError[QError.unsafeAttr = 50] = "unsafeAttr";
+        QError[QError.unsafeAttr = 49] = "unsafeAttr";
     }(QError || (QError = {}));
     const qError = (code, errorMessageArgs = []) => {
         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(!0, message, ...optionalParams))(text, ...errorMessageArgs);
     };
+    const isQrl$1 = value => "function" == typeof value && "function" == typeof value.getSymbol;
+    function assertQrl(qrl) {
+        if (build.isDev && !isQrl$1(qrl)) {
+            throw new Error("Not a QRL");
+        }
+    }
+    const getSymbolHash = symbolName => {
+        const index = symbolName.lastIndexOf("_");
+        return index > -1 ? symbolName.slice(index + 1) : symbolName;
+    };
     var VirtualType;
     !function(VirtualType) {
         VirtualType.Virtual = "V", VirtualType.Fragment = "F", VirtualType.WrappedSignal = "S", 
@@ -223,12 +233,45 @@
             chunk = chunkOrFn;
         }
         return announcedQRL.has(symbol) || (announcedQRL.add(symbol), emitEvent("qprefetch", {
-            symbols: [ getSymbolHash(symbol) ],
+            symbols: [ symbol ],
             bundles: chunk && [ chunk ]
-        })), createQRL(chunk, symbol, null, symbolFn, null, lexicalScopeCapture, null);
+        })), createQRL(chunk, symbol, null, symbolFn, null, lexicalScopeCapture);
+    };
+    const inlinedQrl = (symbol, symbolName, lexicalScopeCapture = EMPTY_ARRAY) => createQRL(null, symbolName, symbol, null, null, lexicalScopeCapture);
+    const _noopQrl = (symbolName, lexicalScopeCapture = EMPTY_ARRAY) => createQRL(null, symbolName, null, null, null, lexicalScopeCapture);
+    var ChoreType;
+    !function(ChoreType) {
+        ChoreType[ChoreType.MACRO = 240] = "MACRO", ChoreType[ChoreType.MICRO = 15] = "MICRO", 
+        ChoreType[ChoreType.QRL_RESOLVE = 1] = "QRL_RESOLVE", ChoreType[ChoreType.RUN_QRL = 2] = "RUN_QRL", 
+        ChoreType[ChoreType.TASK = 3] = "TASK", ChoreType[ChoreType.NODE_DIFF = 4] = "NODE_DIFF", 
+        ChoreType[ChoreType.NODE_PROP = 5] = "NODE_PROP", ChoreType[ChoreType.COMPONENT = 6] = "COMPONENT", 
+        ChoreType[ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS = 7] = "RECOMPUTE_AND_SCHEDULE_EFFECTS", 
+        ChoreType[ChoreType.JOURNAL_FLUSH = 16] = "JOURNAL_FLUSH", ChoreType[ChoreType.VISIBLE = 32] = "VISIBLE", 
+        ChoreType[ChoreType.CLEANUP_VISIBLE = 48] = "CLEANUP_VISIBLE", ChoreType[ChoreType.WAIT_FOR_ALL = 255] = "WAIT_FOR_ALL";
+    }(ChoreType || (ChoreType = {}));
+    const useLexicalScope = () => {
+        const context = getInvokeContext();
+        let qrl = context.$qrl$;
+        if (qrl) {
+            assertQrl(qrl), assertDefined();
+        } else {
+            const el = context.$element$;
+            assertDefined();
+            const containerElement = _getQContainerElement(el);
+            assertDefined();
+            qrl = getDomContainer(containerElement).parseQRL(decodeURIComponent(String(context.$url$)));
+        }
+        return qrl.$captureRef$;
+    };
+    const queueQRL = (...args) => {
+        const [runQrl] = useLexicalScope();
+        const hostElement = getInvokeContext().$hostElement$;
+        const scheduler = getDomContainer(hostElement).$scheduler$;
+        if (!scheduler) {
+            throw qError(QError.schedulerNotFound);
+        }
+        return scheduler(ChoreType.RUN_QRL, hostElement, runQrl, args);
     };
-    const inlinedQrl = (symbol, symbolName, lexicalScopeCapture = EMPTY_ARRAY) => createQRL(null, symbolName, symbol, null, null, lexicalScopeCapture, null);
-    const _noopQrl = (symbolName, lexicalScopeCapture = EMPTY_ARRAY) => createQRL(null, symbolName, null, null, null, lexicalScopeCapture, null);
     const Slot = props => _jsxSorted(Virtual, null, {
         [QSlotS]: ""
     }, props.children, 0, props.name ?? "");
@@ -283,6 +326,34 @@
     function isPreventDefault(key) {
         return key.startsWith("preventdefault:");
     }
+    function getFileLocationFromJsx(jsxDev) {
+        if (!jsxDev) {
+            return null;
+        }
+        const sanitizedFileName = jsxDev.fileName?.replace(/\\/g, "/");
+        return sanitizedFileName ? `${sanitizedFileName}:${jsxDev.lineNumber}:${jsxDev.columnNumber}` : null;
+    }
+    const styleContent = styleId => "⚡️" + styleId;
+    function hasClassAttr(props) {
+        for (const key in props) {
+            if (Object.prototype.hasOwnProperty.call(props, key) && isClassAttr(key)) {
+                return !0;
+            }
+        }
+        return !1;
+    }
+    function isClassAttr(key) {
+        return "class" === key || "className" === key;
+    }
+    const addComponentStylePrefix = styleId => {
+        if (styleId) {
+            let idx = 0;
+            do {
+                styleId = styleId.substring(0, idx) + styleContent(styleId.substring(idx));
+            } while (0 !== (idx = styleId.indexOf(" ", idx) + 1));
+        }
+        return styleId || null;
+    };
     const unitlessNumbers = new Set([ "animationIterationCount", "aspectRatio", "borderImageOutset", "borderImageSlice", "borderImageWidth", "boxFlex", "boxFlexGroup", "boxOrdinalGroup", "columnCount", "columns", "flex", "flexGrow", "flexShrink", "gridArea", "gridRow", "gridRowEnd", "gridRowStart", "gridColumn", "gridColumnEnd", "gridColumnStart", "fontWeight", "lineClamp", "lineHeight", "opacity", "order", "orphans", "scale", "tabSize", "widows", "zIndex", "zoom", "MozAnimationIterationCount", "MozBoxFlex", "msFlex", "msFlexPositive", "WebkitAnimationIterationCount", "WebkitBoxFlex", "WebkitBoxOrdinalGroup", "WebkitColumnCount", "WebkitColumns", "WebkitFlex", "WebkitFlexGrow", "WebkitFlexShrink", "WebkitLineClamp" ]);
     const hashCode = (text, hash = 0) => {
         for (let i = 0; i < text.length; i++) {
@@ -343,30 +414,9 @@
         return value;
     }
     const setValueForStyle = (styleName, value) => "number" != typeof value || 0 === value || unitlessNumbers.has(styleName) ? value : value + "px";
-    const styleContent = styleId => "⭐️" + styleId;
-    function hasClassAttr(props) {
-        for (const key in props) {
-            if (Object.prototype.hasOwnProperty.call(props, key) && isClassAttr(key)) {
-                return !0;
-            }
-        }
-        return !1;
-    }
-    function isClassAttr(key) {
-        return "class" === key || "className" === key;
-    }
-    const addComponentStylePrefix = styleId => {
-        if (styleId) {
-            let idx = 0;
-            do {
-                styleId = styleId.substring(0, idx) + styleContent(styleId.substring(idx));
-            } while (0 !== (idx = styleId.indexOf(" ", idx) + 1));
-        }
-        return styleId || null;
-    };
     const STORE_TARGET = Symbol("store.target");
     const STORE_HANDLER = Symbol("store.handler");
-    const STORE_ARRAY_PROP = Symbol("store.array");
+    const STORE_ALL_PROPS = Symbol("store.all");
     var StoreFlags;
     !function(StoreFlags) {
         StoreFlags[StoreFlags.NONE = 0] = "NONE", StoreFlags[StoreFlags.RECURSIVE = 1] = "RECURSIVE", 
@@ -413,7 +463,7 @@
                     assertTrue();
                 }
                 const effectSubscriber = ctx.$effectSubscriber$;
-                effectSubscriber && addEffect(target, Array.isArray(target) ? STORE_ARRAY_PROP : prop, this, effectSubscriber);
+                effectSubscriber && addStoreEffect(target, Array.isArray(target) ? STORE_ALL_PROPS : prop, this, effectSubscriber);
             }
             if ("toString" === prop && value === Object.prototype.toString) {
                 return this.toString;
@@ -444,7 +494,7 @@
                 const ctx = tryGetInvokeContext();
                 if (ctx) {
                     const effectSubscriber = ctx.$effectSubscriber$;
-                    effectSubscriber && addEffect(target, Array.isArray(target) ? STORE_ARRAY_PROP : prop, this, effectSubscriber);
+                    effectSubscriber && addStoreEffect(target, Array.isArray(target) ? STORE_ALL_PROPS : prop, this, effectSubscriber);
                 }
             }
             return Object.prototype.hasOwnProperty.call(target, prop);
@@ -452,31 +502,93 @@
         ownKeys(target) {
             const ctx = tryGetInvokeContext();
             const effectSubscriber = ctx?.$effectSubscriber$;
-            return effectSubscriber && addEffect(target, STORE_ARRAY_PROP, this, effectSubscriber), 
+            return effectSubscriber && addStoreEffect(target, STORE_ALL_PROPS, this, effectSubscriber), 
             Reflect.ownKeys(target);
         }
         getOwnPropertyDescriptor(target, prop) {
-            return Array.isArray(target) || "symbol" == typeof prop ? Object.getOwnPropertyDescriptor(target, prop) : {
+            const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+            return Array.isArray(target) || "symbol" == typeof prop || descriptor && !descriptor.configurable ? descriptor : {
                 enumerable: !0,
                 configurable: !0
             };
         }
     }
-    function addEffect(target, prop, store, effectSubscriber) {
-        const effectsMap = store.$effects$ ||= {};
-        const effects = Object.prototype.hasOwnProperty.call(effectsMap, prop) && effectsMap[prop] || (effectsMap[prop] = []);
-        ensureContainsEffect(effects, effectSubscriber), ensureContains(effectSubscriber, target), 
-        ensureEffectContainsSubscriber(effectSubscriber[EffectSubscriptionsProp.EFFECT], target, store.$container$);
+    function addStoreEffect(target, prop, store, effectSubscription) {
+        const effectsMap = store.$effects$ ||= new Map;
+        let effects = effectsMap.get(prop);
+        effects || (effects = new Set, effectsMap.set(prop, effects)), ensureContainsSubscription(effects, effectSubscription), 
+        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$));
     }
     function getEffects(target, prop, storeEffects) {
-        let effectsToTrigger = storeEffects ? Array.isArray(target) ? Object.values(storeEffects).flatMap((effects => effects)) : storeEffects[prop] : null;
-        const storeArrayValue = storeEffects?.[STORE_ARRAY_PROP];
-        return storeArrayValue && (effectsToTrigger ||= [], effectsToTrigger.push(...storeArrayValue)), 
-        effectsToTrigger;
+        let effectsToTrigger;
+        if (storeEffects) {
+            if (Array.isArray(target)) {
+                for (const effects of storeEffects.values()) {
+                    effectsToTrigger ||= new Set;
+                    for (const effect of effects) {
+                        effectsToTrigger.add(effect);
+                    }
+                }
+            } else {
+                effectsToTrigger = storeEffects.get(prop);
+            }
+        }
+        const storeArrayValue = storeEffects?.get(STORE_ALL_PROPS);
+        if (storeArrayValue) {
+            effectsToTrigger ||= new Set;
+            for (const effect of storeArrayValue) {
+                effectsToTrigger.add(effect);
+            }
+        }
+        return effectsToTrigger || null;
+    }
+    const NEEDS_COMPUTATION = Symbol("invalid");
+    const _EFFECT_BACK_REF = Symbol("backRef");
+    class BackRef {
+        [_EFFECT_BACK_REF]=null;
     }
+    function clearAllEffects(container, consumer) {
+        vnode_isVNode(consumer) && vnode_isElementVNode(consumer) && ensureMaterialized(consumer);
+        const effects = consumer[_EFFECT_BACK_REF];
+        if (effects) {
+            for (const [, effect] of effects) {
+                const backRefs = effect[EffectSubscriptionProp.BACK_REF];
+                if (!backRefs) {
+                    return;
+                }
+                for (const producer of backRefs) {
+                    if (producer instanceof Signal) {
+                        clearSignal(container, producer, effect);
+                    } else if (container.$storeProxyMap$.has(producer)) {
+                        const target = container.$storeProxyMap$.get(producer);
+                        clearStore(getStoreHandler(target), effect);
+                    }
+                }
+            }
+        }
+    }
+    function clearSignal(container, producer, effect) {
+        const effects = producer.$effects$;
+        effects && effects.delete(effect), producer instanceof WrappedSignal && (producer.$hostElement$ = null, 
+        clearAllEffects(container, producer));
+    }
+    function clearStore(producer, effect) {
+        const effects = producer?.$effects$;
+        if (effects) {
+            for (const propEffects of effects.values()) {
+                propEffects.delete(effect);
+            }
+        }
+    }
+    const implicit$FirstArg = fn => function(first, ...rest) {
+        return fn.call(null, dollar(first), ...rest);
+    };
+    const createSignal = value => new Signal(null, value);
+    const createComputedQrl = qrl => (throwIfQRLNotResolved(qrl), new ComputedSignal(null, qrl));
+    const createComputed$ = /*#__PURE__*/ implicit$FirstArg(createComputedQrl);
     const useSequentialScope = () => {
         const iCtx = useInvokeContext();
         const host = iCtx.$hostElement$;
@@ -493,196 +605,108 @@
             iCtx
         };
     };
-    class Subscriber {
-        $effectDependencies$=null;
-    }
-    function isSubscriber(value) {
-        return value instanceof Subscriber || value instanceof WrappedSignal;
-    }
-    function clearVNodeEffectDependencies(container, value) {
-        vnode_isElementVNode(value) && ensureMaterialized(value);
-        const effects = vnode_getProp(value, "q:subs", container.$getObjectById$);
-        if (effects) {
-            for (let i = effects.length - 1; i >= 0; i--) {
-                clearEffects(effects[i], value, effects, i, container);
-            }
-            0 === effects.length && vnode_setProp(value, "q:subs", null);
-        }
-    }
-    function clearSubscriberEffectDependencies(container, value) {
-        if (value.$effectDependencies$) {
-            for (let i = value.$effectDependencies$.length - 1; i >= 0; i--) {
-                clearEffects(value.$effectDependencies$[i], value, value.$effectDependencies$, i, container);
-            }
-            0 === value.$effectDependencies$.length && (value.$effectDependencies$ = null);
-        }
-    }
-    function clearEffects(subscriber, value, effectArray, indexToRemove, container) {
-        let subscriptionRemoved = !1;
-        const seenSet = new Set;
-        if (subscriber instanceof WrappedSignal) {
-            subscriptionRemoved = clearSignalEffects(subscriber, value, seenSet);
-        } else if (container.$storeProxyMap$.has(subscriber)) {
-            const store = container.$storeProxyMap$.get(subscriber);
-            subscriptionRemoved = clearStoreEffects(getStoreHandler(store), value);
-        }
-        subscriptionRemoved && effectArray.splice(indexToRemove, 1);
-    }
-    function clearSignalEffects(subscriber, value, seenSet) {
-        const effectSubscriptions = subscriber.$effects$;
-        let subscriptionRemoved = !1;
-        if (effectSubscriptions) {
-            for (let i = effectSubscriptions.length - 1; i >= 0; i--) {
-                effectSubscriptions[i][EffectSubscriptionsProp.EFFECT] === value && (effectSubscriptions.splice(i, 1), 
-                subscriptionRemoved = !0);
-            }
-        }
-        if (subscriber instanceof WrappedSignal) {
-            const hostElement = subscriber.$hostElement$;
-            hostElement && hostElement === value && (subscriber.$hostElement$ = null);
-            const args = subscriber.$args$;
-            args && clearArgsEffects(args, subscriber, seenSet);
-        }
-        return subscriptionRemoved;
-    }
-    function clearStoreEffects(storeHandler, value) {
-        const effectSubscriptions = storeHandler.$effects$;
-        if (!effectSubscriptions) {
-            return !1;
-        }
-        let subscriptionRemoved = !1;
-        for (const key in effectSubscriptions) {
-            const effects = effectSubscriptions[key];
-            for (let i = effects.length - 1; i >= 0; i--) {
-                effects[i][EffectSubscriptionsProp.EFFECT] === value && (effects.splice(i, 1), subscriptionRemoved = !0);
-            }
-            0 === effects.length && delete effectSubscriptions[key];
-        }
-        return subscriptionRemoved;
-    }
-    function clearArgsEffects(args, subscriber, seenSet) {
-        for (let i = args.length - 1; i >= 0; i--) {
-            clearArgEffect(args[i], subscriber, seenSet);
-        }
-    }
-    function clearArgEffect(arg, subscriber, seenSet) {
-        if (!seenSet.has(arg)) {
-            if (seenSet.add(arg), isSignal(arg)) {
-                clearSignalEffects(arg, subscriber, seenSet);
-            } else if ("object" == typeof arg && null !== arg) {
-                if (isStore(arg)) {
-                    clearStoreEffects(getStoreHandler(arg), subscriber);
-                } else if (isPropsProxy(arg)) {
-                    const constProps = arg[_CONST_PROPS];
-                    const varProps = arg[_VAR_PROPS];
-                    if (constProps) {
-                        for (const key in constProps) {
-                            clearArgEffect(constProps[key], subscriber, seenSet);
-                        }
-                    }
-                    for (const key in varProps) {
-                        clearArgEffect(varProps[key], subscriber, seenSet);
-                    }
-                } else {
-                    for (const key in arg) {
-                        clearArgEffect(arg[key], subscriber, seenSet);
-                    }
-                }
-            } else {
-                Array.isArray(arg) && clearArgsEffects(arg, subscriber, seenSet);
-            }
-        }
+    function getSubscriber(effect, prop, data) {
+        var value;
+        effect[_EFFECT_BACK_REF] || (build.isServer && ("__brand__" in (value = effect) && "currentComponentNode" in value) ? 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[EffectSubscriptionProp.DATA] = data), 
+        sub;
     }
-    const useResourceQrl = (qrl, opts) => {
-        const {val, set, i, iCtx} = useSequentialScope();
-        if (null != val) {
-            return val;
+    var TaskFlags;
+    !function(TaskFlags) {
+        TaskFlags[TaskFlags.VISIBLE_TASK = 1] = "VISIBLE_TASK", TaskFlags[TaskFlags.TASK = 2] = "TASK", 
+        TaskFlags[TaskFlags.RESOURCE = 4] = "RESOURCE", TaskFlags[TaskFlags.DIRTY = 8] = "DIRTY";
+    }(TaskFlags || (TaskFlags = {}));
+    const useTaskQrl = qrl => {
+        const {val, set, iCtx, i} = useSequentialScope();
+        if (val) {
+            return;
         }
-        assertQrl(qrl);
-        const container = iCtx.$container$;
-        const resource = createResourceReturn(container, opts);
-        const task = new Task(TaskFlags.DIRTY | TaskFlags.RESOURCE, i, iCtx.$hostElement$, qrl, resource, null);
-        return runResource(task, container, iCtx.$hostElement$), set(resource), resource;
-    };
-    const createResourceReturn = (container, opts, initialPromise) => {
-        const result = (opts => ({
-            __brand: "resource",
-            value: void 0,
-            loading: !isServerPlatform(),
-            _resolved: void 0,
-            _error: void 0,
-            _state: "pending",
-            _timeout: opts?.timeout ?? -1,
-            _cache: 0
-        }))(opts);
-        return result.value = initialPromise, createStore(container, result, StoreFlags.RECURSIVE);
+        assertQrl(qrl), set(1);
+        const task = new Task(TaskFlags.DIRTY | TaskFlags.TASK, i, iCtx.$hostElement$, qrl, void 0, null);
+        set(task);
+        const promise = iCtx.$container$.$scheduler$(ChoreType.TASK, task);
+        isPromise(promise) && promise.catch((() => {}));
     };
-    const isResourceReturn = obj => isObject(obj) && "resource" === (getStoreTarget(obj) || obj).__brand;
-    const runResource = (task, container, host) => {
+    const runTask = (task, container, host) => {
         task.$flags$ &= ~TaskFlags.DIRTY, cleanupTask(task);
-        const iCtx = newInvokeContext(container.$locale$, host, void 0, "qResource");
+        const iCtx = newInvokeContext(container.$locale$, host, void 0, "qTask");
         iCtx.$container$ = container;
-        const taskFn = task.$qrl$.getFn(iCtx, (() => clearSubscriberEffectDependencies(container, task)));
-        const resource = task.$state$;
-        assertDefined();
-        const cleanups = [];
-        task.$destroy$ = noSerialize((() => {
-            cleanups.forEach((fn => {
-                try {
-                    fn();
-                } catch (err) {
-                    container.handleError(err, host);
-                }
-            })), done = !0;
-        }));
-        const resourceTarget = unwrapStore(resource);
-        const opts = {
+        const taskFn = task.$qrl$.getFn(iCtx, (() => clearAllEffects(container, task)));
+        let cleanupFns = null;
+        const cleanup = fn => {
+            "function" == typeof fn && (cleanupFns || (cleanupFns = [], task.$destroy$ = noSerialize((() => {
+                task.$destroy$ = null, cleanupFns.forEach((fn => {
+                    try {
+                        fn();
+                    } catch (err) {
+                        container.handleError(err, host);
+                    }
+                }));
+            }))), cleanupFns.push(fn));
+        };
+        const taskApi = {
             track: (obj, prop) => {
                 const ctx = newInvokeContext();
-                return ctx.$effectSubscriber$ = [ task, EffectProperty.COMPONENT ], ctx.$container$ = container, 
-                invoke(ctx, (() => isFunction(obj) ? obj() : prop ? obj[prop] : isSignal(obj) ? obj.value : obj));
-            },
-            cleanup(fn) {
-                "function" == typeof fn && cleanups.push(fn);
-            },
-            cache(policy) {
-                let milliseconds = 0;
-                milliseconds = "immutable" === policy ? 1 / 0 : policy, resource._cache = milliseconds;
+                return ctx.$effectSubscriber$ = getSubscriber(task, EffectProperty.COMPONENT), ctx.$container$ = container, 
+                invoke(ctx, (() => {
+                    if (isFunction(obj)) {
+                        return obj();
+                    }
+                    if (prop) {
+                        return obj[prop];
+                    }
+                    if (isSignal(obj)) {
+                        return obj.value;
+                    }
+                    if (isStore(obj)) {
+                        return addStoreEffect(getStoreTarget(obj), STORE_ALL_PROPS, getStoreHandler(obj), ctx.$effectSubscriber$), 
+                        obj;
+                    }
+                    throw qError(QError.trackObjectWithoutProp);
+                }));
             },
-            previous: resourceTarget._resolved
+            cleanup
         };
-        let resolve;
-        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);
-        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) => {
-                resolve = r, reject = re;
-            }))).catch(ignoreErrorToPreventNodeFromCrashing);
-        }));
-        const promise = safeCall((() => Promise.resolve(taskFn(opts))), (value => {
-            setState(!0, value);
-        }), (err => {
+        return safeCall((() => taskFn(taskApi)), cleanup, (err => {
             if (isPromise(err)) {
-                return err.then((() => runResource(task, container, host)));
+                return err.then((() => runTask(task, container, host)));
             }
-            setState(!1, err);
+            throw err;
         }));
-        const timeout = resourceTarget._timeout;
-        return timeout > 0 ? Promise.race([ promise, delay(timeout).then((() => {
-            setState(!1, new Error("timeout")) && cleanupTask(task);
-        })) ]) : promise;
     };
-    const ignoreErrorToPreventNodeFromCrashing = () => {};
+    const cleanupTask = task => {
+        const destroy = task.$destroy$;
+        if (destroy) {
+            task.$destroy$ = null;
+            try {
+                destroy();
+            } catch (err) {
+                ((message, ...optionalParams) => {
+                    createAndLogError(!1, message, ...optionalParams);
+                })(err);
+            }
+        }
+    };
+    class Task extends BackRef {
+        $flags$;
+        $index$;
+        $el$;
+        $qrl$;
+        $state$;
+        $destroy$;
+        constructor($flags$, $index$, $el$, $qrl$, $state$, $destroy$) {
+            super(), this.$flags$ = $flags$, this.$index$ = $index$, this.$el$ = $el$, this.$qrl$ = $qrl$, 
+            this.$state$ = $state$, this.$destroy$ = $destroy$;
+        }
+    }
+    const isTask = value => value instanceof Task;
+    const scheduleTask = (_event, element) => {
+        const [task] = useLexicalScope();
+        const type = task.$flags$ & TaskFlags.VISIBLE_TASK ? ChoreType.VISIBLE : ChoreType.TASK;
+        getDomContainer(element).$scheduler$(type, task);
+    };
     var VNodeFlags;
     var VNodeFlagsIndex;
     var VNodeProps;
@@ -715,9 +739,29 @@
         VirtualVNodeProps[VirtualVNodeProps.firstChild = 4] = "firstChild", VirtualVNodeProps[VirtualVNodeProps.lastChild = 5] = "lastChild", 
         VirtualVNodeProps[VirtualVNodeProps.PROPS_OFFSET = 6] = "PROPS_OFFSET";
     }(VirtualVNodeProps || (VirtualVNodeProps = {}));
-    const isForeignObjectElement = elementName => "foreignobject" === elementName.toLowerCase();
-    const isSvgElement = elementName => "svg" === elementName || isForeignObjectElement(elementName);
-    const isMathElement = elementName => "math" === elementName;
+    const mapApp_findIndx = (array, key, start) => {
+        assertTrue();
+        let bottom = start >> 1;
+        let top = array.length - 2 >> 1;
+        for (;bottom <= top; ) {
+            const mid = bottom + (top - bottom >> 1);
+            const midKey = array[mid << 1];
+            if (midKey === key) {
+                return mid << 1;
+            }
+            midKey < key ? bottom = mid + 1 : top = mid - 1;
+        }
+        return ~(bottom << 1);
+    };
+    const mapArray_set = (array, key, value, start) => {
+        const indx = mapApp_findIndx(array, key, start);
+        indx >= 0 ? null == value ? array.splice(indx, 2) : array[indx + 1] = value : null != value && array.splice(~indx, 0, key, value);
+    };
+    const mapArray_get = (array, key, start) => {
+        const indx = mapApp_findIndx(array, key, start);
+        return indx >= 0 ? array[indx + 1] : null;
+    };
+    const isForeignObjectElement = elementName => build.isDev ? "foreignobject" === elementName.toLowerCase() : "foreignObject" === elementName;
     function cloneElementWithNamespace(element, elementName, namespace) {
         const newElement = element.ownerDocument.createElementNS(namespace, elementName);
         const attributes = element.attributes;
@@ -788,6 +832,10 @@
         }
         return rootElement;
     }
+    function isSvg(tagOrVNode) {
+        return "string" == typeof tagOrVNode ? "svg" === (elementName = tagOrVNode) || isForeignObjectElement(elementName) : !!(tagOrVNode[VNodeProps.flags] & VNodeFlags.NS_svg);
+        var elementName;
+    }
     function getNewElementNamespaceData(domParentVNode, tagOrVNode) {
         const parentIsDefaultNamespace = !domParentVNode || !(!vnode_getElementName(domParentVNode) || (vnode = domParentVNode, 
         vnode[VNodeProps.flags] & VNodeFlags.NAMESPACE_MASK));
@@ -796,12 +844,10 @@
         let elementNamespace = HTML_NS;
         let elementNamespaceFlag = VNodeFlags.NS_html;
         const isElementVNodeOrString = "string" == typeof tagOrVNode || vnode_isElementVNode(tagOrVNode);
-        if (isElementVNodeOrString && function(tagOrVNode) {
-            return "string" == typeof tagOrVNode ? isSvgElement(tagOrVNode) : !!(tagOrVNode[VNodeProps.flags] & VNodeFlags.NS_svg);
-        }(tagOrVNode)) {
+        if (isElementVNodeOrString && isSvg(tagOrVNode)) {
             elementNamespace = SVG_NS, elementNamespaceFlag = VNodeFlags.NS_svg;
         } else if (isElementVNodeOrString && function(tagOrVNode) {
-            return "string" == typeof tagOrVNode ? isMathElement(tagOrVNode) : !!(tagOrVNode[VNodeProps.flags] & VNodeFlags.NS_math);
+            return "string" == typeof tagOrVNode ? "math" === tagOrVNode : !!(tagOrVNode[VNodeProps.flags] & VNodeFlags.NS_math);
         }(tagOrVNode)) {
             elementNamespace = MATH_NS, elementNamespaceFlag = VNodeFlags.NS_math;
         } else if (domParentVNode && !parentIsForeignObject && !parentIsDefaultNamespace) {
@@ -849,14 +895,14 @@
         };
     };
     const executeComponent = (container, renderHost, subscriptionHost, componentQRL, props) => {
-        const iCtx = newInvokeContext(container.$locale$, subscriptionHost, void 0, "qRender");
+        const iCtx = newInvokeContext(container.$locale$, subscriptionHost || void 0, void 0, "qRender");
         let componentFn;
-        iCtx.$effectSubscriber$ = [ subscriptionHost, EffectProperty.COMPONENT ], iCtx.$container$ = container, 
-        container.ensureProjectionResolved(renderHost);
+        subscriptionHost && (iCtx.$effectSubscriber$ = getSubscriber(subscriptionHost, EffectProperty.COMPONENT), 
+        iCtx.$container$ = container), container.ensureProjectionResolved(renderHost);
         let isInlineComponent = !1;
-        if (null === componentQRL && (componentQRL = componentQRL || container.getHostProp(renderHost, "q:renderFn"), 
-        assertDefined()), isQrl(componentQRL)) {
-            (props = props || container.getHostProp(renderHost, "q:props") || EMPTY_OBJ) && props.children && delete props.children, 
+        if (null === componentQRL && (componentQRL = container.getHostProp(renderHost, "q:renderFn"), 
+        assertDefined()), isQrl$1(componentQRL)) {
+            (props = props || container.getHostProp(renderHost, "q:props") || EMPTY_OBJ).children && delete props.children, 
             componentFn = componentQRL.getFn(iCtx);
         } else if (isQwikComponent(componentQRL)) {
             const qComponentFn = componentQRL;
@@ -867,21 +913,35 @@
             componentFn = () => invokeApply(iCtx, inlineComponent, [ props || EMPTY_OBJ ]);
         }
         const executeComponentWithPromiseExceptionRetry = (retryCount = 0) => safeCall((() => (isInlineComponent || (container.setHostProp(renderHost, "q:seqIdx", null), 
-        container.setHostProp(renderHost, ":onIdx", null), container.getHostProp(renderHost, "q:props") !== props && container.setHostProp(renderHost, "q:props", props)), 
-        vnode_isVNode(renderHost) && clearVNodeEffectDependencies(container, renderHost), 
-        componentFn(props))), (jsx => {
+        container.setHostProp(renderHost, ":onIdx", null), container.setHostProp(renderHost, "q:props", props)), 
+        vnode_isVNode(renderHost) && clearAllEffects(container, renderHost), componentFn(props))), (jsx => {
             const useOnEvents = container.getHostProp(renderHost, ":on");
-            return useOnEvents ? maybeThen(function(jsx, useOnEvents) {
+            return useOnEvents ? function(jsx, useOnEvents) {
                 const jsxElement = findFirstStringJSX(jsx);
+                let jsxResult = jsx;
                 return maybeThen(jsxElement, (jsxElement => {
                     let isInvisibleComponent = !1;
                     jsxElement || (isInvisibleComponent = !0);
                     for (const key in useOnEvents) {
-                        Object.prototype.hasOwnProperty.call(useOnEvents, key) && (isInvisibleComponent ? "onQvisible$" === key ? (jsxElement = addScriptNodeForInvisibleComponents(jsx)) && addUseOnEvent(jsxElement, "document:onQinit$", useOnEvents[key]) : key.startsWith("document:") || key.startsWith("window:") ? (jsxElement = addScriptNodeForInvisibleComponents(jsx)) && addUseOnEvent(jsxElement, key, useOnEvents[key]) : build.isDev && logWarn('You are trying to add an event "' + key + '" using `useOn` hook, but a node to which you can add an event is not found. Please make sure that the component has a valid element node. ') : jsxElement && addUseOnEvent(jsxElement, key, useOnEvents[key]));
+                        if (Object.prototype.hasOwnProperty.call(useOnEvents, key)) {
+                            if (isInvisibleComponent) {
+                                if ("onQvisible$" === key) {
+                                    const [jsxElement, jsx] = addScriptNodeForInvisibleComponents(jsxResult);
+                                    jsxResult = jsx, jsxElement && addUseOnEvent(jsxElement, "document:onQinit$", useOnEvents[key]);
+                                } else if (key.startsWith("document:") || key.startsWith("window:")) {
+                                    const [jsxElement, jsx] = addScriptNodeForInvisibleComponents(jsxResult);
+                                    jsxResult = jsx, jsxElement && addUseOnEvent(jsxElement, key, useOnEvents[key]);
+                                } else {
+                                    build.isDev && logWarn('You are trying to add an event "' + key + '" using `useOn` hook, but a node to which you can add an event is not found. Please make sure that the component has a valid element node. ');
+                                }
+                            } else {
+                                jsxElement && addUseOnEvent(jsxElement, key, useOnEvents[key]);
+                            }
+                        }
                     }
-                    return jsxElement;
+                    return jsxResult;
                 }));
-            }(jsx, useOnEvents), (() => jsx)) : jsx;
+            }(jsx, useOnEvents) : jsx;
         }), (err => {
             if (isPromise(err) && retryCount < 100) {
                 return err.then((() => executeComponentWithPromiseExceptionRetry(retryCount++)));
@@ -925,11 +985,18 @@
                 type: "placeholder",
                 hidden: ""
             }, null, 3);
-            return null == jsx.children ? jsx.children = jsxElement : Array.isArray(jsx.children) ? jsx.children.push(jsxElement) : jsx.children = [ jsx.children, jsxElement ], 
-            jsxElement;
+            return jsx.type === Slot ? [ jsxElement, _jsxSorted(Fragment, null, null, [ jsx, jsxElement ], 0, null) ] : (null == jsx.children ? jsx.children = jsxElement : Array.isArray(jsx.children) ? jsx.children.push(jsxElement) : jsx.children = [ jsx.children, jsxElement ], 
+            [ jsxElement, jsx ]);
         }
-        return Array.isArray(jsx) && jsx.length ? addScriptNodeForInvisibleComponents(jsx[0]) : null;
+        if (Array.isArray(jsx) && jsx.length) {
+            const [jsxElement, _] = addScriptNodeForInvisibleComponents(jsx[0]);
+            return [ jsxElement, jsx ];
+        }
+        return [ null, null ];
     }
+    const _CONST_PROPS = Symbol("CONST");
+    const _VAR_PROPS = Symbol("VAR");
+    const _IMMUTABLE = Symbol("IMMUTABLE");
     function isSlotProp(prop) {
         return !prop.startsWith("q:") && !prop.startsWith(":");
     }
@@ -958,13 +1025,6 @@
         }
         return 0 === lastIdx ? html : escapedHTML + html.substring(lastIdx);
     }
-    function getFileLocationFromJsx(jsxDev) {
-        if (!jsxDev) {
-            return null;
-        }
-        const sanitizedFileName = jsxDev.fileName?.replace(/\\/g, "/");
-        return sanitizedFileName ? `${sanitizedFileName}:${jsxDev.lineNumber}:${jsxDev.columnNumber}` : null;
-    }
     const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
         let journal = container.$journal$;
         const stack = [];
@@ -1002,7 +1062,7 @@
                         if (Array.isArray(jsxValue)) {
                             descend(jsxValue, !1);
                         } else if (isSignal(jsxValue)) {
-                            vCurrent && clearVNodeEffectDependencies(container, vCurrent), expectVirtual(VirtualType.WrappedSignal, null), 
+                            vCurrent && clearAllEffects(container, vCurrent), expectVirtual(VirtualType.WrappedSignal, null), 
                             descend(trackSignalAndAssignHost(jsxValue, vNewNode || vCurrent, EffectProperty.VNODE, container), !0);
                         } else if (isPromise(jsxValue)) {
                             expectVirtual(VirtualType.Awaited, null), asyncQueue.push(jsxValue, vNewNode || vCurrent);
@@ -1084,9 +1144,10 @@
         function expectProjection() {
             const slotName = jsxValue.key;
             vCurrent = vnode_getProp(vParent, slotName, (id => vnode_locate(container.rootVNode, id))), 
+            vCurrent = vCurrent && vCurrent[VNodeProps.flags] & VNodeFlags.Deleted ? null : vCurrent, 
             null == vCurrent && (vNewNode = vnode_newVirtual(), build.isDev && vnode_setProp(vNewNode, "q:type", VirtualType.Projection), 
             build.isDev && vnode_setProp(vNewNode, "q:code", "expectProjection"), vnode_setProp(vNewNode, QSlot, slotName), 
-            vnode_setProp(vNewNode, ":", vParent), vnode_setProp(vParent, slotName, vNewNode));
+            vnode_setProp(vNewNode, "q:sparent", vParent), vnode_setProp(vParent, slotName, vNewNode));
         }
         function expectSlot() {
             const vHost = vnode_getProjectionParentComponent(vParent, container.rootVNode);
@@ -1102,19 +1163,27 @@
                 return directGetPropsProxyProp(jsxNode, "name") || "";
             }(vHost);
             const vProjectedNode = vHost ? vnode_getProp(vHost, slotNameKey, null) : null;
-            return null == vProjectedNode ? (vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore()), 
-            vnode_setProp(vNewNode, QSlot, slotNameKey), vHost && vnode_setProp(vHost, slotNameKey, vNewNode), 
-            build.isDev && vnode_setProp(vNewNode, "q:type", VirtualType.Projection), build.isDev && vnode_setProp(vNewNode, "q:code", "expectSlot" + count++), 
-            !1) : (vProjectedNode === vCurrent || (vnode_insertBefore(journal, vParent, vNewNode = vProjectedNode, vCurrent && getInsertBefore()), 
-            vnode_setProp(vNewNode, QSlot, slotNameKey), vHost && vnode_setProp(vHost, slotNameKey, vNewNode), 
-            build.isDev && vnode_setProp(vNewNode, "q:type", VirtualType.Projection), build.isDev && vnode_setProp(vNewNode, "q:code", "expectSlot" + count++)), 
-            !0);
+            if (null == vProjectedNode) {
+                return vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore()), 
+                vnode_setProp(vNewNode, QSlot, slotNameKey), vHost && vnode_setProp(vHost, slotNameKey, vNewNode), 
+                build.isDev && vnode_setProp(vNewNode, "q:type", VirtualType.Projection), build.isDev && vnode_setProp(vNewNode, "q:code", "expectSlot" + count++), 
+                !1;
+            }
+            if (vProjectedNode === vCurrent) {} else {
+                const parent = vnode_getParent(vProjectedNode);
+                !(!parent || vnode_isElementVNode(parent) && "q:template" === vnode_getElementName(parent)) && vParent !== parent && vnode_remove(journal, parent, vProjectedNode, !1), 
+                vnode_insertBefore(journal, vParent, vNewNode = vProjectedNode, vCurrent && getInsertBefore()), 
+                vnode_setProp(vNewNode, QSlot, slotNameKey), vHost && vnode_setProp(vHost, slotNameKey, vNewNode), 
+                build.isDev && vnode_setProp(vNewNode, "q:type", VirtualType.Projection), build.isDev && vnode_setProp(vNewNode, "q:code", "expectSlot" + count++);
+            }
+            return !0;
         }
         function expectNoMore() {
             if (assertFalse(), null !== vCurrent) {
                 for (;vCurrent; ) {
                     const toRemove = vCurrent;
-                    advanceToNextSibling(), cleanup(container, toRemove), vParent === vnode_getParent(toRemove) && vnode_remove(journal, vParent, toRemove, !0);
+                    advanceToNextSibling(), vParent === vnode_getParent(toRemove) && (cleanup(container, toRemove), 
+                    vnode_remove(journal, vParent, toRemove, !0));
                 }
             }
         }
@@ -1141,8 +1210,12 @@
                     if (isJsxPropertyAnEventName(key)) {
                         const eventName = getEventNameFromJsxProp(key);
                         const scope = getEventNameScopeFromJsxProp(key);
-                        vnode_setProp(vNewNode, HANDLER_PREFIX + ":" + scope + ":" + eventName, value), 
-                        eventName && registerQwikLoaderEvent(eventName), needsQDispatchEventPatch = !0;
+                        if (eventName && (vnode_setProp(vNewNode, HANDLER_PREFIX + ":" + scope + ":" + eventName, value), 
+                        registerQwikLoaderEvent(eventName)), scope) {
+                            const htmlEvent = convertEventNameFromJsxPropToHtmlAttr(key);
+                            htmlEvent && vnode_setAttr(journal, vNewNode, htmlEvent, "");
+                        }
+                        needsQDispatchEventPatch = !0;
                     } else {
                         if ("ref" === key) {
                             if (isSignal(value)) {
@@ -1153,10 +1226,13 @@
                                 value(element);
                                 continue;
                             }
+                            if (null == value) {
+                                continue;
+                            }
                             throw qError(QError.invalidRefValue, [ currentFile ]);
                         }
                         if (isSignal(value)) {
-                            const signalData = new EffectPropData({
+                            const signalData = new SubscriptionData({
                                 $scopedStyleIdPrefix$: scopedStyleIdPrefix,
                                 $isConst$: !0
                             });
@@ -1203,10 +1279,10 @@
             const vNode = vNewNode || vCurrent;
             if (needsQDispatchEventPatch = function(vnode, srcAttrs, currentFile) {
                 vnode_ensureElementInflated(vnode);
-                const dstAttrs = vnode;
+                const dstAttrs = vnode_getProps(vnode);
                 let srcIdx = 0;
                 const srcLength = srcAttrs.length;
-                let dstIdx = ElementVNodeProps.PROPS_OFFSET;
+                let dstIdx = 0;
                 let dstLength = dstAttrs.length;
                 let srcKey = srcIdx < srcLength ? srcAttrs[srcIdx++] : null;
                 let dstKey = dstIdx < dstLength ? dstAttrs[dstIdx++] : null;
@@ -1223,10 +1299,13 @@
                             if ("function" == typeof value) {
                                 return void value(element);
                             }
+                            if (null == value) {
+                                return;
+                            }
                             throw qError(QError.invalidRefValue, [ currentFile ]);
                         }
                         if (isSignal(value)) {
-                            const signalData = new EffectPropData({
+                            const signalData = new SubscriptionData({
                                 $scopedStyleIdPrefix$: scopedStyleIdPrefix,
                                 $isConst$: !1
                             });
@@ -1238,12 +1317,12 @@
                 };
                 const recordJsxEvent = (key, value) => {
                     const eventName = getEventNameFromJsxProp(key);
-                    if (eventName) {
-                        const scope = getEventNameScopeFromJsxProp(key);
-                        record(":" + scope + ":" + eventName, value);
+                    const scope = getEventNameScopeFromJsxProp(key);
+                    if (eventName && (record(":" + scope + ":" + eventName, value), registerQwikLoaderEvent(eventName)), 
+                    scope) {
+                        const htmlEvent = convertEventNameFromJsxPropToHtmlAttr(key);
+                        htmlEvent && record(htmlEvent, "");
                     }
-                    const htmlEvent = convertEventNameFromJsxPropToHtmlAttr(key);
-                    htmlEvent && record(htmlEvent, ""), eventName && registerQwikLoaderEvent(eventName);
                 };
                 for (;null !== srcKey || null !== dstKey; ) {
                     if (dstKey?.startsWith(HANDLER_PREFIX) || dstKey?.startsWith("q:")) {
@@ -1275,7 +1354,7 @@
                     let returnValue = !1;
                     return qrls.flat(2).forEach((qrl => {
                         if (qrl) {
-                            const value = qrl(event, element);
+                            const value = container.$scheduler$(ChoreType.RUN_QRL, vNode, qrl, [ event, element ]);
                             returnValue = returnValue || !0 === value;
                         }
                     })), returnValue;
@@ -1324,16 +1403,16 @@
                 const vNodeComponentHash = getComponentHash(host, container.$getObjectById$);
                 const lookupKey = jsxNode.key || componentHash;
                 if (lookupKey === (getKey(host) || vNodeComponentHash) ? componentHash === vNodeComponentHash || (insertNewComponent(host, componentQRL, jsxProps), 
-                vNewNode && (host && (vNewNode[VNodeProps.flags] = host[VNodeProps.flags]), host = vNewNode, 
-                shouldRender = !0)) : (vNewNode = retrieveChildWithKey(null, lookupKey), vNewNode ? vnode_insertBefore(journal, vParent, vNewNode, vCurrent) : insertNewComponent(host, componentQRL, jsxProps), 
+                host = vNewNode, shouldRender = !0) : (vNewNode = retrieveChildWithKey(null, lookupKey), 
+                vNewNode ? vnode_insertBefore(journal, vParent, vNewNode, vCurrent) : insertNewComponent(host, componentQRL, jsxProps), 
                 host = vNewNode, shouldRender = !0), host) {
                     const vNodeProps = vnode_getProp(host, "q:props", container.$getObjectById$);
                     shouldRender = shouldRender || function(src, dst) {
                         if (!src || !dst) {
                             return !0;
                         }
-                        let srcKeys = removePropsKeys(Object.keys(src), [ "children", "q:subs" ]);
-                        let dstKeys = removePropsKeys(Object.keys(dst), [ "children", "q:subs" ]);
+                        let srcKeys = removePropsKeys(Object.keys(src), [ "children", "q:brefs" ]);
+                        let dstKeys = removePropsKeys(Object.keys(dst), [ "children", "q:brefs" ]);
                         if (srcKeys.length !== dstKeys.length) {
                             return !0;
                         }
@@ -1354,8 +1433,9 @@
                     const createProjectionJSXNode = slotName => new JSXNodeImpl(Projection, EMPTY_OBJ, null, [], 0, slotName);
                     const projections = [];
                     if (host) {
-                        for (let i = vnode_getPropStartIndex(host); i < host.length; i += 2) {
-                            const prop = host[i];
+                        const props = vnode_getProps(host);
+                        for (let i = 0; i < props.length; i += 2) {
+                            const prop = props[i];
                             if (isSlotProp(prop)) {
                                 const slotName = prop;
                                 projections.push(slotName), projections.push(createProjectionJSXNode(slotName));
@@ -1379,13 +1459,11 @@
                 }(jsxNode.children, host);
             } else {
                 const lookupKey = jsxNode.key;
-                if (lookupKey === getKey(host) || (vNewNode = retrieveChildWithKey(null, lookupKey), 
-                vNewNode ? vnode_insertBefore(journal, vParent, vNewNode, vCurrent) : function() {
-                    vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore());
-                    const jsxNode = jsxValue;
-                    build.isDev && vnode_setProp(vNewNode, "q:type", VirtualType.InlineComponent), vnode_setProp(vNewNode, "q:props", jsxNode.props), 
-                    jsxNode.key && vnode_setProp(vNewNode, "q:key", jsxNode.key);
-                }(), host = vNewNode), host) {
+                const lookupKeysAreEqual = lookupKey === getKey(host);
+                const vNodeComponentHash = getComponentHash(host, container.$getObjectById$);
+                if (lookupKeysAreEqual ? null != vNodeComponentHash && (insertNewInlineComponent(), 
+                host = vNewNode) : (vNewNode = retrieveChildWithKey(null, lookupKey), vNewNode ? vnode_insertBefore(journal, vParent, vNewNode, vCurrent) : insertNewInlineComponent(), 
+                host = vNewNode), host) {
                     let componentHost = host;
                     for (;componentHost && (!vnode_isVirtualVNode(componentHost) || null === vnode_getProp(componentHost, "q:renderFn", null)); ) {
                         componentHost = vnode_getParent(componentHost);
@@ -1396,11 +1474,17 @@
             }
         }
         function insertNewComponent(host, componentQRL, jsxProps) {
-            host && clearVNodeEffectDependencies(container, host), vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore());
+            host && clearAllEffects(container, host), vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore());
             const jsxNode = jsxValue;
             build.isDev && vnode_setProp(vNewNode, "q:type", VirtualType.Component), container.setHostProp(vNewNode, "q:renderFn", componentQRL), 
             container.setHostProp(vNewNode, "q:props", jsxProps), container.setHostProp(vNewNode, "q:key", jsxNode.key);
         }
+        function insertNewInlineComponent() {
+            vnode_insertBefore(journal, vParent, vNewNode = vnode_newVirtual(), vCurrent && getInsertBefore());
+            const jsxNode = jsxValue;
+            build.isDev && vnode_setProp(vNewNode, "q:type", VirtualType.InlineComponent), vnode_setProp(vNewNode, "q:props", jsxNode.props), 
+            jsxNode.key && vnode_setProp(vNewNode, "q:key", jsxNode.key);
+        }
         function expectText(text) {
             if (null !== vCurrent) {
                 if (3 === vnode_getType(vCurrent)) {
@@ -1431,30 +1515,28 @@
     function cleanup(container, vNode) {
         let vCursor = vNode;
         if (vnode_isTextVNode(vNode)) {
-            return;
+            return void markVNodeAsDeleted(vCursor);
         }
         let vParent = null;
         for (;;) {
             const type = vCursor[VNodeProps.flags];
             if (type & VNodeFlags.ELEMENT_OR_VIRTUAL_MASK) {
-                if (clearVNodeEffectDependencies(container, vCursor), markVNodeAsDeleted(vCursor), 
-                type & VNodeFlags.Virtual) {
+                if (clearAllEffects(container, vCursor), markVNodeAsDeleted(vCursor), type & VNodeFlags.Virtual) {
                     const seq = container.getHostProp(vCursor, "q:seq");
                     if (seq) {
                         for (let i = 0; i < seq.length; i++) {
                             const obj = seq[i];
                             if (isTask(obj)) {
                                 const task = obj;
-                                clearSubscriberEffectDependencies(container, task), task.$flags$ & TaskFlags.VISIBLE_TASK ? container.$scheduler$(ChoreType.CLEANUP_VISIBLE, task) : cleanupTask(task);
+                                clearAllEffects(container, task), task.$flags$ & TaskFlags.VISIBLE_TASK ? container.$scheduler$(ChoreType.CLEANUP_VISIBLE, task) : cleanupTask(task);
                             }
                         }
                     }
                 }
                 if (type & VNodeFlags.Virtual && null !== vnode_getProp(vCursor, "q:renderFn", null)) {
-                    const attrs = vCursor;
-                    for (let i = VirtualVNodeProps.PROPS_OFFSET; i < attrs.length; i += 2) {
-                        const key = attrs[i];
-                        if (!key.startsWith(":") && isSlotProp(key)) {
+                    const attrs = vnode_getProps(vCursor);
+                    for (let i = 0; i < attrs.length; i += 2) {
+                        if (isSlotProp(attrs[i])) {
                             const value = attrs[i + 1];
                             if (value) {
                                 attrs[i + 1] = null;
@@ -1468,7 +1550,7 @@
                         }
                     }
                 }
-                if (type & VNodeFlags.Virtual && null !== vnode_getProp(vCursor, QSlot, null)) {
+                if (vnode_isProjection(vCursor)) {
                     if (vCursor === vNode) {
                         const vFirstChild = vnode_getFirstChild(vCursor);
                         if (vFirstChild) {
@@ -1482,6 +1564,8 @@
                         continue;
                     }
                 }
+            } else {
+                type & VNodeFlags.Text && markVNodeAsDeleted(vCursor);
             }
             if (vCursor === vNode) {
                 return;
@@ -1524,33 +1608,117 @@
         SiblingsArray[SiblingsArray.VNode = 2] = "VNode", SiblingsArray[SiblingsArray.Size = 3] = "Size", 
         SiblingsArray[SiblingsArray.NextVNode = 5] = "NextVNode";
     }(SiblingsArray || (SiblingsArray = {}));
-    const implicit$FirstArg = fn => function(first, ...rest) {
-        return fn.call(null, dollar(first), ...rest);
+    const useResourceQrl = (qrl, opts) => {
+        const {val, set, i, iCtx} = useSequentialScope();
+        if (null != val) {
+            return val;
+        }
+        assertQrl(qrl);
+        const container = iCtx.$container$;
+        const resource = createResourceReturn(container, opts);
+        const task = new Task(TaskFlags.DIRTY | TaskFlags.RESOURCE, i, iCtx.$hostElement$, qrl, resource, null);
+        return container.$scheduler$(ChoreType.TASK, task), set(resource), resource;
     };
-    const createSignal = value => new Signal(null, value);
-    const createComputedQrl = qrl => (throwIfQRLNotResolved(qrl), new ComputedSignal(null, qrl));
-    const createComputed$ = /*#__PURE__*/ implicit$FirstArg(createComputedQrl);
+    const createResourceReturn = (container, opts, initialPromise) => {
+        const result = (opts => ({
+            __brand: "resource",
+            value: void 0,
+            loading: !isServerPlatform(),
+            _resolved: void 0,
+            _error: void 0,
+            _state: "pending",
+            _timeout: opts?.timeout ?? -1,
+            _cache: 0
+        }))(opts);
+        return result.value = initialPromise, createStore(container, result, StoreFlags.RECURSIVE);
+    };
+    const isResourceReturn = obj => isObject(obj) && "resource" === (getStoreTarget(obj) || obj).__brand;
+    const runResource = (task, container, host) => {
+        task.$flags$ &= ~TaskFlags.DIRTY, cleanupTask(task);
+        const iCtx = newInvokeContext(container.$locale$, host, void 0, "qResource");
+        iCtx.$container$ = container;
+        const taskFn = task.$qrl$.getFn(iCtx, (() => clearAllEffects(container, task)));
+        const resource = task.$state$;
+        assertDefined();
+        const cleanups = [];
+        task.$destroy$ = noSerialize((() => {
+            cleanups.forEach((fn => {
+                try {
+                    fn();
+                } catch (err) {
+                    container.handleError(err, host);
+                }
+            })), done = !0;
+        }));
+        const resourceTarget = unwrapStore(resource);
+        const opts = {
+            track: (obj, prop) => {
+                const ctx = newInvokeContext();
+                return ctx.$effectSubscriber$ = getSubscriber(task, EffectProperty.COMPONENT), ctx.$container$ = container, 
+                invoke(ctx, (() => isFunction(obj) ? obj() : prop ? obj[prop] : isSignal(obj) ? obj.value : obj));
+            },
+            cleanup(fn) {
+                "function" == typeof fn && cleanups.push(fn);
+            },
+            cache(policy) {
+                let milliseconds = 0;
+                milliseconds = "immutable" === policy ? 1 / 0 : policy, resource._cache = milliseconds;
+            },
+            previous: resourceTarget._resolved
+        };
+        let resolve;
+        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);
+        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) => {
+                resolve = r, reject = re;
+            }))).catch(ignoreErrorToPreventNodeFromCrashing);
+        }));
+        const promise = safeCall((() => Promise.resolve(taskFn(opts))), (value => {
+            setState(!0, value);
+        }), (err => {
+            if (isPromise(err)) {
+                return err.then((() => runResource(task, container, host)));
+            }
+            setState(!1, err);
+        }));
+        const timeout = resourceTarget._timeout;
+        return timeout > 0 ? Promise.race([ promise, delay(timeout).then((() => {
+            setState(!1, new Error("timeout")) && cleanupTask(task);
+        })) ]) : promise;
+    };
+    const ignoreErrorToPreventNodeFromCrashing = () => {};
     const aVNodePath = [];
     const bVNodePath = [];
     const aSsrNodePath = [];
     const bSsrNodePath = [];
-    var ChoreType;
-    !function(ChoreType) {
-        ChoreType[ChoreType.MACRO = 240] = "MACRO", ChoreType[ChoreType.MICRO = 15] = "MICRO", 
-        ChoreType[ChoreType.QRL_RESOLVE = 1] = "QRL_RESOLVE", ChoreType[ChoreType.RESOURCE = 2] = "RESOURCE", 
-        ChoreType[ChoreType.TASK = 3] = "TASK", ChoreType[ChoreType.NODE_DIFF = 4] = "NODE_DIFF", 
-        ChoreType[ChoreType.NODE_PROP = 5] = "NODE_PROP", ChoreType[ChoreType.COMPONENT_SSR = 6] = "COMPONENT_SSR", 
-        ChoreType[ChoreType.COMPONENT = 7] = "COMPONENT", ChoreType[ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS = 8] = "RECOMPUTE_AND_SCHEDULE_EFFECTS", 
-        ChoreType[ChoreType.JOURNAL_FLUSH = 16] = "JOURNAL_FLUSH", ChoreType[ChoreType.VISIBLE = 32] = "VISIBLE", 
-        ChoreType[ChoreType.CLEANUP_VISIBLE = 48] = "CLEANUP_VISIBLE", ChoreType[ChoreType.WAIT_FOR_ALL = 255] = "WAIT_FOR_ALL";
-    }(ChoreType || (ChoreType = {}));
+    const getPromise = chore => chore.$promise$ ||= new Promise((resolve => {
+        chore.$resolve$ = resolve;
+    }));
     const createScheduler = (container, scheduleDrain, journalFlush) => {
         const choreQueue = [];
+        const qrlRuns = [];
         let currentChore = null;
-        let journalFlushScheduled = !1;
+        let drainScheduled = !1;
         return function schedule(type, hostOrTask = null, targetOrQrl = null, payload = null) {
-            const runLater = type !== ChoreType.WAIT_FOR_ALL && type !== ChoreType.COMPONENT_SSR;
-            const isTask = type === ChoreType.TASK || type === ChoreType.VISIBLE || type === ChoreType.RESOURCE || type === ChoreType.CLEANUP_VISIBLE;
+            const isServer = !isDomContainer(container);
+            const isComponentSsr = isServer && type === ChoreType.COMPONENT;
+            const runLater = type !== ChoreType.WAIT_FOR_ALL && !isComponentSsr && type !== ChoreType.RUN_QRL;
+            const isTask = type === ChoreType.TASK || type === ChoreType.VISIBLE || type === ChoreType.CLEANUP_VISIBLE;
+            const isClientOnly = type === ChoreType.JOURNAL_FLUSH || type === ChoreType.NODE_DIFF || type === ChoreType.NODE_PROP;
+            if (isServer && isClientOnly) {
+                return;
+            }
             isTask && (hostOrTask.$flags$ |= TaskFlags.DIRTY);
             let chore = {
                 $type$: type,
@@ -1563,7 +1731,7 @@
                 $returnValue$: null,
                 $executed$: !1
             };
-            chore.$promise$ = new Promise((resolve => chore.$resolve$ = resolve)), chore = function(sortedArray, value, rootVNode) {
+            chore = function(sortedArray, value, rootVNode) {
                 const idx = function(sortedArray, value, rootVNode) {
                     let bottom = 0;
                     let top = sortedArray.length;
@@ -1585,129 +1753,156 @@
                     return sortedArray.splice(~idx, 0, value), value;
                 }
                 const existing = sortedArray[idx];
-                return choreUpdate(existing, value), existing;
-            }(choreQueue, chore, container.rootVNode || null), !journalFlushScheduled && runLater && (journalFlushScheduled = !0, 
-            schedule(ChoreType.JOURNAL_FLUSH), scheduleDrain());
-            return runLater ? chore.$promise$ : drainUpTo(chore, container.rootVNode || null);
+                existing.$type$ === ChoreType.NODE_DIFF && (existing.$payload$ = value.$payload$);
+                existing.$executed$ && (existing.$executed$ = !1);
+                return existing;
+            }(choreQueue, chore, container.rootVNode || null), !drainScheduled && runLater && (drainScheduled = !0, 
+            schedule(ChoreType.JOURNAL_FLUSH), scheduleDrain()?.catch?.((() => {})));
+            return runLater ? getPromise(chore) : drainUpTo(chore, isServer);
         };
-        function drainUpTo(runUptoChore, rootVNode) {
-            if (runUptoChore.$executed$) {
-                return runUptoChore.$returnValue$;
-            }
-            if (currentChore) {
-                return runUptoChore.$promise$;
-            }
+        function drainUpTo(runUptoChore, isServer) {
+            let maxRetries = 5e3;
             for (;choreQueue.length; ) {
-                const nextChore = choreQueue.shift();
-                const order = choreComparator(nextChore, runUptoChore, rootVNode);
-                if (null === order) {
-                    continue;
-                }
-                if (order > 0) {
-                    break;
+                if (maxRetries-- < 0) {
+                    throw new Error("drainUpTo: max retries reached");
                 }
-                if (!!((chore = nextChore).$host$ && vnode_isVNode(chore.$host$) && chore.$host$[VNodeProps.flags] & VNodeFlags.Deleted) && nextChore.$type$ !== ChoreType.CLEANUP_VISIBLE) {
-                    continue;
+                if (currentChore) {
+                    return getPromise(currentChore).then((() => drainUpTo(runUptoChore, isServer))).catch((e => {
+                        container.handleError(e, currentChore?.$host$);
+                    }));
                 }
-                const returnValue = executeChore(nextChore);
-                if (isPromise(returnValue)) {
-                    return returnValue.then((() => drainUpTo(runUptoChore, rootVNode)));
+                const nextChore = choreQueue[0];
+                if (nextChore.$executed$) {
+                    if (choreQueue.shift(), nextChore === runUptoChore) {
+                        break;
+                    }
+                } else {
+                    (chore = nextChore).$host$ && vnode_isVNode(chore.$host$) && chore.$host$[VNodeProps.flags] & VNodeFlags.Deleted && nextChore.$type$ !== ChoreType.CLEANUP_VISIBLE ? choreQueue.shift() : executeChore(nextChore, isServer);
                 }
             }
             var chore;
             return runUptoChore.$returnValue$;
         }
-        function executeChore(chore) {
+        function executeChore(chore, isServer) {
             const host = chore.$host$;
             assertEqual(), currentChore = chore;
             let returnValue = null;
-            switch (chore.$type$) {
-              case ChoreType.JOURNAL_FLUSH:
-                returnValue = journalFlush(), journalFlushScheduled = !1;
-                break;
+            try {
+                switch (chore.$type$) {
+                  case ChoreType.WAIT_FOR_ALL:
+                    isServer && (drainScheduled = !1);
+                    break;
 
-              case ChoreType.COMPONENT:
-              case ChoreType.COMPONENT_SSR:
-                returnValue = safeCall((() => executeComponent(container, host, host, chore.$target$, chore.$payload$)), (jsx => {
-                    if (chore.$type$ === ChoreType.COMPONENT) {
-                        const styleScopedId = container.getHostProp(host, "q:sstyle");
-                        return retryOnPromise((() => vnode_diff(container, jsx, host, addComponentStylePrefix(styleScopedId))));
-                    }
-                    return jsx;
-                }), (err => container.handleError(err, host)));
-                break;
+                  case ChoreType.JOURNAL_FLUSH:
+                    returnValue = journalFlush(), drainScheduled = !1;
+                    break;
 
-              case ChoreType.RESOURCE:
-                const result = runResource(chore.$payload$, container, host);
-                returnValue = isDomContainer(container) ? null : result;
-                break;
+                  case ChoreType.COMPONENT:
+                    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 ChoreType.TASK:
-              case ChoreType.VISIBLE:
-                returnValue = runTask(chore.$payload$, container, host);
-                break;
+                  case ChoreType.RUN_QRL:
+                    {
+                        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;
+                    }
+                    break;
 
-              case ChoreType.CLEANUP_VISIBLE:
-                cleanupTask(chore.$payload$);
-                break;
+                  case ChoreType.TASK:
+                  case ChoreType.VISIBLE:
+                    {
+                        const payload = chore.$payload$;
+                        if (payload.$flags$ & TaskFlags.RESOURCE) {
+                            const result = runResource(payload, container, host);
+                            returnValue = isServer ? result : null;
+                        } else {
+                            returnValue = runTask(payload, container, host);
+                        }
+                    }
+                    break;
 
-              case ChoreType.NODE_DIFF:
-                const parentVirtualNode = chore.$target$;
-                let jsx = chore.$payload$;
-                isSignal(jsx) && (jsx = jsx.value), returnValue = retryOnPromise((() => vnode_diff(container, jsx, parentVirtualNode, null)));
-                break;
+                  case ChoreType.CLEANUP_VISIBLE:
+                    cleanupTask(chore.$payload$);
+                    break;
 
-              case ChoreType.NODE_PROP:
-                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 (isConst) {
-                    journal.push(VNodeJournalOpCode.SetAttribute, virtualNode[ElementVNodeProps.element], property, serializedValue);
-                } else {
-                    vnode_setAttr(journal, virtualNode, property, serializedValue);
-                }
-                break;
+                  case ChoreType.NODE_DIFF:
+                    {
+                        const parentVirtualNode = chore.$target$;
+                        let jsx = chore.$payload$;
+                        isSignal(jsx) && (jsx = jsx.value), returnValue = retryOnPromise((() => vnode_diff(container, jsx, parentVirtualNode, null)));
+                    }
+                    break;
 
-              case ChoreType.QRL_RESOLVE:
-                {
-                    const target = chore.$target$;
-                    returnValue = target.resolved ? null : target.resolve();
+                  case ChoreType.NODE_PROP:
+                    {
+                        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 (isConst) {
+                            journal.push(VNodeJournalOpCode.SetAttribute, virtualNode[ElementVNodeProps.element], property, serializedValue);
+                        } else {
+                            vnode_setAttr(journal, virtualNode, property, serializedValue);
+                        }
+                    }
                     break;
-                }
 
-              case ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS:
-                {
-                    const target = chore.$target$;
-                    const forceRunEffects = target.$forceRunEffects$;
-                    if (target.$forceRunEffects$ = !1, !target.$effects$?.length) {
-                        break;
+                  case ChoreType.QRL_RESOLVE:
+                    {
+                        const target = chore.$target$;
+                        returnValue = target.resolved ? null : target.resolve();
                     }
-                    returnValue = retryOnPromise((() => {
-                        (target.$computeIfNeeded$() || forceRunEffects) && triggerEffects(container, target, target.$effects$);
-                    }));
                     break;
+
+                  case ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS:
+                    {
+                        const target = chore.$target$;
+                        const forceRunEffects = target.$forceRunEffects$;
+                        if (target.$forceRunEffects$ = !1, !target.$effects$?.size) {
+                            break;
+                        }
+                        returnValue = retryOnPromise((() => {
+                            (target.$computeIfNeeded$() || forceRunEffects) && triggerEffects(container, target, target.$effects$);
+                        }));
+                    }
                 }
+            } catch (e) {
+                returnValue = Promise.reject(e);
             }
-            return thenFn = value => (currentChore && (currentChore.$executed$ = !0, currentChore.$resolve$?.(value)), 
-            currentChore = null, chore.$returnValue$ = value), isPromise(valueOrPromise = returnValue) ? valueOrPromise.then(thenFn) : thenFn(valueOrPromise);
-            var valueOrPromise, thenFn;
-        }
-    };
-    const toNumber = value => "number" == typeof value ? value : -1;
-    const choreUpdate = (existing, newChore) => {
-        existing.$type$ === ChoreType.NODE_DIFF && (existing.$payload$ = newChore.$payload$);
-    };
-    function choreComparator(a, b, rootVNode) {
-        const macroTypeDiff = (a.$type$ & ChoreType.MACRO) - (b.$type$ & ChoreType.MACRO);
-        if (0 !== macroTypeDiff) {
-            return macroTypeDiff;
+            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);
         }
-        if (a.$type$ !== ChoreType.JOURNAL_FLUSH) {
+        function choreComparator(a, b, rootVNode) {
+            const macroTypeDiff = (a.$type$ & ChoreType.MACRO) - (b.$type$ & ChoreType.MACRO);
+            if (0 !== macroTypeDiff) {
+                return macroTypeDiff;
+            }
             const aHost = a.$host$;
             const bHost = b.$host$;
             if (aHost !== bHost && null !== aHost && null !== bHost) {
@@ -1719,10 +1914,10 @@
                         let aDepth = -1;
                         let bDepth = -1;
                         for (;a; ) {
-                            a = (aVNodePath[++aDepth] = a)[VNodeProps.parent] || rootVNode && vnode_getProp(a, ":", (id => vnode_locate(rootVNode, id)));
+                            a = (aVNodePath[++aDepth] = a)[VNodeProps.parent] || rootVNode && vnode_getProp(a, "q:sparent", (id => vnode_locate(rootVNode, id)));
                         }
                         for (;b; ) {
-                            b = (bVNodePath[++bDepth] = b)[VNodeProps.parent] || rootVNode && vnode_getProp(b, ":", (id => vnode_locate(rootVNode, id)));
+                            b = (bVNodePath[++bDepth] = b)[VNodeProps.parent] || rootVNode && vnode_getProp(b, "q:sparent", (id => vnode_locate(rootVNode, id)));
                         }
                         for (;aDepth >= 0 && bDepth >= 0; ) {
                             if ((a = aVNodePath[aDepth]) !== (b = bVNodePath[bDepth])) {
@@ -1738,7 +1933,7 @@
                                         return -1;
                                     }
                                 } while (cursor);
-                                return rootVNode && vnode_getProp(b, ":", (id => vnode_locate(rootVNode, id))) ? -1 : 1;
+                                return rootVNode && vnode_getProp(b, "q:sparent", (id => vnode_locate(rootVNode, id))) ? -1 : 1;
                             }
                             aDepth--, bDepth--;
                         }
@@ -1748,6 +1943,7 @@
                         return hostDiff;
                     }
                 } 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) => {
@@ -1780,134 +1976,35 @@
                 return microTypeDiff;
             }
             const idxDiff = toNumber(a.$idx$) - toNumber(b.$idx$);
-            if (0 !== idxDiff) {
-                return idxDiff;
-            }
-            if (a.$target$ !== b.$target$ && (a.$type$ === ChoreType.QRL_RESOLVE && b.$type$ === ChoreType.QRL_RESOLVE || a.$type$ === ChoreType.NODE_PROP && b.$type$ === ChoreType.NODE_PROP || a.$type$ === ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS && b.$type$ === ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS)) {
-                return 1;
-            }
-        }
-        return 0;
-    }
-    const useLexicalScope = () => {
-        const context = getInvokeContext();
-        let qrl = context.$qrl$;
-        if (qrl) {
-            assertQrl(qrl), assertDefined();
-        } else {
-            const el = context.$element$;
-            assertDefined();
-            const containerElement = _getQContainerElement(el);
-            assertDefined();
-            qrl = getDomContainer(containerElement).parseQRL(decodeURIComponent(String(context.$url$)));
-        }
-        return qrl.$captureRef$;
-    };
-    var TaskFlags;
-    !function(TaskFlags) {
-        TaskFlags[TaskFlags.VISIBLE_TASK = 1] = "VISIBLE_TASK", TaskFlags[TaskFlags.TASK = 2] = "TASK", 
-        TaskFlags[TaskFlags.RESOURCE = 4] = "RESOURCE", TaskFlags[TaskFlags.DIRTY = 8] = "DIRTY";
-    }(TaskFlags || (TaskFlags = {}));
-    const useTaskQrl = (qrl, opts) => {
-        const {val, set, iCtx, i} = useSequentialScope();
-        if (val) {
-            return;
-        }
-        assertQrl(qrl), set(1);
-        const host = iCtx.$hostElement$;
-        const task = new Task(TaskFlags.DIRTY | TaskFlags.TASK, i, iCtx.$hostElement$, qrl, void 0, null);
-        set(task);
-        const result = runTask(task, iCtx.$container$, host);
-        if (isPromise(result)) {
-            throw result;
-        }
-        qrl.$resolveLazy$(iCtx.$element$), isServerPlatform() && useRunTask(task, opts?.eagerness);
-    };
-    const runTask = (task, container, host) => {
-        task.$flags$ &= ~TaskFlags.DIRTY, cleanupTask(task);
-        const iCtx = newInvokeContext(container.$locale$, host, void 0, "qTask");
-        iCtx.$container$ = container;
-        const taskFn = task.$qrl$.getFn(iCtx, (() => clearSubscriberEffectDependencies(container, task)));
-        const handleError = reason => container.handleError(reason, host);
-        let cleanupFns = null;
-        const cleanup = fn => {
-            "function" == typeof fn && (cleanupFns || (cleanupFns = [], task.$destroy$ = noSerialize((() => {
-                task.$destroy$ = null, cleanupFns.forEach((fn => {
-                    try {
-                        fn();
-                    } catch (err) {
-                        handleError(err);
-                    }
-                }));
-            }))), cleanupFns.push(fn));
-        };
-        const taskApi = {
-            track: (obj, prop) => {
-                const ctx = newInvokeContext();
-                return ctx.$effectSubscriber$ = [ task, EffectProperty.COMPONENT ], ctx.$container$ = container, 
-                invoke(ctx, (() => isFunction(obj) ? obj() : prop ? obj[prop] : isSignal(obj) ? obj.value : obj));
-            },
-            cleanup
-        };
-        return safeCall((() => taskFn(taskApi)), cleanup, (err => isPromise(err) ? err.then((() => runTask(task, container, host))) : handleError(err)));
-    };
-    const cleanupTask = task => {
-        const destroy = task.$destroy$;
-        if (destroy) {
-            task.$destroy$ = null;
-            try {
-                destroy();
-            } catch (err) {
-                ((message, ...optionalParams) => {
-                    createAndLogError(!1, message, ...optionalParams);
-                })(err);
-            }
-        }
-    };
-    const useRunTask = (task, eagerness) => {
-        "visible" === eagerness || "intersection-observer" === eagerness ? useOn("qvisible", getTaskHandlerQrl(task)) : "load" === eagerness || "document-ready" === eagerness ? useOnDocument("qinit", getTaskHandlerQrl(task)) : "idle" !== eagerness && "document-idle" !== eagerness || useOnDocument("qidle", getTaskHandlerQrl(task));
-    };
-    const getTaskHandlerQrl = task => {
-        const taskQrl = task.$qrl$;
-        const taskHandler = createQRL(taskQrl.$chunk$, "_hW", _hW, null, null, [ task ], taskQrl.$symbol$);
-        return taskQrl.dev && (taskHandler.dev = taskQrl.dev), taskHandler;
-    };
-    class Task extends Subscriber {
-        $flags$;
-        $index$;
-        $el$;
-        $qrl$;
-        $state$;
-        $destroy$;
-        constructor($flags$, $index$, $el$, $qrl$, $state$, $destroy$) {
-            super(), this.$flags$ = $flags$, this.$index$ = $index$, this.$el$ = $el$, this.$qrl$ = $qrl$, 
-            this.$state$ = $state$, this.$destroy$ = $destroy$;
+            return 0 !== idxDiff ? idxDiff : a.$target$ !== b.$target$ || a.$payload$ !== b.$payload$ || b === currentChore ? 1 : 0;
         }
-    }
-    const isTask = value => value instanceof Task;
-    const _hW = () => {
-        const [task] = useLexicalScope();
-        getDomContainer(task.$el$).$scheduler$(task.$flags$ & TaskFlags.VISIBLE_TASK ? ChoreType.VISIBLE : ChoreType.TASK, task);
     };
-    const NEEDS_COMPUTATION = Symbol("invalid");
+    const toNumber = value => "number" == typeof value ? value : -1;
+    var SignalFlags;
+    var WrappedSignalFlags;
+    !function(SignalFlags) {
+        SignalFlags[SignalFlags.INVALID = 1] = "INVALID";
+    }(SignalFlags || (SignalFlags = {})), function(WrappedSignalFlags) {
+        WrappedSignalFlags[WrappedSignalFlags.UNWRAP = 2] = "UNWRAP";
+    }(WrappedSignalFlags || (WrappedSignalFlags = {}));
     const throwIfQRLNotResolved = qrl => {
         if (!qrl.resolved) {
             throw qrl.resolve();
         }
     };
     const isSignal = value => value instanceof Signal;
-    class EffectPropData {
+    class SubscriptionData {
         data;
         constructor(data) {
             this.data = data;
         }
     }
-    var EffectSubscriptionsProp;
+    var EffectSubscriptionProp;
     var EffectProperty;
-    !function(EffectSubscriptionsProp) {
-        EffectSubscriptionsProp[EffectSubscriptionsProp.EFFECT = 0] = "EFFECT", EffectSubscriptionsProp[EffectSubscriptionsProp.PROPERTY = 1] = "PROPERTY", 
-        EffectSubscriptionsProp[EffectSubscriptionsProp.FIRST_BACK_REF_OR_DATA = 2] = "FIRST_BACK_REF_OR_DATA";
-    }(EffectSubscriptionsProp || (EffectSubscriptionsProp = {})), function(EffectProperty) {
+    !function(EffectSubscriptionProp) {
+        EffectSubscriptionProp[EffectSubscriptionProp.CONSUMER = 0] = "CONSUMER", EffectSubscriptionProp[EffectSubscriptionProp.PROPERTY = 1] = "PROPERTY", 
+        EffectSubscriptionProp[EffectSubscriptionProp.BACK_REF = 2] = "BACK_REF", EffectSubscriptionProp[EffectSubscriptionProp.DATA = 3] = "DATA";
+    }(EffectSubscriptionProp || (EffectSubscriptionProp = {})), function(EffectProperty) {
         EffectProperty.COMPONENT = ":", EffectProperty.VNODE = ".";
     }(EffectProperty || (EffectProperty = {}));
     class Signal {
@@ -1936,9 +2033,9 @@
                 }
                 const effectSubscriber = ctx.$effectSubscriber$;
                 if (effectSubscriber) {
-                    const effects = this.$effects$ ||= [];
-                    ensureContainsEffect(effects, effectSubscriber), ensureContains(effectSubscriber, this), 
-                    isSubscriber(this) && ensureEffectContainsSubscriber(effectSubscriber[EffectSubscriptionsProp.EFFECT], this, this.$container$);
+                    const effects = this.$effects$ ||= new Set;
+                    ensureContainsSubscription(effects, effectSubscriber), ensureContainsBackRef(effectSubscriber, this), 
+                    addQrlToSerializationCtx(effectSubscriber, this.$container$);
                 }
             }
             return this.untrackedValue;
@@ -1950,7 +2047,7 @@
             qDev;
         }
         toString() {
-            return `[${this.constructor.name}${this.$invalid$ ? " INVALID" : ""} ${String(this.$untrackedValue$)}]` + (this.$effects$?.map((e => "\n -> " + pad(qwikDebugToString(e[0]), "    "))).join("\n") || "");
+            return `[${this.constructor.name}${this.$flags$ & SignalFlags.INVALID ? " INVALID" : ""} ${String(this.$untrackedValue$)}]` + (Array.from(this.$effects$ || []).map((e => "\n -> " + pad(qwikDebugToString(e[0]), "    "))).join("\n") || "");
         }
         toJSON() {
             return {
@@ -1958,114 +2055,93 @@
             };
         }
     }
-    const ensureContains = (array, value) => {
-        -1 === array.indexOf(value) && array.push(value);
-    };
-    const ensureContainsEffect = (array, effectSubscriptions) => {
-        for (let i = 0; i < array.length; i++) {
-            const existingEffect = array[i];
-            if (existingEffect[0] === effectSubscriptions[0] && existingEffect[1] === effectSubscriptions[1]) {
-                return;
-            }
-        }
-        array.push(effectSubscriptions);
+    const ensureContainsSubscription = (array, effectSubscription) => {
+        array.add(effectSubscription);
     };
-    const ensureEffectContainsSubscriber = (effect, subscriber, container) => {
-        if (isSubscriber(effect)) {
-            if (effect.$effectDependencies$ ||= [], subscriberExistInSubscribers(effect.$effectDependencies$, subscriber)) {
-                return;
-            }
-            effect.$effectDependencies$.push(subscriber);
-        } else if (vnode_isVNode(effect) && !vnode_isTextVNode(effect)) {
-            let subscribers = vnode_getProp(effect, "q:subs", container ? container.$getObjectById$ : null);
-            if (subscribers ||= [], subscriberExistInSubscribers(subscribers, subscriber)) {
-                return;
-            }
-            subscribers.push(subscriber), vnode_setProp(effect, "q:subs", subscribers);
-        } else if (isSSRNode(effect)) {
-            let subscribers = effect.getProp("q:subs");
-            if (subscribers ||= [], subscriberExistInSubscribers(subscribers, subscriber)) {
-                return;
-            }
-            subscribers.push(subscriber), effect.setProp("q:subs", subscribers);
-        }
+    const ensureContainsBackRef = (array, value) => {
+        array[EffectSubscriptionProp.BACK_REF] ||= new Set, array[EffectSubscriptionProp.BACK_REF].add(value);
     };
-    const isSSRNode = effect => "setProp" in effect && "getProp" in effect && "removeProp" in effect && "id" in effect;
-    const subscriberExistInSubscribers = (subscribers, subscriber) => {
-        for (let i = 0; i < subscribers.length; i++) {
-            if (subscribers[i] === subscriber) {
-                return !0;
-            }
+    const addQrlToSerializationCtx = (effectSubscriber, container) => {
+        if (container && !isDomContainer(container)) {
+            const effect = effectSubscriber[EffectSubscriptionProp.CONSUMER];
+            const property = effectSubscriber[EffectSubscriptionProp.PROPERTY];
+            let qrl = null;
+            isTask(effect) ? qrl = effect.$qrl$ : effect instanceof ComputedSignal ? qrl = effect.$computeQrl$ : property === EffectProperty.COMPONENT && (qrl = container.getHostProp(effect, "q:renderFn")), 
+            qrl && container.serializationCtx.$eventQrls$.add(qrl);
         }
-        return !1;
     };
     const triggerEffects = (container, signal, effects) => {
+        const isBrowser = isDomContainer(container);
         if (effects) {
-            const scheduleEffect = effectSubscriptions => {
-                const effect = effectSubscriptions[EffectSubscriptionsProp.EFFECT];
-                const property = effectSubscriptions[EffectSubscriptionsProp.PROPERTY];
-                if (assertDefined(), isTask(effect)) {
-                    effect.$flags$ |= TaskFlags.DIRTY;
+            const scheduleEffect = effectSubscription => {
+                const consumer = effectSubscription[EffectSubscriptionProp.CONSUMER];
+                const property = effectSubscription[EffectSubscriptionProp.PROPERTY];
+                if (assertDefined(), isTask(consumer)) {
+                    consumer.$flags$ |= TaskFlags.DIRTY;
                     let choreType = ChoreType.TASK;
-                    effect.$flags$ & TaskFlags.VISIBLE_TASK ? choreType = ChoreType.VISIBLE : effect.$flags$ & TaskFlags.RESOURCE && (choreType = ChoreType.RESOURCE), 
-                    container.$scheduler$(choreType, effect);
-                } else if (effect instanceof Signal) {
-                    effect instanceof ComputedSignal && (effect.$computeQrl$.resolved || container.$scheduler$(ChoreType.QRL_RESOLVE, null, effect.$computeQrl$)), 
-                    effect.$invalidate$();
+                    consumer.$flags$ & TaskFlags.VISIBLE_TASK && (choreType = ChoreType.VISIBLE), container.$scheduler$(choreType, consumer);
+                } else if (consumer instanceof Signal) {
+                    consumer instanceof ComputedSignal && (consumer.$computeQrl$.resolved || container.$scheduler$(ChoreType.QRL_RESOLVE, null, consumer.$computeQrl$)), 
+                    consumer.$invalidate$();
                 } else if (property === EffectProperty.COMPONENT) {
-                    const host = effect;
+                    const host = consumer;
                     const qrl = container.getHostProp(host, "q:renderFn");
                     assertDefined();
                     const props = container.getHostProp(host, "q:props");
                     container.$scheduler$(ChoreType.COMPONENT, host, qrl, props);
-                } else if (property === EffectProperty.VNODE) {
-                    container.$scheduler$(ChoreType.NODE_DIFF, effect, effect, signal);
-                } else {
-                    const effectData = effectSubscriptions[EffectSubscriptionsProp.FIRST_BACK_REF_OR_DATA];
-                    if (effectData instanceof EffectPropData) {
-                        const payload = {
-                            ...effectData.data,
-                            $value$: signal
-                        };
-                        container.$scheduler$(ChoreType.NODE_PROP, effect, property, payload);
+                } else if (isBrowser) {
+                    if (property === EffectProperty.VNODE) {
+                        container.$scheduler$(ChoreType.NODE_DIFF, consumer, consumer, signal);
+                    } else {
+                        const effectData = effectSubscription[EffectSubscriptionProp.DATA];
+                        if (effectData instanceof SubscriptionData) {
+                            const payload = {
+                                ...effectData.data,
+                                $value$: signal
+                            };
+                            container.$scheduler$(ChoreType.NODE_PROP, consumer, property, payload);
+                        }
                     }
                 }
             };
-            effects.forEach(scheduleEffect);
+            for (const effect of effects) {
+                scheduleEffect(effect);
+            }
         }
     };
     class ComputedSignal extends Signal {
         $computeQrl$;
-        $invalid$=!0;
+        $flags$;
         $forceRunEffects$=!1;
-        constructor(container, fn) {
-            super(container, NEEDS_COMPUTATION), this.$computeQrl$ = fn;
+        [_EFFECT_BACK_REF]=null;
+        constructor(container, fn, flags = SignalFlags.INVALID) {
+            super(container, NEEDS_COMPUTATION), this.$computeQrl$ = fn, this.$flags$ = flags;
         }
         $invalidate$() {
-            this.$invalid$ = !0, this.$forceRunEffects$ = !1, this.$container$?.$scheduler$(ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS, null, this);
+            this.$flags$ |= SignalFlags.INVALID, this.$forceRunEffects$ = !1, this.$container$?.$scheduler$(ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS, null, this);
         }
         force() {
-            this.$invalid$ = !0, this.$forceRunEffects$ = !1, triggerEffects(this.$container$, this, this.$effects$);
+            this.$flags$ |= SignalFlags.INVALID, this.$forceRunEffects$ = !1, triggerEffects(this.$container$, this, this.$effects$);
         }
         get untrackedValue() {
             const didChange = this.$computeIfNeeded$();
             return didChange && (this.$forceRunEffects$ = didChange), assertFalse(), this.$untrackedValue$;
         }
         $computeIfNeeded$() {
-            if (!this.$invalid$) {
+            if (!(this.$flags$ & SignalFlags.INVALID)) {
                 return !1;
             }
             const computeQrl = this.$computeQrl$;
             throwIfQRLNotResolved(computeQrl);
             const ctx = tryGetInvokeContext();
             const previousEffectSubscription = ctx?.$effectSubscriber$;
-            ctx && (ctx.$effectSubscriber$ = [ this, EffectProperty.VNODE ]);
+            ctx && (ctx.$effectSubscriber$ = getSubscriber(this, EffectProperty.VNODE));
             try {
                 const untrackedValue = computeQrl.getFn(ctx)();
                 if (isPromise(untrackedValue)) {
                     throw qError(QError.computedNotSync, [ computeQrl.dev ? computeQrl.dev.file : "", computeQrl.$hash$ ]);
                 }
-                this.$invalid$ = !1;
+                this.$flags$ &= ~SignalFlags.INVALID;
                 const didChange = untrackedValue !== this.$untrackedValue$;
                 return didChange && (this.$untrackedValue$ = untrackedValue), didChange;
             } finally {
@@ -2083,25 +2159,26 @@
         $args$;
         $func$;
         $funcStr$;
-        $invalid$=!0;
-        $effectDependencies$=null;
+        $flags$;
         $hostElement$=null;
         $forceRunEffects$=!1;
-        constructor(container, fn, args, fnStr) {
-            super(container, NEEDS_COMPUTATION), this.$args$ = args, this.$func$ = fn, this.$funcStr$ = fnStr;
+        [_EFFECT_BACK_REF]=null;
+        constructor(container, fn, args, fnStr, flags = SignalFlags.INVALID | WrappedSignalFlags.UNWRAP) {
+            super(container, NEEDS_COMPUTATION), this.$args$ = args, this.$func$ = fn, this.$funcStr$ = fnStr, 
+            this.$flags$ = flags;
         }
         $invalidate$() {
-            this.$invalid$ = !0, this.$forceRunEffects$ = !1, this.$container$?.$scheduler$(ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS, this.$hostElement$, this);
+            this.$flags$ |= SignalFlags.INVALID, this.$forceRunEffects$ = !1, this.$container$?.$scheduler$(ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS, this.$hostElement$, this);
         }
         force() {
-            this.$invalid$ = !0, this.$forceRunEffects$ = !1, triggerEffects(this.$container$, this, this.$effects$);
+            this.$flags$ |= SignalFlags.INVALID, this.$forceRunEffects$ = !1, triggerEffects(this.$container$, this, this.$effects$);
         }
         get untrackedValue() {
             const didChange = this.$computeIfNeeded$();
             return didChange && (this.$forceRunEffects$ = didChange), assertFalse(), this.$untrackedValue$;
         }
         $computeIfNeeded$() {
-            if (!this.$invalid$) {
+            if (!(this.$flags$ & SignalFlags.INVALID)) {
                 return !1;
             }
             const untrackedValue = trackSignal((() => this.$func$(...this.$args$)), this, EffectProperty.VNODE, this.$container$);
@@ -2122,18 +2199,10 @@
             this.$scopedStyle$ = $scopedStyle$, this.$componentFrame$ = $componentFrame$;
         }
     }
-    function _walkJSX(ssr, value, options) {
+    async function _walkJSX(ssr, value, options) {
         const stack = [ value ];
-        let resolveDrain;
-        let rejectDrain;
-        const drained = options.allowPromises && new Promise(((res, rej) => {
-            resolveDrain = res, rejectDrain = rej;
-        }));
         const enqueue = value => stack.push(value);
-        const resolveValue = value => {
-            stack.push(value), drain();
-        };
-        const drain = () => {
+        await (async () => {
             for (;stack.length; ) {
                 const value = stack.pop();
                 if (value instanceof ParentComponentData) {
@@ -2145,23 +2214,13 @@
                     });
                 } else {
                     if (value === Promise) {
-                        if (!options.allowPromises) {
-                            throw qError(QError.promisesNotExpected);
-                        }
-                        return void stack.pop().then(resolveValue, rejectDrain);
-                    }
-                    const waitOn = value.apply(ssr);
-                    if (waitOn) {
-                        if (!options.allowPromises) {
-                            throw qError(QError.promisesNotExpected);
-                        }
-                        return void waitOn.then(drain, rejectDrain);
+                        stack.push(await stack.pop());
+                        continue;
                     }
+                    await value.apply(ssr);
                 }
             }
-            0 === stack.length && options.allowPromises && resolveDrain();
-        };
-        return drain(), drained;
+        })();
     }
     function processJSXNode(ssr, enqueue, value, options) {
         if (null == value) {
@@ -2190,7 +2249,6 @@
                 enqueue((async () => {
                     for await (const chunk of value) {
                         await _walkJSX(ssr, chunk, {
-                            allowPromises: !0,
                             currentStyleScoped: options.styleScoped,
                             parentComponentFrame: options.parentComponentFrame
                         }), ssr.commentNode("qkssr-f");
@@ -2225,7 +2283,7 @@
                         const componentFrame = options.parentComponentFrame || ssr.unclaimedProjectionComponentFrameQueue.shift();
                         if (componentFrame) {
                             const projectionAttrs = build.isDev ? [ "q:type", VirtualType.Projection ] : [];
-                            projectionAttrs.push(":", componentFrame.componentNode.id || ""), ssr.openProjection(projectionAttrs);
+                            projectionAttrs.push("q:sparent", componentFrame.componentNode.id || ""), ssr.openProjection(projectionAttrs);
                             const host = componentFrame.componentNode;
                             const node = ssr.getLastNode();
                             const slotName = function(host, jsx, ssr) {
@@ -2257,7 +2315,6 @@
                         value = isFunction(generator) ? generator({
                             async write(chunk) {
                                 await _walkJSX(ssr, chunk, {
-                                    allowPromises: !0,
                                     currentStyleScoped: options.styleScoped,
                                     parentComponentFrame: options.parentComponentFrame
                                 }), ssr.commentNode("qkssr-f");
@@ -2277,7 +2334,7 @@
                             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(ChoreType.COMPONENT_SSR, host, componentQrl, srcProps);
+                            null !== jsx.key && host.setProp("q:key", jsx.key), scheduler(ChoreType.COMPONENT, host, componentQrl, srcProps);
                         })(ssr, jsx, type);
                         const compStyleComponentId = addComponentStylePrefix(host.getProp("q:sstyle"));
                         enqueue(new ParentComponentData(options.styleScoped, options.parentComponentFrame)), 
@@ -2344,18 +2401,20 @@
         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 ])), 
+        qrlToString(serializationCtx, qrl));
         if (Array.isArray(qrls)) {
             for (let i = 0; i <= qrls.length; i++) {
                 const qrl = qrls[i];
-                if (isQrl(qrl)) {
-                    appendToValue(qrlToString(serializationCtx, qrl)), addQwikEventToSerializationContext(serializationCtx, key, qrl);
+                if (isQrl$1(qrl)) {
+                    appendToValue(getQrlString(qrl)), addQwikEventToSerializationContext(serializationCtx, key, qrl);
                 } else if (null != qrl) {
                     const nestedValue = setEvent(serializationCtx, key, qrl);
                     nestedValue && appendToValue(nestedValue);
                 }
             }
         } else {
-            isQrl(qrls) && (value = qrlToString(serializationCtx, qrls), addQwikEventToSerializationContext(serializationCtx, key, qrls));
+            isQrl$1(qrls) && (value = getQrlString(qrls), addQwikEventToSerializationContext(serializationCtx, key, qrls));
         }
         return value;
     }
@@ -2367,7 +2426,7 @@
         const eventName = key.substring(15);
         eventName && serializationCtx.$eventNames$.add(eventName);
     }
-    const version = "2.0.0-alpha.6-dev+d848ba5";
+    const version = "2.0.0-alpha.8-dev+66037b5";
     class _SharedContainer {
         $version$;
         $scheduler$;
@@ -2390,9 +2449,6 @@
             return createSerializationContext(NodeConstructor, DomRefConstructor, symbolToChunkResolver, this.getHostProp.bind(this), this.setHostProp.bind(this), this.$storeProxyMap$, writer, prepVNodeData);
         }
     }
-    const _CONST_PROPS = Symbol("CONST");
-    const _VAR_PROPS = Symbol("VAR");
-    const _IMMUTABLE = Symbol("IMMUTABLE");
     const getValueProp = p0 => p0.value;
     const getProp = (p0, p1) => p0[p1];
     const getWrapped = args => new WrappedSignal(null, 1 === args.length ? getValueProp : getProp, args, null);
@@ -2403,7 +2459,7 @@
             return obj[prop];
         }
         if (isSignal(obj)) {
-            return assertEqual(), obj instanceof WrappedSignal ? obj : getWrapped(args);
+            return assertEqual(), obj instanceof WrappedSignal && obj.flags & WrappedSignalFlags.UNWRAP ? obj : getWrapped(args);
         }
         if (isPropsProxy(obj)) {
             const constProps = obj[_CONST_PROPS];
@@ -2497,7 +2553,7 @@
                 return this.$children$;
             }
             const value = this.$constProps$ && prop in this.$constProps$ ? this.$constProps$[prop] : this.$varProps$[prop];
-            return value instanceof WrappedSignal ? value.value : value;
+            return value instanceof WrappedSignal && value.$flags$ & WrappedSignalFlags.UNWRAP ? value.value : value;
         }
         set(_, prop, value) {
             return prop === _CONST_PROPS ? (this.$constProps$ = value, !0) : prop === _VAR_PROPS ? (this.$varProps$ = value, 
@@ -2597,7 +2653,7 @@
         return String(value);
     };
     const VNodeDataSeparator_REFERENCE = 126, VNodeDataSeparator_ADVANCE_1 = 33, VNodeDataSeparator_ADVANCE_8192 = 46;
-    const VNodeDataChar_OPEN = 123, VNodeDataChar_CLOSE = 125, VNodeDataChar_SCOPED_STYLE = 59, VNodeDataChar_RENDER_FN = 60, VNodeDataChar_ID = 61, VNodeDataChar_PROPS = 62, VNodeDataChar_SLOT_REF = 63, VNodeDataChar_KEY = 64, VNodeDataChar_SEQ = 91, VNodeDataChar_CONTEXT = 93, VNodeDataChar_SEQ_IDX = 94, VNodeDataChar_SUBS = 96, VNodeDataChar_SEPARATOR = 124, VNodeDataChar_SLOT = 126;
+    const VNodeDataChar_OPEN = 123, VNodeDataChar_CLOSE = 125, VNodeDataChar_SCOPED_STYLE = 59, VNodeDataChar_RENDER_FN = 60, VNodeDataChar_ID = 61, VNodeDataChar_PROPS = 62, VNodeDataChar_SLOT_PARENT = 63, VNodeDataChar_KEY = 64, VNodeDataChar_SEQ = 91, VNodeDataChar_CONTEXT = 93, VNodeDataChar_SEQ_IDX = 94, VNodeDataChar_BACK_REFS = 96, VNodeDataChar_SEPARATOR = 124, VNodeDataChar_SLOT = 126;
     var VNodeJournalOpCode;
     !function(VNodeJournalOpCode) {
         VNodeJournalOpCode[VNodeJournalOpCode.SetText = 1] = "SetText", VNodeJournalOpCode[VNodeJournalOpCode.SetAttribute = 2] = "SetAttribute", 
@@ -2648,6 +2704,10 @@
         assertDefined();
         return (vNode[VNodeProps.flags] & VNodeFlags.Virtual) === VNodeFlags.Virtual;
     };
+    const vnode_isProjection = vNode => {
+        assertDefined();
+        return (vNode[VNodeProps.flags] & VNodeFlags.Virtual) === VNodeFlags.Virtual && null !== vnode_getProp(vNode, QSlot, null);
+    };
     const ensureTextVNode = vNode => (assertTrue(vnode_isTextVNode(vNode), vnode_getNodeTypeName(vNode)), 
     vNode);
     const ensureElementOrVirtualVNode = vNode => {
@@ -2676,6 +2736,7 @@
             elementVNode[VNodeProps.flags] ^= VNodeFlags.Inflated;
             const element = elementVNode[ElementVNodeProps.element];
             const attributes = element.attributes;
+            const props = vnode_getProps(elementVNode);
             for (let idx = 0; idx < attributes.length; idx++) {
                 const attr = attributes[idx];
                 const key = attr.name;
@@ -2683,9 +2744,9 @@
                     break;
                 }
                 if (key.startsWith("q:container")) {
-                    attr.value === QContainerValue.HTML ? mapArray_set(elementVNode, "dangerouslySetInnerHTML", element.innerHTML, ElementVNodeProps.PROPS_OFFSET) : attr.value === QContainerValue.TEXT && "value" in element && mapArray_set(elementVNode, "value", element.value, ElementVNodeProps.PROPS_OFFSET);
+                    attr.value === QContainerValue.HTML ? mapArray_set(props, "dangerouslySetInnerHTML", element.innerHTML, 0) : attr.value === QContainerValue.TEXT && "value" in element && mapArray_set(props, "value", element.value, 0);
                 } else if (!key.startsWith("on:")) {
-                    mapArray_set(elementVNode, key, attr.value, ElementVNodeProps.PROPS_OFFSET);
+                    mapArray_set(props, key, attr.value, 0);
                 }
             }
         }
@@ -2905,7 +2966,7 @@
                 let key = journal[idx++];
                 "className" === key && (key = "class");
                 const value = journal[idx++];
-                isBooleanAttr(element, key) ? element[key] = parseBoolean(value) : "value" === key && key in element ? element.value = escapeHTML(String(value)) : "dangerouslySetInnerHTML" === key ? element.innerHTML = value : null == value || !1 === value ? element.removeAttribute(key) : element.setAttribute(key, String(value));
+                isBooleanAttr(element, key) ? element[key] = parseBoolean(value) : "value" === key && key in element ? element.value = String(value) : "dangerouslySetInnerHTML" === key ? element.innerHTML = value : null == value || !1 === value ? element.removeAttribute(key) : element.setAttribute(key, String(value));
                 break;
 
               case VNodeJournalOpCode.HoistStyles:
@@ -2936,30 +2997,9 @@
         }
         journal.length = 0;
     };
-    const mapApp_findIndx = (elementVNode, key, start) => {
-        assertTrue();
-        let bottom = start >> 1;
-        let top = elementVNode.length - 2 >> 1;
-        for (;bottom <= top; ) {
-            const mid = bottom + (top - bottom >> 1);
-            const midKey = elementVNode[mid << 1];
-            if (midKey === key) {
-                return mid << 1;
-            }
-            midKey < key ? bottom = mid + 1 : top = mid - 1;
-        }
-        return ~(bottom << 1);
-    };
-    const mapArray_set = (elementVNode, key, value, start) => {
-        const indx = mapApp_findIndx(elementVNode, key, start);
-        indx >= 0 ? null == value ? elementVNode.splice(indx, 2) : elementVNode[indx + 1] = value : null != value && elementVNode.splice(~indx, 0, key, value);
-    };
-    const mapArray_get = (elementVNode, key, start) => {
-        const indx = mapApp_findIndx(elementVNode, key, start);
-        return indx >= 0 ? elementVNode[indx + 1] : null;
-    };
     const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
-        ensureElementOrVirtualVNode(parent), vnode_isElementVNode(parent) && ensureMaterialized(parent);
+        ensureElementOrVirtualVNode(parent), vnode_isElementVNode(parent) && ensureMaterialized(parent), 
+        newChild === insertBefore && (insertBefore = null);
         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) => {
@@ -3037,9 +3077,23 @@
     const vnode_getElementName = vnode => {
         const elementVNode = ensureElementVNode(vnode);
         let elementName = elementVNode[ElementVNodeProps.elementName];
-        return void 0 === elementName && (elementName = elementVNode[ElementVNodeProps.elementName] = elementVNode[ElementVNodeProps.element].nodeName.toLowerCase(), 
-        elementVNode[VNodeProps.flags] |= (elementName => isSvgElement(elementName) ? VNodeFlags.NS_svg : isMathElement(elementName) ? VNodeFlags.NS_math : VNodeFlags.NS_html)(elementName)), 
-        elementName;
+        if (void 0 === elementName) {
+            const element = elementVNode[ElementVNodeProps.element];
+            const nodeName = build.isDev ? fastNodeName(element).toLowerCase() : fastNodeName(element);
+            elementName = elementVNode[ElementVNodeProps.elementName] = nodeName, elementVNode[VNodeProps.flags] |= (element => {
+                switch (fastNamespaceURI(element)) {
+                  case SVG_NS:
+                    return VNodeFlags.NS_svg;
+
+                  case MATH_NS:
+                    return VNodeFlags.NS_math;
+
+                  default:
+                    return VNodeFlags.NS_html;
+                }
+            })(element);
+        }
+        return elementName;
     };
     const vnode_getText = vnode => {
         const textVNode = ensureTextVNode(vnode);
@@ -3115,16 +3169,16 @@
                         container.$setRawState$(parseInt(id), vParent), build.isDev && vnode_setAttr(null, vParent, "q:id", id);
                     } else if (peek() === VNodeDataChar_PROPS) {
                         vnode_setAttr(null, vParent, "q:props", consumeValue());
-                    } else if (peek() === VNodeDataChar_SLOT_REF) {
-                        vnode_setAttr(null, vParent, "q:sref", consumeValue());
                     } else if (peek() === VNodeDataChar_KEY) {
                         vnode_setAttr(null, vParent, "q:key", consumeValue());
                     } else if (peek() === VNodeDataChar_SEQ) {
                         vnode_setAttr(null, vParent, "q:seq", consumeValue());
                     } else if (peek() === VNodeDataChar_SEQ_IDX) {
                         vnode_setAttr(null, vParent, "q:seqIdx", consumeValue());
-                    } else if (peek() === VNodeDataChar_SUBS) {
-                        vnode_setProp(vParent, "q:subs", consumeValue());
+                    } else if (peek() === VNodeDataChar_BACK_REFS) {
+                        container || (container = getDomContainer(element)), setEffectBackRefFromVNodeData(vParent, consumeValue(), container);
+                    } else if (peek() === VNodeDataChar_SLOT_PARENT) {
+                        vnode_setProp(vParent, "q:sparent", consumeValue());
                     } else if (peek() === VNodeDataChar_CONTEXT) {
                         vnode_setAttr(null, vParent, "q:ctx", consumeValue());
                     } else if (peek() === VNodeDataChar_OPEN) {
@@ -3228,6 +3282,12 @@
         }
         return node;
     };
+    let _fastNamespaceURI = null;
+    const fastNamespaceURI = element => (_fastNamespaceURI || (_fastNamespaceURI = fastGetter(element, "namespaceURI")), 
+    _fastNamespaceURI.call(element));
+    let _fastNodeName = null;
+    const fastNodeName = element => (_fastNodeName || (_fastNodeName = fastGetter(element, "nodeName")), 
+    _fastNodeName.call(element));
     const fastGetter = (prototype, name) => {
         let getter;
         for (;prototype && !(getter = Object.getOwnPropertyDescriptor(prototype, name)?.get); ) {
@@ -3265,12 +3325,27 @@
                     const id = consumeValue();
                     container.$setRawState$(parseInt(id), vParent), build.isDev && vnode_setAttr(null, vParent, "q:id", id);
                 } else {
-                    peek() === VNodeDataChar_SUBS ? vnode_setProp(vParent, "q:subs", consumeValue()) : consumeValue();
+                    peek() === VNodeDataChar_BACK_REFS ? (container || (container = getDomContainer(vParent[ElementVNodeProps.element])), 
+                    setEffectBackRefFromVNodeData(vParent, consumeValue(), container)) : consumeValue();
                 }
             }));
         }
         return vFirstChild;
     };
+    function setEffectBackRefFromVNodeData(vParent, value, container) {
+        const deserializedSubMap = container.$getObjectById$(value);
+        if (vParent[_EFFECT_BACK_REF]) {
+            ((map1, map2) => {
+                for (const [k, v] of map2) {
+                    map1.set(k, v);
+                }
+            })(vParent[_EFFECT_BACK_REF], deserializedSubMap);
+        } else {
+            Object.defineProperty(vParent, _EFFECT_BACK_REF, {
+                value: deserializedSubMap
+            });
+        }
+    }
     const processVNodeData$1 = (vData, callback) => {
         let nextToConsumeIdx = 0;
         let ch = 0;
@@ -3295,8 +3370,9 @@
         if (vnode[VNodeProps.flags] & VNodeFlags.ELEMENT_OR_VIRTUAL_MASK) {
             vnode_ensureElementInflated(vnode);
             const keys = [];
-            for (let i = vnode_getPropStartIndex(vnode); i < vnode.length; i += 2) {
-                const key = vnode[i];
+            const props = vnode_getProps(vnode);
+            for (let i = 0; i < props.length; i += 2) {
+                const key = props[i];
                 key.startsWith(":") || keys.push(key);
             }
             return keys;
@@ -3307,27 +3383,35 @@
         const type = vnode[VNodeProps.flags];
         if (type & VNodeFlags.ELEMENT_OR_VIRTUAL_MASK) {
             vnode_ensureElementInflated(vnode);
-            const idx = mapApp_findIndx(vnode, key, vnode_getPropStartIndex(vnode));
+            const props = vnode_getProps(vnode);
+            const idx = mapApp_findIndx(props, key, 0);
             if (idx >= 0) {
-                if (vnode[idx + 1] != value && type & VNodeFlags.Element) {
+                if (props[idx + 1] != value && type & VNodeFlags.Element) {
                     journal && journal.push(VNodeJournalOpCode.SetAttribute, vnode[ElementVNodeProps.element], key, value);
                 }
-                null == value ? vnode.splice(idx, 2) : vnode[idx + 1] = value;
-            } else if (null != value && (vnode.splice(~idx, 0, key, value), type & VNodeFlags.Element)) {
+                null == value ? props.splice(idx, 2) : props[idx + 1] = value;
+            } else if (null != value && (props.splice(~idx, 0, key, value), type & VNodeFlags.Element)) {
                 journal && journal.push(VNodeJournalOpCode.SetAttribute, vnode[ElementVNodeProps.element], key, value);
             }
         }
     };
-    const vnode_getAttr = (vnode, key) => vnode[VNodeProps.flags] & VNodeFlags.ELEMENT_OR_VIRTUAL_MASK ? (vnode_ensureElementInflated(vnode), 
-    mapArray_get(vnode, key, vnode_getPropStartIndex(vnode))) : null;
+    const vnode_getAttr = (vnode, key) => {
+        if (vnode[VNodeProps.flags] & VNodeFlags.ELEMENT_OR_VIRTUAL_MASK) {
+            vnode_ensureElementInflated(vnode);
+            const props = vnode_getProps(vnode);
+            return mapArray_get(props, key, 0);
+        }
+        return null;
+    };
     const vnode_getProp = (vnode, key, getObject) => {
         const type = vnode[VNodeProps.flags];
         if (type & VNodeFlags.ELEMENT_OR_VIRTUAL_MASK) {
             type & VNodeFlags.Element && vnode_ensureElementInflated(vnode);
-            const idx = mapApp_findIndx(vnode, key, vnode_getPropStartIndex(vnode));
+            const props = vnode_getProps(vnode);
+            const idx = mapApp_findIndx(props, key, 0);
             if (idx >= 0) {
-                let value = vnode[idx + 1];
-                return "string" == typeof value && getObject && (vnode[idx + 1] = value = getObject(value)), 
+                let value = props[idx + 1];
+                return "string" == typeof value && getObject && (props[idx + 1] = value = getObject(value)), 
                 value;
             }
         }
@@ -3335,10 +3419,11 @@
     };
     const vnode_setProp = (vnode, key, value) => {
         ensureElementOrVirtualVNode(vnode);
-        const idx = mapApp_findIndx(vnode, key, vnode_getPropStartIndex(vnode));
-        idx >= 0 ? vnode[idx + 1] = value : null != value && vnode.splice(~idx, 0, key, value);
+        const props = vnode_getProps(vnode);
+        const idx = mapApp_findIndx(props, key, 0);
+        idx >= 0 ? props[idx + 1] = value : null != value && props.splice(~idx, 0, key, value);
     };
-    const vnode_getPropStartIndex = vnode => {
+    const vnode_getProps = vnode => vnode[(vnode => {
         const type = vnode[VNodeProps.flags] & VNodeFlags.TYPE_MASK;
         if (type === VNodeFlags.Element) {
             return ElementVNodeProps.PROPS_OFFSET;
@@ -3347,7 +3432,7 @@
             return VirtualVNodeProps.PROPS_OFFSET;
         }
         throw qError(QError.invalidVNodeType, [ type ]);
-    };
+    })(vnode)];
     const vnode_getParent = vnode => vnode[VNodeProps.parent] || null;
     const vnode_getNode = vnode => null === vnode || vnode_isVirtualVNode(vnode) ? null : vnode_isElementVNode(vnode) ? vnode[ElementVNodeProps.element] : (assertTrue(vnode_isTextVNode(vnode)), 
     vnode[TextVNodeProps.node]);
@@ -3430,7 +3515,7 @@
         let projectionDepth = 1;
         for (;projectionDepth--; ) {
             for (;vHost && (!vnode_isVirtualVNode(vHost) || null === vnode_getProp(vHost, "q:renderFn", null)); ) {
-                const qSlotParent = vnode_getProp(vHost, ":", (id => vnode_locate(rootVNode, id)));
+                const qSlotParent = vnode_getProp(vHost, "q:sparent", (id => vnode_locate(rootVNode, id)));
                 const vProjectionParent = vnode_isVirtualVNode(vHost) && qSlotParent;
                 vProjectionParent && projectionDepth++, vHost = vProjectionParent || vnode_getParent(vHost);
             }
@@ -3440,19 +3525,16 @@
     };
     const VNodeArray = class VNode extends Array {
         static createElement(flags, parent, previousSibling, nextSibling, firstChild, lastChild, element, elementName) {
-            const vnode = new VNode(flags, parent, previousSibling, nextSibling);
-            return vnode.push(firstChild, lastChild, element, elementName), vnode;
+            return new VNode(flags, parent, previousSibling, nextSibling, firstChild, lastChild, element, elementName, []);
         }
         static createText(flags, parent, previousSibling, nextSibling, textNode, text) {
-            const vnode = new VNode(flags, parent, previousSibling, nextSibling);
-            return vnode.push(textNode, text), vnode;
+            return new VNode(flags, parent, previousSibling, nextSibling, textNode, text);
         }
         static createVirtual(flags, parent, previousSibling, nextSibling, firstChild, lastChild) {
-            const vnode = new VNode(flags, parent, previousSibling, nextSibling);
-            return vnode.push(firstChild, lastChild), vnode;
+            return new VNode(flags, parent, previousSibling, nextSibling, firstChild, lastChild, []);
         }
-        constructor(flags, parent, previousSibling, nextSibling) {
-            super(), this.push(flags, parent, previousSibling, nextSibling), build.isDev && (this.toString = vnode_toString);
+        constructor(flags, parent, previousSibling, nextSibling, ...rest) {
+            super(flags, parent, previousSibling, nextSibling, ...rest), build.isDev && (this.toString = vnode_toString);
         }
     };
     let _context;
@@ -3503,11 +3585,13 @@
         return returnValue;
     }
     const newInvokeContextFromTuple = ([element, event, url]) => {
-        const container = element.closest(QContainerSelector);
+        const domContainer = getDomContainer(element);
+        const container = domContainer.element;
+        const vNode = container ? vnode_locate(domContainer.rootVNode, element) : void 0;
         const locale = container?.getAttribute("q:locale") || void 0;
         return locale && function(locale) {
             _locale = locale;
-        }(locale), newInvokeContext(locale, void 0, element, event, url);
+        }(locale), newInvokeContext(locale, vNode, element, event, url);
     };
     const newInvokeContext = (locale, hostElement, element, event, url) => {
         const ctx = {
@@ -3529,7 +3613,7 @@
         const previousSubscriber = trackInvocation.$effectSubscriber$;
         const previousContainer = trackInvocation.$container$;
         try {
-            return trackInvocation.$effectSubscriber$ = [ subscriber, property ], data && trackInvocation.$effectSubscriber$.push(data), 
+            return trackInvocation.$effectSubscriber$ = getSubscriber(subscriber, property, data), 
             trackInvocation.$container$ = container, invoke(trackInvocation, fn);
         } finally {
             trackInvocation.$effectSubscriber$ = previousSubscriber, trackInvocation.$container$ = previousContainer;
@@ -3591,9 +3675,9 @@
         $storeProxyMap$=new WeakMap;
         $qFuncs$;
         $instanceHash$;
-        stateData;
+        vNodeLocate=id => vnode_locate(this.rootVNode, id);
+        $stateData$;
         $styleIds$=null;
-        $vnodeLocate$=id => vnode_locate(this.rootVNode, id);
         $renderCount$=0;
         constructor(element) {
             if (super((() => this.scheduleRender()), (() => vnode_applyJournal(this.$journal$)), {}, element.getAttribute("q:locale")), 
@@ -3603,7 +3687,7 @@
             this.$journal$ = [ VNodeJournalOpCode.HoistStyles, element.ownerDocument ], this.document = element.ownerDocument, 
             this.element = element, this.qBase = element.getAttribute("q:base"), this.$instanceHash$ = element.getAttribute("q:instance"), 
             this.qManifestHash = element.getAttribute("q:manifest-hash"), this.rootVNode = vnode_newUnMaterializedElement(this.element), 
-            this.$rawStateData$ = null, this.stateData = null;
+            this.$rawStateData$ = null, this.$stateData$ = null;
             const document = this.element.ownerDocument;
             document.qVNodeData || function(document) {
                 const vNodeDataMap = document.qVNodeData || (document.qVNodeData = new WeakMap);
@@ -3761,22 +3845,22 @@
                 };
                 const walker = document.createTreeWalker(document, 129);
                 walkContainer(walker, null, walker.firstChild(), null, "", null);
-            }(document), this.$rawStateData$ = [], this.stateData = [];
+            }(document), this.$rawStateData$ = [], this.$stateData$ = [];
             const qwikStates = element.querySelectorAll('script[type="qwik/state"]');
             if (0 !== qwikStates.length) {
                 this.$rawStateData$ = JSON.parse(qwikStates[qwikStates.length - 1].textContent), 
-                this.stateData = wrapDeserializerProxy(this, this.$rawStateData$);
+                this.$stateData$ = wrapDeserializerProxy(this, this.$rawStateData$);
             }
             this.$qFuncs$ = getQFuncs(document, this.$instanceHash$) || EMPTY_ARRAY;
         }
         $setRawState$(id, vParent) {
-            this.stateData[id] = vParent;
+            this.$stateData$[id] = vParent;
         }
         parseQRL(qrl) {
             return inflateQRL(this, parseQRL(qrl));
         }
         handleError(err, host) {
-            const errorStore = this.resolveContext(host, ERROR_CONTEXT);
+            const errorStore = host && this.resolveContext(host, ERROR_CONTEXT);
             if (!errorStore) {
                 throw err;
             }
@@ -3805,7 +3889,7 @@
                     if (null !== vnode_getProp(vNode, "q:renderFn", null)) {
                         return vNode;
                     }
-                    vNode = vnode_getParent(vNode) || vnode_getProp(vNode, ":", this.$vnodeLocate$);
+                    vNode = vnode_getParent(vNode) || vnode_getProp(vNode, "q:sparent", this.vNodeLocate);
                 } else {
                     vNode = vnode_getParent(vNode);
                 }
@@ -3823,7 +3907,7 @@
               case "q:props":
               case "q:renderFn":
               case "q:ctx":
-              case "q:subs":
+              case "q:brefs":
                 getObjectById = this.$getObjectById$;
                 break;
 
@@ -3835,7 +3919,10 @@
         }
         scheduleRender() {
             return this.$renderCount$++, this.renderDone ||= getPlatform().nextTick((() => this.processChores())), 
-            this.renderDone;
+            this.renderDone.finally((() => emitEvent("qrender", {
+                instanceHash: this.$instanceHash$,
+                renderCount: this.$renderCount$
+            })));
         }
         processChores() {
             let renderCount = this.$renderCount$;
@@ -3853,16 +3940,17 @@
         ensureProjectionResolved(vNode) {
             if (!(vNode[VNodeProps.flags] & VNodeFlags.Resolved)) {
                 vNode[VNodeProps.flags] |= VNodeFlags.Resolved;
-                for (let i = vnode_getPropStartIndex(vNode); i < vNode.length; i += 2) {
-                    if (isSlotProp(vNode[i])) {
-                        const value = vNode[i + 1];
-                        "string" == typeof value && (vNode[i + 1] = this.$vnodeLocate$(value));
+                const props = vnode_getProps(vNode);
+                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));
                     }
                 }
             }
         }
         $getObjectById$=id => ("string" == typeof id && (id = parseFloat(id)), assertTrue(), 
-        this.stateData[id]);
+        this.$stateData$[id]);
         getSyncFn(id) {
             const fn = this.$qFuncs$[id];
             return assertTrue(), fn;
@@ -3988,7 +4076,7 @@
             const task = target;
             const v = data;
             task.$qrl$ = inflateQRL(container, v[0]), task.$flags$ = v[1], task.$index$ = v[2], 
-            task.$el$ = v[3], task.$effectDependencies$ = v[4], task.$state$ = v[5];
+            task.$el$ = v[3], task[_EFFECT_BACK_REF] = v[4], task.$state$ = v[5];
             break;
 
           case TypeIds.Resource:
@@ -4006,11 +4094,9 @@
           case TypeIds.Store:
           case TypeIds.StoreArray:
             {
-                const [value, flags, effects, storeEffect] = data;
+                const [value, flags, effects] = data;
                 const store = getOrCreateStore(value, flags, container);
-                const storeHandler = getStoreHandler(store);
-                storeEffect && (effects[STORE_ARRAY_PROP] = storeEffect), storeHandler.$effects$ = effects, 
-                target = store;
+                getStoreHandler(store).$effects$ = effects, target = store;
                 break;
             }
 
@@ -4018,7 +4104,7 @@
             {
                 const signal = target;
                 const d = data;
-                signal.$untrackedValue$ = d[0], signal.$effects$ = d.slice(1);
+                signal.$untrackedValue$ = d[0], signal.$effects$ = new Set(d.slice(1));
                 break;
             }
 
@@ -4026,8 +4112,9 @@
             {
                 const signal = target;
                 const d = data;
-                signal.$func$ = container.getSyncFn(d[0]), signal.$args$ = d[1], signal.$effectDependencies$ = d[2], 
-                signal.$untrackedValue$ = d[3], signal.$hostElement$ = d[4], signal.$effects$ = d.slice(5);
+                signal.$func$ = container.getSyncFn(d[0]), signal.$args$ = d[1], signal[_EFFECT_BACK_REF] = d[2], 
+                signal.$untrackedValue$ = d[3], signal.$flags$ = d[4], signal.$hostElement$ = d[5], 
+                signal.$effects$ = new Set(d.slice(6));
                 break;
             }
 
@@ -4035,7 +4122,7 @@
             {
                 const computed = target;
                 const d = data;
-                computed.$computeQrl$ = d[0], computed.$effects$ = d[1], 3 === d.length ? computed.$untrackedValue$ = d[2] : (computed.$invalid$ = !0, 
+                computed.$computeQrl$ = d[0], computed.$effects$ = d[1], 3 === d.length ? computed.$untrackedValue$ = d[2] : (computed.$flags$ |= SignalFlags.INVALID, 
                 computed.$computeQrl$.resolve(), container.$scheduler$?.(ChoreType.QRL_RESOLVE, null, computed.$computeQrl$));
                 break;
             }
@@ -4130,7 +4217,7 @@
         }
         return target;
     };
-    const _constants = [ void 0, null, !0, !1, "", EMPTY_ARRAY, EMPTY_OBJ, NEEDS_COMPUTATION, Slot, Fragment, NaN, 1 / 0, -1 / 0, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER - 1, Number.MIN_SAFE_INTEGER ];
+    const _constants = [ void 0, null, !0, !1, "", EMPTY_ARRAY, EMPTY_OBJ, NEEDS_COMPUTATION, STORE_ALL_PROPS, Slot, Fragment, NaN, 1 / 0, -1 / 0, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER - 1, Number.MIN_SAFE_INTEGER ];
     const allocate = (container, typeId, value) => {
         if (void 0 === value) {
             return typeId;
@@ -4219,7 +4306,7 @@
             const promise = new Promise(((res, rej) => {
                 resolve = res, reject = rej;
             }));
-            return resolvers.set(promise, [ resolve, reject ]), promise;
+            return resolvers.set(promise, [ resolve, reject ]), promise.catch((() => {})), promise;
 
           case TypeIds.Uint8Array:
             const encodedLength = value.length;
@@ -4229,12 +4316,10 @@
           case TypeIds.PropsProxy:
             return createPropsProxy(null, null);
 
-          case TypeIds.RefVNode:
           case TypeIds.VNode:
-            const vnodeOrDocument = retrieveVNodeOrDocument(container, value);
-            if (typeId === TypeIds.VNode) {
-                return vnodeOrDocument;
-            }
+            return retrieveVNodeOrDocument(container, value);
+
+          case TypeIds.RefVNode:
             const vNode = retrieveVNodeOrDocument(container, value);
             if (vnode_isVNode(vNode)) {
                 return vnode_getNode(vNode);
@@ -4242,7 +4327,7 @@
             throw qError(QError.serializeErrorExpectedVNode, [ typeof vNode ]);
 
           case TypeIds.EffectData:
-            return new EffectPropData({});
+            return new SubscriptionData({});
 
           default:
             throw qError(QError.serializeErrorCannotAllocate, [ typeId ]);
@@ -4263,7 +4348,7 @@
             const backChannel = globalThis[QRL_RUNTIME_CHUNK];
             assertDefined(), qrlRef = backChannel.get(symbol);
         }
-        return createQRL(chunk, symbol, qrlRef, null, captureIds, null, null);
+        return createQRL(chunk, symbol, qrlRef, null, captureIds, null);
     }
     function inflateQRL(container, qrl) {
         const captureIds = qrl.$capture$;
@@ -4330,7 +4415,7 @@
                                 output(TypeIds.Constant, Constants.Slot);
                             } else if (value === Fragment) {
                                 output(TypeIds.Constant, Constants.Fragment);
-                            } else if (isQrl(value)) {
+                            } else if (isQrl$1(value)) {
                                 const qrl = qrlToString(serializationContext, value);
                                 const id = serializationContext.$addRoot$(qrl);
                                 output(TypeIds.QRL, id);
@@ -4356,11 +4441,13 @@
                             }
                         } else if (void 0 === value) {
                             output(TypeIds.Constant, Constants.Undefined);
+                        } else if (value === NEEDS_COMPUTATION) {
+                            output(TypeIds.Constant, Constants.NEEDS_COMPUTATION);
                         } else {
-                            if (value !== NEEDS_COMPUTATION) {
+                            if (value !== STORE_ALL_PROPS) {
                                 throw qError(QError.serializeErrorUnknownType, [ typeof value ]);
                             }
-                            output(TypeIds.Constant, Constants.NEEDS_COMPUTATION);
+                            output(TypeIds.Constant, Constants.STORE_ALL_PROPS);
                         }
                     };
                     const writeObjectValue = (value, idx) => {
@@ -4376,7 +4463,7 @@
                             const constProps = value[_CONST_PROPS];
                             const out = constProps ? [ varProps, constProps ] : Object.keys(varProps).length ? [ varProps ] : 0;
                             output(TypeIds.PropsProxy, out);
-                        } else if (value instanceof EffectPropData) {
+                        } else if (value instanceof SubscriptionData) {
                             output(TypeIds.EffectData, [ value.data.$scopedStyleIdPrefix$, value.data.$isConst$ ]);
                         } else if (isStore(value)) {
                             if (function(value) {
@@ -4393,7 +4480,6 @@
                                 const storeTarget = getStoreTarget(value);
                                 const flags = storeHandler.$flags$;
                                 const effects = storeHandler.$effects$;
-                                const storeEffect = effects?.[STORE_ARRAY_PROP] ?? null;
                                 const innerStores = [];
                                 for (const prop in storeTarget) {
                                     const propValue = storeTarget[prop];
@@ -4402,7 +4488,7 @@
                                         innerStores.push(innerStore), serializationContext.$addRoot$(innerStore);
                                     }
                                 }
-                                const out = [ storeTarget, flags, effects, storeEffect, ...innerStores ];
+                                const out = [ storeTarget, flags, effects, ...innerStores ];
                                 for (;null == out[out.length - 1]; ) {
                                     out.pop();
                                 }
@@ -4421,9 +4507,9 @@
                         } else if ($isDomRef$(value)) {
                             value.$ssrNode$.vnodeData[0] |= VNodeDataFlag.SERIALIZE, output(TypeIds.RefVNode, value.$ssrNode$.id);
                         } else if (value instanceof Signal) {
-                            const v = value instanceof ComputedSignal && (value.$invalid$ || fastSkipSerialize(value.$untrackedValue$)) ? NEEDS_COMPUTATION : value.$untrackedValue$;
+                            const v = value instanceof ComputedSignal && (value.$flags$ & SignalFlags.INVALID || fastSkipSerialize(value.$untrackedValue$)) ? NEEDS_COMPUTATION : value.$untrackedValue$;
                             if (value instanceof WrappedSignal) {
-                                output(TypeIds.WrappedSignal, [ ...serializeWrappingFn(serializationContext, value), value.$effectDependencies$, v, value.$hostElement$, ...value.$effects$ || [] ]);
+                                output(TypeIds.WrappedSignal, [ ...serializeWrappingFn(serializationContext, value), filterEffectBackRefs(value[_EFFECT_BACK_REF]), v, value.$flags$, value.$hostElement$, ...value.$effects$ || [] ]);
                             } else if (value instanceof ComputedSignal) {
                                 const out = [ value.$computeQrl$, value.$effects$ ];
                                 v !== NEEDS_COMPUTATION && out.push(v), output(TypeIds.ComputedSignal, out);
@@ -4471,7 +4557,7 @@
                         } else if (isJSXNode(value)) {
                             output(TypeIds.JSXNode, [ value.type, value.varProps, value.constProps, value.children, value.flags, value.key ]);
                         } else if (value instanceof Task) {
-                            const out = [ value.$qrl$, value.$flags$, value.$index$, value.$el$, value.$effectDependencies$, value.$state$ ];
+                            const out = [ value.$qrl$, value.$flags$, value.$index$, value.$el$, value[_EFFECT_BACK_REF], value.$state$ ];
                             for (;null == out[out.length - 1]; ) {
                                 out.pop();
                             }
@@ -4482,18 +4568,18 @@
                                 throw qError(QError.serializeErrorUnvisited, [ "promise" ]);
                             }
                             output(TypeIds.Promise, res);
+                        } else if (value instanceof Uint8Array) {
+                            let buf = "";
+                            for (const c of value) {
+                                buf += String.fromCharCode(c);
+                            }
+                            const out = btoa(buf).replace(/=+$/, "");
+                            output(TypeIds.Uint8Array, out);
                         } else {
-                            if (!(value instanceof Uint8Array)) {
+                            if (!vnode_isVNode(value)) {
                                 throw qError(QError.serializeErrorUnknownType, [ typeof value ]);
                             }
-                            {
-                                let buf = "";
-                                for (const c of value) {
-                                    buf += String.fromCharCode(c);
-                                }
-                                const out = btoa(buf).replace(/=+$/, "");
-                                output(TypeIds.Uint8Array, out);
-                            }
+                            output(TypeIds.Constant, Constants.Undefined);
                         }
                     };
                     writeValue(serializationContext.$roots$, -1);
@@ -4541,18 +4627,18 @@
                 const promises = [];
                 const visit = obj => {
                     if ("function" == typeof obj) {
-                        if (isQrl(obj)) {
+                        if (isQrl$1(obj)) {
                             obj.$captureRef$ && discoveredValues.push(...obj.$captureRef$);
                         } else if (isQwikComponent(obj)) {
                             const [qrl] = obj[SERIALIZABLE_STATE];
                             discoveredValues.push(qrl);
                         }
-                    } else if ("object" != typeof obj || null === obj || obj instanceof URL || obj instanceof Date || obj instanceof RegExp || obj instanceof Uint8Array || obj instanceof URLSearchParams || "undefined" != typeof FormData && obj instanceof FormData || fastSkipSerialize(obj)) {} else if (obj instanceof Error) {
+                    } else if ("object" != typeof obj || null === obj || obj instanceof URL || obj instanceof Date || obj instanceof RegExp || obj instanceof Uint8Array || obj instanceof URLSearchParams || vnode_isVNode(obj) || "undefined" != typeof FormData && obj instanceof FormData || fastSkipSerialize(obj)) {} else if (obj instanceof Error) {
                         discoveredValues.push(...Object.values(obj));
                     } else if (isStore(obj)) {
                         const target = getStoreTarget(obj);
                         const effects = getStoreHandler(obj).$effects$;
-                        discoveredValues.push(target, effects, effects?.[STORE_ARRAY_PROP] ?? null);
+                        discoveredValues.push(target, effects);
                         for (const prop in target) {
                             const propValue = target[prop];
                             storeProxyMap.has(propValue) && discoveredValues.push(prop, storeProxyMap.get(propValue));
@@ -4564,12 +4650,13 @@
                             discoveredValues.push(k, v);
                         }));
                     } else if (obj instanceof Signal) {
-                        const v = obj instanceof WrappedSignal ? obj.untrackedValue : obj instanceof ComputedSignal && (obj.$invalid$ || fastSkipSerialize(obj)) ? NEEDS_COMPUTATION : obj.$untrackedValue$;
-                        v !== NEEDS_COMPUTATION && discoveredValues.push(v), obj.$effects$ && discoveredValues.push(...obj.$effects$), 
-                        obj instanceof WrappedSignal ? (obj.$effectDependencies$ && discoveredValues.push(...obj.$effectDependencies$), 
-                        obj.$args$ && discoveredValues.push(...obj.$args$), obj.$hostElement$ && discoveredValues.push(obj.$hostElement$)) : obj instanceof ComputedSignal && discoveredValues.push(obj.$computeQrl$);
+                        const v = obj instanceof WrappedSignal ? obj.untrackedValue : obj instanceof ComputedSignal && (obj.$flags$ & SignalFlags.INVALID || fastSkipSerialize(obj)) ? NEEDS_COMPUTATION : obj.$untrackedValue$;
+                        v !== NEEDS_COMPUTATION && discoveredValues.push(v), obj.$effects$ && discoveredValues.push(obj.$effects$), 
+                        obj instanceof WrappedSignal ? (discoverEffectBackRefs(obj[_EFFECT_BACK_REF], discoveredValues), 
+                        obj.$args$ && discoveredValues.push(...obj.$args$), obj.$hostElement$ && discoveredValues.push(obj.$hostElement$)) : obj instanceof ComputedSignal && (discoverEffectBackRefs(obj[_EFFECT_BACK_REF], discoveredValues), 
+                        discoveredValues.push(obj.$computeQrl$));
                     } else if (obj instanceof Task) {
-                        discoveredValues.push(obj.$el$, obj.$qrl$, obj.$state$, obj.$effectDependencies$);
+                        discoveredValues.push(obj.$el$, obj.$qrl$, obj.$state$), discoverEffectBackRefs(obj[_EFFECT_BACK_REF], discoveredValues);
                     } else if (isSsrNode(obj)) {
                         if (discoverValuesForVNodeData(obj.vnodeData, discoveredValues), obj.childrenVNodeData && obj.childrenVNodeData.length) {
                             for (const data of obj.childrenVNodeData) {
@@ -4582,7 +4669,7 @@
                         discoveredValues.push(obj.type, obj.props, obj.constProps, obj.children);
                     } else if (Array.isArray(obj)) {
                         discoveredValues.push(...obj);
-                    } else if (isQrl(obj)) {
+                    } else if (isQrl$1(obj)) {
                         obj.$captureRef$ && obj.$captureRef$.length && discoveredValues.push(...obj.$captureRef$);
                     } else if (isPropsProxy(obj)) {
                         discoveredValues.push(obj[_VAR_PROPS], obj[_CONST_PROPS]);
@@ -4592,7 +4679,7 @@
                         }), (error => {
                             promiseResults.set(obj, [ !1, error ]), discoveredValues.push(error);
                         })), promises.push(obj);
-                    } else if (obj instanceof EffectPropData) {
+                    } else if (obj instanceof SubscriptionData) {
                         discoveredValues.push(obj.data);
                     } else {
                         if (!isObjectLiteral(obj)) {
@@ -4633,15 +4720,26 @@
         for (const value of vnodeData) {
             if (isSsrAttrs(value)) {
                 for (let i = 1; i < value.length; i += 2) {
-                    if ("q:key" === value[i - 1]) {
-                        continue;
-                    }
-                    discoveredValues.push(value[i]);
+                    const attrValue = value[i];
+                    "string" != typeof attrValue && discoveredValues.push(attrValue);
                 }
             }
         }
     };
+    const discoverEffectBackRefs = (effectsBackRefs, discoveredValues) => {
+        effectsBackRefs && discoveredValues.push(effectsBackRefs);
+    };
     const promiseResults = new WeakMap;
+    function filterEffectBackRefs(effectBackRef) {
+        let effectBackRefToSerialize = null;
+        if (effectBackRef) {
+            for (const [effectProp, effect] of effectBackRef) {
+                effect[EffectSubscriptionProp.BACK_REF] && (effectBackRefToSerialize ||= new Map, 
+                effectBackRefToSerialize.set(effectProp, effect));
+            }
+        }
+        return effectBackRefToSerialize;
+    }
     function serializeWrappingFn(serializationContext, value) {
         value.$funcStr$ && "{" === value.$funcStr$[0] && (value.$funcStr$ = `(${value.$funcStr$})`);
         return [ serializationContext.$addSyncFn$(value.$funcStr$, value.$args$.length, value.$func$), value.$args$ ];
@@ -4649,13 +4747,13 @@
     function qrlToString(serializationContext, value) {
         let symbol = value.$symbol$;
         let chunk = value.$chunk$;
-        const refSymbol = value.$refSymbol$ ?? symbol;
         const platform = getPlatform();
         if (platform) {
-            const result = platform.chunkForSymbol(refSymbol, chunk, value.dev?.file);
-            result && (chunk = result[1], value.$refSymbol$ || (symbol = result[0]));
+            const result = platform.chunkForSymbol(symbol, chunk, value.dev?.file);
+            result && (chunk = result[1], symbol = result[0]);
         }
-        if (isSyncQrl(value)) {
+        const isSync = (value => isQrl$1(value) && "<sync>" == value.$symbol$)(value);
+        if (isSync) {
             chunk = "", symbol = String(serializationContext.$addSyncFn$(null, 0, value.resolved));
         } else {
             chunk || (chunk = serializationContext.$symbolToChunkResolver$(value.$hash$));
@@ -4709,16 +4807,20 @@
         const prototype = Object.getPrototypeOf(obj);
         return null == prototype || prototype === Object.prototype || prototype === Array.prototype;
     }
-    const frameworkType = obj => "object" == typeof obj && null !== obj && (obj instanceof Signal || obj instanceof Task || isJSXNode(obj)) || isQrl(obj);
-    const canSerialize = value => {
+    const frameworkType = obj => "object" == typeof obj && null !== obj && (obj instanceof Signal || obj instanceof Task || isJSXNode(obj)) || isQrl$1(obj);
+    const canSerialize = (value, seen = new WeakSet) => {
         if (null == value || "string" == typeof value || "number" == typeof value || "boolean" == typeof value || "bigint" == typeof value) {
             return !0;
         }
         if ("object" == typeof value) {
+            if (seen.has(value)) {
+                return !0;
+            }
+            seen.add(value);
             const proto = Object.getPrototypeOf(value);
             if (isStore(value) && (value = getStoreTarget(value)), proto == Object.prototype) {
                 for (const key in value) {
-                    if (!canSerialize(untrack((() => value[key])))) {
+                    if (!canSerialize(untrack((() => value[key])), seen)) {
                         return !1;
                     }
                 }
@@ -4726,7 +4828,7 @@
             }
             if (proto == Array.prototype) {
                 for (let i = 0; i < value.length; i++) {
-                    if (!canSerialize(value[i])) {
+                    if (!canSerialize(value[i], seen)) {
                         return !1;
                     }
                 }
@@ -4774,7 +4876,7 @@
             if (isDomRef?.(value)) {
                 return !0;
             }
-        } else if ("function" == typeof value && (isQrl(value) || isQwikComponent(value))) {
+        } else if ("function" == typeof value && (isQrl$1(value) || isQwikComponent(value))) {
             return !0;
         }
         return !1;
@@ -4802,13 +4904,14 @@
         Constants[Constants.True = 2] = "True", Constants[Constants.False = 3] = "False", 
         Constants[Constants.EmptyString = 4] = "EmptyString", Constants[Constants.EMPTY_ARRAY = 5] = "EMPTY_ARRAY", 
         Constants[Constants.EMPTY_OBJ = 6] = "EMPTY_OBJ", Constants[Constants.NEEDS_COMPUTATION = 7] = "NEEDS_COMPUTATION", 
-        Constants[Constants.Slot = 8] = "Slot", Constants[Constants.Fragment = 9] = "Fragment", 
-        Constants[Constants.NaN = 10] = "NaN", Constants[Constants.PositiveInfinity = 11] = "PositiveInfinity", 
-        Constants[Constants.NegativeInfinity = 12] = "NegativeInfinity", Constants[Constants.MaxSafeInt = 13] = "MaxSafeInt", 
-        Constants[Constants.AlmostMaxSafeInt = 14] = "AlmostMaxSafeInt", Constants[Constants.MinSafeInt = 15] = "MinSafeInt";
+        Constants[Constants.STORE_ALL_PROPS = 8] = "STORE_ALL_PROPS", Constants[Constants.Slot = 9] = "Slot", 
+        Constants[Constants.Fragment = 10] = "Fragment", Constants[Constants.NaN = 11] = "NaN", 
+        Constants[Constants.PositiveInfinity = 12] = "PositiveInfinity", Constants[Constants.NegativeInfinity = 13] = "NegativeInfinity", 
+        Constants[Constants.MaxSafeInt = 14] = "MaxSafeInt", Constants[Constants.AlmostMaxSafeInt = 15] = "AlmostMaxSafeInt", 
+        Constants[Constants.MinSafeInt = 16] = "MinSafeInt";
     }(Constants || (Constants = {}));
     const verifySerializable = (value, preMessage) => {
-        const seen = new Set;
+        const seen = new WeakSet;
         return _verifySerializable(value, seen, "_", preMessage);
     };
     const _verifySerializable = (value, seen, ctx, preMessage) => {
@@ -4817,10 +4920,13 @@
             return value;
         }
         if (shouldSerialize(unwrapped)) {
-            if (seen.has(unwrapped)) {
-                return value;
+            if ("object" == typeof unwrapped) {
+                if (seen.has(unwrapped)) {
+                    return value;
+                }
+                seen.add(unwrapped);
             }
-            if (seen.add(unwrapped), isSignal(unwrapped)) {
+            if (isSignal(unwrapped)) {
                 return value;
             }
             if (canSerialize(unwrapped)) {
@@ -4874,9 +4980,7 @@
     const shouldSerialize = obj => !isObject(obj) && !isFunction(obj) || !noSerializeSet.has(obj);
     const fastSkipSerialize = obj => noSerializeSet.has(obj);
     const noSerialize = input => (null != input && noSerializeSet.add(input), input);
-    const isQrl = value => "function" == typeof value && "function" == typeof value.getSymbol;
-    const isSyncQrl = value => isQrl(value) && "<sync>" == value.$symbol$;
-    const createQRL = (chunk, symbol, symbolRef, symbolFn, capture, captureRef, refSymbol) => {
+    const createQRL = (chunk, symbol, symbolRef, symbolFn, capture, captureRef) => {
         let _containerEl;
         const qrl = async function(...args) {
             const boundedFn = bindFnToContext.call(this, tryGetInvokeContext());
@@ -4884,9 +4988,14 @@
         };
         const setContainer = el => (_containerEl || (_containerEl = el), _containerEl);
         function bindFnToContext(currentCtx, beforeFn) {
-            return (...args) => maybeThen(resolveLazy(), (fn => {
-                if (!isFunction(fn)) {
-                    throw qError(QError.qrlIsNotFunction);
+            const bound = (...args) => {
+                if (!qrl.resolved) {
+                    return qrl.resolve().then((fn => {
+                        if (!isFunction(fn)) {
+                            throw qError(QError.qrlIsNotFunction);
+                        }
+                        return bound(...args);
+                    }));
                 }
                 if (beforeFn && !1 === beforeFn()) {
                     return;
@@ -4896,17 +5005,29 @@
                 const prevEvent = context.$event$;
                 context.$qrl$ = qrl, context.$event$ ||= this;
                 try {
-                    return invoke.call(this, context, fn, ...args);
+                    return invoke.call(this, context, symbolRef, ...args);
                 } finally {
                     context.$qrl$ = prevQrl, context.$event$ = prevEvent;
                 }
-            }));
+            };
+            return bound;
         }
-        const resolveLazy = containerEl => null !== symbolRef ? symbolRef : resolve(containerEl);
         const wrapFn = fn => "function" != typeof fn || !capture?.length && !captureRef?.length ? fn : function(...args) {
             let context = tryGetInvokeContext();
-            return context ? fn.apply(this, args) : (context = newInvokeContext(), context.$qrl$ = qrl, 
-            context.$event$ = this, invoke.call(this, context, fn, ...args));
+            if (context) {
+                if (context.$qrl$?.$symbol$ === qrl.$symbol$) {
+                    return fn.apply(this, args);
+                }
+                const prevQrl = context.$qrl$;
+                context.$qrl$ = qrl;
+                try {
+                    return fn.apply(this, args);
+                } finally {
+                    context.$qrl$ = prevQrl;
+                }
+            }
+            return context = newInvokeContext(), context.$qrl$ = qrl, context.$event$ = this, 
+            invoke.call(this, context, fn, ...args);
         };
         const resolve = async containerEl => {
             if (null !== symbolRef) {
@@ -4921,46 +5042,37 @@
             const start = now();
             const ctx = tryGetInvokeContext();
             if (null !== symbolFn) {
-                symbolRef = symbolFn().then((module => qrl.resolved = symbolRef = wrapFn(module[symbol])));
+                symbolRef = symbolFn().then((module => qrl.resolved = wrapFn(symbolRef = module[symbol])));
             } else {
                 const imported = getPlatform().importSymbol(_containerEl, chunk, symbol);
-                symbolRef = maybeThen(imported, (ref => qrl.resolved = symbolRef = wrapFn(ref)));
+                symbolRef = maybeThen(imported, (ref => qrl.resolved = wrapFn(symbolRef = ref)));
             }
             return "object" == typeof symbolRef && isPromise(symbolRef) && symbolRef.then((() => emitUsedSymbol(symbol, ctx?.$element$, start)), (err => {
                 throw console.error(`qrl ${symbol} failed to load`, err), symbolRef = null, err;
             })), symbolRef;
         };
         const createOrReuseInvocationContext = invoke => null == invoke ? newInvokeContext() : isArray(invoke) ? newInvokeContextFromTuple(invoke) : invoke;
-        const resolvedSymbol = refSymbol ?? symbol;
-        const hash = getSymbolHash(resolvedSymbol);
+        const hash = getSymbolHash(symbol);
         return Object.assign(qrl, {
-            getSymbol: () => resolvedSymbol,
+            getSymbol: () => symbol,
             getHash: () => hash,
             getCaptured: () => captureRef,
             resolve,
-            $resolveLazy$: resolveLazy,
+            $resolveLazy$: containerEl => null !== symbolRef ? symbolRef : resolve(containerEl),
             $setContainer$: setContainer,
             $chunk$: chunk,
             $symbol$: symbol,
-            $refSymbol$: refSymbol,
             $hash$: hash,
             getFn: bindFnToContext,
             $capture$: capture,
             $captureRef$: captureRef,
             dev: null,
             resolved: void 0
-        }), symbolRef && (symbolRef = maybeThen(symbolRef, (resolved => qrl.resolved = symbolRef = wrapFn(resolved)))), 
+        }), symbolRef && (symbolRef = maybeThen(symbolRef, (resolved => qrl.resolved = wrapFn(symbolRef = resolved)))), 
         build.isDev && Object.defineProperty(qrl, "_devOnlySymbolRef", {
             get: () => symbolRef
         }), qrl;
     };
-    const getSymbolHash = symbolName => {
-        const index = symbolName.lastIndexOf("_");
-        return index > -1 ? symbolName.slice(index + 1) : symbolName;
-    };
-    function assertQrl() {
-        qDev;
-    }
     const EMITTED = /*#__PURE__*/ new Set;
     const emitUsedSymbol = (symbol, element, reqTime) => {
         EMITTED.has(symbol) || (EMITTED.add(symbol), emitEvent("qsymbol", {
@@ -4977,12 +5089,12 @@
     };
     const now = () => isServerPlatform() ? 0 : "object" == typeof performance ? performance.now() : 0;
     let runtimeSymbolId = 0;
-    const $ = expression => createQRL(null, "s" + runtimeSymbolId++, expression, null, null, null, null);
+    const $ = expression => createQRL(null, "s" + runtimeSymbolId++, expression, null, null, null);
     const dollar = $;
     const eventQrl = qrl => qrl;
     const componentQrl = componentQrl => {
         function QwikComponent(props, key, flags = 0) {
-            assertQrl();
+            assertQrl(componentQrl);
             const finalKey = componentQrl.$hash$.slice(0, 4) + ":" + (key || "");
             const InnerCmp = () => {};
             return InnerCmp[SERIALIZABLE_STATE] = [ componentQrl ], _jsxSplit(InnerCmp, props, null, props.children, flags, finalKey);
@@ -5062,7 +5174,7 @@
             out.push(css.substring(lastIdx, idx)), lastIdx = idx;
         }
         function insertScopingSelector(idx) {
-            mode === pseudoGlobal || shouldNotInsertScoping() || (flush(idx), out.push(".", "⭐️", scopeId));
+            mode === pseudoGlobal || shouldNotInsertScoping() || (flush(idx), out.push(".", "⚡️", scopeId));
         }
         function lookAhead(arc) {
             let prefix = 0;
@@ -5132,16 +5244,16 @@
     });
     const useStyles$ = /*#__PURE__*/ implicit$FirstArg(useStylesQrl);
     const useStylesScopedQrl = styles => ({
-        scopeId: "⭐️" + _useStyles(styles, getScopedStyles, !0)
+        scopeId: "⚡️" + _useStyles(styles, getScopedStyles, !0)
     });
     const useStylesScoped$ = /*#__PURE__*/ implicit$FirstArg(useStylesScopedQrl);
     const _useStyles = (styleQrl, transform, scoped) => {
-        assertQrl();
+        assertQrl(styleQrl);
         const {val, set, iCtx, i} = useSequentialScope();
         if (val) {
             return val;
         }
-        const styleId = (qStyles = styleQrl, index = i, assertQrl(), `${hashCode(qStyles.$hash$)}-${index}`);
+        const styleId = (index = i, assertQrl(qStyles = styleQrl), `${hashCode(qStyles.$hash$)}-${index}`);
         var qStyles, index;
         const host = iCtx.$hostElement$;
         set(styleId);
@@ -5162,7 +5274,7 @@
         if (val) {
             return val;
         }
-        assertQrl();
+        assertQrl(qrl);
         const signal = new ComputedSignal(null, qrl);
         return set(signal), throwIfQRLNotResolved(qrl), signal;
     };
@@ -5172,11 +5284,15 @@
         if (val) {
             return void (isServerPlatform() && useRunTask(val, eagerness));
         }
-        assertQrl();
+        assertQrl(qrl);
         const task = new Task(TaskFlags.VISIBLE_TASK, i, iCtx.$hostElement$, qrl, void 0, null);
         set(task), useRunTask(task, eagerness), isServerPlatform() || (qrl.$resolveLazy$(iCtx.$element$), 
         iCtx.$container$.$scheduler$(ChoreType.VISIBLE, 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));
+    };
+    const getTaskHandlerQrl = task => createQRL(null, "_task", scheduleTask, null, null, [ task ]);
     const useTask$ = /*#__PURE__*/ implicit$FirstArg(useTaskQrl);
     const useVisibleTask$ = /*#__PURE__*/ implicit$FirstArg(useVisibleTaskQrl);
     const useComputed$ = implicit$FirstArg(useComputedQrl);
@@ -5250,7 +5366,7 @@
         return _jsxSorted("script", null, props, null, 0, "prefetch-service-worker");
     }, exports.RenderOnce = RenderOnce, exports.Resource = props => _jsxSorted(Fragment, null, null, function(props) {
         const resource = props.value;
-        if (isResourceReturn(resource)) {
+        if (isResourceReturn(resource) && resource.value) {
             if (!isServerPlatform()) {
                 const state = resource._state;
                 if ("pending" === state && props.onPending) {
@@ -5275,9 +5391,9 @@
     }), props.children, jsx(SSRComment, {
         data: "qkssr-po"
     }) ], exports.SkipRender = SkipRender, exports.Slot = Slot, exports._CONST_PROPS = _CONST_PROPS, 
-    exports._DomContainer = DomContainer, exports._EMPTY_ARRAY = EMPTY_ARRAY, exports._EffectData = EffectPropData, 
-    exports._IMMUTABLE = _IMMUTABLE, exports._SharedContainer = _SharedContainer, exports._VAR_PROPS = _VAR_PROPS, 
-    exports._deserialize = function(rawStateData, element) {
+    exports._DomContainer = DomContainer, exports._EFFECT_BACK_REF = _EFFECT_BACK_REF, 
+    exports._EMPTY_ARRAY = EMPTY_ARRAY, exports._EffectData = SubscriptionData, exports._IMMUTABLE = _IMMUTABLE, 
+    exports._SharedContainer = _SharedContainer, exports._VAR_PROPS = _VAR_PROPS, exports._deserialize = function(rawStateData, element) {
         if (null == rawStateData) {
             return [];
         }
@@ -5298,7 +5414,7 @@
         if (iCtx) {
             const hostElement = iCtx.$hostElement$;
             let element = null;
-            return vnode_isVNode(hostElement) && vnode_isElementVNode(hostElement) && (element = vnode_getNode(hostElement)), 
+            return null != hostElement && (vnode_isVNode(hostElement) ? vnode_isElementVNode(hostElement) && (element = vnode_getNode(hostElement)) : element = hostElement), 
             element ?? iCtx.$qrl$?.$setContainer$(void 0);
         }
     }, exports._getContextEvent = () => {
@@ -5307,7 +5423,7 @@
             return iCtx.$event$;
         }
     }, exports._getDomContainer = getDomContainer, exports._getQContainerElement = _getQContainerElement, 
-    exports._hW = _hW, exports._isJSXNode = isJSXNode, exports._isStringifiable = function(value) {
+    exports._isJSXNode = isJSXNode, exports._isStringifiable = function(value) {
         return null === value || "string" == typeof value || "number" == typeof value || "boolean" == typeof value;
     }, exports._jsxBranch = input => input, exports._jsxC = (type, mutable, _flags, key) => jsx(type, mutable, key), 
     exports._jsxQ = (type, mutable, immutable, children, _flags, key) => jsx(type, {
@@ -5323,21 +5439,31 @@
         return newQrl.dev = opts, newQrl;
     }, exports._qrlSync = function(fn, serializedFn) {
         return void 0 === serializedFn && (serializedFn = fn.toString()), fn.serialized = serializedFn, 
-        createQRL("", "<sync>", fn, null, null, null, null);
+        createQRL("", "<sync>", fn, null, null, null);
     }, exports._regSymbol = (symbol, hash) => (void 0 === globalThis.__qwik_reg_symbols && (globalThis.__qwik_reg_symbols = new Map), 
     globalThis.__qwik_reg_symbols.set(hash, symbol), symbol), exports._restProps = (props, omit, target = {}) => {
-        for (const key in props) {
-            omit.includes(key) || (target[key] = props[key]);
+        let constPropsTarget = null;
+        const constProps = props[_CONST_PROPS];
+        if (constProps) {
+            for (const key in constProps) {
+                omit.includes(key) || (constPropsTarget ||= {}, constPropsTarget[key] = constProps[key]);
+            }
         }
-        return target;
-    }, exports._serialize = async function(data) {
+        const varPropsTarget = target;
+        const varProps = props[_VAR_PROPS];
+        for (const key in varProps) {
+            omit.includes(key) || (varPropsTarget[key] = varProps[key]);
+        }
+        return createPropsProxy(varPropsTarget, constPropsTarget);
+    }, exports._run = queueQRL, exports._serialize = async function(data) {
         const serializationContext = createSerializationContext(null, null, (() => ""), (() => ""), (() => {}), new WeakMap);
         for (const root of data) {
             serializationContext.$addRoot$(root);
         }
         return await serializationContext.$breakCircularDepsAndAwaitPromises$(), serializationContext.$serialize$(), 
         serializationContext.$writer$.toString();
-    }, exports._verifySerializable = verifySerializable, exports._waitUntilRendered = elm => {
+    }, exports._task = scheduleTask, exports._verifySerializable = verifySerializable, 
+    exports._waitUntilRendered = elm => {
         const containerEl = _getQContainerElement(elm);
         if (!containerEl) {
             return Promise.resolve();
@@ -5348,6 +5474,9 @@
     input), exports._wrapProp = _wrapProp, exports._wrapSignal = (obj, prop) => {
         const r = _wrapProp(obj, prop);
         return r === _IMMUTABLE ? obj[prop] : r;
+    }, exports._wrapStore = (obj, prop) => {
+        const value = getStoreTarget(obj)[prop];
+        return isSignal(value) ? value : new WrappedSignal(null, getProp, [ obj, prop ], null, SignalFlags.INVALID);
     }, exports.component$ = onMount => componentQrl(dollar(onMount)), exports.componentQrl = componentQrl, 
     exports.createComputed$ = createComputed$, exports.createComputedQrl = createComputedQrl, 
     exports.createContextId = createContextId, exports.createElement = h, exports.createSignal = createSignal, 
@@ -5401,7 +5530,7 @@
                 cleanup(container, container.rootVNode);
             }
         };
-    }, exports.setPlatform = plt => _platform = plt, exports.sync$ = fn => createQRL("", "<sync>", fn, null, null, null, null), 
+    }, exports.setPlatform = plt => _platform = plt, exports.sync$ = fn => createQRL("", "<sync>", fn, null, null, null), 
     exports.untrack = untrack, exports.unwrapStore = unwrapStore, exports.useComputed$ = useComputed$, 
     exports.useComputedQrl = useComputedQrl, exports.useConstant = useConstant, exports.useContext = (context, defaultValue) => {
         const {val, set, iCtx} = useSequentialScope();