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

package/dist/core.prod.mjs

@@ -1,11 +1,11 @@
 /**
  * @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
  */
-import { isServer, isDev } from "@qwik.dev/core/build";
+import { isDev, isServer } from "@qwik.dev/core/build";
 
 export { isBrowser, isDev, isServer } from "@qwik.dev/core/build";
 
@@ -80,8 +80,8 @@ const codeToText = code => `Code(Q${code}) https://github.com/QwikDev/qwik/blob/
 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", 
@@ -106,7 +106,7 @@ var QError;
     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 = []) => {
@@ -114,6 +114,23 @@ const qError = (code, errorMessageArgs = []) => {
     return logErrorAndStop(text, ...errorMessageArgs);
 };
 
+const SYNC_QRL = "<sync>";
+
+const isSyncQrl = value => isQrl$1(value) && "<sync>" == value.$symbol$;
+
+const isQrl$1 = value => "function" == typeof value && "function" == typeof value.getSymbol;
+
+function assertQrl(qrl) {
+    if (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;
+};
+
 const DEBUG_TYPE = "q:type";
 
 var VirtualType;
@@ -147,13 +164,11 @@ var QContainerValue;
 
 const OnRenderProp = "q:renderFn";
 
-const ComponentStylesPrefixContent = "⭐️";
+const ComponentStylesPrefixContent = "⚡️";
 
 const QSlot = "q:slot";
 
-const QSlotParent = ":";
-
-const QSlotRef = "q:sref";
+const QSlotParent = "q:sparent";
 
 const QSlotS = "q:s";
 
@@ -169,7 +184,7 @@ const QScopedStyle = "q:sstyle";
 
 const QCtxAttr = "q:ctx";
 
-const QSubscribers = "q:subs";
+const QBackRefs = "q:brefs";
 
 const QFuncsPrefix = "qFuncs_";
 
@@ -314,8 +329,6 @@ const safeCall = (call, thenFn, rejectFn) => {
 
 const maybeThen = (valueOrPromise, thenFn) => isPromise(valueOrPromise) ? valueOrPromise.then(thenFn, shouldNotError) : thenFn(valueOrPromise);
 
-const maybeThenPassError = (valueOrPromise, thenFn) => isPromise(valueOrPromise) ? valueOrPromise.then(thenFn) : thenFn(valueOrPromise);
-
 const shouldNotError = reason => {
     throwErrorAndStop(reason);
 };
@@ -389,7 +402,7 @@ function setLocale(locale) {
     VNodeDataFlag[VNodeDataFlag.REFERENCE = 8] = "REFERENCE", VNodeDataFlag[VNodeDataFlag.SERIALIZE = 16] = "SERIALIZE";
 }(VNodeDataFlag || (VNodeDataFlag = {}));
 
-const isQrl$1 = value => "function" == typeof value && "function" == typeof value.getSymbol;
+const isQrl = value => "function" == typeof value && "function" == typeof value.getSymbol;
 
 const EMPTY_ARRAY = [];
 
@@ -434,14 +447,14 @@ const qrl = (chunkOrFn, symbol, lexicalScopeCapture = EMPTY_ARRAY, stackOffset =
         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, null);
+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, null);
+const _noopQrl = (symbolName, lexicalScopeCapture = EMPTY_ARRAY) => createQRL(null, symbolName, null, null, null, lexicalScopeCapture);
 
 const _noopQrlDEV = (symbolName, opts, lexicalScopeCapture = EMPTY_ARRAY) => {
     const newQrl = _noopQrl(symbolName, lexicalScopeCapture);
@@ -461,6 +474,43 @@ const inlinedQrlDEV = (symbol, symbolName, opts, lexicalScopeCapture = EMPTY_ARR
 const _regSymbol = (symbol, hash) => (void 0 === globalThis.__qwik_reg_symbols && (globalThis.__qwik_reg_symbols = new Map), 
 globalThis.__qwik_reg_symbols.set(hash, symbol), symbol);
 
+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(qrl.$captureRef$, "invoke: qrl $captureRef$ must be defined inside useLexicalScope()", qrl);
+    } else {
+        const el = context.$element$;
+        assertDefined(el, "invoke: element must be defined inside useLexicalScope()", context);
+        const containerElement = _getQContainerElement(el);
+        assertDefined(containerElement, "invoke: cant find parent q:container of", el);
+        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 Slot = props => _jsxSorted(Virtual, null, {
     [QSlotS]: ""
 }, props.children, 0, props.name ?? "");
@@ -539,6 +589,47 @@ 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;
+}
+
+function convertScopedStyleIdsToArray(scopedStyleIds) {
+    return scopedStyleIds?.split(" ") ?? null;
+}
+
+function convertStyleIdsToString(scopedStyleIds) {
+    return Array.from(scopedStyleIds).join(" ");
+}
+
+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 isUnitlessNumber = name => unitlessNumbers.has(name);
@@ -619,44 +710,11 @@ function isAriaAttribute(prop) {
 
 const styleKey = (qStyles, index) => (assertQrl(qStyles), `${hashCode(qStyles.$hash$)}-${index}`);
 
-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;
-}
-
-function convertScopedStyleIdsToArray(scopedStyleIds) {
-    return scopedStyleIds?.split(" ") ?? null;
-}
-
-function convertStyleIdsToString(scopedStyleIds) {
-    return Array.from(scopedStyleIds).join(" ");
-}
-
-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;
 
@@ -712,7 +770,7 @@ class StoreHandler {
                 assertTrue(!ctx.$container$ || ctx.$container$ === this.$container$, "Do not use signals across containers");
             }
             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;
@@ -743,7 +801,7 @@ class StoreHandler {
             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);
@@ -751,22 +809,23 @@ class StoreHandler {
     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) {
@@ -774,259 +833,215 @@ function setNewValueAndTriggerEffects(prop, value, target, currentStore) {
 }
 
 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 useSequentialScope = () => {
-    const iCtx = useInvokeContext();
-    const host = iCtx.$hostElement$;
-    let seq = iCtx.$container$.getHostProp(host, "q:seq");
-    null === seq && (seq = [], iCtx.$container$.setHostProp(host, "q:seq", seq));
-    let seqIdx = iCtx.$container$.getHostProp(host, "q:seqIdx");
-    for (null === seqIdx && (seqIdx = 0), iCtx.$container$.setHostProp(host, "q:seqIdx", seqIdx + 1); seq.length <= seqIdx; ) {
-        seq.push(void 0);
-    }
-    return {
-        val: seq[seqIdx],
-        set: value => seq[seqIdx] = value,
-        i: seqIdx,
-        iCtx
-    };
-};
+const NEEDS_COMPUTATION = Symbol("invalid");
 
-class Subscriber {
-    $effectDependencies$=null;
-}
+const _EFFECT_BACK_REF = Symbol("backRef");
 
-function isSubscriber(value) {
-    return value instanceof Subscriber || value instanceof WrappedSignal;
+class BackRef {
+    [_EFFECT_BACK_REF]=null;
 }
 
-function clearVNodeEffectDependencies(container, value) {
-    vnode_isElementVNode(value) && ensureMaterialized(value);
-    const effects = vnode_getProp(value, "q:subs", container.$getObjectById$);
+function clearAllEffects(container, consumer) {
+    vnode_isVNode(consumer) && vnode_isElementVNode(consumer) && ensureMaterialized(consumer);
+    const effects = consumer[_EFFECT_BACK_REF];
     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);
+        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);
+                }
+            }
         }
-        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 clearSignal(container, producer, effect) {
+    const effects = producer.$effects$;
+    effects && effects.delete(effect), producer instanceof WrappedSignal && (producer.$hostElement$ = null, 
+    clearAllEffects(container, producer));
 }
 
-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);
+function clearStore(producer, effect) {
+    const effects = producer?.$effects$;
+    if (effects) {
+        for (const propEffects of effects.values()) {
+            propEffects.delete(effect);
         }
     }
-    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;
-}
+const implicit$FirstArg = fn => function(first, ...rest) {
+    return fn.call(null, dollar(first), ...rest);
+};
 
-function clearArgsEffects(args, subscriber, seenSet) {
-    for (let i = args.length - 1; i >= 0; i--) {
-        clearArgEffect(args[i], subscriber, seenSet);
-    }
-}
+const createSignal$1 = value => new Signal(null, value);
 
-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);
-        }
-    }
-}
+const createComputedSignal = qrl => (throwIfQRLNotResolved(qrl), new ComputedSignal(null, qrl));
 
-const useResourceQrl = (qrl, opts) => {
-    const {val, set, i, iCtx} = useSequentialScope();
-    if (null != val) {
-        return val;
+const createSignal = createSignal$1;
+
+const createComputedQrl = createComputedSignal;
+
+const createComputed$ = /*#__PURE__*/ implicit$FirstArg(createComputedQrl);
+
+const useSequentialScope = () => {
+    const iCtx = useInvokeContext();
+    const host = iCtx.$hostElement$;
+    let seq = iCtx.$container$.getHostProp(host, "q:seq");
+    null === seq && (seq = [], iCtx.$container$.setHostProp(host, "q:seq", seq));
+    let seqIdx = iCtx.$container$.getHostProp(host, "q:seqIdx");
+    for (null === seqIdx && (seqIdx = 0), iCtx.$container$.setHostProp(host, "q:seqIdx", seqIdx + 1); seq.length <= seqIdx; ) {
+        seq.push(void 0);
     }
-    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;
+    return {
+        val: seq[seqIdx],
+        set: value => seq[seqIdx] = value,
+        i: seqIdx,
+        iCtx
+    };
 };
 
-const Resource = props => _jsxSorted(Fragment, null, null, getResourceValueAsPromise(props), 0, null);
+function getSubscriber(effect, prop, data) {
+    effect[_EFFECT_BACK_REF] || (isServer && isSsrNode(effect) ? effect.setProp("q:brefs", new Map) : effect[_EFFECT_BACK_REF] = new Map);
+    const subMap = effect[_EFFECT_BACK_REF];
+    let sub = subMap.get(prop);
+    return sub || (sub = [ effect, prop ], subMap.set(prop, sub)), data && (sub[EffectSubscriptionProp.DATA] = data), 
+    sub;
+}
 
-function getResourceValueAsPromise(props) {
-    const resource = props.value;
-    if (isResourceReturn(resource)) {
-        if (!isServerPlatform()) {
-            const state = resource._state;
-            if ("pending" === state && props.onPending) {
-                return Promise.resolve().then(useBindInvokeContext(props.onPending));
-            }
-            if ("rejected" === state && props.onRejected) {
-                return Promise.resolve(resource._error).then(useBindInvokeContext(props.onRejected));
-            }
-            {
-                const resolvedValue = untrack((() => resource._resolved));
-                if (void 0 !== resolvedValue) {
-                    return Promise.resolve(resolvedValue).then(useBindInvokeContext(props.onResolved));
-                }
-            }
-        }
-        return resource.value.then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
-    }
-    return isPromise(resource) ? resource.then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected)) : isSignal(resource) ? Promise.resolve(resource.value).then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected)) : Promise.resolve(resource).then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
+function isSsrNode(value) {
+    return "__brand__" in value && "currentComponentNode" in value;
 }
 
-const _createResourceReturn = opts => ({
-    __brand: "resource",
-    value: void 0,
-    loading: !isServerPlatform(),
-    _resolved: void 0,
-    _error: void 0,
-    _state: "pending",
-    _timeout: opts?.timeout ?? -1,
-    _cache: 0
-});
+var TaskFlags;
 
-const createResourceReturn = (container, opts, initialPromise) => {
-    const result = _createResourceReturn(opts);
-    return result.value = initialPromise, createStore(container, result, StoreFlags.RECURSIVE);
-};
+!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 isResourceReturn = obj => isObject(obj) && "resource" === (getStoreTarget(obj) || obj).__brand;
+const useTaskQrl = qrl => {
+    const {val, set, iCtx, i} = useSequentialScope();
+    if (val) {
+        return;
+    }
+    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 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(resource, 'useResource: when running a resource, "task.resource" must be a defined.', task);
-    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) {
+            logError(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;
 
@@ -1067,7 +1082,32 @@ var VirtualVNodeProps;
     VirtualVNodeProps[VirtualVNodeProps.PROPS_OFFSET = 6] = "PROPS_OFFSET";
 }(VirtualVNodeProps || (VirtualVNodeProps = {}));
 
-const isForeignObjectElement = elementName => "foreignobject" === elementName.toLowerCase();
+const mapApp_findIndx = (array, key, start) => {
+    assertTrue(start % 2 == 0, "Expecting even number.");
+    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 => isDev ? "foreignobject" === elementName.toLowerCase() : "foreignObject" === elementName;
 
 const isSvgElement = elementName => "svg" === elementName || isForeignObjectElement(elementName);
 
@@ -1075,7 +1115,18 @@ const isMathElement = elementName => "math" === elementName;
 
 const vnode_isDefaultNamespace = vnode => !(vnode[VNodeProps.flags] & VNodeFlags.NAMESPACE_MASK);
 
-const vnode_getElementNamespaceFlags = elementName => isSvgElement(elementName) ? VNodeFlags.NS_svg : isMathElement(elementName) ? VNodeFlags.NS_math : VNodeFlags.NS_html;
+const vnode_getElementNamespaceFlags = element => {
+    switch (fastNamespaceURI(element)) {
+      case SVG_NS:
+        return VNodeFlags.NS_svg;
+
+      case MATH_NS:
+        return VNodeFlags.NS_math;
+
+      default:
+        return VNodeFlags.NS_html;
+    }
+};
 
 function vnode_getDomChildrenWithCorrectNamespacesToInsert(journal, domParentVNode, newChild) {
     const {elementNamespace, elementNamespaceFlag} = getNewElementNamespaceData(domParentVNode, newChild);
@@ -1246,14 +1297,14 @@ const useOnEventsSequentialScope = () => {
 };
 
 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 && assertDefined(componentQRL = componentQRL || container.getHostProp(renderHost, "q:renderFn"), "No Component found at this location"), 
-    isQrl(componentQRL)) {
-        (props = props || container.getHostProp(renderHost, "q:props") || EMPTY_OBJ) && props.children && delete props.children, 
+    if (null === componentQRL && assertDefined(componentQRL = container.getHostProp(renderHost, "q:renderFn"), "No Component found at this location"), 
+    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;
@@ -1264,11 +1315,10 @@ const executeComponent = (container, renderHost, subscriptionHost, componentQRL,
         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(addUseOnEvents(jsx, useOnEvents), (() => jsx)) : jsx;
+        return useOnEvents ? addUseOnEvents(jsx, useOnEvents) : jsx;
     }), (err => {
         if (isPromise(err) && retryCount < 100) {
             return err.then((() => executeComponentWithPromiseExceptionRetry(retryCount++)));
@@ -1280,13 +1330,28 @@ const executeComponent = (container, renderHost, subscriptionHost, componentQRL,
 
 function addUseOnEvents(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]) : 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 {
+                        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;
     }));
 }
 
@@ -1327,25 +1392,40 @@ function addScriptNodeForInvisibleComponents(jsx) {
             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 ]);
+    }
+    if (Array.isArray(jsx) && jsx.length) {
+        const [jsxElement, _] = addScriptNodeForInvisibleComponents(jsx[0]);
+        return [ jsxElement, jsx ];
     }
-    return Array.isArray(jsx) && jsx.length ? addScriptNodeForInvisibleComponents(jsx[0]) : null;
+    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(":");
 }
 
-function isParentSlotProp(prop) {
-    return prop.startsWith(":");
-}
-
 const _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;
+    const varPropsTarget = target;
+    const varProps = props[_VAR_PROPS];
+    for (const key in varProps) {
+        omit.includes(key) || (varPropsTarget[key] = varProps[key]);
+    }
+    return createPropsProxy(varPropsTarget, constPropsTarget);
 };
 
 function escapeHTML(html) {
@@ -1374,14 +1454,6 @@ function escapeHTML(html) {
     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 = [];
@@ -1419,7 +1491,7 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                     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);
@@ -1501,9 +1573,10 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
     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(), isDev && vnode_setProp(vNewNode, "q:type", VirtualType.Projection), 
         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);
@@ -1519,19 +1592,27 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
             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), 
-        isDev && vnode_setProp(vNewNode, "q:type", VirtualType.Projection), 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), 
-        isDev && vnode_setProp(vNewNode, "q:type", VirtualType.Projection), 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), 
+            isDev && vnode_setProp(vNewNode, "q:type", VirtualType.Projection), isDev && vnode_setProp(vNewNode, "q:code", "expectSlot" + count++), 
+            !1;
+        }
+        if (vProjectedNode === vCurrent) {} else {
+            const parent = vnode_getParent(vProjectedNode);
+            !(!parent || vnode_isElementVNode(parent) && vnode_getElementName(parent) === QTemplate) && 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), 
+            isDev && vnode_setProp(vNewNode, "q:type", VirtualType.Projection), isDev && vnode_setProp(vNewNode, "q:code", "expectSlot" + count++);
+        }
+        return !0;
     }
     function expectNoMore() {
         if (assertFalse(vParent === vCurrent, "Parent and current can't be the same"), 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));
             }
         }
     }
@@ -1558,8 +1639,12 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                 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)) {
@@ -1570,10 +1655,13 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                             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
                         });
@@ -1620,10 +1708,10 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
         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;
@@ -1640,10 +1728,13 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                         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
                         });
@@ -1655,12 +1746,12 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
             };
             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:")) {
@@ -1692,7 +1783,7 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                 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;
@@ -1741,8 +1832,8 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
             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 || propsDiffer(jsxProps, vNodeProps), shouldRender && (host[VNodeProps.flags] &= ~VNodeFlags.Deleted, 
@@ -1753,8 +1844,9 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                 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));
@@ -1778,13 +1870,11 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
             }(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;
-                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);
@@ -1795,11 +1885,17 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
         }
     }
     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;
         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;
+        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)) {
@@ -1828,8 +1924,8 @@ function propsDiffer(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;
     }
@@ -1855,30 +1951,28 @@ function removePropsKeys(keys, propKeys) {
 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 (!isParentSlotProp(key) && 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;
@@ -1892,7 +1986,7 @@ function cleanup(container, vNode) {
                     }
                 }
             }
-            if (type & VNodeFlags.Virtual && null !== vnode_getProp(vCursor, QSlot, null)) {
+            if (vnode_isProjection(vCursor)) {
                 if (vCursor === vNode) {
                     const vFirstChild = vnode_getFirstChild(vCursor);
                     if (vFirstChild) {
@@ -1906,6 +2000,8 @@ function cleanup(container, vNode) {
                     continue;
                 }
             }
+        } else {
+            type & VNodeFlags.Text && markVNodeAsDeleted(vCursor);
         }
         if (vCursor === vNode) {
             return;
@@ -1955,19 +2051,127 @@ var SiblingsArray;
     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$1 = value => new Signal(null, value);
+const Resource = props => _jsxSorted(Fragment, null, null, getResourceValueAsPromise(props), 0, null);
 
-const createComputedSignal = qrl => (throwIfQRLNotResolved(qrl), new ComputedSignal(null, qrl));
+function getResourceValueAsPromise(props) {
+    const resource = props.value;
+    if (isResourceReturn(resource) && resource.value) {
+        if (!isServerPlatform()) {
+            const state = resource._state;
+            if ("pending" === state && props.onPending) {
+                return Promise.resolve().then(useBindInvokeContext(props.onPending));
+            }
+            if ("rejected" === state && props.onRejected) {
+                return Promise.resolve(resource._error).then(useBindInvokeContext(props.onRejected));
+            }
+            {
+                const resolvedValue = untrack((() => resource._resolved));
+                if (void 0 !== resolvedValue) {
+                    return Promise.resolve(resolvedValue).then(useBindInvokeContext(props.onResolved));
+                }
+            }
+        }
+        return resource.value.then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
+    }
+    return isPromise(resource) ? resource.then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected)) : isSignal(resource) ? Promise.resolve(resource.value).then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected)) : Promise.resolve(resource).then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
+}
 
-const createSignal = createSignal$1;
+const _createResourceReturn = opts => ({
+    __brand: "resource",
+    value: void 0,
+    loading: !isServerPlatform(),
+    _resolved: void 0,
+    _error: void 0,
+    _state: "pending",
+    _timeout: opts?.timeout ?? -1,
+    _cache: 0
+});
 
-const createComputedQrl = createComputedSignal;
+const createResourceReturn = (container, opts, initialPromise) => {
+    const result = _createResourceReturn(opts);
+    return result.value = initialPromise, createStore(container, result, StoreFlags.RECURSIVE);
+};
 
-const createComputed$ = /*#__PURE__*/ implicit$FirstArg(createComputedQrl);
+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(resource, 'useResource: when running a resource, "task.resource" must be a defined.', task);
+    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 = [];
 
@@ -1980,10 +2184,10 @@ const vnode_documentPosition = (a, b, rootVNode) => {
     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])) {
@@ -1999,7 +2203,7 @@ const vnode_documentPosition = (a, b, rootVNode) => {
                     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--;
     }
@@ -2031,25 +2235,26 @@ const ssrNodeDocumentPosition = (a, b) => {
     return aDepth < bDepth ? -1 : 1;
 };
 
-var ChoreType;
+const DEBUG$1 = !1;
 
-!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,
@@ -2062,134 +2267,177 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
             $returnValue$: null,
             $executed$: !1
         };
-        chore.$promise$ = new Promise((resolve => chore.$resolve$ = resolve)), chore = sortedInsert(choreQueue, chore, container.rootVNode || null), 
-        !journalFlushScheduled && runLater && (journalFlushScheduled = !0, schedule(ChoreType.JOURNAL_FLUSH), 
-        scheduleDrain());
-        return runLater ? chore.$promise$ : drainUpTo(chore, container.rootVNode || null);
+        chore = function(sortedArray, value, rootVNode) {
+            const idx = function(sortedArray, value, rootVNode) {
+                let bottom = 0;
+                let top = sortedArray.length;
+                for (;bottom < top; ) {
+                    const middle = bottom + (top - bottom >> 1);
+                    const comp = choreComparator(value, sortedArray[middle], rootVNode);
+                    if (comp < 0) {
+                        top = middle;
+                    } else {
+                        if (!(comp > 0)) {
+                            return middle;
+                        }
+                        bottom = middle + 1;
+                    }
+                }
+                return ~bottom;
+            }(sortedArray, value, rootVNode);
+            if (idx < 0) {
+                return sortedArray.splice(~idx, 0, value), value;
+            }
+            const existing = sortedArray[idx];
+            existing.$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 (vNodeAlreadyDeleted(nextChore) && 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 {
+                vNodeAlreadyDeleted(nextChore) && nextChore.$type$ !== ChoreType.CLEANUP_VISIBLE ? choreQueue.shift() : executeChore(nextChore, isServer);
             }
         }
         return runUptoChore.$returnValue$;
     }
-    function executeChore(chore) {
+    function executeChore(chore, isServer) {
         const host = chore.$host$;
         assertEqual(currentChore, null, "Chore already running."), 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 maybeThenPassError(returnValue, (value => (currentChore && (currentChore.$executed$ = !0, 
-        currentChore.$resolve$?.(value)), currentChore = null, chore.$returnValue$ = value)));
-    }
-};
-
-const toNumber = value => "number" == typeof value ? value : -1;
-
-const choreUpdate = (existing, newChore) => {
-    existing.$type$ === ChoreType.NODE_DIFF && (existing.$payload$ = newChore.$payload$);
-};
-
-function vNodeAlreadyDeleted(chore) {
-    return !!(chore.$host$ && vnode_isVNode(chore.$host$) && chore.$host$[VNodeProps.flags] & VNodeFlags.Deleted);
-}
-
-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) {
@@ -2199,6 +2447,8 @@ function choreComparator(a, b, rootVNode) {
                     return hostDiff;
                 }
             } else {
+                assertFalse(vnode_isVNode(aHost), "expected aHost to be SSRNode but it is a VNode"), 
+                assertFalse(vnode_isVNode(bHost), "expected bHost to be SSRNode but it is a VNode");
                 const errorMessage = `SERVER: during HTML streaming, re-running tasks on a different host is not allowed.\n          You are attempting to change a state that has already been streamed to the client.\n          This can lead to inconsistencies between Server-Side Rendering (SSR) and Client-Side Rendering (CSR).\n          Problematic Node: ${aHost.toString()}`;
                 logWarn(errorMessage);
                 const hostDiff = ssrNodeDocumentPosition(aHost, bHost);
@@ -2212,157 +2462,60 @@ function choreComparator(a, b, rootVNode) {
             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;
-}
-
-function sortedFindIndex(sortedArray, value, rootVNode) {
-    let bottom = 0;
-    let top = sortedArray.length;
-    for (;bottom < top; ) {
-        const middle = bottom + (top - bottom >> 1);
-        const comp = choreComparator(value, sortedArray[middle], rootVNode);
-        if (comp < 0) {
-            top = middle;
-        } else {
-            if (!(comp > 0)) {
-                return middle;
-            }
-            bottom = middle + 1;
-        }
-    }
-    return ~bottom;
-}
-
-function sortedInsert(sortedArray, value, rootVNode) {
-    const idx = sortedFindIndex(sortedArray, value, rootVNode);
-    if (idx < 0) {
-        return sortedArray.splice(~idx, 0, value), value;
-    }
-    const existing = sortedArray[idx];
-    return choreUpdate(existing, value), existing;
-}
-
-const useLexicalScope = () => {
-    const context = getInvokeContext();
-    let qrl = context.$qrl$;
-    if (qrl) {
-        assertQrl(qrl), assertDefined(qrl.$captureRef$, "invoke: qrl $captureRef$ must be defined inside useLexicalScope()", qrl);
-    } else {
-        const el = context.$element$;
-        assertDefined(el, "invoke: element must be defined inside useLexicalScope()", context);
-        const containerElement = _getQContainerElement(el);
-        assertDefined(containerElement, "invoke: cant find parent q:container of", el);
-        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;
+        return 0 !== idxDiff ? idxDiff : a.$target$ !== b.$target$ || a.$payload$ !== b.$payload$ || b === currentChore ? 1 : 0;
     }
-    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 toNumber = value => "number" == typeof value ? value : -1;
 
-const cleanupTask = task => {
-    const destroy = task.$destroy$;
-    if (destroy) {
-        task.$destroy$ = null;
-        try {
-            destroy();
-        } catch (err) {
-            logError(err);
-        }
-    }
-};
+function vNodeAlreadyDeleted(chore) {
+    return !!(chore.$host$ && vnode_isVNode(chore.$host$) && chore.$host$[VNodeProps.flags] & VNodeFlags.Deleted);
+}
 
-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));
-};
+function debugChoreTypeToString(type) {
+    return {
+        [ChoreType.QRL_RESOLVE]: "QRL_RESOLVE",
+        [ChoreType.RUN_QRL]: "RUN_QRL",
+        [ChoreType.TASK]: "TASK",
+        [ChoreType.NODE_DIFF]: "NODE_DIFF",
+        [ChoreType.NODE_PROP]: "NODE_PROP",
+        [ChoreType.COMPONENT]: "COMPONENT",
+        [ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS]: "RECOMPUTE_SIGNAL",
+        [ChoreType.JOURNAL_FLUSH]: "JOURNAL_FLUSH",
+        [ChoreType.VISIBLE]: "VISIBLE",
+        [ChoreType.CLEANUP_VISIBLE]: "CLEANUP_VISIBLE",
+        [ChoreType.WAIT_FOR_ALL]: "WAIT_FOR_ALL"
+    }[type] || "UNKNOWN: " + type;
+}
 
-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;
-};
+function debugChoreToString(chore) {
+    const type = debugChoreTypeToString(chore.$type$);
+    const host = String(chore.$host$).replaceAll(/\n.*/gim, "");
+    const qrlTarget = chore.$target$?.$symbol$;
+    return `Chore(${type} ${chore.$type$ === ChoreType.QRL_RESOLVE || chore.$type$ === ChoreType.RUN_QRL ? qrlTarget : host} ${chore.$idx$})`;
+}
 
-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$;
-    }
+function debugTrace(action, arg, currentChore, queue) {
+    const lines = [ "===========================\nScheduler: " + action ];
+    arg && !("$type$" in arg) && lines.push("      arg: " + String(arg).replaceAll(/\n.*/gim, "")), 
+    queue && queue.forEach((chore => {
+        lines.push(`     ${chore === arg ? ">>>" : "   "} > ` + (chore === currentChore ? "[running] " : "") + debugChoreToString(chore));
+    })), console.log(lines.join("\n") + "\n");
 }
 
-const isTask = value => value instanceof Task;
+const DEBUG = !1;
 
-const _hW = () => {
-    const [task] = useLexicalScope();
-    getDomContainer(task.$el$).$scheduler$(task.$flags$ & TaskFlags.VISIBLE_TASK ? ChoreType.VISIBLE : ChoreType.TASK, task);
-};
+const log = (...args) => console.log("SIGNAL", ...args.map(qwikDebugToString));
 
-const NEEDS_COMPUTATION = Symbol("invalid");
+var SignalFlags;
 
-const DEBUG = !1;
+var WrappedSignalFlags;
 
-const log = (...args) => console.log("SIGNAL", ...args.map(qwikDebugToString));
+!function(SignalFlags) {
+    SignalFlags[SignalFlags.INVALID = 1] = "INVALID";
+}(SignalFlags || (SignalFlags = {})), function(WrappedSignalFlags) {
+    WrappedSignalFlags[WrappedSignalFlags.UNWRAP = 2] = "UNWRAP";
+}(WrappedSignalFlags || (WrappedSignalFlags = {}));
 
 const throwIfQRLNotResolved = qrl => {
     if (!qrl.resolved) {
@@ -2372,21 +2525,21 @@ const throwIfQRLNotResolved = qrl => {
 
 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 = {}));
 
@@ -2416,9 +2569,9 @@ class Signal {
             }
             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;
@@ -2430,7 +2583,7 @@ class Signal {
         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 {
@@ -2439,100 +2592,77 @@ class Signal {
     }
 }
 
-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(container, "Container must be defined."), isTask(effect)) {
-                effect.$flags$ |= TaskFlags.DIRTY;
+        const scheduleEffect = effectSubscription => {
+            const consumer = effectSubscription[EffectSubscriptionProp.CONSUMER];
+            const property = effectSubscription[EffectSubscriptionProp.PROPERTY];
+            if (assertDefined(container, "Container must be defined."), 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(qrl, "Component must have QRL");
                 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$();
@@ -2540,20 +2670,20 @@ class ComputedSignal extends Signal {
         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 {
@@ -2572,18 +2702,19 @@ class WrappedSignal extends Signal {
     $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$();
@@ -2591,7 +2722,7 @@ class WrappedSignal extends Signal {
         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$);
@@ -2618,7 +2749,7 @@ const applyQwikComponentBody = (ssr, jsx, component) => {
     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);
 };
 
 class ParentComponentData {
@@ -2629,18 +2760,10 @@ class ParentComponentData {
     }
 }
 
-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) {
@@ -2652,23 +2775,13 @@ function _walkJSX(ssr, value, options) {
                 });
             } 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) {
@@ -2696,7 +2809,6 @@ function processJSXNode(ssr, enqueue, value, options) {
             enqueue((async () => {
                 for await (const chunk of value) {
                     await _walkJSX(ssr, chunk, {
-                        allowPromises: !0,
                         currentStyleScoped: options.styleScoped,
                         parentComponentFrame: options.parentComponentFrame
                     }), ssr.commentNode("qkssr-f");
@@ -2725,7 +2837,7 @@ function processJSXNode(ssr, enqueue, value, options) {
                     const componentFrame = options.parentComponentFrame || ssr.unclaimedProjectionComponentFrameQueue.shift();
                     if (componentFrame) {
                         const projectionAttrs = 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 = getSlotName(host, jsx, ssr);
@@ -2747,7 +2859,6 @@ function processJSXNode(ssr, enqueue, value, options) {
                     value = isFunction(generator) ? generator({
                         async write(chunk) {
                             await _walkJSX(ssr, chunk, {
-                                allowPromises: !0,
                                 currentStyleScoped: options.styleScoped,
                                 parentComponentFrame: options.parentComponentFrame
                             }), ssr.commentNode("qkssr-f");
@@ -2835,18 +2946,20 @@ function setEvent(serializationCtx, key, rawValue) {
     const appendToValue = valueToAppend => {
         value = (null == value ? "" : value + "\n") + valueToAppend;
     };
+    const getQrlString = qrl => (qrl.$symbol$.startsWith("_") || !qrl.$captureRef$ && !qrl.$capture$ || (qrl = createQRL(null, "_run", queueQRL, null, null, [ qrl ])), 
+    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;
 }
@@ -2881,7 +2994,7 @@ function appendClassIfScopedStyleExists(jsx, styleScoped) {
     jsx.constProps.class = "");
 }
 
-const version = "2.0.0-alpha.6-dev+d848ba5";
+const version = "2.0.0-alpha.8-dev+66037b5";
 
 class _SharedContainer {
     $version$;
@@ -2906,12 +3019,6 @@ class _SharedContainer {
     }
 }
 
-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];
@@ -2926,7 +3033,7 @@ const _wrapProp = (...args) => {
     }
     if (isSignal(obj)) {
         return assertEqual(prop, "value", "Left side is a signal, prop must be value"), 
-        obj instanceof WrappedSignal ? obj : getWrapped(args);
+        obj instanceof WrappedSignal && obj.flags & WrappedSignalFlags.UNWRAP ? obj : getWrapped(args);
     }
     if (isPropsProxy(obj)) {
         const constProps = obj[_CONST_PROPS];
@@ -2943,6 +3050,11 @@ const _wrapProp = (...args) => {
     return getWrapped(args);
 };
 
+const _wrapStore = (obj, prop) => {
+    const value = getStoreTarget(obj)[prop];
+    return isSignal(value) ? value : new WrappedSignal(null, getProp, [ obj, prop ], null, SignalFlags.INVALID);
+};
+
 const _wrapSignal = (obj, prop) => {
     const r = _wrapProp(obj, prop);
     return r === _IMMUTABLE ? obj[prop] : r;
@@ -3071,7 +3183,7 @@ class PropsProxyHandler {
             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, 
@@ -3128,7 +3240,7 @@ function qwikDebugToString(value) {
     if (isTask(value)) {
         return `Task(${qwikDebugToString(value.$qrl$)})`;
     }
-    if (isQrl$1(value)) {
+    if (isQrl(value)) {
         return `Qrl(${value.$symbol$})`;
     }
     if ("object" == typeof value || "function" == typeof value) {
@@ -3222,8 +3334,8 @@ const VNodeDataChar = {
     ID_CHAR: "=",
     PROPS: 62,
     PROPS_CHAR: ">",
-    SLOT_REF: 63,
-    SLOT_REF_CHAR: "?",
+    SLOT_PARENT: 63,
+    SLOT_PARENT_CHAR: "?",
     KEY: 64,
     KEY_CHAR: "@",
     SEQ: 91,
@@ -3234,14 +3346,21 @@ const VNodeDataChar = {
     CONTEXT_CHAR: "]",
     SEQ_IDX: 94,
     SEQ_IDX_CHAR: "^",
-    SUBS: 96,
-    SUBS_CHAR: "`",
+    BACK_REFS: 96,
+    BACK_REFS_CHAR: "`",
     SEPARATOR: 124,
     SEPARATOR_CHAR: "|",
     SLOT: 126,
     SLOT_CHAR: "~"
 };
 
+const mergeMaps = (map1, map2) => {
+    for (const [k, v] of map2) {
+        map1.set(k, v);
+    }
+    return map1;
+};
+
 var VNodeJournalOpCode;
 
 !function(VNodeJournalOpCode) {
@@ -3315,6 +3434,11 @@ const vnode_isVirtualVNode = vNode => {
     return (vNode[VNodeProps.flags] & VNodeFlags.Virtual) === VNodeFlags.Virtual;
 };
 
+const vnode_isProjection = vNode => {
+    assertDefined(vNode, "Missing vNode");
+    return (vNode[VNodeProps.flags] & VNodeFlags.Virtual) === VNodeFlags.Virtual && null !== vnode_getProp(vNode, QSlot, null);
+};
+
 const ensureTextVNode = vNode => (assertTrue(vnode_isTextVNode(vNode), "Expecting TextVNode was: " + vnode_getNodeTypeName(vNode)), 
 vNode);
 
@@ -3347,6 +3471,7 @@ const vnode_ensureElementInflated = vnode => {
         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;
@@ -3354,9 +3479,9 @@ const vnode_ensureElementInflated = vnode => {
                 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);
             }
         }
     }
@@ -3594,7 +3719,7 @@ const vnode_applyJournal = journal => {
             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)) : key === dangerouslySetInnerHTML ? 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) : key === dangerouslySetInnerHTML ? element.innerHTML = value : null == value || !1 === value ? element.removeAttribute(key) : element.setAttribute(key, String(value));
             break;
 
           case VNodeJournalOpCode.HoistStyles:
@@ -3626,33 +3751,9 @@ const vnode_applyJournal = journal => {
     journal.length = 0;
 };
 
-const mapApp_findIndx = (elementVNode, key, start) => {
-    assertTrue(start % 2 == 0, "Expecting even number.");
-    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 && vnode_ensureInflatedIfText(journal, adjustedInsertBefore);
@@ -3711,9 +3812,12 @@ const vnode_truncate = (journal, vParent, vDelete) => {
 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] |= vnode_getElementNamespaceFlags(elementName)), 
-    elementName;
+    if (void 0 === elementName) {
+        const element = elementVNode[ElementVNodeProps.element];
+        const nodeName = isDev ? fastNodeName(element).toLowerCase() : fastNodeName(element);
+        elementName = elementVNode[ElementVNodeProps.elementName] = nodeName, elementVNode[VNodeProps.flags] |= vnode_getElementNamespaceFlags(element);
+    }
+    return elementName;
 };
 
 const vnode_getText = vnode => {
@@ -3841,6 +3945,16 @@ const fastFirstChild = node => {
     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); ) {
@@ -3880,13 +3994,25 @@ const materializeFromDOM = (vParent, firstChild, vData) => {
                 const id = consumeValue();
                 container.$setRawState$(parseInt(id), vParent), 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]) {
+        mergeMaps(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;
@@ -3914,8 +4040,9 @@ const vnode_getAttrKeys = vnode => {
     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;
@@ -3927,29 +4054,37 @@ const vnode_setAttr = (journal, vnode, key, value) => {
     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;
         }
     }
@@ -3958,8 +4093,9 @@ const vnode_getProp = (vnode, key, getObject) => {
 
 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 => {
@@ -3973,6 +4109,8 @@ const vnode_getPropStartIndex = vnode => {
     throw qError(QError.invalidVNodeType, [ type ]);
 };
 
+const vnode_getProps = vnode => vnode[vnode_getPropStartIndex(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), "Expecting Text Node."), 
@@ -4085,16 +4223,16 @@ function materializeFromVNodeData(vParent, vData, element, child) {
             container.$setRawState$(parseInt(id), vParent), 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) {
@@ -4144,7 +4282,7 @@ const vnode_getProjectionParentComponent = (vHost, rootVNode) => {
     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);
         }
@@ -4155,19 +4293,16 @@ const vnode_getProjectionParentComponent = (vHost, rootVNode) => {
 
 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), isDev && (this.toString = vnode_toString);
+    constructor(flags, parent, previousSibling, nextSibling, ...rest) {
+        super(flags, parent, previousSibling, nextSibling, ...rest), isDev && (this.toString = vnode_toString);
     }
 };
 
@@ -4228,9 +4363,11 @@ function invokeApply(context, fn, args) {
 }
 
 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 && setLocale(locale), newInvokeContext(locale, void 0, element, event, url);
+    return locale && setLocale(locale), newInvokeContext(locale, vNode, element, event, url);
 };
 
 const newInvokeContext = (locale, hostElement, element, event, url) => {
@@ -4256,7 +4393,7 @@ const trackSignal = (fn, subscriber, property, container, data) => {
     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;
@@ -4271,7 +4408,7 @@ const _getContextElement = () => {
     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);
     }
 };
@@ -4552,9 +4689,9 @@ class DomContainer extends _SharedContainer {
     $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")), 
@@ -4564,24 +4701,24 @@ class DomContainer extends _SharedContainer {
         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 || processVNodeData(document), this.$rawStateData$ = [], this.stateData = [];
+        document.qVNodeData || processVNodeData(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;
         }
@@ -4610,7 +4747,7 @@ class DomContainer extends _SharedContainer {
                 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);
             }
@@ -4628,7 +4765,7 @@ class DomContainer extends _SharedContainer {
           case "q:props":
           case "q:renderFn":
           case "q:ctx":
-          case "q:subs":
+          case "q:brefs":
             getObjectById = this.$getObjectById$;
             break;
 
@@ -4640,7 +4777,10 @@ class DomContainer extends _SharedContainer {
     }
     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$;
@@ -4658,16 +4798,17 @@ class DomContainer extends _SharedContainer {
     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(id < this.$rawStateData$.length / 2, `Invalid reference: ${id} >= ${this.$rawStateData$.length / 2}`), 
-    this.stateData[id]);
+    this.$stateData$[id]);
     getSyncFn(id) {
         const fn = this.$qFuncs$[id];
         return assertTrue("function" == typeof fn, "Invalid reference: " + id), fn;
@@ -4799,7 +4940,7 @@ const inflate = (container, target, typeId, data) => {
         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:
@@ -4817,11 +4958,9 @@ const inflate = (container, target, typeId, data) => {
       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;
         }
 
@@ -4829,7 +4968,7 @@ const inflate = (container, target, typeId, data) => {
         {
             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;
         }
 
@@ -4837,8 +4976,9 @@ const inflate = (container, target, typeId, data) => {
         {
             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;
         }
 
@@ -4846,7 +4986,7 @@ const inflate = (container, target, typeId, data) => {
         {
             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;
         }
@@ -4942,7 +5082,7 @@ const inflate = (container, target, typeId, data) => {
     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) {
@@ -5032,7 +5172,7 @@ const allocate = (container, typeId, value) => {
         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;
@@ -5042,12 +5182,10 @@ const allocate = (container, typeId, value) => {
       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);
@@ -5055,7 +5193,7 @@ const allocate = (container, typeId, value) => {
         throw qError(QError.serializeErrorExpectedVNode, [ typeof vNode ]);
 
       case TypeIds.EffectData:
-        return new EffectPropData({});
+        return new SubscriptionData({});
 
       default:
         throw qError(QError.serializeErrorCannotAllocate, [ typeId ]);
@@ -5078,7 +5216,7 @@ function parseQRL(qrl) {
         const backChannel = globalThis[QRL_RUNTIME_CHUNK];
         assertDefined(backChannel, "Missing QRL_RUNTIME_CHUNK"), 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) {
@@ -5156,18 +5294,18 @@ const createSerializationContext = (NodeConstructor, DomRefConstructor, symbolTo
             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));
@@ -5179,12 +5317,13 @@ const createSerializationContext = (NodeConstructor, DomRefConstructor, symbolTo
                         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) {
@@ -5197,7 +5336,7 @@ const createSerializationContext = (NodeConstructor, DomRefConstructor, symbolTo
                     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]);
@@ -5207,7 +5346,7 @@ const createSerializationContext = (NodeConstructor, DomRefConstructor, symbolTo
                     }), (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)) {
@@ -5250,15 +5389,17 @@ const discoverValuesForVNodeData = (vnodeData, discoveredValues) => {
     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 serialize(serializationContext) {
@@ -5297,7 +5438,7 @@ function serialize(serializationContext) {
                 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);
@@ -5323,11 +5464,13 @@ function serialize(serializationContext) {
             }
         } 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) => {
@@ -5343,7 +5486,7 @@ function serialize(serializationContext) {
             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 (isResource(value)) {
@@ -5358,7 +5501,6 @@ function serialize(serializationContext) {
                 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];
@@ -5367,7 +5509,7 @@ function serialize(serializationContext) {
                         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();
                 }
@@ -5386,9 +5528,9 @@ function serialize(serializationContext) {
         } 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);
@@ -5436,7 +5578,7 @@ function serialize(serializationContext) {
         } 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();
             }
@@ -5447,23 +5589,34 @@ function serialize(serializationContext) {
                 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);
 }
 
+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$ ];
@@ -5472,11 +5625,10 @@ function serializeWrappingFn(serializationContext, value) {
 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)) {
         chunk = "", symbol = String(serializationContext.$addSyncFn$(null, 0, value.resolved));
@@ -5570,17 +5722,21 @@ function isResource(value) {
     return "__brand" in value && "resource" === value.__brand;
 }
 
-const frameworkType = obj => "object" == typeof obj && null !== obj && (obj instanceof Signal || obj instanceof Task || isJSXNode(obj)) || isQrl(obj);
+const frameworkType = obj => "object" == typeof obj && null !== obj && (obj instanceof Signal || obj instanceof Task || isJSXNode(obj)) || isQrl$1(obj);
 
-const canSerialize = value => {
+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;
                 }
             }
@@ -5588,7 +5744,7 @@ const canSerialize = value => {
         }
         if (proto == Array.prototype) {
             for (let i = 0; i < value.length; i++) {
-                if (!canSerialize(value[i])) {
+                if (!canSerialize(value[i], seen)) {
                     return !1;
                 }
             }
@@ -5636,7 +5792,7 @@ const canSerialize = value => {
         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;
@@ -5668,14 +5824,15 @@ var Constants;
     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);
 };
 
@@ -5685,10 +5842,13 @@ const _verifySerializable = (value, seen, ctx, preMessage) => {
         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)) {
@@ -5750,13 +5910,7 @@ const noSerialize = input => (null != input && noSerializeSet.add(input), input)
 
 const _weakSerialize = input => (weakSerializeSet.add(input), input);
 
-const isQrl = value => "function" == typeof value && "function" == typeof value.getSymbol;
-
-const SYNC_QRL = "<sync>";
-
-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());
@@ -5764,9 +5918,14 @@ const createQRL = (chunk, symbol, symbolRef, symbolFn, capture, captureRef, refS
     };
     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;
@@ -5776,17 +5935,29 @@ const createQRL = (chunk, symbol, symbolRef, symbolFn, capture, captureRef, refS
             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) {
@@ -5801,49 +5972,38 @@ const createQRL = (chunk, symbol, symbolRef, symbolFn, capture, captureRef, refS
         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)))), 
     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) => {
@@ -5865,17 +6025,17 @@ const now = () => isServerPlatform() ? 0 : "object" == typeof performance ? perf
 
 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 sync$ = fn => createQRL("", "<sync>", fn, null, null, null, null);
+const sync$ = fn => createQRL("", "<sync>", fn, null, null, null);
 
 const _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);
 };
 
 const componentQrl = componentQrl => {
@@ -6005,7 +6165,7 @@ const scopeStylesheet = (css, scopeId) => {
         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;
@@ -6156,7 +6316,7 @@ const useStylesQrl = styles => ({
 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);
@@ -6211,6 +6371,12 @@ const useVisibleTaskQrl = (qrl, opts) => {
     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 useResource$ = (generatorFn, opts) => useResourceQrl(dollar(generatorFn), opts);
 
 const useTask$ = /*#__PURE__*/ implicit$FirstArg(useTaskQrl);
@@ -6283,4 +6449,4 @@ const PrefetchGraph = (opts = {}) => {
     }, null, 0, "prefetch-graph");
 };
 
-export { $, Fragment, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SkipRender, Slot, _CONST_PROPS, DomContainer as _DomContainer, EMPTY_ARRAY as _EMPTY_ARRAY, EffectPropData as _EffectData, _IMMUTABLE, _SharedContainer, _VAR_PROPS, _deserialize, _fnSignal, _getContextElement, _getContextEvent, getDomContainer as _getDomContainer, _getQContainerElement, _hW, isJSXNode as _isJSXNode, isStringifiable as _isStringifiable, _jsxBranch, _jsxC, _jsxQ, _jsxS, _jsxSorted, _jsxSplit, _noopQrl, _noopQrlDEV, _qrlSync, _regSymbol, _restProps, _serialize, verifySerializable as _verifySerializable, _waitUntilRendered, _walkJSX, _weakSerialize, _wrapProp, _wrapSignal, component$, componentQrl, createComputed$, createComputedQrl, createContextId, h as createElement, createSignal, event$, eventQrl, getDomContainer, getLocale, getPlatform, h, implicit$FirstArg, inlinedQrl, inlinedQrlDEV, isSignal, jsx, jsxDEV, jsx as jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, useErrorBoundary, useId, useLexicalScope, useOn, useOnDocument, useOnWindow, useResource$, useResourceQrl, useServerData, useSignal, useStore, useStyles$, useStylesQrl, useStylesScoped$, useStylesScopedQrl, useTask$, useTaskQrl, useVisibleTask$, useVisibleTaskQrl, version, withLocale };
+export { $, Fragment, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SkipRender, Slot, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, EMPTY_ARRAY as _EMPTY_ARRAY, SubscriptionData as _EffectData, _IMMUTABLE, _SharedContainer, _VAR_PROPS, _deserialize, _fnSignal, _getContextElement, _getContextEvent, getDomContainer as _getDomContainer, _getQContainerElement, isJSXNode as _isJSXNode, isStringifiable as _isStringifiable, _jsxBranch, _jsxC, _jsxQ, _jsxS, _jsxSorted, _jsxSplit, _noopQrl, _noopQrlDEV, _qrlSync, _regSymbol, _restProps, queueQRL as _run, _serialize, scheduleTask as _task, verifySerializable as _verifySerializable, _waitUntilRendered, _walkJSX, _weakSerialize, _wrapProp, _wrapSignal, _wrapStore, component$, componentQrl, createComputed$, createComputedQrl, createContextId, h as createElement, createSignal, event$, eventQrl, getDomContainer, getLocale, getPlatform, h, implicit$FirstArg, inlinedQrl, inlinedQrlDEV, isSignal, jsx, jsxDEV, jsx as jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, useErrorBoundary, useId, useLexicalScope, useOn, useOnDocument, useOnWindow, useResource$, useResourceQrl, useServerData, useSignal, useStore, useStyles$, useStylesQrl, useStylesScoped$, useStylesScopedQrl, useTask$, useTaskQrl, useVisibleTask$, useVisibleTaskQrl, version, withLocale };