@qwik.dev/core 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/core.prod.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.1-dev+495e8d9
+ * @qwik.dev/core 2.0.0-beta.10-dev+4669425
  * Copyright QwikDev. All Rights Reserved.
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://github.com/QwikDev/qwik/blob/main/LICENSE
@@ -11,6 +11,8 @@ export { isBrowser, isDev, isServer } from "@qwik.dev/core/build";
 
 import { p } from "@qwik.dev/core/preloader";
 
+const version = "2.0.0-beta.10-dev+4669425";
+
 const qDev = !1;
 
 const qInspector = !1;
@@ -50,11 +52,28 @@ const logWarn = () => {
 const createAndLogError = (asyncThrow, message, ...optionalParams) => {
     const err = message instanceof Error ? message : new Error(message);
     return console.error("%cQWIK ERROR", "", err.message, ...optionalParams, err.stack), 
-    asyncThrow && setTimeout((() => {
+    asyncThrow && setTimeout(() => {
         throw err;
-    }), 0), err;
+    }, 0), err;
+};
+
+const isSerializableObject = v => {
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === Array.prototype || null === proto;
 };
 
+const isObject = v => "object" == typeof v && null !== v;
+
+const isArray = v => Array.isArray(v);
+
+const isString = v => "string" == typeof v;
+
+const isNumber$1 = v => "number" == typeof v;
+
+const isFunction = v => "function" == typeof v;
+
+const isPrimitive = v => "object" != typeof v && "function" != typeof v && null != v;
+
 const codeToText = code => `Code(Q${code}) https://github.com/QwikDev/qwik/blob/main/packages/qwik/src/core/error/error.ts#L${8 + code}`;
 
 const qError = (code, errorMessageArgs = []) => {
@@ -137,6 +156,10 @@ const SVG_NS = "http://www.w3.org/2000/svg";
 
 const MATH_NS = "http://www.w3.org/1998/Math/MathML";
 
+const XLINK_NS = "http://www.w3.org/1999/xlink";
+
+const XML_NS = "http://www.w3.org/XML/1998/namespace";
+
 const ResourceEvent = "qResource";
 
 const RenderEvent = "qRender";
@@ -196,18 +219,13 @@ const createPlatform = () => ({
         const urlDoc = toUrl(containerEl.ownerDocument, containerEl, url).toString();
         const urlCopy = new URL(urlDoc);
         urlCopy.hash = "";
-        return import(urlCopy.href).then((mod => mod[symbolName]));
+        return import(urlCopy.href).then(mod => mod[symbolName]);
     },
-    raf: fn => new Promise((resolve => {
-        requestAnimationFrame((() => {
-            resolve(fn());
-        }));
-    })),
-    nextTick: fn => new Promise((resolve => {
-        setTimeout((() => {
+    raf: fn => new Promise(resolve => {
+        requestAnimationFrame(() => {
             resolve(fn());
-        }));
-    })),
+        });
+    }),
     chunkForSymbol: (symbolName, chunk) => [ symbolName, chunk ?? "_" ]
 });
 
@@ -250,9 +268,9 @@ const shouldNotError = reason => {
     throwErrorAndStop(reason);
 };
 
-const delay = timeout => new Promise((resolve => {
+const delay = timeout => new Promise(resolve => {
     setTimeout(resolve, timeout);
-}));
+});
 
 function retryOnPromise(fn, retryCount = 0) {
     const retryOrThrow = e => {
@@ -263,7 +281,7 @@ function retryOnPromise(fn, retryCount = 0) {
     };
     try {
         const result = fn();
-        return isPromise(result) ? result.catch((e => retryOrThrow(e))) : result;
+        return isPromise(result) ? result.catch(e => retryOrThrow(e)) : result;
     } catch (e) {
         if (isDev && isServer && e instanceof ReferenceError && e.message.includes("window")) {
             throw e.message = 'It seems like you forgot to add "if (isBrowser) {...}" here:' + e.message, 
@@ -273,19 +291,6 @@ function retryOnPromise(fn, retryCount = 0) {
     }
 }
 
-const isSerializableObject = v => {
-    const proto = Object.getPrototypeOf(v);
-    return proto === Object.prototype || proto === Array.prototype || null === proto;
-};
-
-const isObject = v => !!v && "object" == typeof v;
-
-const isArray = v => Array.isArray(v);
-
-const isString = v => "string" == typeof v;
-
-const isFunction = v => "function" == typeof v;
-
 const ASSERT_DISCLAIMER = "Internal assert, this is likely caused by a bug in Qwik: ";
 
 function assertDefined() {
@@ -354,6 +359,9 @@ class SignalImpl {
     constructor(container, value) {
         this.$container$ = container, this.$untrackedValue$ = value;
     }
+    force() {
+        this.$container$?.$scheduler$(7, null, this, this.$effects$);
+    }
     get untrackedValue() {
         return this.$untrackedValue$;
     }
@@ -361,16 +369,16 @@ class SignalImpl {
         this.$untrackedValue$ = value;
     }
     get value() {
-        return setupSignalValueAccess(this, (() => this.$effects$ ||= new Set), (() => this.untrackedValue));
+        return setupSignalValueAccess(this, () => this.$effects$ ||= new Set, () => this.untrackedValue);
     }
     set value(value) {
-        value !== this.$untrackedValue$ && (this.$untrackedValue$ = value, triggerEffects(this.$container$, this, this.$effects$));
+        value !== this.$untrackedValue$ && (this.$untrackedValue$ = value, this.$container$?.$scheduler$(7, null, this, this.$effects$));
     }
     valueOf() {
         qDev;
     }
     toString() {
-        return isDev ? `[${this.constructor.name}${1 & this.$flags$ ? " INVALID" : ""} ${String(this.$untrackedValue$)}]` + (Array.from(this.$effects$ || []).map((e => "\n -> " + pad(qwikDebugToString(e[0]), "    "))).join("\n") || "") : this.constructor.name;
+        return isDev ? `[${this.constructor.name}${1 & this.$flags$ ? " INVALID" : ""} ${String(this.$untrackedValue$)}]` + (Array.from(this.$effects$ || []).map(e => "\n -> " + pad(qwikDebugToString(e[0]), "    ")).join("\n") || "") : this.constructor.name;
     }
     toJSON() {
         return {
@@ -407,30 +415,27 @@ class WrappedSignalImpl extends SignalImpl {
     $funcStr$;
     $flags$;
     $hostElement$=null;
-    $forceRunEffects$=!1;
     [_EFFECT_BACK_REF]=null;
-    constructor(container, fn, args, fnStr, flags = 3) {
+    constructor(container, fn, args, fnStr, flags = 5) {
         super(container, NEEDS_COMPUTATION), this.$args$ = args, this.$func$ = fn, this.$funcStr$ = fnStr, 
         this.$flags$ = flags;
     }
-    $invalidate$() {
-        this.$flags$ |= 1, this.$forceRunEffects$ = !1, this.$container$?.$scheduler$(7, this.$hostElement$, this, this.$effects$);
+    invalidate() {
+        this.$flags$ |= 1, this.$container$?.$scheduler$(7, this.$hostElement$, this, this.$effects$);
     }
     force() {
-        this.$flags$ |= 1, this.$forceRunEffects$ = !1, triggerEffects(this.$container$, this, this.$effects$);
+        this.$flags$ |= 2, this.$container$?.$scheduler$(7, this.$hostElement$, this, this.$effects$);
     }
     get untrackedValue() {
-        const didChange = this.$computeIfNeeded$();
-        return didChange && (this.$forceRunEffects$ = didChange), assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state"), 
+        return this.$computeIfNeeded$(), assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state"), 
         this.$untrackedValue$;
     }
     $computeIfNeeded$() {
         if (!(1 & this.$flags$)) {
-            return !1;
+            return;
         }
-        const untrackedValue = trackSignal((() => this.$func$(...this.$args$)), this, ".", this.$container$);
-        const didChange = untrackedValue !== this.$untrackedValue$;
-        return didChange && (this.$untrackedValue$ = untrackedValue), didChange;
+        const untrackedValue = trackSignal(() => this.$func$(...this.$args$), this, ".", this.$container$);
+        untrackedValue !== this.$untrackedValue$ && (this.$flags$ |= 2, this.$untrackedValue$ = untrackedValue);
     }
     set value(_) {
         throw qError(31);
@@ -524,7 +529,7 @@ const newInvokeContext = (locale, hostElement, element, event, url) => {
         $event$: event,
         $qrl$: void 0,
         $effectSubscriber$: void 0,
-        $locale$: locale || ("object" == typeof event && event && "locale" in event ? event.locale : void 0),
+        $locale$: locale || (event && isObject(event) && "locale" in event ? event.locale : void 0),
         $container$: void 0
     };
     return seal(), ctx;
@@ -546,7 +551,7 @@ const trackSignal = (fn, subscriber, property, container, data) => {
 };
 
 const trackSignalAndAssignHost = (value, host, property, container, data) => (value instanceof WrappedSignalImpl && value.$hostElement$ !== host && host && (value.$hostElement$ = host), 
-trackSignal((() => value.value), host, property, container, data));
+trackSignal(() => value.value, host, property, container, data));
 
 const _getContextElement = () => {
     const iCtx = tryGetInvokeContext();
@@ -565,15 +570,27 @@ const _getContextEvent = () => {
     }
 };
 
+const _getContextContainer = () => {
+    const iCtx = tryGetInvokeContext();
+    if (iCtx) {
+        return iCtx.$container$;
+    }
+};
+
 const _jsxBranch = input => input;
 
 const _waitUntilRendered = elm => {
-    const containerEl = _getQContainerElement(elm);
-    if (!containerEl) {
-        return Promise.resolve();
-    }
-    const container = containerEl.qContainer;
-    return container?.renderDone ?? Promise.resolve();
+    const container = _getQContainerElement(elm)?.qContainer;
+    return container ? (async () => {
+        for (;;) {
+            await container.$scheduler$(255).$returnValue$;
+            const firstEpoch = container.$flushEpoch$ || 0;
+            await Promise.resolve();
+            if (firstEpoch === (container.$flushEpoch$ || 0)) {
+                return;
+            }
+        }
+    })() : Promise.resolve();
 };
 
 const useSequentialScope = () => {
@@ -692,12 +709,18 @@ const validateContext = context => {
     }
 };
 
+const _resolveContextWithoutSequentialScope = context => {
+    const iCtx = getInvokeContext();
+    const hostElement = iCtx.$hostElement$;
+    if (hostElement) {
+        return iCtx.$container$?.resolveContext(hostElement, context);
+    }
+};
+
 const ERROR_CONTEXT = /*#__PURE__*/ createContextId("qk-error");
 
 const isRecoverable = err => !(err && err instanceof Error && "plugin" in err);
 
-const version = "2.0.0-beta.1-dev+495e8d9";
-
 const EMPTY_ARRAY = [];
 
 const EMPTY_OBJ = {};
@@ -727,7 +750,7 @@ const qrl = (chunkOrFn, symbol, lexicalScopeCapture = EMPTY_ARRAY, stackOffset =
                 {
                     const ref = "QWIK-SELF";
                     const frames = new Error(ref).stack.split("\n");
-                    const start = frames.findIndex((f => f.includes(ref)));
+                    const start = frames.findIndex(f => f.includes(ref));
                     match = frames[start + 2 + stackOffset].match(EXTRACT_FILE_NAME), chunk = match ? match[1] : "main";
                 }
             }
@@ -778,7 +801,7 @@ const useLexicalScope = () => {
     return qrl.$captureRef$;
 };
 
-const queueQRL = (...args) => {
+const _run = (...args) => {
     const [runQrl] = useLexicalScope();
     const context = getInvokeContext();
     const hostElement = context.$hostElement$;
@@ -789,15 +812,45 @@ const queueQRL = (...args) => {
     if (!scheduler) {
         throw qError(1);
     }
-    return scheduler(2, hostElement, runQrl, args);
+    const chore = scheduler(2, hostElement, runQrl, args);
+    return getChorePromise(chore);
+};
+
+const mapApp_findIndx = (array, key, start) => {
+    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, allowNullValue = !1) => {
+    const indx = mapApp_findIndx(array, key, start);
+    indx >= 0 ? null != value || allowNullValue ? array[indx + 1] = value : array.splice(indx, 2) : (null != value || allowNullValue) && array.splice(-1 ^ 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 mapArray_has = (array, key, start) => mapApp_findIndx(array, key, start) >= 0;
+
 const _CONST_PROPS = Symbol("CONST");
 
 const _VAR_PROPS = Symbol("VAR");
 
 const _IMMUTABLE = Symbol("IMMUTABLE");
 
+const _UNINITIALIZED = Symbol("UNINITIALIZED");
+
 const implicit$FirstArg = fn => function(first, ...rest) {
     return fn.call(null, dollar(first), ...rest);
 };
@@ -809,25 +862,23 @@ const log = (...args) => console.log("COMPUTED SIGNAL", ...args.map(qwikDebugToS
 class ComputedSignalImpl extends SignalImpl {
     $computeQrl$;
     $flags$;
-    $forceRunEffects$=!1;
     [_EFFECT_BACK_REF]=null;
-    constructor(container, fn, flags = 1) {
+    constructor(container, fn, flags = 33) {
         super(container, NEEDS_COMPUTATION), this.$computeQrl$ = fn, this.$flags$ = flags;
     }
-    $invalidate$() {
-        this.$flags$ |= 1, this.$forceRunEffects$ = !1, this.$container$?.$scheduler$(7, null, this, this.$effects$);
+    invalidate() {
+        this.$flags$ |= 1, this.$container$?.$scheduler$(7, null, this, this.$effects$);
     }
     force() {
-        this.$forceRunEffects$ = !0, this.$container$?.$scheduler$(7, null, this, this.$effects$);
+        this.$flags$ |= 2, super.force();
     }
     get untrackedValue() {
-        const didChange = this.$computeIfNeeded$();
-        return didChange && (this.$forceRunEffects$ = didChange), assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state"), 
+        return this.$computeIfNeeded$(), assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state"), 
         this.$untrackedValue$;
     }
     $computeIfNeeded$() {
         if (!(1 & this.$flags$)) {
-            return !1;
+            return;
         }
         const computeQrl = this.$computeQrl$;
         throwIfQRLNotResolved(computeQrl);
@@ -840,8 +891,8 @@ class ComputedSignalImpl extends SignalImpl {
                 throw qError(29, [ computeQrl.dev ? computeQrl.dev.file : "", computeQrl.$hash$ ]);
             }
             this.$flags$ &= -2;
-            const didChange = untrackedValue !== this.$untrackedValue$;
-            return didChange && (this.$untrackedValue$ = untrackedValue), didChange;
+            untrackedValue !== this.$untrackedValue$ && (this.$untrackedValue$ !== NEEDS_COMPUTATION && (this.$flags$ |= 2), 
+            this.$untrackedValue$ = untrackedValue);
         } finally {
             ctx && (ctx.$effectSubscriber$ = previousEffectSubscription);
         }
@@ -856,12 +907,12 @@ class ComputedSignalImpl extends SignalImpl {
 
 class SerializerSignalImpl extends ComputedSignalImpl {
     constructor(container, argQrl) {
-        super(container, argQrl);
+        super(container, argQrl, 33);
     }
     $didInitialize$=!1;
     $computeIfNeeded$() {
         if (!(1 & this.$flags$)) {
-            return !1;
+            return;
         }
         throwIfQRLNotResolved(this.$computeQrl$);
         let arg = this.$computeQrl$.resolved;
@@ -869,10 +920,10 @@ class SerializerSignalImpl extends ComputedSignalImpl {
         const {deserialize, initial} = arg;
         const update = arg.update;
         const currentValue = this.$untrackedValue$ === NEEDS_COMPUTATION ? initial : this.$untrackedValue$;
-        const untrackedValue = trackSignal((() => this.$didInitialize$ ? update?.(currentValue) : deserialize(currentValue)), this, ".", this.$container$);
+        const untrackedValue = trackSignal(() => this.$didInitialize$ ? update?.(currentValue) || currentValue : deserialize(currentValue), this, ".", this.$container$);
         const didChange = this.$didInitialize$ && "undefined" !== untrackedValue || untrackedValue !== this.$untrackedValue$;
-        return this.$flags$ &= -2, this.$didInitialize$ = !0, didChange && (this.$untrackedValue$ = untrackedValue), 
-        didChange;
+        this.$flags$ &= -2, this.$didInitialize$ = !0, didChange && (this.$flags$ |= 2, 
+        this.$untrackedValue$ = untrackedValue);
     }
 }
 
@@ -880,6 +931,16 @@ const getStoreHandler = value => value[STORE_HANDLER];
 
 const getStoreTarget = value => value?.[STORE_TARGET] || null;
 
+const forceStoreEffects = (value, prop) => {
+    const handler = getStoreHandler(value);
+    handler && handler.force(prop);
+};
+
+const _hasStoreEffects = (value, prop) => {
+    const handler = getStoreHandler(value);
+    return !!handler && (handler.$effects$?.get(prop)?.size ?? 0) > 0;
+};
+
 const unwrapStore = value => getStoreTarget(value) || value;
 
 const isStore = value => STORE_TARGET in value;
@@ -907,6 +968,10 @@ class StoreHandler {
     toString() {
         return "[Store]";
     }
+    force(prop) {
+        const target = getStoreTarget(this);
+        this.$container$?.$scheduler$(7, null, this, getEffects(target, prop, this.$effects$));
+    }
     get(target, prop) {
         if ("symbol" == typeof prop) {
             return prop === STORE_TARGET ? target : prop === STORE_HANDLER ? this : target[prop];
@@ -928,7 +993,7 @@ class StoreHandler {
         if ("toString" === prop && value === Object.prototype.toString) {
             return this.toString;
         }
-        return 1 & this.$flags$ && "object" == typeof value && null !== value && !Object.isFrozen(value) && !isStore(value) && !Object.isFrozen(target) ? getOrCreateStore(value, this.$flags$, this.$container$) : value;
+        return 1 & this.$flags$ && isObject(value) && !Object.isFrozen(value) && !isStore(value) && !Object.isFrozen(target) ? getOrCreateStore(value, this.$flags$, this.$container$) : value;
     }
     set(target, prop, value) {
         if ("symbol" == typeof prop) {
@@ -943,7 +1008,7 @@ class StoreHandler {
         return !0;
     }
     deleteProperty(target, prop) {
-        return "string" == typeof prop && delete target[prop] && (triggerEffects(this.$container$, this, getEffects(target, prop, this.$effects$)), 
+        return "string" == typeof prop && delete target[prop] && (Array.isArray(target) || this.$container$?.$scheduler$(7, null, this, getEffects(target, prop, this.$effects$)), 
         !0);
     }
     has(target, prop) {
@@ -982,7 +1047,9 @@ function addStoreEffect(target, prop, store, effectSubscription) {
 }
 
 function setNewValueAndTriggerEffects(prop, value, target, currentStore) {
-    target[prop] = value, triggerEffects(currentStore.$container$, currentStore, getEffects(target, prop, currentStore.$effects$));
+    target[prop] = value;
+    const effects = getEffects(target, prop, currentStore.$effects$);
+    effects && currentStore.$container$?.$scheduler$(7, null, currentStore, effects);
 }
 
 function getEffects(target, prop, storeEffects) {
@@ -1012,7 +1079,7 @@ function getEffects(target, prop, storeEffects) {
 const trackFn = (target, container) => (obj, prop) => {
     const ctx = newInvokeContext();
     return ctx.$effectSubscriber$ = getSubscriber(target, ":"), ctx.$container$ = container || void 0, 
-    invoke(ctx, (() => {
+    invoke(ctx, () => {
         if (isFunction(obj)) {
             return obj();
         }
@@ -1027,21 +1094,21 @@ const trackFn = (target, container) => (obj, prop) => {
             obj;
         }
         throw qError(2);
-    }));
+    });
 };
 
 const cleanupFn = (target, handleError) => {
     let cleanupFns = null;
     return [ fn => {
-        "function" == typeof fn && (cleanupFns || (cleanupFns = [], target.$destroy$ = noSerialize((() => {
-            target.$destroy$ = null, cleanupFns.forEach((fn => {
+        "function" == typeof fn && (cleanupFns || (cleanupFns = [], target.$destroy$ = noSerialize(() => {
+            target.$destroy$ = null, cleanupFns.forEach(fn => {
                 try {
                     fn();
                 } catch (err) {
                     handleError(err);
                 }
-            }));
-        }))), cleanupFns.push(fn));
+            });
+        })), cleanupFns.push(fn));
     }, cleanupFns ?? [] ];
 };
 
@@ -1051,13 +1118,13 @@ class AsyncComputedSignalImpl extends ComputedSignalImpl {
     $loadingEffects$=null;
     $errorEffects$=null;
     $destroy$;
-    $promiseValue$=null;
+    $promiseValue$=NEEDS_COMPUTATION;
     [_EFFECT_BACK_REF]=null;
     constructor(container, fn, flags = 1) {
         super(container, fn, flags);
     }
     get loading() {
-        return setupSignalValueAccess(this, (() => this.$loadingEffects$ ||= new Set), (() => this.untrackedLoading));
+        return setupSignalValueAccess(this, () => this.$loadingEffects$ ||= new Set, () => this.untrackedLoading);
     }
     set untrackedLoading(value) {
         value !== this.$untrackedLoading$ && (this.$untrackedLoading$ = value, this.$container$?.$scheduler$(7, null, this, this.$loadingEffects$));
@@ -1066,7 +1133,7 @@ class AsyncComputedSignalImpl extends ComputedSignalImpl {
         return this.$untrackedLoading$;
     }
     get error() {
-        return setupSignalValueAccess(this, (() => this.$errorEffects$ ||= new Set), (() => this.untrackedError));
+        return setupSignalValueAccess(this, () => this.$errorEffects$ ||= new Set, () => this.untrackedError);
     }
     set untrackedError(value) {
         value !== this.$untrackedError$ && (this.$untrackedError$ = value, this.$container$?.$scheduler$(7, null, this, this.$errorEffects$));
@@ -1074,40 +1141,48 @@ class AsyncComputedSignalImpl extends ComputedSignalImpl {
     get untrackedError() {
         return this.$untrackedError$;
     }
+    invalidate() {
+        super.invalidate(), this.$promiseValue$ = NEEDS_COMPUTATION;
+    }
     $computeIfNeeded$() {
         if (!(1 & this.$flags$)) {
-            return !1;
+            return;
         }
         const computeQrl = this.$computeQrl$;
         throwIfQRLNotResolved(computeQrl);
-        const [cleanup] = cleanupFn(this, (err => this.$container$?.handleError(err, null)));
-        const untrackedValue = this.$promiseValue$ ?? computeQrl.getFn()({
+        const [cleanup] = cleanupFn(this, err => this.$container$?.handleError(err, null));
+        const untrackedValue = this.$promiseValue$ === NEEDS_COMPUTATION ? computeQrl.getFn()({
             track: trackFn(this, this.$container$),
             cleanup
-        });
+        }) : this.$promiseValue$;
         if (isPromise(untrackedValue)) {
-            throw this.untrackedLoading = !0, this.untrackedError = null, untrackedValue.then((promiseValue => {
+            throw this.untrackedLoading = !0, this.untrackedError = null, untrackedValue.then(promiseValue => {
                 this.$promiseValue$ = promiseValue, this.untrackedLoading = !1, this.untrackedError = null;
-            })).catch((err => {
-                this.untrackedLoading = !1, this.untrackedError = err;
-            }));
+            }).catch(err => {
+                this.$promiseValue$ = err, this.untrackedLoading = !1, this.untrackedError = err;
+            });
         }
-        this.$promiseValue$ = null, this.$flags$ &= -2;
+        this.$promiseValue$ = NEEDS_COMPUTATION, this.$flags$ &= -2;
         const didChange = untrackedValue !== this.$untrackedValue$;
-        return didChange && (this.$untrackedValue$ = untrackedValue), didChange;
+        return didChange && (this.$flags$ |= 2, this.$untrackedValue$ = untrackedValue), 
+        didChange;
     }
 }
 
 const createSignal$1 = value => new SignalImpl(null, value);
 
-const createComputedSignal = qrl => (throwIfQRLNotResolved(qrl), new ComputedSignalImpl(null, qrl));
+const createComputedSignal = (qrl, options) => new ComputedSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || "always"));
 
-const createSerializerSignal = arg => (throwIfQRLNotResolved(arg), new SerializerSignalImpl(null, arg));
+const createAsyncComputedSignal = (qrl, options) => new AsyncComputedSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || "never"));
+
+const createSerializerSignal = arg => new SerializerSignalImpl(null, arg);
 
 const createSignal = createSignal$1;
 
 const createComputed$ = /*#__PURE__*/ implicit$FirstArg(createComputedSignal);
 
+const createAsyncComputed$ = /*#__PURE__*/ implicit$FirstArg(createAsyncComputedSignal);
+
 const createSerializer$ = implicit$FirstArg(createSerializerSignal);
 
 const getValueProp = p0 => p0.value;
@@ -1124,7 +1199,7 @@ const _wrapProp = (...args) => {
     }
     if (isSignal(obj)) {
         return obj instanceof AsyncComputedSignalImpl || assertEqual(prop, "value", "Left side is a signal, prop must be value"), 
-        obj instanceof WrappedSignalImpl && 2 & obj.flags ? obj : getWrapped(args);
+        obj instanceof WrappedSignalImpl && 4 & obj.flags ? obj : getWrapped(args);
     }
     if (isPropsProxy(obj)) {
         const constProps = obj[_CONST_PROPS];
@@ -1141,11 +1216,6 @@ const _wrapProp = (...args) => {
     return obj[prop];
 };
 
-const _wrapStore = (obj, prop) => {
-    const value = getStoreTarget(obj)[prop];
-    return isSignal(value) ? value : new WrappedSignalImpl(null, getProp, [ obj, prop ], null, 1);
-};
-
 const _wrapSignal = (obj, prop) => {
     const r = _wrapProp(obj, prop);
     return r === _IMMUTABLE ? obj[prop] : r;
@@ -1168,7 +1238,7 @@ function isSlotProp(prop) {
     return !prop.startsWith("q:") && !prop.startsWith(":");
 }
 
-const _restProps = (props, omit, target = {}) => {
+const _restProps = (props, omit = [], target = {}) => {
     let constPropsTarget = null;
     const constProps = props[_CONST_PROPS];
     if (constProps) {
@@ -1410,45 +1480,51 @@ const executeComponent = (container, renderHost, subscriptionHost, componentQRL,
         const inlineComponent = 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.setHostProp(renderHost, "q:props", props)), 
-    vnode_isVNode(renderHost) && clearAllEffects(container, renderHost), componentFn(props))), (jsx => {
+    const executeComponentWithPromiseExceptionRetry = (retryCount = 0) => safeCall(() => (isInlineComponent || (container.setHostProp(renderHost, "q:seqIdx", null), 
+    container.setHostProp(renderHost, ":onIdx", null)), vnode_isVNode(renderHost) && clearAllEffects(container, renderHost), 
+    componentFn(props)), jsx => {
         const useOnEvents = container.getHostProp(renderHost, ":on");
         return useOnEvents ? addUseOnEvents(jsx, useOnEvents) : jsx;
-    }), (err => {
+    }, err => {
         if (isPromise(err) && retryCount < 100) {
-            return err.then((() => executeComponentWithPromiseExceptionRetry(retryCount++)));
+            return err.then(() => executeComponentWithPromiseExceptionRetry(++retryCount));
+        }
+        if (retryCount >= 100) {
+            throw new Error("Max retry count of component execution reached");
         }
         throw err;
-    }));
+    });
     return executeComponentWithPromiseExceptionRetry();
 };
 
 function addUseOnEvents(jsx, useOnEvents) {
-    const jsxElement = findFirstStringJSX(jsx);
+    const jsxElement = findFirstElementNode(jsx);
     let jsxResult = jsx;
-    return maybeThen(jsxElement, (jsxElement => {
-        let isInvisibleComponent = !1;
-        jsxElement || (isInvisibleComponent = !0);
+    return maybeThen(jsxElement, jsxElement => {
+        const isHeadless = !jsxElement;
+        let placeholderElement = null;
         for (const key in useOnEvents) {
             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 {
+                let targetElement = jsxElement;
+                let eventKey = key;
+                if (isHeadless) {
+                    if ("onQvisible$" !== key && !key.startsWith("document:on") && !key.startsWith("window:on")) {
                         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. ');
+                        continue;
                     }
-                } else {
-                    jsxElement && addUseOnEvent(jsxElement, key, useOnEvents[key]);
+                    if (!placeholderElement) {
+                        const [createdElement, newJsx] = injectPlaceholderElement(jsxResult);
+                        jsxResult = newJsx, placeholderElement = createdElement;
+                    }
+                    targetElement = placeholderElement;
                 }
+                targetElement && ("script" === targetElement.type && "onQvisible$" === key && (eventKey = "document:onQInit$", 
+                logWarn('You are trying to add an event "' + key + '" using `useVisibleTask$` hook, but a node to which you can add an event is not found. Using document:onQInit$ instead.')), 
+                addUseOnEvent(targetElement, eventKey, useOnEvents[key]));
             }
         }
         return jsxResult;
-    }));
+    });
 }
 
 function addUseOnEvent(jsxElement, key, value) {
@@ -1459,7 +1535,7 @@ function addUseOnEvent(jsxElement, key, value) {
     propValue.push(...value), props[key] = propValue;
 }
 
-function findFirstStringJSX(jsx) {
+function findFirstElementNode(jsx) {
     const queue = [ jsx ];
     for (;queue.length; ) {
         const jsx = queue.shift();
@@ -1468,34 +1544,42 @@ function findFirstStringJSX(jsx) {
                 return jsx;
             }
             queue.push(jsx.children);
-        } else if (Array.isArray(jsx)) {
+        } else if (isArray(jsx)) {
             queue.push(...jsx);
         } else {
             if (isPromise(jsx)) {
-                return maybeThen(jsx, (jsx => findFirstStringJSX(jsx)));
+                return maybeThen(jsx, jsx => findFirstElementNode(jsx));
             }
             if (isSignal(jsx)) {
-                return findFirstStringJSX(untrack((() => jsx.value)));
+                return findFirstElementNode(untrack(() => jsx.value));
             }
         }
     }
     return null;
 }
 
-function addScriptNodeForInvisibleComponents(jsx) {
+function injectPlaceholderElement(jsx) {
     if (isJSXNode(jsx)) {
-        const jsxElement = new JSXNodeImpl("script", {}, {
-            type: "placeholder",
-            hidden: ""
-        }, null, 3);
-        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 ]);
+        const placeholder = createPlaceholderScriptNode();
+        return jsx.type === Slot ? [ placeholder, _jsxSorted(Fragment, null, null, [ jsx, placeholder ], 0, null) ] : (null == jsx.children ? jsx.children = placeholder : isArray(jsx.children) ? jsx.children.push(placeholder) : jsx.children = [ jsx.children, placeholder ], 
+        [ placeholder, jsx ]);
+    }
+    if (isPrimitive(jsx)) {
+        const placeholder = createPlaceholderScriptNode();
+        return [ placeholder, _jsxSorted(Fragment, null, null, [ jsx, placeholder ], 0, null) ];
     }
-    if (Array.isArray(jsx) && jsx.length) {
-        const [jsxElement, _] = addScriptNodeForInvisibleComponents(jsx[0]);
-        return [ jsxElement, jsx ];
+    if (isArray(jsx) && jsx.length > 0) {
+        const [createdElement, _] = injectPlaceholderElement(jsx[0]);
+        return [ createdElement, jsx ];
     }
-    return [ null, null ];
+    return [ null, jsx ];
+}
+
+function createPlaceholderScriptNode() {
+    return new JSXNodeImpl("script", {}, {
+        type: "placeholder",
+        hidden: ""
+    }, null, 3);
 }
 
 const applyInlineComponent = (ssr, componentHost, inlineComponentFunction, jsx) => {
@@ -1507,10 +1591,10 @@ const applyQwikComponentBody = (ssr, jsx, component) => {
     const host = ssr.getOrCreateLastNode();
     const [componentQrl] = component[SERIALIZABLE_STATE];
     const srcProps = jsx.props;
-    srcProps && srcProps.children && delete srcProps.children;
-    const scheduler = ssr.$scheduler$;
-    return host.setProp("q:renderFn", componentQrl), host.setProp("q:props", srcProps), 
-    null !== jsx.key && host.setProp("q:key", jsx.key), scheduler(6, host, componentQrl, srcProps);
+    srcProps && srcProps.children && delete srcProps.children, host.setProp("q:renderFn", componentQrl), 
+    host.setProp("q:props", srcProps), null !== jsx.key && host.setProp("q:key", jsx.key);
+    const componentChore = ssr.$scheduler$(6, host, componentQrl, srcProps);
+    return getChorePromise(componentChore);
 };
 
 class ParentComponentData {
@@ -1531,7 +1615,12 @@ async function _walkJSX(ssr, value, options) {
             const value = stack.pop();
             if (value instanceof ParentComponentData) {
                 options.currentStyleScoped = value.$scopedStyle$, options.parentComponentFrame = value.$componentFrame$;
-            } else if (value !== MaybeAsyncSignal) {
+            } else {
+                if (value === MaybeAsyncSignal) {
+                    const trackFn = stack.pop();
+                    await retryOnPromise(() => stack.push(trackFn()));
+                    continue;
+                }
                 if ("function" != typeof value) {
                     processJSXNode(ssr, enqueue, value, {
                         styleScoped: options.currentStyleScoped,
@@ -1544,9 +1633,6 @@ async function _walkJSX(ssr, value, options) {
                     }
                     await value.apply(ssr);
                 }
-            } else {
-                const trackFn = stack.pop();
-                await retryOnPromise((() => stack.push(trackFn())));
             }
         }
     })();
@@ -1569,20 +1655,20 @@ function processJSXNode(ssr, enqueue, value, options) {
         } else if (isSignal(value)) {
             ssr.openFragment(isDev ? [ DEBUG_TYPE, "S" ] : EMPTY_ARRAY);
             const signalNode = ssr.getOrCreateLastNode();
-            enqueue(ssr.closeFragment), enqueue((() => trackSignalAndAssignHost(value, signalNode, ".", ssr))), 
+            enqueue(ssr.closeFragment), enqueue(() => trackSignalAndAssignHost(value, signalNode, ".", ssr)), 
             enqueue(MaybeAsyncSignal);
         } else if (isPromise(value)) {
             ssr.openFragment(isDev ? [ DEBUG_TYPE, "A" ] : EMPTY_ARRAY), enqueue(ssr.closeFragment), 
-            enqueue(value), enqueue(Promise), enqueue((() => ssr.commentNode("qkssr-f")));
+            enqueue(value), enqueue(Promise), enqueue(() => ssr.commentNode("qkssr-f"));
         } else if (isAsyncGenerator(value)) {
-            enqueue((async () => {
+            enqueue(async () => {
                 for await (const chunk of value) {
                     await _walkJSX(ssr, chunk, {
                         currentStyleScoped: options.styleScoped,
                         parentComponentFrame: options.parentComponentFrame
                     }), ssr.commentNode("qkssr-f");
                 }
-            }));
+            });
         } else {
             const jsx = value;
             const type = jsx.type;
@@ -1590,7 +1676,14 @@ function processJSXNode(ssr, enqueue, value, options) {
                 appendClassIfScopedStyleExists(jsx, options.styleScoped);
                 let qwikInspectorAttrValue = null;
                 isDev && jsx.dev && "head" !== jsx.type && (qwikInspectorAttrValue = getFileLocationFromJsx(jsx.dev));
-                const innerHTML = ssr.openElement(type, varPropsToSsrAttrs(jsx.varProps, jsx.constProps, ssr.serializationCtx, options.styleScoped, jsx.key), constPropsToSsrAttrs(jsx.constProps, jsx.varProps, ssr.serializationCtx, options.styleScoped), qwikInspectorAttrValue);
+                const innerHTML = ssr.openElement(type, varPropsToSsrAttrs(jsx.varProps, jsx.constProps, {
+                    serializationCtx: ssr.serializationCtx,
+                    styleScopedId: options.styleScoped,
+                    key: jsx.key
+                }), constPropsToSsrAttrs(jsx.constProps, jsx.varProps, {
+                    serializationCtx: ssr.serializationCtx,
+                    styleScopedId: options.styleScoped
+                }), qwikInspectorAttrValue);
                 innerHTML && ssr.htmlNode(innerHTML), enqueue(ssr.closeElement), "head" === type ? (ssr.emitQwikLoaderAtTopIfNeeded(), 
                 ssr.emitPreloaderPre(), enqueue(ssr.additionalHeadNodes)) : "body" === type ? enqueue(ssr.additionalBodyNodes) : ssr.isHtml || ssr._didAddQwikLoader || (ssr.emitQwikLoaderAtTopIfNeeded(), 
                 ssr.emitPreloaderPre(), ssr._didAddQwikLoader = !0);
@@ -1658,18 +1751,19 @@ function processJSXNode(ssr, enqueue, value, options) {
     }
 }
 
-function varPropsToSsrAttrs(varProps, constProps, serializationCtx, styleScopedId, key) {
-    return toSsrAttrs(varProps, constProps, serializationCtx, !0, styleScopedId, key);
+function varPropsToSsrAttrs(varProps, constProps, options) {
+    return toSsrAttrs(varProps, constProps, !1, options);
 }
 
-function constPropsToSsrAttrs(constProps, varProps, serializationCtx, styleScopedId) {
-    return toSsrAttrs(constProps, varProps, serializationCtx, !1, styleScopedId);
+function constPropsToSsrAttrs(constProps, varProps, options) {
+    return toSsrAttrs(constProps, varProps, !0, options);
 }
 
-function toSsrAttrs(record, anotherRecord, serializationCtx, pushMergedEventProps, styleScopedId, key) {
+function toSsrAttrs(record, anotherRecord, isConst, options) {
     if (null == record) {
         return null;
     }
+    const pushMergedEventProps = !isConst;
     const ssrAttrs = [];
     for (const key in record) {
         let value = record[key];
@@ -1683,14 +1777,14 @@ function toSsrAttrs(record, anotherRecord, serializationCtx, pushMergedEventProp
                     value = getMergedEventPropValues(value, anotherValue);
                 }
             }
-            const eventValue = setEvent(serializationCtx, key, value);
+            const eventValue = setEvent(options.serializationCtx, key, value);
             eventValue && ssrAttrs.push(jsxEventToHtmlAttribute(key), eventValue);
-        } else {
-            isSignal(value) ? isClassAttr(key) ? ssrAttrs.push(key, [ value, styleScopedId ]) : ssrAttrs.push(key, value) : (isPreventDefault(key) && addPreventDefaultEventToSerializationContext(serializationCtx, key), 
-            value = serializeAttribute(key, value, styleScopedId), ssrAttrs.push(key, value));
+            continue;
         }
+        isSignal(value) ? isClassAttr(key) ? ssrAttrs.push(key, [ value, options.styleScopedId ]) : ssrAttrs.push(key, value) : (isPreventDefault(key) && addPreventDefaultEventToSerializationContext(options.serializationCtx, key), 
+        value = serializeAttribute(key, value, options.styleScopedId), ssrAttrs.push(key, value));
     }
-    return null != key && ssrAttrs.push("q:key", key), ssrAttrs;
+    return null != options.key && ssrAttrs.push("q:key", options.key), ssrAttrs;
 }
 
 function getMergedEventPropValues(value, anotherValue) {
@@ -1715,7 +1809,7 @@ function setEvent(serializationCtx, key, rawValue) {
     const appendToValue = valueToAppend => {
         value = (null == value ? "" : value + "\n") + valueToAppend;
     };
-    const getQrlString = qrl => (qrl.$symbol$.startsWith("_") || !qrl.$captureRef$ && !qrl.$capture$ || (qrl = createQRL(null, "_run", queueQRL, null, null, [ qrl ])), 
+    const getQrlString = qrl => (qrl.$symbol$.startsWith("_") || !qrl.$captureRef$ && !qrl.$capture$ || (qrl = createQRL(null, "_run", _run, null, null, [ qrl ])), 
     qrlToString(serializationCtx, qrl));
     if (Array.isArray(qrls)) {
         for (let i = 0; i <= qrls.length; i++) {
@@ -1771,27 +1865,29 @@ const useTaskQrl = qrl => {
     assertQrl(qrl), set(1);
     const task = new Task(10, i, iCtx.$hostElement$, qrl, void 0, null);
     set(task);
-    const promise = iCtx.$container$.$scheduler$(3, task);
-    isPromise(promise) && promise.catch((() => {}));
+    const result = runTask(task, iCtx.$container$, iCtx.$hostElement$);
+    if (isPromise(result)) {
+        throw result;
+    }
 };
 
 const runTask = (task, container, host) => {
     task.$flags$ &= -9, cleanupTask(task);
     const iCtx = newInvokeContext(container.$locale$, host, void 0, "qTask");
     iCtx.$container$ = container;
-    const taskFn = task.$qrl$.getFn(iCtx, (() => clearAllEffects(container, task)));
+    const taskFn = task.$qrl$.getFn(iCtx, () => clearAllEffects(container, task));
     const track = trackFn(task, container);
-    const [cleanup] = cleanupFn(task, (reason => container.handleError(reason, host)));
+    const [cleanup] = cleanupFn(task, reason => container.handleError(reason, host));
     const taskApi = {
         track,
         cleanup
     };
-    return safeCall((() => taskFn(taskApi)), cleanup, (err => {
+    return safeCall(() => taskFn(taskApi), cleanup, err => {
         if (isPromise(err)) {
-            return err.then((() => runTask(task, container, host)));
+            return err.then(() => runTask(task, container, host));
         }
         throw err;
-    }));
+    });
 };
 
 const cleanupTask = task => {
@@ -1823,7 +1919,7 @@ const isTask = value => value instanceof Task;
 
 const scheduleTask = (_event, element) => {
     const [task] = useLexicalScope();
-    const type = 1 & task.$flags$ ? 32 : 3;
+    const type = 1 & task.$flags$ ? 16 : 3;
     getDomContainer(element).$scheduler$(type, task);
 };
 
@@ -1835,11 +1931,11 @@ const _jsxSorted = (type, varProps, constProps, children, flags, key) => {
 
 const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
     let sortedProps;
-    return sortedProps = varProps ? Object.fromEntries(untrack((() => Object.entries(varProps))).filter((entry => {
+    return sortedProps = varProps ? Object.fromEntries(untrack(() => Object.entries(varProps)).filter(entry => {
         const attr = entry[0];
         return "children" === attr ? (children ??= entry[1], !1) : "key" === attr ? (key = entry[1], 
         !1) : !constProps || !(attr in constProps) || /^on[A-Z].*\$$/.test(attr);
-    })).sort((([a], [b]) => a < b ? -1 : 1))) : "string" == typeof type ? EMPTY_OBJ : {}, 
+    }).sort(([a], [b]) => a < b ? -1 : 1)) : "string" == typeof type ? EMPTY_OBJ : {}, 
     constProps && "children" in constProps && (children = constProps.children, constProps.children = void 0), 
     _jsxSorted(type, sortedProps, constProps, children, flags, key, dev);
 };
@@ -1910,10 +2006,10 @@ const Fragment = props => props.children;
 
 const jsxDEV = (type, props, key, _isStatic, opts) => {
     const processed = null == key ? null : String(key);
-    const children = untrack((() => {
+    const children = untrack(() => {
         const c = props.children;
         return "string" == typeof type && delete props.children, c;
-    }));
+    });
     isString(type) && "className" in props && (props.class = props.className, delete props.className);
     const node = new JSXNodeImpl(type, props, null, children, 0, processed);
     return node.dev = {
@@ -1944,7 +2040,7 @@ class PropsProxyHandler {
             return this.$children$;
         }
         const value = this.$constProps$ && prop in this.$constProps$ ? this.$constProps$[prop] : this.$varProps$[prop];
-        return value instanceof WrappedSignalImpl && 2 & value.$flags$ ? value.value : value;
+        return value instanceof WrappedSignalImpl && 4 & value.$flags$ ? value.value : value;
     }
     set(_, prop, value) {
         return prop === _CONST_PROPS ? (this.$constProps$ = value, !0) : prop === _VAR_PROPS ? (this.$varProps$ = value, 
@@ -1983,30 +2079,12 @@ class PropsProxyHandler {
 
 const directGetPropsProxyProp = (jsx, prop) => jsx.constProps && prop in jsx.constProps ? jsx.constProps[prop] : jsx.varProps[prop];
 
-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 _getVarProps = props => props ? _VAR_PROPS in props ? "children" in props ? {
+    ...props[_VAR_PROPS],
+    children: props.children
+} : props[_VAR_PROPS] : props : null;
 
-const mapArray_get = (array, key, start) => {
-    const indx = mapApp_findIndx(array, key, start);
-    return indx >= 0 ? array[indx + 1] : null;
-};
+const _getConstProps = props => props && _CONST_PROPS in props ? props[_CONST_PROPS] : null;
 
 const isForeignObjectElement = elementName => isDev ? "foreignobject" === elementName.toLowerCase() : "foreignObject" === elementName;
 
@@ -2153,6 +2231,27 @@ function getNewElementNamespaceData(domParentVNode, tagOrVNode) {
     };
 }
 
+function getAttributeNamespace(attributeName) {
+    switch (attributeName) {
+      case "xlink:href":
+      case "xlink:actuate":
+      case "xlink:arcrole":
+      case "xlink:role":
+      case "xlink:show":
+      case "xlink:title":
+      case "xlink:type":
+        return XLINK_NS;
+
+      case "xml:base":
+      case "xml:lang":
+      case "xml:space":
+        return XML_NS;
+
+      default:
+        return null;
+    }
+}
+
 function escapeHTML(html) {
     let escapedHTML = "";
     const length = html.length;
@@ -2198,42 +2297,44 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
             const jsxNode = asyncQueue.shift();
             const vHostNode = asyncQueue.shift();
             if (isPromise(jsxNode)) {
-                return jsxNode.then((jsxNode => (diff(jsxNode, vHostNode), drainAsyncQueue())));
+                return jsxNode.then(jsxNode => (diff(jsxNode, vHostNode), drainAsyncQueue()));
             }
             diff(jsxNode, vHostNode);
         }
     }();
     function diff(jsxNode, vStartNode) {
-        for (assertFalse(vnode_isVNode(jsxNode), "JSXNode should not be a VNode"), assertTrue(vnode_isVNode(vStartNode), "vStartNode should be a VNode"), 
+        if (assertFalse(vnode_isVNode(jsxNode), "JSXNode should not be a VNode"), assertTrue(vnode_isVNode(vStartNode), "vStartNode should be a VNode"), 
         vParent = vStartNode, vNewNode = null, vCurrent = vnode_getFirstChild(vStartNode), 
-        stackPush(jsxNode, !0); stack.length; ) {
-            for (;jsxIdx < jsxCount; ) {
-                if (assertFalse(vParent === vCurrent, "Parent and current can't be the same"), "string" == typeof jsxValue) {
-                    expectText(jsxValue);
-                } else if ("number" == typeof jsxValue) {
-                    expectText(String(jsxValue));
-                } else if (jsxValue && "object" == typeof jsxValue) {
-                    if (Array.isArray(jsxValue)) {
-                        descend(jsxValue, !1);
-                    } else if (isSignal(jsxValue)) {
-                        vCurrent && clearAllEffects(container, vCurrent), expectVirtual("S", null), descend(trackSignalAndAssignHost(jsxValue, vNewNode || vCurrent, ".", container), !0);
-                    } else if (isPromise(jsxValue)) {
-                        expectVirtual("A", null), asyncQueue.push(jsxValue, vNewNode || vCurrent);
-                    } else if (isJSXNode(jsxValue)) {
-                        const type = jsxValue.type;
-                        "string" == typeof type ? (expectNoMoreTextNodes(), expectElement(jsxValue, type), 
-                        descend(jsxValue.children, !0)) : "function" == typeof type && (type === Fragment ? (expectNoMoreTextNodes(), 
-                        expectVirtual("F", jsxValue.key), descend(jsxValue.children, !0)) : type === Slot ? (expectNoMoreTextNodes(), 
-                        expectSlot() || descend(jsxValue.children, !0)) : type === Projection ? (expectProjection(), 
-                        descend(jsxValue.children, !0)) : type === SSRComment || type === SSRRaw ? expectNoMore() : (expectNoMoreTextNodes(), 
-                        expectComponent(type)));
+        stackPush(jsxNode, !0), !(32 & vParent[0])) {
+            for (;stack.length; ) {
+                for (;jsxIdx < jsxCount; ) {
+                    if (assertFalse(vParent === vCurrent, "Parent and current can't be the same"), "string" == typeof jsxValue) {
+                        expectText(jsxValue);
+                    } else if ("number" == typeof jsxValue) {
+                        expectText(String(jsxValue));
+                    } else if (jsxValue && "object" == typeof jsxValue) {
+                        if (Array.isArray(jsxValue)) {
+                            descend(jsxValue, !1);
+                        } else if (isSignal(jsxValue)) {
+                            vCurrent && clearAllEffects(container, vCurrent), expectVirtual("S", null), descend(trackSignalAndAssignHost(jsxValue, vNewNode || vCurrent, ".", container), !0);
+                        } else if (isPromise(jsxValue)) {
+                            expectVirtual("A", null), asyncQueue.push(jsxValue, vNewNode || vCurrent);
+                        } else if (isJSXNode(jsxValue)) {
+                            const type = jsxValue.type;
+                            "string" == typeof type ? (expectNoMoreTextNodes(), expectElement(jsxValue, type), 
+                            descend(jsxValue.children, !0)) : "function" == typeof type && (type === Fragment ? (expectNoMoreTextNodes(), 
+                            expectVirtual("F", jsxValue.key), descend(jsxValue.children, !0)) : type === Slot ? (expectNoMoreTextNodes(), 
+                            expectSlot() || descend(jsxValue.children, !0)) : type === Projection ? (expectProjection(), 
+                            descend(jsxValue.children, !0)) : type === SSRComment || type === SSRRaw ? expectNoMore() : (expectNoMoreTextNodes(), 
+                            expectComponent(type)));
+                        }
+                    } else {
+                        jsxValue === SkipRender ? journal = [] : expectText("");
                     }
-                } else {
-                    jsxValue === SkipRender ? journal = [] : expectText("");
+                    advance();
                 }
-                advance();
+                expectNoMore(), ascend();
             }
-            expectNoMore(), ascend();
         }
     }
     function advance() {
@@ -2285,7 +2386,7 @@ 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 = vnode_getProp(vParent, slotName, id => vnode_locate(container.rootVNode, id)), 
         vCurrent = vCurrent && 32 & vCurrent[0] ? null : vCurrent, null == vCurrent && (vNewNode = vnode_newVirtual(), 
         isDev && vnode_setProp(vNewNode, DEBUG_TYPE, "P"), isDev && vnode_setProp(vNewNode, "q:code", "expectProjection"), 
         vnode_setProp(vNewNode, QSlot, slotName), vnode_setProp(vNewNode, "q:sparent", vParent), 
@@ -2351,43 +2452,52 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
                         htmlEvent && vnode_setAttr(journal, vNewNode, htmlEvent, "");
                     }
                     needsQDispatchEventPatch = !0;
-                } else {
-                    if ("ref" === key) {
-                        if (isSignal(value)) {
-                            value.value = element;
-                            continue;
-                        }
-                        if ("function" == typeof value) {
-                            value(element);
-                            continue;
-                        }
-                        if (null == value) {
-                            continue;
-                        }
-                        throw qError(15, [ currentFile ]);
-                    }
+                    continue;
+                }
+                if ("ref" === key) {
                     if (isSignal(value)) {
-                        const signalData = new SubscriptionData({
-                            $scopedStyleIdPrefix$: scopedStyleIdPrefix,
-                            $isConst$: !0
-                        });
-                        value = trackSignalAndAssignHost(value, vNewNode, key, container, signalData);
+                        value.value = element;
+                        continue;
                     }
-                    if (key !== dangerouslySetInnerHTML) {
-                        if ("textarea" !== elementName || "value" !== key) {
-                            value = serializeAttribute(key, value, scopedStyleIdPrefix), null != value && element.setAttribute(key, String(value));
-                        } else {
-                            if (value && "string" != typeof value) {
-                                if (isDev) {
-                                    throw qError(23, [ currentFile, value ]);
+                    if ("function" == typeof value) {
+                        value(element);
+                        continue;
+                    }
+                    if (null == value) {
+                        continue;
+                    }
+                    throw qError(15, [ currentFile ]);
+                }
+                if (isSignal(value)) {
+                    const signalData = new SubscriptionData({
+                        $scopedStyleIdPrefix$: scopedStyleIdPrefix,
+                        $isConst$: !0
+                    });
+                    value = trackSignalAndAssignHost(value, vNewNode, key, container, signalData);
+                }
+                if (key !== dangerouslySetInnerHTML) {
+                    if ("textarea" !== elementName || "value" !== key) {
+                        if (value = serializeAttribute(key, value, scopedStyleIdPrefix), null != value) {
+                            if (64 & vNewNode[0]) {
+                                const namespace = getAttributeNamespace(key);
+                                if (namespace) {
+                                    element.setAttributeNS(namespace, key, String(value));
+                                    continue;
                                 }
-                                continue;
                             }
-                            element.value = escapeHTML(value || "");
+                            element.setAttribute(key, String(value));
                         }
                     } else {
-                        element.innerHTML = value, element.setAttribute("q:container", "html");
+                        if (value && "string" != typeof value) {
+                            if (isDev) {
+                                throw qError(23, [ currentFile, value ]);
+                            }
+                            continue;
+                        }
+                        element.value = escapeHTML(value || "");
                     }
+                } else {
+                    value && (element.innerHTML = String(value), element.setAttribute("q:container", "html"));
                 }
             }
         }
@@ -2484,12 +2594,16 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
             const eventProp = ":" + scope.substring(1) + ":" + eventName;
             const qrls = [ vnode_getProp(vNode, eventProp, null), vnode_getProp(vNode, HANDLER_PREFIX + eventProp, null) ];
             let returnValue = !1;
-            return qrls.flat(2).forEach((qrl => {
+            return qrls.flat(2).forEach(qrl => {
                 if (qrl) {
-                    const value = container.$scheduler$(2, vNode, qrl, [ event, element ]);
-                    returnValue = returnValue || !0 === value;
+                    if (isSyncQrl(qrl)) {
+                        qrl(event, element);
+                    } else {
+                        const value = container.$scheduler$(2, vNode, qrl, [ event, element ]);
+                        returnValue = returnValue || !0 === value;
+                    }
                 }
-            })), returnValue;
+            }), returnValue;
         }));
     }
     function registerQwikLoaderEvent(eventName) {
@@ -2541,9 +2655,12 @@ const vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
             host = vNewNode, shouldRender = !0) : (vNewNode = retrieveChildWithKey(null, lookupKey), 
             vNewNode ? vnode_insertBefore(journal, vParent, vNewNode, vCurrent) : (insertNewComponent(host, componentQRL, jsxProps), 
             shouldRender = !0), host = vNewNode), host) {
-                const vNodeProps = vnode_getProp(host, "q:props", container.$getObjectById$);
-                shouldRender = shouldRender || propsDiffer(jsxProps, vNodeProps), shouldRender && (host[0] &= -33, 
-                container.$scheduler$(6, host, componentQRL, jsxProps));
+                let vNodeProps = vnode_getProp(host, "q:props", container.$getObjectById$);
+                const propsAreDifferent = propsDiffer(jsxProps, vNodeProps);
+                shouldRender = shouldRender || propsAreDifferent, shouldRender && (propsAreDifferent && (vNodeProps ? (vNodeProps[_CONST_PROPS] = jsxProps[_CONST_PROPS], 
+                vNodeProps[_VAR_PROPS] = jsxProps[_VAR_PROPS]) : jsxProps && (vnode_setProp(host, "q:props", jsxProps), 
+                vNodeProps = jsxProps)), vnode_setProp(host, "q:renderFn", componentQRL), host[0] &= -33, 
+                container.$scheduler$(6, host, componentQRL, vNodeProps));
             }
             !function(children, host) {
                 const projectionChildren = Array.isArray(children) ? children : [ children ];
@@ -2679,7 +2796,7 @@ function cleanup(container, vNode) {
                         const obj = seq[i];
                         if (isTask(obj)) {
                             const task = obj;
-                            clearAllEffects(container, task), 1 & task.$flags$ ? container.$scheduler$(48, task) : cleanupTask(task);
+                            clearAllEffects(container, task), 1 & task.$flags$ ? container.$scheduler$(32, task) : cleanupTask(task);
                         }
                     }
                 }
@@ -2705,7 +2822,9 @@ function cleanup(container, vNode) {
                 if (vCursor === vNode) {
                     const vFirstChild = vnode_getFirstChild(vCursor);
                     if (vFirstChild) {
-                        return void vnode_walkVNode(vFirstChild);
+                        return void vnode_walkVNode(vFirstChild, vNode => {
+                            2 & vNode[0] && vnode_getProp(vNode, "q:sparent", id => vnode_locate(container.rootVNode, id));
+                        });
                     }
                 }
             } else {
@@ -2766,8 +2885,9 @@ const useResourceQrl = (qrl, opts) => {
     assertQrl(qrl);
     const container = iCtx.$container$;
     const resource = createResourceReturn(container, opts);
-    const task = new Task(12, i, iCtx.$hostElement$, qrl, resource, null);
-    return container.$scheduler$(3, task), set(resource), resource;
+    const el = iCtx.$hostElement$;
+    const task = new Task(12, i, el, qrl, resource, null);
+    return set(resource), runResource(task, container, el), resource;
 };
 
 const Resource = props => _jsxSorted(Fragment, null, null, getResourceValueAsPromise(props), 0, null);
@@ -2775,8 +2895,8 @@ const Resource = props => _jsxSorted(Fragment, null, null, getResourceValueAsPro
 function getResourceValueAsPromise(props) {
     const resource = props.value;
     if (isResourceReturn(resource)) {
+        const state = resource._state;
         if (!isServerPlatform()) {
-            const state = resource._state;
             if ("pending" === state && props.onPending) {
                 return Promise.resolve().then(useBindInvokeContext(props.onPending));
             }
@@ -2784,16 +2904,22 @@ function getResourceValueAsPromise(props) {
                 return Promise.resolve(resource._error).then(useBindInvokeContext(props.onRejected));
             }
             {
-                const resolvedValue = untrack((() => resource._resolved));
+                const resolvedValue = untrack(() => resource._resolved);
                 if (void 0 !== resolvedValue) {
                     return Promise.resolve(resolvedValue).then(useBindInvokeContext(props.onResolved));
                 }
             }
         }
-        const value = resource.value;
-        return value ? value.then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected)) : Promise.resolve(void 0);
+        return untrack(() => resource.value).then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
+    }
+    if (isPromise(resource)) {
+        return resource.then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
     }
-    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));
+    if (isSignal(resource)) {
+        const value = retryOnPromise(() => resource.value);
+        return (isPromise(value) ? value : Promise.resolve(value)).then(useBindInvokeContext(props.onResolved));
+    }
+    return Promise.resolve(resource).then(useBindInvokeContext(props.onResolved));
 }
 
 const _createResourceReturn = opts => ({
@@ -2818,11 +2944,11 @@ const runResource = (task, container, host) => {
     task.$flags$ &= -9, cleanupTask(task);
     const iCtx = newInvokeContext(container.$locale$, host, void 0, "qResource");
     iCtx.$container$ = container;
-    const taskFn = task.$qrl$.getFn(iCtx, (() => clearAllEffects(container, task)));
+    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 track = trackFn(task, container);
-    const [cleanup, cleanups] = cleanupFn(task, (reason => container.handleError(reason, host)));
+    const [cleanup, cleanups] = cleanupFn(task, reason => container.handleError(reason, host));
     const resourceTarget = unwrapStore(resource);
     const opts = {
         track,
@@ -2837,36 +2963,34 @@ const runResource = (task, container, host) => {
     let reject;
     let done = !1;
     const setState = (resolved, value) => !done && (done = !0, resolved ? (done = !0, 
-    resource.loading = !1, resource._state = "resolved", resource._resolved = value, 
-    resource._error = void 0, resolve(value)) : (done = !0, resource.loading = !1, resource._state = "rejected", 
-    resource._error = value, reject(value)), !0);
-    cleanups.push((() => {
-        if (!0 === untrack((() => resource.loading))) {
-            const value = untrack((() => resource._resolved));
+    resourceTarget.loading = !1, resourceTarget._state = "resolved", resourceTarget._resolved = value, 
+    resourceTarget._error = void 0, resolve(value)) : (done = !0, resourceTarget.loading = !1, 
+    resourceTarget._state = "rejected", resourceTarget._error = value, reject(value)), 
+    isServerPlatform() || forceStoreEffects(resource, "_state"), !0);
+    cleanups.push(() => {
+        if (!0 === untrack(() => resource.loading)) {
+            const value = untrack(() => resource._resolved);
             setState(!0, value);
         }
-    })), invoke(iCtx, (() => {
-        resource._state = "pending", resource.loading = !isServerPlatform();
-        (resource.value = new Promise(((r, re) => {
+    }), 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 => {
+        });
+    });
+    const promise = safeCall(() => taskFn(opts), value => {
         setState(!0, value);
-    }), (err => {
+    }, err => {
         if (isPromise(err)) {
-            return err.then((() => runResource(task, container, host)));
+            return err.then(() => runResource(task, container, host));
         }
         setState(!1, err);
-    }));
+    });
     const timeout = resourceTarget._timeout;
-    return timeout > 0 ? Promise.race([ promise, delay(timeout).then((() => {
+    return timeout > 0 ? Promise.race([ promise, delay(timeout).then(() => {
         setState(!1, new Error("timeout")) && cleanupTask(task);
-    })) ]) : promise;
+    }) ]) : promise;
 };
 
-const ignoreErrorToPreventNodeFromCrashing = () => {};
-
 const aVNodePath = [];
 
 const bVNodePath = [];
@@ -2878,10 +3002,10 @@ const vnode_documentPosition = (a, b, rootVNode) => {
     let aDepth = -1;
     let bDepth = -1;
     for (;a; ) {
-        a = (aVNodePath[++aDepth] = a)[1] || rootVNode && vnode_getProp(a, "q:sparent", (id => vnode_locate(rootVNode, id)));
+        a = (aVNodePath[++aDepth] = a)[1] || rootVNode && vnode_getProp(a, "q:sparent", id => vnode_locate(rootVNode, id));
     }
     for (;b; ) {
-        b = (bVNodePath[++bDepth] = b)[1] || rootVNode && vnode_getProp(b, "q:sparent", (id => vnode_locate(rootVNode, id)));
+        b = (bVNodePath[++bDepth] = b)[1] || rootVNode && vnode_getProp(b, "q:sparent", id => vnode_locate(rootVNode, id));
     }
     for (;aDepth >= 0 && bDepth >= 0; ) {
         if ((a = aVNodePath[aDepth]) !== (b = bVNodePath[bDepth])) {
@@ -2897,7 +3021,7 @@ const vnode_documentPosition = (a, b, rootVNode) => {
                     return -1;
                 }
             } while (cursor);
-            return rootVNode && vnode_getProp(b, "q:sparent", (id => vnode_locate(rootVNode, id))) ? -1 : 1;
+            return rootVNode && vnode_getProp(b, "q:sparent", id => vnode_locate(rootVNode, id)) ? -1 : 1;
         }
         aDepth--, bDepth--;
     }
@@ -2915,10 +3039,10 @@ const ssrNodeDocumentPosition = (a, b) => {
     let aDepth = -1;
     let bDepth = -1;
     for (;a; ) {
-        a = (aSsrNodePath[++aDepth] = a).parentSsrNode;
+        a = (aSsrNodePath[++aDepth] = a).parentComponent;
     }
     for (;b; ) {
-        b = (bSsrNodePath[++bDepth] = b).parentSsrNode;
+        b = (bSsrNodePath[++bDepth] = b).parentComponent;
     }
     for (;aDepth >= 0 && bDepth >= 0; ) {
         if ((a = aSsrNodePath[aDepth]) !== (b = bSsrNodePath[bDepth])) {
@@ -2929,26 +3053,199 @@ const ssrNodeDocumentPosition = (a, b) => {
     return aDepth < bDepth ? -1 : 1;
 };
 
+const VISIBLE_BLOCKING_RULES = [ {
+    blockedType: 16,
+    blockingType: 4,
+    match: (blocked, blocking, container) => isDescendant(blocked, blocking, container) || isDescendant(blocking, blocked, container)
+}, {
+    blockedType: 16,
+    blockingType: 6,
+    match: (blocked, blocking, container) => isDescendant(blocked, blocking, container) || isDescendant(blocking, blocked, container)
+} ];
+
+const BLOCKING_RULES = [ {
+    blockedType: 2,
+    blockingType: 1,
+    match: (blocked, blocking) => {
+        const blockedQrl = blocked.$target$;
+        const blockingQrl = blocking.$target$;
+        return isSameHost(blocked, blocking) && isSameQrl(blockedQrl, blockingQrl);
+    }
+}, {
+    blockedType: 3,
+    blockingType: 1,
+    match: (blocked, blocking) => {
+        const blockedTask = blocked.$payload$;
+        const blockingQrl = blocking.$target$;
+        return isSameHost(blocked, blocking) && isSameQrl(blockedTask.$qrl$, blockingQrl);
+    }
+}, {
+    blockedType: 16,
+    blockingType: 1,
+    match: (blocked, blocking) => {
+        const blockedTask = blocked.$payload$;
+        const blockingQrl = blocking.$target$;
+        return isSameHost(blocked, blocking) && isSameQrl(blockedTask.$qrl$, blockingQrl);
+    }
+}, {
+    blockedType: 4,
+    blockingType: 6,
+    match: (blocked, blocking) => blocked.$host$ === blocking.$host$
+}, {
+    blockedType: 5,
+    blockingType: 6,
+    match: (blocked, blocking) => blocked.$host$ === blocking.$host$
+}, ...VISIBLE_BLOCKING_RULES, {
+    blockedType: 3,
+    blockingType: 3,
+    match: (blocked, blocking, container) => {
+        if (blocked.$host$ !== blocking.$host$) {
+            return !1;
+        }
+        const blockedIdx = blocked.$idx$;
+        if (!isNumber$1(blockedIdx) || blockedIdx <= 0) {
+            return !1;
+        }
+        return findPreviousTaskInComponent(blocked.$host$, blockedIdx, container) === blocking.$payload$;
+    }
+} ];
+
+function isDescendant(descendantChore, ancestorChore, container) {
+    const descendantHost = descendantChore.$host$;
+    const ancestorHost = ancestorChore.$host$;
+    return !(!vnode_isVNode(descendantHost) || !vnode_isVNode(ancestorHost)) && vnode_isDescendantOf(descendantHost, ancestorHost, container.rootVNode);
+}
+
+function isSameHost(a, b) {
+    return a.$host$ === b.$host$;
+}
+
+function isSameQrl(a, b) {
+    return a.$symbol$ === b.$symbol$;
+}
+
+function findBlockingChoreInQueue(chore, choreQueue, container) {
+    for (const candidate of choreQueue) {
+        if (!(candidate.$type$ >= 16 || 3 === candidate.$type$) && isDescendant(chore, candidate, container)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+
+function findBlockingChore(chore, choreQueue, blockedChores, runningChores, container) {
+    const blockingChoreInChoreQueue = findBlockingChoreInQueue(chore, choreQueue, container);
+    if (blockingChoreInChoreQueue) {
+        return blockingChoreInChoreQueue;
+    }
+    const blockingChoreInBlockedChores = findBlockingChoreInQueue(chore, Array.from(blockedChores), container);
+    if (blockingChoreInBlockedChores) {
+        return blockingChoreInBlockedChores;
+    }
+    const blockingChoreInRunningChores = findBlockingChoreInQueue(chore, Array.from(runningChores), container);
+    if (blockingChoreInRunningChores) {
+        return blockingChoreInRunningChores;
+    }
+    for (const rule of BLOCKING_RULES) {
+        if (chore.$type$ === rule.blockedType) {
+            for (const candidate of choreQueue) {
+                if (candidate.$type$ === rule.blockingType && rule.match(chore, candidate, container)) {
+                    return candidate;
+                }
+            }
+            for (const candidate of blockedChores) {
+                if (candidate.$type$ === rule.blockingType && rule.match(chore, candidate, container)) {
+                    return candidate;
+                }
+            }
+            for (const candidate of runningChores) {
+                if (candidate.$type$ === rule.blockingType && rule.match(chore, candidate, container)) {
+                    return candidate;
+                }
+            }
+        }
+    }
+    return null;
+}
+
+function findPreviousTaskInComponent(host, currentTaskIdx, container) {
+    const elementSeq = container.getHostProp(host, "q:seq");
+    if (!elementSeq || elementSeq.length <= currentTaskIdx) {
+        return null;
+    }
+    for (let i = currentTaskIdx - 1; i >= 0; i--) {
+        const candidate = elementSeq[i];
+        if (candidate instanceof Task && 2 & candidate.$flags$) {
+            return candidate;
+        }
+    }
+    return null;
+}
+
+function findBlockingChoreForVisible(chore, runningChores, container) {
+    for (const rule of VISIBLE_BLOCKING_RULES) {
+        if (chore.$type$ === rule.blockedType) {
+            for (const candidate of runningChores) {
+                if (candidate.$type$ === rule.blockingType && rule.match(chore, candidate, container)) {
+                    return candidate;
+                }
+            }
+        }
+    }
+    return null;
+}
+
+const createNextTick = fn => {
+    let nextTick;
+    if ("function" == typeof setImmediate) {
+        nextTick = () => {
+            setImmediate(fn);
+        };
+    } else if ("undefined" != typeof MessageChannel) {
+        const channel = new MessageChannel;
+        channel.port1.onmessage = () => {
+            fn();
+        }, nextTick = () => {
+            channel.port2.postMessage(null);
+        };
+    } else {
+        nextTick = () => {
+            setTimeout(fn);
+        };
+    }
+    return nextTick;
+};
+
 const DEBUG = !1;
 
-const getPromise = chore => chore.$promise$ ||= new Promise((resolve => {
-    chore.$resolve$ = resolve;
-}));
+var ChoreState;
+
+!function(ChoreState) {
+    ChoreState[ChoreState.NONE = 0] = "NONE", ChoreState[ChoreState.RUNNING = 1] = "RUNNING", 
+    ChoreState[ChoreState.FAILED = 2] = "FAILED", ChoreState[ChoreState.DONE = 3] = "DONE";
+}(ChoreState || (ChoreState = {}));
+
+const getChorePromise = chore => chore.$state$ === ChoreState.NONE ? chore.$returnValue$ ||= new Promise((resolve, reject) => {
+    chore.$resolve$ = resolve, chore.$reject$ = reject;
+}) : chore.$returnValue$;
 
-const createScheduler = (container, scheduleDrain, journalFlush) => {
-    const choreQueue = [];
-    const qrlRuns = [];
-    let currentChore = null;
+const createScheduler = (container, journalFlush, choreQueue = [], blockedChores = new Set, runningChores = new Set) => {
+    let drainChore = null;
     let drainScheduled = !1;
-    return function schedule(type, hostOrTask = null, targetOrQrl = null, payload = null) {
-        const isServer = !isDomContainer(container);
-        const isComponentSsr = isServer && 6 === type;
-        const runLater = 255 !== type && !isComponentSsr && 2 !== type;
-        const isTask = 3 === type || 32 === type || 48 === type;
-        const isClientOnly = 16 === type || 4 === type || 5 === type || 1 === type || 7 === type;
-        if (isServer && isClientOnly) {
-            return;
-        }
+    let isDraining = !1;
+    let isJournalFlushRunning = !1;
+    let flushBudgetStart = 0;
+    let currentTime = performance.now();
+    const nextTick = createNextTick(drainChoreQueue);
+    function drainInNextTick() {
+        drainScheduled || (drainScheduled = !0, nextTick());
+    }
+    const FREQUENCY_MS = Math.floor(1e3 / 60);
+    return function(type, hostOrTask = null, targetOrQrl = null, payload = null) {
+        if (255 === type && drainChore) {
+            return drainChore;
+        }
+        const isTask = 3 === type || 16 === type || 32 === type;
         isTask && (hostOrTask.$flags$ |= 8);
         let chore = {
             $type$: type,
@@ -2956,183 +3253,218 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
             $host$: isTask ? hostOrTask.$el$ : hostOrTask,
             $target$: targetOrQrl,
             $payload$: isTask ? hostOrTask : payload,
-            $resolve$: null,
-            $promise$: null,
-            $returnValue$: null,
-            $executed$: !1
+            $state$: ChoreState.NONE,
+            $blockedChores$: null,
+            $startTime$: void 0,
+            $endTime$: void 0,
+            $resolve$: void 0,
+            $reject$: void 0,
+            $returnValue$: null
         };
-        chore = function(sortedArray, value, rootVNode) {
-            const idx = function(sortedArray, value, rootVNode) {
-                let bottom = 0;
-                let top = sortedArray.length;
-                for (;bottom < top; ) {
-                    const middle = bottom + (top - bottom >> 1);
-                    const comp = choreComparator(value, sortedArray[middle], rootVNode);
-                    if (comp < 0) {
-                        top = middle;
-                    } else {
-                        if (!(comp > 0)) {
-                            return middle;
-                        }
-                        bottom = middle + 1;
+        if (255 === type) {
+            return getChorePromise(chore), drainChore = chore, drainInNextTick(), chore;
+        }
+        const isServer = isServerPlatform();
+        const isClientOnly = 4 === type || 1 === type;
+        if (isServer && isClientOnly) {
+            return finishChore(chore, void 0), chore;
+        }
+        if (isServer && chore.$host$ && isSsrNode(chore.$host$)) {
+            if (!!!(1 & chore.$host$.flags) && 5 !== chore.$type$ && 7 !== chore.$type$) {
+                const warningMessage = `A '${choreTypeToName(chore.$type$)}' chore was scheduled on a host element that has already been streamed to the client.\nThis can lead to inconsistencies between Server-Side Rendering (SSR) and Client-Side Rendering (CSR).\n\nProblematic chore:\n  - Type: ${choreTypeToName(chore.$type$)}\n  - Host: ${chore.$host$.toString()}\n  - Nearest element location: ${chore.$host$.currentFile}\n\nThis is often caused by modifying a signal in an already rendered component during SSR.`;
+                return logWarn(warningMessage), chore;
+            }
+        }
+        const blockingChore = findBlockingChore(chore, choreQueue, blockedChores, runningChores, container);
+        if (blockingChore) {
+            return addBlockedChore(chore, blockingChore, blockedChores), chore;
+        }
+        chore = sortedInsert(choreQueue, chore, container.rootVNode || null);
+        const runImmediately = isServer && 6 === type || 2 === type;
+        runImmediately && !isDraining ? (drainScheduled = !0, drainChoreQueue()) : drainInNextTick();
+        return chore;
+    };
+    function applyJournalFlush() {
+        isJournalFlushRunning || (isJournalFlushRunning = !0, journalFlush(), isJournalFlushRunning = !1, 
+        flushBudgetStart = performance.now());
+    }
+    function shouldApplyJournalFlush(isServer) {
+        return !isServer && currentTime - flushBudgetStart >= FREQUENCY_MS;
+    }
+    function drainChoreQueue() {
+        const isServer = isServerPlatform();
+        if (drainScheduled = !1, isDraining) {
+            return;
+        }
+        if (!choreQueue.length) {
+            return applyJournalFlush(), void (drainChore && !runningChores.size && (drainChore.$resolve$(null), 
+            drainChore = null));
+        }
+        isDraining = !0, flushBudgetStart = performance.now();
+        const maybeFinishDrain = () => choreQueue.length ? (drainInNextTick(), !1) : drainChore && runningChores.size ? (shouldApplyJournalFlush(isServer) && applyJournalFlush(), 
+        !1) : (currentChore = null, applyJournalFlush(), drainChore?.$resolve$(null), drainChore = null, 
+        !0);
+        const scheduleBlockedChoresAndDrainIfNeeded = chore => {
+            let blockedChoresScheduled = !1;
+            if (chore.$blockedChores$) {
+                for (const blockedChore of chore.$blockedChores$) {
+                    const blockingChore = findBlockingChore(blockedChore, choreQueue, blockedChores, runningChores, container);
+                    blockingChore ? addBlockedChore(blockedChore, blockingChore, blockedChores) : (blockedChores.delete(blockedChore), 
+                    sortedInsert(choreQueue, blockedChore, container.rootVNode || null), blockedChoresScheduled = !0);
+                }
+                chore.$blockedChores$ = null;
+            }
+            blockedChoresScheduled && !isDraining && drainInNextTick();
+        };
+        let currentChore = null;
+        try {
+            for (;choreQueue.length; ) {
+                currentTime = performance.now();
+                const chore = currentChore = choreQueue.shift();
+                if (chore.$state$ !== ChoreState.NONE) {
+                    continue;
+                }
+                if (vNodeAlreadyDeleted(chore) && 32 !== chore.$type$) {
+                    continue;
+                }
+                if (16 === chore.$type$) {
+                    applyJournalFlush();
+                    const blockingChore = findBlockingChoreForVisible(chore, runningChores, container);
+                    if (blockingChore && blockingChore.$state$ === ChoreState.RUNNING) {
+                        addBlockedChore(chore, blockingChore, blockedChores);
+                        continue;
                     }
                 }
-                return ~bottom;
-            }(sortedArray, value, rootVNode);
-            if (idx < 0) {
-                return sortedArray.splice(~idx, 0, value), value;
-            }
-            const existing = sortedArray[idx];
-            4 === existing.$type$ && (existing.$payload$ = value.$payload$);
-            existing.$executed$ && (existing.$executed$ = !1);
-            return existing;
-        }(choreQueue, chore, container.rootVNode || null), !drainScheduled && runLater && (drainScheduled = !0, 
-        schedule(16), scheduleDrain()?.catch?.((() => {})));
-        return runLater ? getPromise(chore) : drainUpTo(chore, isServer);
-    };
-    function drainUpTo(runUptoChore, isServer) {
-        let maxRetries = 5e3;
-        for (;choreQueue.length; ) {
-            if (maxRetries-- < 0) {
-                throw new Error("drainUpTo: max retries reached");
-            }
-            if (currentChore) {
-                return getPromise(currentChore).then((() => drainUpTo(runUptoChore, isServer))).catch((e => {
-                    container.handleError(e, currentChore?.$host$);
-                }));
-            }
-            const nextChore = choreQueue[0];
-            if (nextChore.$executed$) {
-                if (choreQueue.shift(), nextChore === runUptoChore) {
-                    break;
+                chore.$startTime$ = performance.now();
+                const result = executeChore(chore, isServer);
+                if (chore.$returnValue$ = result, isPromise(result) ? (runningChores.add(chore), 
+                chore.$state$ = ChoreState.RUNNING, result.then(value => {
+                    finishChore(chore, value);
+                }).catch(e => {
+                    chore.$state$ === ChoreState.RUNNING && handleError(chore, e);
+                }).finally(() => {
+                    if (runningChores.delete(chore), scheduleBlockedChoresAndDrainIfNeeded(chore), !runningChores.size) {
+                        let finished = !1;
+                        drainChore && (finished = maybeFinishDrain()), finished || isDraining || applyJournalFlush();
+                    }
+                })) : (finishChore(chore, result), scheduleBlockedChoresAndDrainIfNeeded(chore)), 
+                shouldApplyJournalFlush(isServer)) {
+                    return applyJournalFlush(), void drainInNextTick();
                 }
-            } else {
-                vNodeAlreadyDeleted(nextChore) && 48 !== nextChore.$type$ ? choreQueue.shift() : executeChore(nextChore, isServer);
             }
+        } catch (e) {
+            handleError(currentChore, e), scheduleBlockedChoresAndDrainIfNeeded(currentChore);
+        } finally {
+            isDraining = !1, maybeFinishDrain();
         }
-        return runUptoChore.$returnValue$;
+    }
+    function finishChore(chore, value) {
+        chore.$endTime$ = performance.now(), chore.$state$ = ChoreState.DONE, chore.$returnValue$ = value, 
+        chore.$resolve$?.(value);
+    }
+    function handleError(chore, e) {
+        chore.$endTime$ = performance.now(), chore.$state$ = ChoreState.FAILED, chore.$reject$?.(e), 
+        container.handleError(e, chore.$host$);
     }
     function executeChore(chore, isServer) {
         const host = chore.$host$;
-        assertEqual(currentChore, null, "Chore already running."), currentChore = chore;
-        let returnValue = null;
-        try {
-            switch (chore.$type$) {
-              case 255:
-                isServer && (drainScheduled = !1);
-                break;
-
-              case 16:
-                returnValue = journalFlush(), drainScheduled = !1;
-                break;
-
-              case 6:
-                returnValue = safeCall((() => executeComponent(container, host, host, chore.$target$, chore.$payload$)), (jsx => {
-                    if (isServer) {
-                        return jsx;
-                    }
-                    {
-                        const styleScopedId = container.getHostProp(host, "q:sstyle");
-                        return retryOnPromise((() => vnode_diff(container, jsx, host, addComponentStylePrefix(styleScopedId))));
-                    }
-                }), (err => container.handleError(err, host)));
-                break;
-
-              case 2:
-                {
-                    const fn = chore.$target$.getFn();
-                    const result = retryOnPromise((() => fn(...chore.$payload$)));
-                    if (isPromise(result)) {
-                        const handled = result.finally((() => {
-                            qrlRuns.splice(qrlRuns.indexOf(handled), 1);
-                        })).catch((error => {
-                            container.handleError(error, chore.$host$);
-                        }));
-                        return qrlRuns.push(handled), chore.$returnValue$ = handled, chore.$resolve$?.(handled), 
-                        currentChore = null, void (chore.$executed$ = !0);
-                    }
-                    returnValue = null;
+        let returnValue;
+        switch (chore.$type$) {
+          case 6:
+            returnValue = safeCall(() => executeComponent(container, host, host, chore.$target$, chore.$payload$), jsx => {
+                if (isServer) {
+                    return jsx;
                 }
-                break;
-
-              case 3:
-              case 32:
                 {
-                    const payload = chore.$payload$;
-                    if (4 & payload.$flags$) {
-                        const result = runResource(payload, container, host);
-                        returnValue = isServer ? result : null;
-                    } else {
-                        returnValue = runTask(payload, container, host);
-                    }
+                    const styleScopedId = container.getHostProp(host, "q:sstyle");
+                    return retryOnPromise(() => vnode_diff(container, jsx, host, addComponentStylePrefix(styleScopedId)));
                 }
-                break;
+            }, err => {
+                handleError(chore, err);
+            });
+            break;
 
-              case 48:
-                cleanupTask(chore.$payload$);
-                break;
+          case 2:
+            {
+                const fn = chore.$target$.getFn();
+                returnValue = retryOnPromise(() => fn(...chore.$payload$));
+            }
+            break;
 
-              case 4:
-                {
-                    const parentVirtualNode = chore.$target$;
-                    let jsx = chore.$payload$;
-                    isSignal(jsx) && (jsx = jsx.value), returnValue = retryOnPromise((() => vnode_diff(container, jsx, parentVirtualNode, null)));
-                }
-                break;
+          case 3:
+          case 16:
+            {
+                const payload = chore.$payload$;
+                returnValue = 4 & payload.$flags$ ? runResource(payload, container, host) : runTask(payload, container, host);
+            }
+            break;
 
-              case 5:
-                {
-                    const virtualNode = chore.$host$;
-                    const payload = chore.$payload$;
-                    let value = payload.$value$;
-                    isSignal(value) && (value = value.value);
-                    const isConst = payload.$isConst$;
-                    const journal = container.$journal$;
-                    const property = chore.$idx$;
-                    const serializedValue = serializeAttribute(property, value, payload.$scopedStyleIdPrefix$);
+          case 32:
+            cleanupTask(chore.$payload$);
+            break;
+
+          case 4:
+            {
+                const parentVirtualNode = chore.$target$;
+                let jsx = chore.$payload$;
+                isSignal(jsx) && (jsx = jsx.value), returnValue = retryOnPromise(() => vnode_diff(container, jsx, parentVirtualNode, null));
+            }
+            break;
+
+          case 5:
+            {
+                const virtualNode = chore.$host$;
+                const payload = chore.$payload$;
+                let value = payload.$value$;
+                isSignal(value) && (value = value.value);
+                const isConst = payload.$isConst$;
+                const journal = container.$journal$;
+                const property = chore.$idx$;
+                const serializedValue = serializeAttribute(property, value, payload.$scopedStyleIdPrefix$);
+                if (isServer) {
+                    container.addBackpatchEntry(chore.$host$.id, property, serializedValue), returnValue = null;
+                } else {
                     if (isConst) {
                         journal.push(2, virtualNode[6], property, serializedValue);
                     } else {
                         vnode_setAttr(journal, virtualNode, property, serializedValue);
                     }
+                    returnValue = void 0;
                 }
-                break;
+            }
+            break;
 
-              case 1:
-                {
-                    const target = chore.$target$;
-                    returnValue = target.resolved ? null : target.resolve();
-                }
-                break;
+          case 1:
+            {
+                const target = chore.$target$;
+                returnValue = target.resolved ? null : target.resolve();
+            }
+            break;
 
-              case 7:
-                {
-                    const target = chore.$target$;
-                    const effects = chore.$payload$;
-                    if (target instanceof ComputedSignalImpl || target instanceof WrappedSignalImpl) {
-                        const forceRunEffects = target.$forceRunEffects$;
-                        if (target.$forceRunEffects$ = !1, !target.$effects$?.size) {
-                            break;
+          case 7:
+            {
+                const target = chore.$target$;
+                const effects = chore.$payload$;
+                if (!effects?.size) {
+                    break;
+                }
+                let shouldCompute = target instanceof ComputedSignalImpl || target instanceof WrappedSignalImpl;
+                if (target instanceof AsyncComputedSignalImpl && effects !== target.$effects$ && (shouldCompute = !1), 
+                shouldCompute) {
+                    const ctx = newInvokeContext();
+                    ctx.$container$ = container, returnValue = maybeThen(retryOnPromise(() => invoke.call(target, ctx, target.$computeIfNeeded$)), () => {
+                        if (2 & target.$flags$) {
+                            return target.$flags$ &= -3, retryOnPromise(() => triggerEffects(container, target, effects));
                         }
-                        returnValue = retryOnPromise((() => {
-                            (target.$computeIfNeeded$() || forceRunEffects) && triggerEffects(container, target, effects);
-                        }));
-                    } else {
-                        returnValue = retryOnPromise((() => {
-                            triggerEffects(container, target, effects);
-                        }));
-                    }
+                    });
+                } else {
+                    returnValue = retryOnPromise(() => {
+                        triggerEffects(container, target, effects);
+                    });
                 }
             }
-        } catch (e) {
-            returnValue = Promise.reject(e);
         }
-        const after = (value, error) => {
-            currentChore = null, chore.$executed$ = !0, error ? container.handleError(error, host) : (chore.$returnValue$ = value, 
-            chore.$resolve$?.(value));
-        };
-        isPromise(returnValue) ? (chore.$promise$ = returnValue.then(after, (error => after(void 0, error))), 
-        chore.$resolve$?.(chore.$promise$), chore.$resolve$ = void 0) : after(returnValue);
+        return returnValue;
     }
     function choreComparator(a, b, rootVNode) {
         const macroTypeDiff = (240 & a.$type$) - (240 & b.$type$);
@@ -3150,8 +3482,6 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
             } else {
                 assertFalse(vnode_isVNode(aHost), "expected aHost to be SSRNode but it is a VNode"), 
                 assertFalse(vnode_isVNode(bHost), "expected bHost to be SSRNode but it is a VNode");
-                const errorMessage = `SERVER: during HTML streaming, re-running tasks on a different host is not allowed.\n          You are attempting to change a state that has already been streamed to the client.\n          This can lead to inconsistencies between Server-Side Rendering (SSR) and Client-Side Rendering (CSR).\n          Problematic Node: ${aHost.toString()}`;
-                logWarn(errorMessage);
                 const hostDiff = ssrNodeDocumentPosition(aHost, bHost);
                 if (0 !== hostDiff) {
                     return hostDiff;
@@ -3163,7 +3493,39 @@ const createScheduler = (container, scheduleDrain, journalFlush) => {
             return microTypeDiff;
         }
         const idxDiff = toNumber(a.$idx$) - toNumber(b.$idx$);
-        return 0 !== idxDiff ? idxDiff : a.$target$ !== b.$target$ || a.$payload$ !== b.$payload$ || b === currentChore ? 1 : 0;
+        return 0 !== idxDiff ? idxDiff : a.$target$ !== b.$target$ ? isQrl(a.$target$) && isQrl(b.$target$) && a.$target$.$hash$ === b.$target$.$hash$ ? 0 : 1 : 7 === a.$type$ && 7 === b.$type$ && (a.$target$ instanceof StoreHandler && b.$target$ instanceof StoreHandler || a.$target$ instanceof AsyncComputedSignalImpl && b.$target$ instanceof AsyncComputedSignalImpl) && a.$payload$ !== b.$payload$ ? 1 : 0;
+    }
+    function sortedInsert(sortedArray, value, rootVNode) {
+        const idx = function(sortedArray, value, rootVNode) {
+            let bottom = 0;
+            let top = sortedArray.length;
+            for (;bottom < top; ) {
+                const middle = bottom + (top - bottom >> 1);
+                const comp = choreComparator(value, sortedArray[middle], rootVNode);
+                if (comp < 0) {
+                    top = middle;
+                } else {
+                    if (!(comp > 0)) {
+                        return middle;
+                    }
+                    bottom = middle + 1;
+                }
+            }
+            return ~bottom;
+        }(sortedArray, value, rootVNode);
+        if (idx < 0 && runningChores.size) {
+            for (const chore of runningChores) {
+                if (0 === choreComparator(value, chore, rootVNode)) {
+                    return chore;
+                }
+            }
+        }
+        if (idx < 0) {
+            return sortedArray.splice(~idx, 0, value), value;
+        }
+        const existing = sortedArray[idx];
+        return existing.$payload$ !== value.$payload$ && (existing.$payload$ = value.$payload$), 
+        existing;
     }
 };
 
@@ -3173,6 +3535,26 @@ function vNodeAlreadyDeleted(chore) {
     return !!(chore.$host$ && vnode_isVNode(chore.$host$) && 32 & chore.$host$[0]);
 }
 
+function addBlockedChore(blockedChore, blockingChore, blockedChores) {
+    blockingChore.$blockedChores$ ||= [], blockingChore.$blockedChores$.push(blockedChore), 
+    blockedChores.add(blockedChore);
+}
+
+function choreTypeToName(type) {
+    return {
+        1: "Resolve QRL",
+        2: "Run QRL",
+        3: "Task",
+        4: "Changes diffing",
+        5: "Updating node property",
+        6: "Component",
+        7: "Signal recompute",
+        16: "Visible",
+        32: "Cleanup visible",
+        255: "Wait for queue"
+    }[type] || "Unknown: " + type;
+}
+
 function debugChoreTypeToString(type) {
     return {
         1: "QRL_RESOLVE",
@@ -3182,26 +3564,53 @@ function debugChoreTypeToString(type) {
         5: "NODE_PROP",
         6: "COMPONENT",
         7: "RECOMPUTE_SIGNAL",
-        16: "JOURNAL_FLUSH",
-        32: "VISIBLE",
-        48: "CLEANUP_VISIBLE",
-        255: "WAIT_FOR_ALL"
+        16: "VISIBLE",
+        32: "CLEANUP_VISIBLE",
+        255: "WAIT_FOR_QUEUE"
     }[type] || "UNKNOWN: " + type;
 }
 
-function debugChoreToString(chore) {
-    const type = debugChoreTypeToString(chore.$type$);
-    const host = String(chore.$host$).replaceAll(/\n.*/gim, "");
-    const qrlTarget = chore.$target$?.$symbol$;
-    return `Chore(${type} ${1 === chore.$type$ || 2 === chore.$type$ ? qrlTarget : host} ${chore.$idx$})`;
-}
-
-function debugTrace(action, arg, currentChore, queue) {
-    const lines = [ "===========================\nScheduler: " + action ];
-    arg && !("$type$" in arg) && lines.push("      arg: " + String(arg).replaceAll(/\n.*/gim, "")), 
-    queue && queue.forEach((chore => {
-        lines.push(`     ${chore === arg ? ">>>" : "   "} > ` + (chore === currentChore ? "[running] " : "") + debugChoreToString(chore));
-    })), console.log(lines.join("\n") + "\n");
+function debugTrace(action, arg, queue, blockedChores) {
+    const lines = [];
+    if (lines.push(`Scheduler: ${action}`), arg) {
+        if (lines.push(""), arg && "$type$" in arg) {
+            const chore = arg;
+            const type = debugChoreTypeToString(chore.$type$);
+            const host = String(chore.$host$).replaceAll(/\n.*/gim, "");
+            const qrlTarget = chore.$target$?.$symbol$;
+            const targetOrHost = 1 === chore.$type$ || 2 === chore.$type$ ? qrlTarget : host;
+            if (lines.push("🎯 Current Chore:"), lines.push(`  Type: ${type}`), lines.push(`  Host: ${targetOrHost}`), 
+            chore.$startTime$ && chore.$endTime$) {
+                lines.push(`  Time: ${(chore.$endTime$ - chore.$startTime$).toFixed(2)}ms`);
+            } else if (chore.$startTime$) {
+                const elapsedTime = performance.now() - chore.$startTime$;
+                lines.push(`  Time: ${elapsedTime.toFixed(2)}ms (running)`);
+            }
+            chore.$blockedChores$ && chore.$blockedChores$.length > 0 && (lines.push("  ⛔ Blocked Chores:"), 
+            chore.$blockedChores$.forEach((blockedChore, index) => {
+                const blockedType = debugChoreTypeToString(blockedChore.$type$);
+                const blockedTarget = String(blockedChore.$host$).replaceAll(/\n.*/gim, "");
+                lines.push(`    ${index + 1}. ${blockedType} ${blockedTarget} ${blockedChore.$idx$}`);
+            }));
+        } else {
+            lines.push(`📝 Argument: ${String(arg).replaceAll(/\n.*/gim, "")}`);
+        }
+    }
+    queue && queue.length > 0 && (lines.push(""), lines.push(`📋 Queue (${queue.length} items):`), 
+    queue.forEach(chore => {
+        const activeMarker = chore === arg ? "▶ " : "  ";
+        const type = debugChoreTypeToString(chore.$type$);
+        const state = chore.$state$ ? `[${ChoreState[chore.$state$]}]` : "";
+        const host = String(chore.$host$).replaceAll(/\n.*/gim, "");
+        const qrlTarget = chore.$target$?.$symbol$;
+        lines.push(`${activeMarker}${state} ${type} ${1 === chore.$type$ || 2 === chore.$type$ ? qrlTarget : host} ${chore.$idx$}`);
+    })), blockedChores && blockedChores.size > 0 && (lines.push(""), lines.push(`🚫 Blocked Chores (${blockedChores.size} items):`), 
+    Array.from(blockedChores).forEach((chore, index) => {
+        const type = debugChoreTypeToString(chore.$type$);
+        const host = String(chore.$host$).replaceAll(/\n.*/gim, "");
+        const qrlTarget = chore.$target$?.$symbol$;
+        lines.push(`  ${index + 1}. ${type} ${1 === chore.$type$ || 2 === chore.$type$ ? qrlTarget : host} ${chore.$idx$}`);
+    })), lines.push(""), lines.push("─".repeat(60)), console.log(lines.join("\n") + "\n");
 }
 
 class _SharedContainer {
@@ -3214,11 +3623,12 @@ class _SharedContainer {
     $currentUniqueId$=0;
     $instanceHash$=null;
     $buildBase$=null;
-    constructor(scheduleDrain, journalFlush, serverData, locale) {
+    $flushEpoch$=0;
+    constructor(journalFlush, serverData, locale) {
         this.$serverData$ = serverData, this.$locale$ = locale, this.$version$ = version, 
         this.$storeProxyMap$ = new WeakMap, this.$getObjectById$ = () => {
             throw Error("Not implemented");
-        }, this.$scheduler$ = createScheduler(this, scheduleDrain, journalFlush);
+        }, this.$scheduler$ = createScheduler(this, journalFlush);
     }
     trackSignalValue(signal, subscriber, property, data) {
         return trackSignalAndAssignHost(signal, subscriber, property, this, data);
@@ -3266,14 +3676,14 @@ function processVNodeData$1(document) {
         };
     })(prototype, "nodeType");
     const attachVnodeDataAndRefs = element => {
-        Array.from(element.querySelectorAll('script[type="qwik/vnode"]')).forEach((script => {
+        Array.from(element.querySelectorAll('script[type="qwik/vnode"]')).forEach(script => {
             script.setAttribute("type", "x-qwik/vnode");
             const qContainerElement = script.closest("[q\\:container]");
             qContainerElement.qVnodeData = script.textContent, qContainerElement.qVNodeRefs = new Map;
-        })), element.querySelectorAll("[q\\:shadowroot]").forEach((parent => {
+        }), element.querySelectorAll("[q\\:shadowroot]").forEach(parent => {
             const shadowRoot = parent.shadowRoot;
             shadowRoot && attachVnodeDataAndRefs(shadowRoot);
-        }));
+        });
     };
     attachVnodeDataAndRefs(document);
     const getFastNodeType = node => {
@@ -3296,10 +3706,10 @@ function processVNodeData$1(document) {
                 return 16;
             }
             if (nodeValue.startsWith("q:container")) {
-                return 5;
+                return 9;
             }
             if (nodeValue.startsWith("/q:container-island")) {
-                return 128;
+                return 64;
             }
             if (nodeValue.startsWith("/q:ignore")) {
                 return 32;
@@ -3326,10 +3736,6 @@ function processVNodeData$1(document) {
         for (;node && (node = node.nextSibling) && 0 === getFastNodeType(node); ) {}
         return node;
     };
-    const firstChild = node => {
-        for (;node && (node = node.firstChild) && 0 === getFastNodeType(node); ) {}
-        return node;
-    };
     const walkContainer = (walker, containerNode, node, exitNode, vData, qVNodeRefs) => {
         const vData_length = vData.length;
         let elementIdx = 0;
@@ -3366,7 +3772,7 @@ function processVNodeData$1(document) {
                     }
                 } while (65 !== getFastNodeType(islandNode));
                 nextNode = null;
-            } else if (128 === nodeType) {
+            } else if (64 === nodeType) {
                 nextNode = node;
                 do {
                     if (nextNode = walker.nextNode(), !nextNode) {
@@ -3374,7 +3780,7 @@ function processVNodeData$1(document) {
                     }
                 } while (32 !== getFastNodeType(nextNode));
                 nextNode = null;
-            } else if (5 === nodeType) {
+            } else if (9 === nodeType) {
                 nextNode = node;
                 do {
                     if (nextNode = nextSibling(nextNode), !nextNode) {
@@ -3386,7 +3792,7 @@ function processVNodeData$1(document) {
                 nextNode = nextSibling(node);
                 const shadowRootContainer = node;
                 const shadowRoot = shadowRootContainer?.shadowRoot;
-                shadowRoot && walkContainer(document.createTreeWalker(shadowRoot, 129), null, firstChild(shadowRoot), null, "", null);
+                shadowRoot && walkContainer(document.createTreeWalker(shadowRoot, 129), null, shadowRoot, null, "", null);
             }
             if (!(2 & ~nodeType)) {
                 if (vNodeElementIndex < elementIdx) {
@@ -3427,7 +3833,7 @@ function getDomContainerFromQContainerElement(qContainerElement) {
 }
 
 function _getQContainerElement(element) {
-    return (Array.isArray(element) ? vnode_getDomParent(element) : element).closest(QContainerSelector);
+    return (Array.isArray(element) ? vnode_getDomParent(element, !0) : element).closest(QContainerSelector);
 }
 
 const isDomContainer = container => container instanceof DomContainer;
@@ -3439,20 +3845,20 @@ class DomContainer extends _SharedContainer {
     rootVNode;
     document;
     $journal$;
-    renderDone=null;
     $rawStateData$;
     $storeProxyMap$=new WeakMap;
     $qFuncs$;
     $instanceHash$;
     $forwardRefs$=null;
-    $initialQRLsIndexes$=null;
+    $initialQRLs$=null;
     vNodeLocate=id => vnode_locate(this.rootVNode, id);
     $stateData$;
     $styleIds$=null;
-    $renderCount$=0;
     constructor(element) {
-        if (super((() => this.scheduleRender()), (() => vnode_applyJournal(this.$journal$)), {}, element.getAttribute("q:locale")), 
-        this.qContainer = element.getAttribute("q:container"), !this.qContainer) {
+        if (super(() => {
+            this.$flushEpoch$++, vnode_applyJournal(this.$journal$);
+        }, {}, element.getAttribute("q:locale")), this.qContainer = element.getAttribute("q:container"), 
+        !this.qContainer) {
             throw qError(25);
         }
         this.$journal$ = [ 3, element.ownerDocument ], this.document = element.ownerDocument, 
@@ -3484,16 +3890,13 @@ class DomContainer extends _SharedContainer {
     }
     setContext(host, context, value) {
         let ctx = this.getHostProp(host, "q:ctx");
-        ctx || this.setHostProp(host, "q:ctx", ctx = []), mapArray_set(ctx, context.id, value, 0);
+        null == ctx && this.setHostProp(host, "q:ctx", ctx = []), mapArray_set(ctx, context.id, value, 0, !0);
     }
     resolveContext(host, contextId) {
         for (;host; ) {
             const ctx = this.getHostProp(host, "q:ctx");
-            if (ctx) {
-                const value = mapArray_get(ctx, contextId.id, 0);
-                if (value) {
-                    return value;
-                }
+            if (null != ctx && mapArray_has(ctx, contextId.id, 0)) {
+                return mapArray_get(ctx, contextId.id, 0);
             }
             host = this.getParentHost(host);
         }
@@ -3533,26 +3936,6 @@ class DomContainer extends _SharedContainer {
         }
         return vnode_getProp(vNode, name, getObjectById);
     }
-    scheduleRender() {
-        return this.$renderCount$++, this.renderDone ||= getPlatform().nextTick((() => this.processChores())), 
-        this.renderDone.finally((() => emitEvent("qrender", {
-            instanceHash: this.$instanceHash$,
-            renderCount: this.$renderCount$
-        })));
-    }
-    processChores() {
-        let renderCount = this.$renderCount$;
-        const result = this.$scheduler$(255);
-        if (isPromise(result)) {
-            return result.then((async () => {
-                for (;renderCount !== this.$renderCount$; ) {
-                    renderCount = this.$renderCount$, await this.$scheduler$(255);
-                }
-                this.renderDone = null;
-            }));
-        }
-        renderCount === this.$renderCount$ ? this.renderDone = null : this.processChores();
-    }
     ensureProjectionResolved(vNode) {
         if (!(16 & vNode[0])) {
             vNode[0] |= 16;
@@ -3560,7 +3943,10 @@ class DomContainer extends _SharedContainer {
             for (let i = 0; i < props.length; i += 2) {
                 if (isSlotProp(props[i])) {
                     const value = props[i + 1];
-                    "string" == typeof value && (props[i + 1] = this.vNodeLocate(value));
+                    if ("string" == typeof value) {
+                        const projection = this.vNodeLocate(value);
+                        props[i + 1] = projection, vnode_getProp(projection, "q:sparent", id => this.vNodeLocate(id));
+                    }
                 }
             }
         }
@@ -3576,9 +3962,9 @@ class DomContainer extends _SharedContainer {
             const scopedStyleIds = new Set(convertScopedStyleIdsToArray(scopedStyleIdsString));
             scopedStyleIds.add(styleId), this.setHostProp(host, "q:sstyle", convertStyleIdsToString(scopedStyleIds));
         }
-        if (null == this.$styleIds$ && (this.$styleIds$ = new Set, this.element.querySelectorAll(QStyleSelector).forEach((style => {
+        if (null == this.$styleIds$ && (this.$styleIds$ = new Set, this.element.querySelectorAll(QStyleSelector).forEach(style => {
             this.$styleIds$.add(style.getAttribute(QStyle));
-        }))), !this.$styleIds$.has(styleId)) {
+        })), !this.$styleIds$.has(styleId)) {
             this.$styleIds$.add(styleId);
             const styleElement = this.document.createElement("style");
             styleElement.setAttribute(QStyle, styleId), styleElement.textContent = content, 
@@ -3599,11 +3985,12 @@ class DomContainer extends _SharedContainer {
         };
     }
     $scheduleInitialQRLs$() {
-        if (this.$initialQRLsIndexes$) {
-            for (const index of this.$initialQRLsIndexes$) {
-                this.$scheduler$(1, null, this.$getObjectById$(index));
+        if (this.$initialQRLs$) {
+            for (const qrl of this.$initialQRLs$) {
+                const match = /#(.*)_([a-zA-Z0-9]+)(\[|$)/.exec(qrl);
+                match && p(match[2], .3);
             }
-            this.$initialQRLsIndexes$ = null;
+            this.$initialQRLs$ = null;
         }
     }
 }
@@ -3635,7 +4022,7 @@ const addQrlToSerializationCtx = (effectSubscriber, container) => {
 };
 
 const triggerEffects = (container, signal, effects) => {
-    const isBrowser = isDomContainer(container);
+    const isBrowser = !isServerPlatform();
     if (effects) {
         const scheduleEffect = effectSubscription => {
             const consumer = effectSubscription[0];
@@ -3643,28 +4030,28 @@ const triggerEffects = (container, signal, effects) => {
             if (assertDefined(container, "Container must be defined."), isTask(consumer)) {
                 consumer.$flags$ |= 8;
                 let choreType = 3;
-                1 & consumer.$flags$ && (choreType = 32), container.$scheduler$(choreType, consumer);
+                1 & consumer.$flags$ && (choreType = 16), container.$scheduler$(choreType, consumer);
             } else if (consumer instanceof SignalImpl) {
                 consumer instanceof ComputedSignalImpl && (consumer.$computeQrl$.resolved || container.$scheduler$(1, null, consumer.$computeQrl$)), 
-                consumer.$invalidate$();
+                consumer.invalidate();
             } else if (":" === property) {
                 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$(6, host, qrl, props);
-            } else if (isBrowser) {
-                if ("." === property) {
+            } else if ("." === property) {
+                if (isBrowser) {
                     container.$scheduler$(4, consumer, consumer, signal);
-                } else {
-                    const effectData = effectSubscription[3];
-                    if (effectData instanceof SubscriptionData) {
-                        const payload = {
-                            ...effectData.data,
-                            $value$: signal
-                        };
-                        container.$scheduler$(5, consumer, property, payload);
-                    }
+                }
+            } else {
+                const effectData = effectSubscription[3];
+                if (effectData instanceof SubscriptionData) {
+                    const payload = {
+                        ...effectData.data,
+                        $value$: signal
+                    };
+                    container.$scheduler$(5, consumer, property, payload);
                 }
             }
         };
@@ -3674,7 +4061,20 @@ const triggerEffects = (container, signal, effects) => {
     }
 };
 
-const isSerializerObj = obj => "object" == typeof obj && null !== obj && "function" == typeof obj[SerializerSymbol];
+const isSerializerObj = obj => isObject(obj) && "function" == typeof obj[SerializerSymbol];
+
+const getComputedSignalFlags = serializationStrategy => {
+    let flags = 1;
+    switch (serializationStrategy) {
+      case "never":
+        flags |= 16;
+        break;
+
+      case "always":
+        flags |= 32;
+    }
+    return flags;
+};
 
 const stringifyPath = [];
 
@@ -3721,7 +4121,7 @@ function qwikDebugToString(value) {
     return value;
 }
 
-const pad = (text, prefix) => String(text).split("\n").map(((line, idx) => (idx ? prefix : "") + line)).join("\n");
+const pad = (text, prefix) => String(text).split("\n").map((line, idx) => (idx ? prefix : "") + line).join("\n");
 
 const jsxToString = value => {
     if (isJSXNode(value)) {
@@ -3731,9 +4131,9 @@ const jsxToString = value => {
                 str += " " + key + "=" + qwikDebugToString(val);
             }
             const children = value.children;
-            null != children ? (str += ">", Array.isArray(children) ? children.forEach((child => {
+            null != children ? (str += ">", Array.isArray(children) ? children.forEach(child => {
                 str += jsxToString(child);
-            })) : str += jsxToString(children), str += "</" + value.type + ">") : str += "/>";
+            }) : str += jsxToString(children), str += "</" + value.type + ">") : str += "/>";
         }
         return str;
     }
@@ -3865,13 +4265,16 @@ const vnode_ensureElementInflated = vnode => {
     }
 };
 
-function vnode_walkVNode(vNode) {
+function vnode_walkVNode(vNode, callback) {
     let vCursor = vNode;
     if (vnode_isTextVNode(vNode)) {
         return;
     }
     let vParent = null;
     for (;;) {
+        if (callback?.(vCursor, vParent)) {
+            return;
+        }
         const vFirstChild = vnode_getFirstChild(vCursor);
         if (vFirstChild) {
             vCursor = vFirstChild;
@@ -3970,6 +4373,7 @@ const vnode_ensureTextInflated = (journal, vnode) => {
     const textVNode = ensureTextVNode(vnode);
     if (!(8 & textVNode[0])) {
         const parentNode = vnode_getDomParent(vnode);
+        assertDefined(parentNode, "Missing parent node.");
         const sharedTextNode = textVNode[4];
         const doc = parentNode.ownerDocument;
         let cursor = vnode_getDomSibling(vnode, !1, !0);
@@ -4086,6 +4490,17 @@ const indexOfAlphanumeric = (id, length) => {
     return length;
 };
 
+const vnode_createErrorDiv = (document, host, err, journal) => {
+    const errorDiv = document.createElement("errored-host");
+    err && err instanceof Error && (errorDiv.props = {
+        error: err
+    }), errorDiv.setAttribute("q:key", "_error_");
+    const vErrorDiv = vnode_newElement(errorDiv, "errored-host");
+    return vnode_getDOMChildNodes(journal, host, !0).forEach(child => {
+        vnode_insertBefore(journal, vErrorDiv, child, null);
+    }), vErrorDiv;
+};
+
 const parseBoolean = value => "false" !== value && Boolean(value);
 
 const isBooleanAttr = (element, key) => ("allowfullscreen" == key || "async" == key || "autofocus" == key || "autoplay" == key || "checked" == key || "controls" == key || "default" == key || "defer" == key || "disabled" == key || "formnovalidate" == key || "inert" == key || "ismap" == key || "itemscope" == key || "loop" == key || "multiple" == key || "muted" == key || "nomodule" == key || "novalidate" == key || "open" == key || "playsinline" == key || "readonly" == key || "required" == key || "reversed" == key || "selected" == key) && key in element;
@@ -4146,26 +4561,29 @@ const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
         }
         insertBefore = null;
     }
-    const domParentVNode = vnode_getDomParentVNode(parent);
+    const domParentVNode = vnode_getDomParentVNode(parent, !1);
     const parentNode = domParentVNode && domParentVNode[6];
     let domChildren = null;
     domParentVNode && (domChildren = vnode_getDomChildrenWithCorrectNamespacesToInsert(journal, domParentVNode, newChild)), 
     newChildCurrentParent && (newChild[2] || newChild[3] || newChildCurrentParent !== parent) && vnode_remove(journal, newChildCurrentParent, newChild, !1);
-    let adjustedInsertBefore = null;
-    null == insertBefore ? vnode_isVirtualVNode(parent) && (adjustedInsertBefore = vnode_getDomSibling(parent, !0, !1)) : adjustedInsertBefore = vnode_isVirtualVNode(insertBefore) ? vnode_getDomSibling(insertBefore, !0, !0) : insertBefore, 
-    adjustedInsertBefore && vnode_ensureInflatedIfText(journal, adjustedInsertBefore), 
-    domChildren && domChildren.length && journal.push(5, parentNode, vnode_getNode(adjustedInsertBefore), ...domChildren);
+    const parentIsDeleted = 32 & parent[0];
+    if (!parentIsDeleted) {
+        let adjustedInsertBefore = null;
+        null == insertBefore ? vnode_isVirtualVNode(parent) && (adjustedInsertBefore = vnode_getDomSibling(parent, !0, !1)) : adjustedInsertBefore = vnode_isVirtualVNode(insertBefore) ? vnode_getDomSibling(insertBefore, !0, !0) : insertBefore, 
+        adjustedInsertBefore && vnode_ensureInflatedIfText(journal, adjustedInsertBefore), 
+        domChildren && domChildren.length && journal.push(5, parentNode, vnode_getNode(adjustedInsertBefore), ...domChildren);
+    }
     const vNext = insertBefore;
     const vPrevious = vNext ? vNext[2] : parent[5];
     vNext ? vNext[2] = newChild : parent[5] = newChild, vPrevious ? vPrevious[3] = newChild : parent[4] = newChild, 
-    newChild[2] = vPrevious, newChild[3] = vNext, newChild[1] = parent;
+    newChild[2] = vPrevious, newChild[3] = vNext, newChild[1] = parent, parentIsDeleted && (newChild[0] |= 32);
 };
 
-const vnode_getDomParent = vnode => (vnode = vnode_getDomParentVNode(vnode)) && vnode[6];
+const vnode_getDomParent = (vnode, includeProjection = !0) => (vnode = vnode_getDomParentVNode(vnode, includeProjection)) && vnode[6];
 
-const vnode_getDomParentVNode = vnode => {
+const vnode_getDomParentVNode = (vnode, includeProjection = !0) => {
     for (;vnode && !vnode_isElementVNode(vnode); ) {
-        vnode = vnode[1];
+        vnode = vnode[1] || (includeProjection ? vnode_getProp(vnode, "q:sparent", id => vnode_isVNode(id) ? id : null) : null);
     }
     return vnode;
 };
@@ -4173,7 +4591,7 @@ const vnode_getDomParentVNode = vnode => {
 const vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
     if (assertEqual(vParent, vnode_getParent(vToRemove), "Parent mismatch."), vnode_isTextVNode(vToRemove) && vnode_ensureTextInflated(journal, vToRemove), 
     removeDOM) {
-        const domParent = vnode_getDomParent(vParent);
+        const domParent = vnode_getDomParent(vParent, !1);
         if (vnode_getAttr(vParent, dangerouslySetInnerHTML)) {
             return;
         }
@@ -4371,7 +4789,7 @@ const materializeFromDOM = (vParent, firstChild, vData) => {
     }
     if (vParent[5] = vChild || null, vParent[4] = vFirstChild, vData) {
         let container = null;
-        processVNodeData(vData, ((peek, consumeValue) => {
+        processVNodeData(vData, (peek, consumeValue) => {
             if (peek() === VNodeDataChar.ID) {
                 container || (container = getDomContainer(vParent[6]));
                 const id = consumeValue();
@@ -4380,18 +4798,30 @@ const materializeFromDOM = (vParent, firstChild, vData) => {
                 peek() === VNodeDataChar.BACK_REFS ? (container || (container = getDomContainer(vParent[6])), 
                 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);
+        mergeMaps(vParent[_EFFECT_BACK_REF], container.$getObjectById$(value));
     } else {
         Object.defineProperty(vParent, _EFFECT_BACK_REF, {
-            value: deserializedSubMap
+            get() {
+                const subMap = container.$getObjectById$(value);
+                return vParent[_EFFECT_BACK_REF] = subMap, subMap;
+            },
+            set(value) {
+                Object.defineProperty(vParent, _EFFECT_BACK_REF, {
+                    value,
+                    writable: !0,
+                    enumerable: !0,
+                    configurable: !0
+                });
+            },
+            enumerable: !0,
+            configurable: !0
         });
     }
 }
@@ -4400,7 +4830,8 @@ const processVNodeData = (vData, callback) => {
     let nextToConsumeIdx = 0;
     let ch = 0;
     let peekCh = 0;
-    const peek = () => 0 !== peekCh ? peekCh : peekCh = nextToConsumeIdx < vData.length ? vData.charCodeAt(nextToConsumeIdx) : 0;
+    const getChar = idx => idx < vData.length ? vData.charCodeAt(idx) : 0;
+    const peek = () => 0 !== peekCh ? peekCh : peekCh = getChar(nextToConsumeIdx);
     const consume = () => (ch = peek(), peekCh = 0, nextToConsumeIdx++, ch);
     const consumeValue = () => {
         consume();
@@ -4411,7 +4842,7 @@ const processVNodeData = (vData, callback) => {
         return vData.substring(start, nextToConsumeIdx);
     };
     for (;0 !== peek(); ) {
-        callback(peek, consumeValue, consume, nextToConsumeIdx);
+        callback(peek, consumeValue, consume, getChar, nextToConsumeIdx);
     }
 };
 
@@ -4444,7 +4875,7 @@ const vnode_setAttr = (journal, vnode, key, value) => {
                 journal && journal.push(2, vnode[6], key, value);
             }
             null == value ? props.splice(idx, 2) : props[idx + 1] = value;
-        } else if (null != value && (props.splice(~idx, 0, key, value), 1 & type)) {
+        } else if (null != value && (props.splice(-1 ^ idx, 0, key, value), 1 & type)) {
             journal && journal.push(2, vnode[6], key, value);
         }
     }
@@ -4478,7 +4909,7 @@ const vnode_setProp = (vnode, key, value) => {
     ensureElementOrVirtualVNode(vnode);
     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);
+    idx >= 0 ? props[idx + 1] = value : null != value && props.splice(-1 ^ idx, 0, key, value);
 };
 
 const vnode_getPropStartIndex = vnode => {
@@ -4496,6 +4927,27 @@ const vnode_getProps = vnode => vnode[vnode_getPropStartIndex(vnode)];
 
 const vnode_getParent = vnode => vnode[1] || null;
 
+const vnode_isDescendantOf = (vnode, ancestor, rootVNode) => {
+    let parent = vnode_getParentOrProjectionParent(vnode, rootVNode);
+    for (;parent; ) {
+        if (parent === ancestor) {
+            return !0;
+        }
+        parent = vnode_getParentOrProjectionParent(parent, rootVNode);
+    }
+    return !1;
+};
+
+const vnode_getParentOrProjectionParent = (vnode, rootVNode) => {
+    if (rootVNode) {
+        const parentProjection = vnode_getProp(vnode, "q:sparent", id => vnode_locate(rootVNode, id));
+        if (parentProjection) {
+            return parentProjection;
+        }
+    }
+    return vnode_getParent(vnode);
+};
+
 const vnode_getNode = vnode => null === vnode || vnode_isVirtualVNode(vnode) ? null : vnode_isElementVNode(vnode) ? vnode[6] : (assertTrue(vnode_isTextVNode(vnode), "Expecting Text Node."), 
 vnode[4]);
 
@@ -4516,12 +4968,12 @@ function vnode_toString(depth = 20, offset = "", materialize = !1, siblings = !1
             strings.push(qwikDebugToString(vnode_getText(vnode)));
         } else if (vnode_isVirtualVNode(vnode)) {
             const attrs = [ "[" + String(vnode[0] >>> 8) + "]" ];
-            vnode_getAttrKeys(vnode).forEach((key => {
+            vnode_getAttrKeys(vnode).forEach(key => {
                 if (key !== DEBUG_TYPE) {
                     const value = vnode_getAttr(vnode, key);
                     attrs.push(" " + key + "=" + qwikDebugToString(value));
                 }
-            }));
+            });
             const name = (colorize ? "" : "") + (VirtualTypeName[vnode_getAttr(vnode, DEBUG_TYPE) || "V"] || VirtualTypeName.V) + (colorize ? "" : "");
             strings.push("<" + name + attrs.join("") + ">");
             const child = vnode_getFirstChild(vnode);
@@ -4531,10 +4983,10 @@ function vnode_toString(depth = 20, offset = "", materialize = !1, siblings = !1
             const tag = vnode_getElementName(vnode);
             const attrs = [];
             const keys = vnode_getAttrKeys(vnode);
-            keys.forEach((key => {
+            keys.forEach(key => {
                 const value = vnode_getAttr(vnode, key);
                 attrs.push(" " + key + "=" + qwikDebugToString(value));
-            }));
+            });
             const node = vnode_getNode(vnode);
             if (node) {
                 const vnodeData = node.ownerDocument.qVNodeData?.get(node);
@@ -4576,16 +5028,13 @@ function materializeFromVNodeData(vParent, vData, element, child) {
     let textIdx = 0;
     let combinedText = null;
     let container = null;
-    return processVNodeData(vData, ((peek, consumeValue, consume, nextToConsumeIdx) => {
+    return processVNodeData(vData, (peek, consumeValue, consume, getChar, nextToConsumeIdx) => {
         if (isNumber(peek())) {
-            for (;!isElement(child); ) {
+            for (;!isElement(child) || isQStyleElement(child); ) {
                 if (!(child = fastNextSibling(child))) {
                     throw qError(27, [ vData, peek(), nextToConsumeIdx ]);
                 }
             }
-            for (;isQStyleElement(child); ) {
-                child = fastNextSibling(child);
-            }
             combinedText = null, previousTextNode = null;
             let value = 0;
             for (;isNumber(peek()); ) {
@@ -4605,7 +5054,9 @@ function materializeFromVNodeData(vParent, vData, element, child) {
         } else if (peek() === VNodeDataChar.PROPS) {
             vnode_setAttr(null, vParent, "q:props", consumeValue());
         } else if (peek() === VNodeDataChar.KEY) {
-            vnode_setAttr(null, vParent, "q:key", consumeValue());
+            let value;
+            getChar(nextToConsumeIdx + 1) === VNodeDataChar.SEPARATOR ? (consume(), value = decodeURI(consumeValue()), 
+            consume()) : value = consumeValue(), vnode_setAttr(null, vParent, "q:key", value);
         } else if (peek() === VNodeDataChar.SEQ) {
             vnode_setAttr(null, vParent, "q:seq", consumeValue());
         } else if (peek() === VNodeDataChar.SEQ_IDX) {
@@ -4629,6 +5080,9 @@ function materializeFromVNodeData(vParent, vData, element, child) {
         } else if (peek() === VNodeDataChar.SLOT) {
             vnode_setAttr(null, vParent, QSlot, consumeValue());
         } else {
+            for (;isQStyleElement(child); ) {
+                child = fastNextSibling(child);
+            }
             const textNode = child && 3 === fastNodeType(child) ? child : null;
             null === combinedText && (combinedText = textNode ? textNode.nodeValue : null, textIdx = 0);
             let length = 0;
@@ -4640,7 +5094,7 @@ function materializeFromVNodeData(vParent, vData, element, child) {
             addVNode(previousTextNode = vnode_newSharedText(previousTextNode, textNode, text)), 
             textIdx += length;
         }
-    })), vParent[5] = vLast, vFirst;
+    }), vParent[5] = vLast, vFirst;
 }
 
 const vnode_getType = vnode => {
@@ -4663,7 +5117,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, "q:sparent", (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);
         }
@@ -4687,9 +5141,11 @@ const VNodeArray = class VNode extends Array {
     }
 };
 
+const needsInflation = typeId => typeId >= 14 || 4 === typeId || 5 === typeId;
+
 const deserializedProxyMap = new WeakMap;
 
-const isDeserializerProxy = value => "object" == typeof value && null !== value && SERIALIZER_PROXY_UNWRAP in value;
+const isDeserializerProxy = value => isObject(value) && SERIALIZER_PROXY_UNWRAP in value;
 
 const SERIALIZER_PROXY_UNWRAP = Symbol("UNWRAP");
 
@@ -4723,14 +5179,13 @@ class DeserializationHandler {
         const idx = 2 * i;
         const typeId = this.$data$[idx];
         const value = this.$data$[idx + 1];
-        if (void 0 === typeId) {
+        if (0 === typeId) {
             return value;
         }
         const container = this.$container$;
-        let propValue = allocate(container, typeId, value);
-        return typeId >= 14 && (propValue = inflate(container, propValue, typeId, value)), 
-        Reflect.set(target, property, propValue), this.$data$[idx] = void 0, this.$data$[idx + 1] = propValue, 
-        propValue;
+        const propValue = allocate(container, typeId, value);
+        return Reflect.set(target, property, propValue), this.$data$[idx] = 0, this.$data$[idx + 1] = propValue, 
+        needsInflation(typeId) && inflate(container, propValue, typeId, value), propValue;
     }
     has(target, property) {
         return property === SERIALIZER_PROXY_UNWRAP || Object.prototype.hasOwnProperty.call(target, property);
@@ -4745,7 +5200,7 @@ class DeserializationHandler {
             return out;
         }
         const idx = 2 * i;
-        return this.$data$[idx] = void 0, this.$data$[idx + 1] = value, !0;
+        return this.$data$[idx] = 0, this.$data$[idx + 1] = value, !0;
     }
 }
 
@@ -4760,318 +5215,300 @@ const _eagerDeserializeArray = (container, data) => {
 const resolvers = new WeakMap;
 
 const inflate = (container, target, typeId, data) => {
-    if (void 0 === typeId) {
-        return target;
-    }
-    switch (15 !== typeId && Array.isArray(data) && (data = _eagerDeserializeArray(container, data)), 
-    typeId) {
-      case 15:
-        for (let i = 0; i < data.length; i += 4) {
-            const key = deserializeData(container, data[i], data[i + 1]);
-            const valType = data[i + 2];
-            const valData = data[i + 3];
-            0 === valType || valType >= 14 ? Object.defineProperty(target, key, {
-                get() {
-                    const value = deserializeData(container, valType, valData);
-                    return target[key] = value, value;
-                },
-                set(value) {
-                    Object.defineProperty(target, key, {
-                        value,
-                        writable: !0,
-                        enumerable: !0,
-                        configurable: !0
-                    });
-                },
-                enumerable: !0,
-                configurable: !0
-            }) : target[key] = deserializeData(container, valType, valData);
-        }
-        break;
-
-      case 20:
-      case 21:
-        inflateQRL(container, target);
-        break;
-
-      case 22:
-        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[_EFFECT_BACK_REF] = v[4], task.$state$ = v[5];
-        break;
-
-      case 23:
-        const [resolved, result, effects] = data;
-        const resource = target;
-        resolved ? (resource.value = Promise.resolve(result), resource._resolved = result, 
-        resource._state = "resolved") : (resource.value = Promise.reject(result), resource._error = result, 
-        resource._state = "rejected"), getStoreHandler(target).$effects$ = effects;
-        break;
-
-      case 24:
-        target[SERIALIZABLE_STATE][0] = data[0];
-        break;
+    if (0 !== typeId) {
+        switch (Array.isArray(data) && (data = _eagerDeserializeArray(container, data)), 
+        typeId) {
+          case 4:
+            for (let i = 0; i < target.length; i++) {}
+            break;
 
-      case 30:
-      case 31:
-        {
-            const [value, flags, effects] = data;
-            const store = getOrCreateStore(value, flags, container);
-            getStoreHandler(store).$effects$ = effects, target = store;
+          case 5:
+            for (let i = 0; i < data.length; i += 2) {
+                target[data[i]] = data[i + 1];
+            }
             break;
-        }
 
-      case 25:
-        {
-            const signal = target;
-            const d = data;
-            signal.$untrackedValue$ = d[0], signal.$effects$ = new Set(d.slice(1));
+          case 19:
+          case 20:
+            inflateQRL(container, target);
             break;
-        }
 
-      case 26:
-        {
-            const signal = target;
-            const d = data;
-            signal.$func$ = container.getSyncFn(d[0]), signal.$args$ = d[1], signal[_EFFECT_BACK_REF] = d[2], 
-            signal.$untrackedValue$ = NEEDS_COMPUTATION, signal.$flags$ = d[3], signal.$flags$ |= 1, 
-            signal.$hostElement$ = d[4], signal.$effects$ = new Set(d.slice(5));
+          case 21:
+            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[_EFFECT_BACK_REF] = v[4], task.$state$ = v[5];
             break;
-        }
 
-      case 28:
-        {
-            const asyncComputed = target;
-            const d = data;
-            asyncComputed.$computeQrl$ = d[0], asyncComputed.$effects$ = new Set(d[1]), asyncComputed.$loadingEffects$ = new Set(d[2]), 
-            asyncComputed.$errorEffects$ = new Set(d[3]), asyncComputed.$untrackedLoading$ = d[4], 
-            asyncComputed.$untrackedError$ = d[5];
-            d.length > 6 ? asyncComputed.$untrackedValue$ = d[6] : asyncComputed.$flags$ |= 1;
+          case 22:
+            const [resolved, result, effects] = data;
+            const resource = target;
+            resolved ? (resource.value = Promise.resolve(result), resource._resolved = result, 
+            resource._state = "resolved") : (resource.value = Promise.reject(result), resource._error = result, 
+            resource._state = "rejected"), getStoreHandler(target).$effects$ = effects;
             break;
-        }
 
-      case 29:
-      case 27:
-        {
-            const computed = target;
-            const d = data;
-            computed.$computeQrl$ = d[0], computed.$effects$ = new Set(d[1]);
-            d.length > 2 ? (computed.$untrackedValue$ = d[2], 29 === typeId && (computed.$flags$ |= 1)) : (computed.$flags$ |= 1, 
-            computed.$computeQrl$.resolve(), container.$scheduler$?.(1, null, computed.$computeQrl$));
+          case 23:
+            target[SERIALIZABLE_STATE][0] = data[0];
             break;
-        }
 
-      case 14:
-        {
-            const d = data;
-            target.message = d[0];
-            for (let i = 1; i < d.length; i += 2) {
-                target[d[i]] = d[i + 1];
+          case 29:
+            {
+                const [, flags, effects] = data;
+                const storeHandler = getStoreHandler(target);
+                storeHandler.$flags$ = flags, storeHandler.$effects$ = effects;
+                break;
             }
-            break;
-        }
 
-      case 32:
-        {
-            const formData = target;
-            const d = data;
-            for (let i = 0; i < d.length; i++) {
-                formData.append(d[i++], d[i]);
+          case 24:
+            {
+                const signal = target;
+                const d = data;
+                signal.$untrackedValue$ = d[0], signal.$effects$ = new Set(d.slice(1));
+                break;
             }
-            break;
-        }
 
-      case 33:
-        {
-            const jsx = target;
-            const [type, varProps, constProps, children, flags, key] = data;
-            jsx.type = type, jsx.varProps = varProps, jsx.constProps = constProps, jsx.children = children, 
-            jsx.flags = flags, jsx.key = key;
-            break;
-        }
+          case 25:
+            {
+                const signal = target;
+                const d = data;
+                signal.$func$ = container.getSyncFn(d[0]), signal.$args$ = d[1], signal[_EFFECT_BACK_REF] = d[2], 
+                signal.$untrackedValue$ = NEEDS_COMPUTATION, signal.$flags$ = d[3], signal.$flags$ |= 1, 
+                signal.$hostElement$ = d[4], signal.$effects$ = new Set(d.slice(5));
+                break;
+            }
 
-      case 17:
-        {
-            const set = target;
-            const d = data;
-            for (let i = 0; i < d.length; i++) {
-                set.add(d[i]);
+          case 27:
+            {
+                const asyncComputed = target;
+                const d = data;
+                asyncComputed.$computeQrl$ = d[0], asyncComputed.$effects$ = new Set(d[1]), asyncComputed.$loadingEffects$ = new Set(d[2]), 
+                asyncComputed.$errorEffects$ = new Set(d[3]), asyncComputed.$untrackedLoading$ = d[4], 
+                asyncComputed.$untrackedError$ = d[5];
+                d.length > 6 && (asyncComputed.$untrackedValue$ = d[6]), asyncComputed.$flags$ |= 1;
+                break;
             }
-            break;
-        }
 
-      case 18:
-        {
-            const map = target;
-            const d = data;
-            for (let i = 0; i < d.length; i++) {
-                map.set(d[i++], d[i]);
+          case 28:
+          case 26:
+            {
+                const computed = target;
+                const d = data;
+                computed.$computeQrl$ = d[0], computed.$effects$ = new Set(d[1]);
+                d.length > 2 ? (computed.$untrackedValue$ = d[2], 28 === typeId && (computed.$flags$ |= 1)) : (computed.$flags$ |= 1, 
+                computed.$computeQrl$.resolve(), container.$scheduler$(1, null, computed.$computeQrl$));
+                break;
             }
-            break;
-        }
 
-      case 16:
-        {
-            const promise = target;
-            const [resolved, result] = data;
-            const [resolve, reject] = resolvers.get(promise);
-            resolved ? resolve(result) : reject(result);
-            break;
-        }
+          case 14:
+            {
+                const d = data;
+                target.message = d[0];
+                for (let i = 1; i < d.length; i += 2) {
+                    target[d[i]] = d[i + 1];
+                }
+                break;
+            }
 
-      case 19:
-        const bytes = target;
-        const buf = atob(data);
-        let i = 0;
-        for (const s of buf) {
-            bytes[i++] = s.charCodeAt(0);
-        }
-        break;
+          case 30:
+            {
+                const formData = target;
+                const d = data;
+                for (let i = 0; i < d.length; i++) {
+                    formData.append(d[i++], d[i]);
+                }
+                break;
+            }
 
-      case 34:
-        const propsProxy = target;
-        propsProxy[_VAR_PROPS] = 0 === data ? {} : data[0], propsProxy[_CONST_PROPS] = data[1];
-        break;
+          case 31:
+            {
+                const jsx = target;
+                const [type, varProps, constProps, children, flags, key] = data;
+                jsx.type = type, jsx.varProps = varProps, jsx.constProps = constProps, jsx.children = children, 
+                jsx.flags = flags, jsx.key = key;
+                break;
+            }
 
-      case 35:
-        {
-            const effectData = target;
-            effectData.data.$scopedStyleIdPrefix$ = data[0], effectData.data.$isConst$ = data[1];
+          case 16:
+            {
+                const set = target;
+                const d = data;
+                for (let i = 0; i < d.length; i++) {
+                    set.add(d[i]);
+                }
+                break;
+            }
+
+          case 17:
+            {
+                const map = target;
+                const d = data;
+                for (let i = 0; i < d.length; i++) {
+                    map.set(d[i++], d[i]);
+                }
+                break;
+            }
+
+          case 15:
+            {
+                const promise = target;
+                const [resolved, result] = data;
+                const [resolve, reject] = resolvers.get(promise);
+                resolved ? resolve(result) : reject(result);
+                break;
+            }
+
+          case 18:
+            const bytes = target;
+            const buf = atob(data);
+            let i = 0;
+            for (const s of buf) {
+                bytes[i++] = s.charCodeAt(0);
+            }
             break;
-        }
 
-      default:
-        throw qError(16, [ typeId ]);
+          case 32:
+            const propsProxy = target;
+            propsProxy[_VAR_PROPS] = 0 === data ? {} : data[0], propsProxy[_CONST_PROPS] = data[1];
+            break;
+
+          case 33:
+            {
+                const effectData = target;
+                effectData.data.$scopedStyleIdPrefix$ = data[0], effectData.data.$isConst$ = data[1];
+                break;
+            }
+
+          default:
+            throw qError(16, [ typeId ]);
+        }
     }
-    return target;
 };
 
-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 _constants = [ void 0, null, !0, !1, "", EMPTY_ARRAY, EMPTY_OBJ, NEEDS_COMPUTATION, STORE_ALL_PROPS, _UNINITIALIZED, Slot, Fragment, NaN, 1 / 0, -1 / 0, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER - 1, Number.MIN_SAFE_INTEGER ];
 
-const _constantNames = [ "undefined", "null", "true", "false", "''", "EMPTY_ARRAY", "EMPTY_OBJ", "NEEDS_COMPUTATION", "STORE_ALL_PROPS", "Slot", "Fragment", "NaN", "Infinity", "-Infinity", "MAX_SAFE_INTEGER", "MAX_SAFE_INTEGER-1", "MIN_SAFE_INTEGER" ];
+const _constantNames = [ "undefined", "null", "true", "false", "''", "EMPTY_ARRAY", "EMPTY_OBJ", "NEEDS_COMPUTATION", "STORE_ALL_PROPS", "_UNINITIALIZED", "Slot", "Fragment", "NaN", "Infinity", "-Infinity", "MAX_SAFE_INTEGER", "MAX_SAFE_INTEGER-1", "MIN_SAFE_INTEGER" ];
 
 const allocate = (container, typeId, value) => {
-    if (void 0 === value) {
-        return typeId;
+    if (0 === typeId) {
+        return value;
     }
     switch (typeId) {
-      case 0:
+      case 1:
         return container.$getObjectById$(value);
 
-      case 1:
+      case 2:
         if (!container.$forwardRefs$) {
             throw qError(18, [ "forward ref" ]);
         }
-        return container.$getObjectById$(container.$forwardRefs$[value]);
+        const rootRef = container.$forwardRefs$[value];
+        return -1 === rootRef ? _UNINITIALIZED : container.$getObjectById$(rootRef);
 
-      case 2:
-      case 4:
-      case 5:
+      case 13:
         return value;
 
       case 3:
         return _constants[value];
 
-      case 6:
+      case 4:
         return wrapDeserializerProxy(container, value);
 
-      case 15:
+      case 5:
         return {};
 
+      case 19:
       case 20:
-      case 21:
         return parseQRL("number" == typeof value ? container.$getObjectById$(value) : value);
 
-      case 22:
+      case 21:
         return new Task(-1, -1, null, null, null, null);
 
-      case 23:
+      case 22:
         {
             const res = createResourceReturn(container, void 0, void 0);
             return res.loading = !1, res;
         }
 
-      case 7:
+      case 6:
         return new URL(value);
 
-      case 8:
+      case 7:
         return new Date(value);
 
-      case 9:
+      case 8:
         const idx = value.lastIndexOf("/");
         return new RegExp(value.slice(1, idx), value.slice(idx + 1));
 
       case 14:
         return new Error;
 
-      case 24:
+      case 23:
         return componentQrl(null);
 
-      case 25:
+      case 24:
         return new SignalImpl(container, 0);
 
-      case 26:
+      case 25:
         return new WrappedSignalImpl(container, null, null, null);
 
-      case 27:
+      case 26:
         return new ComputedSignalImpl(container, null);
 
-      case 28:
+      case 27:
         return new AsyncComputedSignalImpl(container, null);
 
-      case 29:
+      case 28:
         return new SerializerSignalImpl(container, null);
 
-      case 30:
-      case 31:
-        return null;
+      case 29:
+        const storeValue = deserializeData(container, value[0], value[1]);
+        return value[0] = 0, value[1] = storeValue, getOrCreateStore(storeValue, 0, container);
 
-      case 13:
+      case 12:
         return new URLSearchParams(value);
 
-      case 32:
+      case 30:
         return new FormData;
 
-      case 33:
+      case 31:
         return new JSXNodeImpl(null, null, null, null, -1, null);
 
-      case 12:
+      case 11:
         return BigInt(value);
 
-      case 17:
+      case 16:
         return new Set;
 
-      case 18:
+      case 17:
         return new Map;
 
-      case 16:
+      case 15:
         let resolve;
         let reject;
-        const promise = new Promise(((res, rej) => {
+        const promise = new Promise((res, rej) => {
             resolve = res, reject = rej;
-        }));
-        return resolvers.set(promise, [ resolve, reject ]), promise.catch((() => {})), promise;
+        });
+        return resolvers.set(promise, [ resolve, reject ]), promise.catch(() => {}), promise;
 
-      case 19:
+      case 18:
         const encodedLength = value.length;
         const rest = 3 & encodedLength;
         return new Uint8Array(3 * (encodedLength >>> 2) + (rest ? rest - 1 : 0));
 
-      case 34:
+      case 32:
         return createPropsProxy(null, null);
 
-      case 10:
+      case 9:
         return retrieveVNodeOrDocument(container, value);
 
-      case 11:
+      case 10:
         const vNode = retrieveVNodeOrDocument(container, value);
         if (vnode_isVNode(vNode)) {
-            return vnode_getNode(vNode);
+            return ensureMaterialized(vNode), vnode_getNode(vNode);
         }
         throw qError(17, [ typeof vNode ]);
 
-      case 35:
+      case 33:
         return new SubscriptionData({});
 
       default:
@@ -5089,7 +5526,7 @@ function parseQRL(qrl) {
     const captureEnd = qrl.indexOf("]", captureStart);
     const chunk = qrl.slice(0, hashIdx > -1 ? hashIdx : captureStart);
     const symbol = captureStart > -1 ? qrl.slice(hashIdx + 1, captureStart) : qrl.slice(hashIdx + 1);
-    const captureIds = captureStart > -1 && captureEnd > -1 ? qrl.slice(captureStart + 1, captureEnd).split(" ").filter((v => v.length)).map((s => parseInt(s, 10))) : null;
+    const captureIds = captureStart > -1 && captureEnd > -1 ? qrl.slice(captureStart + 1, captureEnd).split(" ").filter(v => v.length).map(s => parseInt(s, 10)) : null;
     let qrlRef = null;
     if (chunk === QRL_RUNTIME_CHUNK) {
         const backChannel = globalThis.__qrl_back_channel__;
@@ -5100,7 +5537,7 @@ function parseQRL(qrl) {
 
 function inflateQRL(container, qrl) {
     const captureIds = qrl.$capture$;
-    return qrl.$captureRef$ = captureIds ? captureIds.map((id => container.$getObjectById$(id))) : null, 
+    return qrl.$captureRef$ = captureIds ? captureIds.map(id => container.$getObjectById$(id)) : null, 
     container.element && qrl.$setContainer$(container.element), qrl;
 }
 
@@ -5115,12 +5552,12 @@ const createSerializationContext = (NodeConstructor, DomRefConstructor, symbolTo
         };
     }
     const seenObjsMap = new Map;
-    const rootsPathMap = new Map;
+    const objectPathStringCache = new Map;
     const syncFnMap = new Map;
     const syncFns = [];
     const roots = [];
     const $addRootPath$ = obj => {
-        const rootPath = rootsPathMap.get(obj);
+        const rootPath = objectPathStringCache.get(obj);
         if (rootPath) {
             return rootPath;
         }
@@ -5134,7 +5571,7 @@ const createSerializationContext = (NodeConstructor, DomRefConstructor, symbolTo
             current = seenObjsMap.get(current.$parent$);
         }
         const pathStr = path.length > 1 ? path.join(" ") : path.length ? path[0] : seen.$index$;
-        return rootsPathMap.set(obj, pathStr), pathStr;
+        return objectPathStringCache.set(obj, pathStr), pathStr;
     };
     const isSsrNode = NodeConstructor ? obj => obj instanceof NodeConstructor : () => !1;
     return isDomRef = DomRefConstructor ? obj => obj instanceof DomRefConstructor : () => !1, 
@@ -5197,7 +5634,7 @@ const createSerializationContext = (NodeConstructor, DomRefConstructor, symbolTo
         $storeProxyMap$: storeProxyMap,
         $getProp$: getProp,
         $setProp$: setProp,
-        $pathMap$: rootsPathMap
+        $objectPathStringCache$: objectPathStringCache
     };
 };
 
@@ -5216,7 +5653,7 @@ const discoverValuesForVNodeData = (vnodeData, callback) => {
         if (isSsrAttrs(value)) {
             for (let i = 1; i < value.length; i += 2) {
                 const attrValue = value[i];
-                "string" == typeof attrValue || "q:props" === value[i - 1] && 0 === Object.keys(attrValue).length || callback(attrValue);
+                null == attrValue || "string" == typeof attrValue || "q:props" === value[i - 1] && 0 === Object.keys(attrValue).length || callback(attrValue);
             }
         }
     }
@@ -5234,13 +5671,24 @@ class PromiseResult {
     }
 }
 
+class SerializationWeakRef {
+    $obj$;
+    constructor($obj$) {
+        this.$obj$ = $obj$;
+    }
+}
+
+const _serializationWeakRef = obj => new SerializationWeakRef(obj);
+
 async function serialize(serializationContext) {
-    const {$writer$, $isSsrNode$, $isDomRef$, $storeProxyMap$, $addRoot$, $pathMap$, $wasSeen$} = serializationContext;
+    const {$writer$, $isSsrNode$, $isDomRef$, $storeProxyMap$, $addRoot$, $objectPathStringCache$, $wasSeen$} = serializationContext;
     let depth = 0;
+    let rootIdx = 0;
     const forwardRefs = [];
     let forwardRefsId = 0;
     const promises = new Set;
     const preloadQrls = new Set;
+    const s11nWeakRefs = new Map;
     let parent = null;
     const outputArray = (value, writeFn) => {
         $writer$.write("[");
@@ -5262,37 +5710,49 @@ async function serialize(serializationContext) {
             }
             $writer$.write(0 === lastIdx ? s : s.slice(lastIdx));
         } else {
-            depth++, outputArray(value, ((valueItem, idx) => {
+            depth++, outputArray(value, (valueItem, idx) => {
                 $discoverRoots$(serializationContext, valueItem, parent, idx), writeValue(valueItem);
-            })), depth--;
+            }), depth--;
         }
     };
     const addPreloadQrl = qrl => {
-        preloadQrls.add(qrl), serializationContext.$addRoot$(qrl, null);
+        preloadQrls.add(qrl), serializationContext.$addRoot$(qrl);
     };
-    const outputRootRef = (value, rootDepth = 0) => {
+    const outputAsRootRef = (value, rootDepth = 0) => {
         const seen = $wasSeen$(value);
-        const rootRefPath = $pathMap$.get(value);
-        return rootDepth === depth && seen && null !== seen.$parent$ && rootRefPath ? (output(0, rootRefPath), 
-        !0) : !!(depth > rootDepth && seen && -1 !== seen.$rootIndex$) && (output(0, seen.$rootIndex$), 
-        !0);
+        const rootRefPath = $objectPathStringCache$.get(value);
+        if (rootDepth === depth && seen && null !== seen.$parent$ && rootRefPath) {
+            return output(1, rootRefPath), !0;
+        }
+        if (depth > rootDepth && seen && -1 !== seen.$rootIndex$) {
+            return output(1, seen.$rootIndex$), !0;
+        }
+        if (s11nWeakRefs.has(value)) {
+            const forwardRefId = s11nWeakRefs.get(value);
+            if (rootDepth !== depth) {
+                const rootRef = $addRoot$(value);
+                return output(1, rootRef), forwardRefs[forwardRefId] = rootRef, !0;
+            }
+            forwardRefs[forwardRefId] = rootIdx;
+        }
+        return !1;
     };
     const writeValue = value => {
         if (fastSkipSerialize(value)) {
             output(3, 0);
         } else if ("bigint" == typeof value) {
-            output(12, value.toString());
+            output(11, value.toString());
         } else if ("boolean" == typeof value) {
             output(3, value ? 2 : 3);
         } else if ("function" == typeof value) {
             if (value === Slot) {
-                output(3, 9);
-            } else if (value === Fragment) {
                 output(3, 10);
+            } else if (value === Fragment) {
+                output(3, 11);
             } else if (isQrl(value)) {
-                if (!outputRootRef(value)) {
+                if (!outputAsRootRef(value)) {
                     const qrl = qrlToString(serializationContext, value);
-                    const type = preloadQrls.has(value) ? 21 : 20;
+                    const type = preloadQrls.has(value) ? 20 : 19;
                     if (0 === depth) {
                         output(type, qrl);
                     } else {
@@ -5306,11 +5766,11 @@ async function serialize(serializationContext) {
                 }
                 {
                     const [qrl] = value[SERIALIZABLE_STATE];
-                    serializationContext.$renderSymbols$.add(qrl.$symbol$), output(24, [ qrl ]);
+                    serializationContext.$renderSymbols$.add(qrl.$symbol$), output(23, [ qrl ]);
                 }
             }
         } else if ("number" == typeof value) {
-            Number.isNaN(value) ? output(3, 11) : Number.isFinite(value) ? value === Number.MAX_SAFE_INTEGER ? output(3, 14) : value === Number.MAX_SAFE_INTEGER - 1 ? output(3, 15) : value === Number.MIN_SAFE_INTEGER ? output(3, 16) : output(4, value) : output(3, value < 0 ? 13 : 12);
+            Number.isNaN(value) ? output(3, 12) : Number.isFinite(value) ? value === Number.MAX_SAFE_INTEGER ? output(3, 15) : value === Number.MAX_SAFE_INTEGER - 1 ? output(3, 16) : value === Number.MIN_SAFE_INTEGER ? output(3, 17) : output(0, value) : output(3, value < 0 ? 14 : 13);
         } else if ("object" == typeof value) {
             if (value === EMPTY_ARRAY) {
                 output(3, 5);
@@ -5324,32 +5784,34 @@ async function serialize(serializationContext) {
                 parent = value, writeObjectValue(value), parent = oldParent, depth--;
             }
         } else if ("string" == typeof value) {
-            0 === value.length ? output(3, 4) : outputRootRef(value) || output(5, value);
+            0 === value.length ? output(3, 4) : outputAsRootRef(value) || output(0, value);
         } else if (void 0 === value) {
             output(3, 0);
         } else if (value === NEEDS_COMPUTATION) {
             output(3, 7);
+        } else if (value === STORE_ALL_PROPS) {
+            output(3, 8);
         } else {
-            if (value !== STORE_ALL_PROPS) {
+            if (value !== _UNINITIALIZED) {
                 throw qError(20, [ typeof value ]);
             }
-            output(3, 8);
+            output(3, 9);
         }
     };
     const writeObjectValue = value => {
-        if (!outputRootRef(value, 1)) {
+        if (!outputAsRootRef(value, 1)) {
             if (isPropsProxy(value)) {
                 const varProps = value[_VAR_PROPS];
                 const constProps = value[_CONST_PROPS];
                 const out = constProps ? [ varProps, constProps ] : Object.keys(varProps).length ? [ varProps ] : 0;
-                output(34, out);
+                output(32, out);
             } else if (value instanceof SubscriptionData) {
-                output(35, [ value.data.$scopedStyleIdPrefix$, value.data.$isConst$ ]);
+                output(33, [ value.data.$scopedStyleIdPrefix$, value.data.$isConst$ ]);
             } else if (isStore(value)) {
                 if (isResource(value)) {
                     serializationContext.$resources$.add(value);
-                    const forwardRefId = $resolvePromise$(value.value, $addRoot$, ((resolved, resolvedValue) => new PromiseResult(23, resolved, resolvedValue, getStoreHandler(value).$effects$)));
-                    output(1, forwardRefId);
+                    const forwardRefId = $resolvePromise$(value.value, $addRoot$, (resolved, resolvedValue) => new PromiseResult(22, resolved, resolvedValue, getStoreHandler(value).$effects$));
+                    output(2, forwardRefId);
                 } else {
                     const storeHandler = getStoreHandler(value);
                     const storeTarget = getStoreTarget(value);
@@ -5357,79 +5819,79 @@ async function serialize(serializationContext) {
                     const effects = storeHandler.$effects$;
                     const innerStores = [];
                     for (const prop in storeTarget) {
-                        const propValue = storeTarget[prop];
-                        if ($storeProxyMap$.has(propValue)) {
-                            const innerStore = $storeProxyMap$.get(propValue);
-                            innerStores.push(innerStore), serializationContext.$addRoot$(innerStore);
-                        }
+                        const innerStore = $storeProxyMap$.get(storeTarget[prop]);
+                        innerStore && innerStores.push(innerStore);
                     }
                     const out = [ storeTarget, flags, effects, ...innerStores ];
                     for (;null == out[out.length - 1]; ) {
                         out.pop();
                     }
-                    output(Array.isArray(storeTarget) ? 31 : 30, out);
+                    output(29, out);
                 }
             } else if (isSerializerObj(value)) {
                 const result = value[SerializerSymbol](value);
                 if (isPromise(result)) {
-                    const forwardRef = $resolvePromise$(result, $addRoot$, ((resolved, resolvedValue) => new PromiseResult(29, resolved, resolvedValue, null, null)));
-                    output(1, forwardRef);
+                    const forwardRef = $resolvePromise$(result, $addRoot$, (resolved, resolvedValue) => new PromiseResult(28, resolved, resolvedValue, null, null));
+                    output(2, forwardRef);
                 } else {
                     depth--, writeValue(result), depth++;
                 }
             } else if (isObjectLiteral(value)) {
                 if (Array.isArray(value)) {
-                    output(6, value);
+                    output(4, value);
                 } else {
                     const out = [];
                     for (const key in value) {
                         Object.prototype.hasOwnProperty.call(value, key) && !fastSkipSerialize(value[key]) && out.push(key, value[key]);
                     }
-                    output(15, out);
+                    output(5, out);
                 }
             } else if ($isDomRef$(value)) {
-                value.$ssrNode$.vnodeData[0] |= 16, output(11, value.$ssrNode$.id);
+                value.$ssrNode$.vnodeData[0] |= 16, output(10, value.$ssrNode$.id);
             } else if (value instanceof SignalImpl) {
                 if (value instanceof SerializerSignalImpl) {
                     addPreloadQrl(value.$computeQrl$);
-                    const forwardRefId = $resolvePromise$($getCustomSerializerPromise$(value, value.$untrackedValue$), $addRoot$, ((resolved, resolvedValue) => new PromiseResult(29, resolved, resolvedValue, value.$effects$, value.$computeQrl$)));
-                    return void output(1, forwardRefId);
+                    const forwardRefId = $resolvePromise$($getCustomSerializerPromise$(value, value.$untrackedValue$), $addRoot$, (resolved, resolvedValue) => new PromiseResult(28, resolved, resolvedValue, value.$effects$, value.$computeQrl$));
+                    return void output(2, forwardRefId);
                 }
-                const v = value instanceof ComputedSignalImpl && (1 & value.$flags$ || fastSkipSerialize(value.$untrackedValue$)) ? NEEDS_COMPUTATION : value.$untrackedValue$;
                 if (value instanceof WrappedSignalImpl) {
-                    output(26, [ ...serializeWrappingFn(serializationContext, value), filterEffectBackRefs(value[_EFFECT_BACK_REF]), value.$flags$, value.$hostElement$, ...value.$effects$ || [] ]);
-                } else if (value instanceof AsyncComputedSignalImpl) {
-                    addPreloadQrl(value.$computeQrl$);
-                    const out = [ value.$computeQrl$, value.$effects$, value.$loadingEffects$, value.$errorEffects$, value.$untrackedLoading$, value.$untrackedError$ ];
-                    v !== NEEDS_COMPUTATION && out.push(v), output(28, out);
+                    output(25, [ ...serializeWrappingFn(serializationContext, value), filterEffectBackRefs(value[_EFFECT_BACK_REF]), value.$flags$, value.$hostElement$, ...value.$effects$ || [] ]);
                 } else if (value instanceof ComputedSignalImpl) {
+                    let v = value.$untrackedValue$;
+                    const shouldAlwaysSerialize = 32 & value.$flags$;
+                    const shouldNeverSerialize = 16 & value.$flags$;
+                    const isInvalid = 1 & value.$flags$;
+                    const isSkippable = fastSkipSerialize(value.$untrackedValue$);
+                    shouldAlwaysSerialize ? v = value.$untrackedValue$ : (shouldNeverSerialize || isInvalid || isSkippable) && (v = NEEDS_COMPUTATION), 
                     addPreloadQrl(value.$computeQrl$);
                     const out = [ value.$computeQrl$, value.$effects$ ];
-                    v !== NEEDS_COMPUTATION && out.push(v), output(27, out);
+                    const isAsync = value instanceof AsyncComputedSignalImpl;
+                    isAsync && out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedLoading$, value.$untrackedError$), 
+                    v !== NEEDS_COMPUTATION && out.push(v), output(isAsync ? 27 : 26, out);
                 } else {
-                    output(25, [ v, ...value.$effects$ || [] ]);
+                    output(24, [ value.$untrackedValue$, ...value.$effects$ || [] ]);
                 }
             } else if (value instanceof URL) {
-                output(7, value.href);
+                output(6, value.href);
             } else if (value instanceof Date) {
-                output(8, Number.isNaN(value.valueOf()) ? "" : value.valueOf());
+                output(7, Number.isNaN(value.valueOf()) ? "" : value.valueOf());
             } else if (value instanceof RegExp) {
-                output(9, value.toString());
+                output(8, value.toString());
             } else if (value instanceof Error) {
                 const out = [ value.message ];
                 out.push(...Object.entries(value).flat()), out.push("stack", value.stack), output(14, out);
             } else if ($isSsrNode$(value)) {
                 const rootIndex = $addRoot$(value);
-                serializationContext.$setProp$(value, "q:id", String(rootIndex)), output(10, value.id);
+                serializationContext.$setProp$(value, "q:id", String(rootIndex)), output(9, value.id);
                 const vNodeData = value.vnodeData;
-                if (vNodeData && (discoverValuesForVNodeData(vNodeData, (vNodeDataValue => $addRoot$(vNodeDataValue))), 
+                if (vNodeData && (discoverValuesForVNodeData(vNodeData, vNodeDataValue => $addRoot$(vNodeDataValue)), 
                 vNodeData[0] |= 16), value.children) {
                     for (const child of value.children) {
                         const childVNodeData = child.vnodeData;
                         if (childVNodeData) {
                             for (const value of childVNodeData) {
                                 if (isSsrAttrs(value)) {
-                                    const backRefKeyIndex = value.findIndex((v => "q:brefs" === v));
+                                    const backRefKeyIndex = value.findIndex(v => "q:brefs" === v);
                                     -1 !== backRefKeyIndex && $addRoot$(value[backRefKeyIndex + 1]);
                                 }
                             }
@@ -5439,36 +5901,36 @@ async function serialize(serializationContext) {
                 }
             } else if ("undefined" != typeof FormData && value instanceof FormData) {
                 const array = [];
-                value.forEach(((value, key) => {
+                value.forEach((value, key) => {
                     array.push(key, "string" == typeof value ? value : value.name);
-                })), output(32, array);
+                }), output(30, array);
             } else if (value instanceof URLSearchParams) {
-                output(13, value.toString());
+                output(12, value.toString());
             } else if (value instanceof Set) {
-                output(17, [ ...value.values() ]);
+                output(16, [ ...value.values() ]);
             } else if (value instanceof Map) {
                 const combined = [];
                 for (const [k, v] of value.entries()) {
                     combined.push(k, v);
                 }
-                output(18, combined);
+                output(17, combined);
             } else if (isJSXNode(value)) {
-                output(33, [ value.type, value.varProps, value.constProps, value.children, value.flags, value.key ]);
+                output(31, [ 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[_EFFECT_BACK_REF], value.$state$ ];
                 for (;null == out[out.length - 1]; ) {
                     out.pop();
                 }
-                output(22, out);
+                output(21, out);
             } else if (isPromise(value)) {
-                const forwardRefId = $resolvePromise$(value, $addRoot$, ((resolved, resolvedValue) => new PromiseResult(16, resolved, resolvedValue)));
-                output(1, forwardRefId);
+                const forwardRefId = $resolvePromise$(value, $addRoot$, (resolved, resolvedValue) => new PromiseResult(15, resolved, resolvedValue));
+                output(2, forwardRefId);
             } else if (value instanceof PromiseResult) {
-                if (23 === value.$type$) {
-                    output(23, [ value.$resolved$, value.$value$, value.$effects$ ]);
-                } else if (29 === value.$type$) {
+                if (22 === value.$type$) {
+                    output(22, [ value.$resolved$, value.$value$, value.$effects$ ]);
+                } else if (28 === value.$type$) {
                     if (value.$qrl$) {
-                        output(29, [ value.$qrl$, value.$effects$, value.$value$ ]);
+                        output(28, [ value.$qrl$, value.$effects$, value.$value$ ]);
                     } else {
                         if (!value.$resolved$) {
                             throw console.error(value.$value$), qError(33);
@@ -5476,7 +5938,7 @@ async function serialize(serializationContext) {
                         writeValue(value.$value$);
                     }
                 } else {
-                    output(16, [ value.$resolved$, value.$value$ ]);
+                    output(15, [ value.$resolved$, value.$value$ ]);
                 }
             } else if (value instanceof Uint8Array) {
                 let buf = "";
@@ -5484,7 +5946,10 @@ async function serialize(serializationContext) {
                     buf += String.fromCharCode(c);
                 }
                 const out = btoa(buf).replace(/=+$/, "");
-                output(19, out);
+                output(18, out);
+            } else if (value instanceof SerializationWeakRef) {
+                const forwardRefId = forwardRefsId++;
+                s11nWeakRefs.set(value.$obj$, forwardRefId), forwardRefs[forwardRefId] = -1, output(2, forwardRefId);
             } else {
                 if (!vnode_isVNode(value)) {
                     throw qError(20, [ typeof value ]);
@@ -5495,43 +5960,42 @@ async function serialize(serializationContext) {
     };
     function $resolvePromise$(promise, $addRoot$, classCreator) {
         const forwardRefId = forwardRefsId++;
-        return promise.then((resolvedValue => {
+        return promise.then(resolvedValue => {
             promises.delete(promise), forwardRefs[forwardRefId] = $addRoot$(classCreator(!0, resolvedValue));
-        })).catch((err => {
+        }).catch(err => {
             promises.delete(promise), forwardRefs[forwardRefId] = $addRoot$(classCreator(!1, err));
-        })), promises.add(promise), forwardRefId;
+        }), promises.add(promise), forwardRefId;
     }
     await (async () => {
         $writer$.write("[");
-        let lastRootsLength = 0;
         let rootsLength = serializationContext.$roots$.length;
-        for (;lastRootsLength < rootsLength || promises.size; ) {
-            0 !== lastRootsLength && $writer$.write(",");
+        for (;rootIdx < rootsLength || promises.size; ) {
+            0 !== rootIdx && $writer$.write(",");
             let separator = !1;
-            for (let i = lastRootsLength; i < rootsLength; i++) {
-                separator ? $writer$.write(",") : separator = !0, writeValue(serializationContext.$roots$[i]);
+            for (;rootIdx < rootsLength; rootIdx++) {
+                separator ? $writer$.write(",") : separator = !0, writeValue(serializationContext.$roots$[rootIdx]);
             }
             if (promises.size) {
                 try {
                     await Promise.race(promises);
                 } catch {}
             }
-            lastRootsLength = rootsLength, rootsLength = serializationContext.$roots$.length;
+            rootsLength = serializationContext.$roots$.length;
         }
-        forwardRefs.length && ($writer$.write(","), $writer$.write("2,"), outputArray(forwardRefs, (value => {
+        forwardRefs.length && ($writer$.write(","), $writer$.write("13,"), outputArray(forwardRefs, value => {
             $writer$.write(String(value));
-        }))), $writer$.write("]");
+        })), $writer$.write("]");
     })();
 }
 
 function $getCustomSerializerPromise$(signal, value) {
-    return new Promise((resolve => {
-        signal.$computeQrl$.resolve().then((arg => {
+    return new Promise(resolve => {
+        signal.$computeQrl$.resolve().then(arg => {
             let data;
             arg.serialize ? data = arg.serialize(value) : SerializerSymbol in value && (data = value[SerializerSymbol](value)), 
             void 0 === data && (data = NEEDS_COMPUTATION), resolve(data);
-        }));
-    }));
+        });
+    });
 }
 
 function filterEffectBackRefs(effectBackRef) {
@@ -5585,7 +6049,7 @@ function qrlToString(serializationContext, value) {
 }
 
 async function _serialize(data) {
-    const serializationContext = createSerializationContext(null, null, (() => ""), (() => ""), (() => {}), new WeakMap);
+    const serializationContext = createSerializationContext(null, null, () => "", () => "", () => {}, new WeakMap);
     for (const root of data) {
         serializationContext.$addRoot$(root);
     }
@@ -5610,12 +6074,11 @@ function _deserialize(rawStateData, element) {
 }
 
 function deserializeData(container, typeId, value) {
-    if (void 0 === typeId) {
+    if (0 === typeId) {
         return value;
     }
-    let propValue = allocate(container, typeId, value);
-    return typeId >= 14 && (propValue = inflate(container, propValue, typeId, value)), 
-    propValue;
+    const propValue = allocate(container, typeId, value);
+    return needsInflation(typeId) && inflate(container, propValue, typeId, value), propValue;
 }
 
 function getObjectById(id, stateData) {
@@ -5631,7 +6094,7 @@ function _createDeserializeContainer(stateData, element) {
         $storeProxyMap$: new WeakMap,
         element: null,
         $forwardRefs$: null,
-        $initialQRLsIndexes$: null,
+        $initialQRLs$: null,
         $scheduler$: null
     };
     return preprocessState(stateData, container), state = wrapDeserializerProxy(container, stateData), 
@@ -5639,34 +6102,40 @@ function _createDeserializeContainer(stateData, element) {
 }
 
 function preprocessState(data, container) {
-    const isForwardRefsMap = type => 2 === type;
-    const isPreloadQrlType = type => 21 === type;
+    const isRootDeepRef = (type, value) => 1 === type && "string" == typeof value;
+    const isForwardRefsMap = type => 13 === type;
+    const isPreloadQrlType = type => 20 === type;
     const processRootRef = index => {
         const rootRefPath = data[index + 1].split(" ");
         let object = data;
-        let objectType = 0;
+        let objectType = 1;
         let typeIndex = 0;
         let valueIndex = 0;
         let parent = null;
         for (let i = 0; i < rootRefPath.length; i++) {
             if (parent = object, typeIndex = 2 * parseInt(rootRefPath[i], 10), valueIndex = typeIndex + 1, 
-            objectType = object[typeIndex], object = object[valueIndex], 0 === objectType) {
+            objectType = object[typeIndex], object = object[valueIndex], 1 === objectType) {
                 const rootRefTypeIndex = 2 * object;
                 objectType = data[rootRefTypeIndex], object = data[rootRefTypeIndex + 1];
             }
         }
-        parent && (parent[typeIndex] = 0, parent[valueIndex] = index / 2), data[index] = objectType, 
+        parent && (parent[typeIndex] = 1, parent[valueIndex] = index / 2), data[index] = objectType, 
         data[index + 1] = object;
     };
     for (let i = 0; i < data.length; i += 2) {
-        value = data[i + 1], 0 === data[i] && "string" == typeof value ? processRootRef(i) : isForwardRefsMap(data[i]) ? container.$forwardRefs$ = data[i + 1] : isPreloadQrlType(data[i]) && (container.$initialQRLsIndexes$ ||= [], 
-        container.$initialQRLsIndexes$.push(i / 2));
+        if (isRootDeepRef(data[i], data[i + 1])) {
+            processRootRef(i);
+        } else if (isForwardRefsMap(data[i])) {
+            container.$forwardRefs$ = data[i + 1];
+        } else if (isPreloadQrlType(data[i])) {
+            const qrl = data[i + 1];
+            (container.$initialQRLs$ ||= []).push(qrl);
+        }
     }
-    var value;
 }
 
 function shouldTrackObj(obj) {
-    return "object" == typeof obj && null !== obj || "string" == typeof obj && obj.length > 1;
+    return isObject(obj) || "string" == typeof obj && obj.length > 1;
 }
 
 function isObjectLiteral(obj) {
@@ -5678,7 +6147,7 @@ function isResource(value) {
     return "__brand" in value && "resource" === value.__brand;
 }
 
-const frameworkType = obj => "object" == typeof obj && null !== obj && (obj instanceof SignalImpl || obj instanceof Task || isJSXNode(obj)) || isQrl(obj);
+const frameworkType = obj => isObject(obj) && (obj instanceof SignalImpl || obj instanceof Task || isJSXNode(obj)) || isQrl(obj);
 
 const canSerialize = (value, seen = new WeakSet) => {
     if (null == value || "string" == typeof value || "number" == typeof value || "boolean" == typeof value || "bigint" == typeof value) {
@@ -5692,7 +6161,7 @@ const canSerialize = (value, seen = new WeakSet) => {
         const proto = Object.getPrototypeOf(value);
         if (isStore(value) && (value = getStoreTarget(value)), proto == Object.prototype) {
             for (const key in value) {
-                if (!canSerialize(untrack((() => value[key])), seen)) {
+                if (!canSerialize(untrack(() => value[key]), seen)) {
                     return !1;
                 }
             }
@@ -5748,7 +6217,11 @@ const canSerialize = (value, seen = new WeakSet) => {
         if (isDomRef?.(value)) {
             return !0;
         }
-    } else if ("function" == typeof value && (isQrl(value) || isQwikComponent(value))) {
+    } else if ("function" == typeof value) {
+        if (isQrl(value) || isQwikComponent(value)) {
+            return !0;
+        }
+    } else if (value === _UNINITIALIZED) {
         return !0;
     }
     return !1;
@@ -5756,19 +6229,19 @@ const canSerialize = (value, seen = new WeakSet) => {
 
 const QRL_RUNTIME_CHUNK = "mock-chunk";
 
-const _typeIdNames = [ "RootRef", "ForwardRef", "ForwardRefs", "Constant", "Number", "String", "Array", "URL", "Date", "Regex", "VNode", "RefVNode", "BigInt", "URLSearchParams", "Error", "Object", "Promise", "Set", "Map", "Uint8Array", "QRL", "PreloadQRL", "Task", "Resource", "Component", "Signal", "WrappedSignal", "ComputedSignal", "AsyncComputedSignal", "SerializerSignal", "Store", "StoreArray", "FormData", "JSXNode", "PropsProxy", "EffectData" ];
+const _typeIdNames = [ "Plain", "RootRef", "ForwardRef", "Constant", "Array", "Object", "URL", "Date", "Regex", "VNode", "RefVNode", "BigInt", "URLSearchParams", "ForwardRefs", "Error", "Promise", "Set", "Map", "Uint8Array", "QRL", "PreloadQRL", "Task", "Resource", "Component", "Signal", "WrappedSignal", "ComputedSignal", "AsyncComputedSignal", "SerializerSignal", "Store", "FormData", "JSXNode", "PropsProxy", "SubscriptionData" ];
 
 const circularProofJson = (obj, indent) => {
     const seen = new WeakSet;
-    return JSON.stringify(obj, ((key, value) => {
-        if ("object" == typeof value && null !== value) {
+    return JSON.stringify(obj, (_, value) => {
+        if (isObject(value)) {
             if (seen.has(value)) {
                 return `[Circular ${value.constructor.name}]`;
             }
             seen.add(value);
         }
         return value;
-    }), indent);
+    }, indent);
 };
 
 const printRaw = (value, prefix) => {
@@ -5791,11 +6264,18 @@ const dumpState = (state, color = !1, prefix = "", limit = 20) => {
         }
         const key = state[i];
         let value = state[++i];
-        void 0 === key ? (hasRaw = !0, out.push(`${RED}[raw${"object" == typeof value && value ? ` ${value.constructor.name}` : ""}]${RESET} ${printRaw(value, `${prefix}  `)}`)) : (3 === key ? value = constantToName(value) : "string" == typeof value ? (value = JSON.stringify(value), 
-        value.length > 120 && (value = value.slice(0, 120) + '"...')) : 2 === key ? value = `[\n${prefix}  ${value.join(`\n${prefix}  `)}\n${prefix}]` : Array.isArray(value) && (value = value.length ? `[\n${dumpState(value, color, `${prefix}  `)}\n${prefix}]` : "[]"), 
-        out.push(`${RED}${typeIdToName(key)}${RESET} ${value}`));
+        if (0 === key) {
+            const isRaw = "number" != typeof value && "string" != typeof value;
+            isRaw && (hasRaw = !0);
+            const type = isRaw ? `[raw${isObject(value) ? ` ${value.constructor.name}` : ""}]` : typeIdToName(key);
+            out.push(`${RED}${type}${RESET} ${printRaw(value, `${prefix}  `)}`);
+        } else {
+            3 === key ? value = constantToName(value) : "string" == typeof value ? (value = JSON.stringify(value), 
+            value.length > 120 && (value = value.slice(0, 120) + '"...')) : 13 === key ? value = `[\n${prefix}  ${value.join(`\n${prefix}  `)}\n${prefix}]` : Array.isArray(value) && (value = value.length ? `[\n${dumpState(value, color, `${prefix}  `)}\n${prefix}]` : "[]"), 
+            out.push(`${RED}${typeIdToName(key)}${RESET} ${value}`);
+        }
     }
-    const result = out.map(((v, i) => `${prefix}${isRoot ? `${i} ` : ""}${v}`)).join("\n");
+    const result = out.map((v, i) => `${prefix}${isRoot ? `${i} ` : ""}${v}`).join("\n");
     if (isRoot) {
         const count = hasRaw ? "" : `(${JSON.stringify(state).length} chars)`;
         return hasRaw = !1, `\n${result}\n${count}`;
@@ -5841,12 +6321,12 @@ const _verifySerializable = (value, seen, ctx, preMessage) => {
             }
             if (isArray(unwrapped)) {
                 let expectIndex = 0;
-                return unwrapped.forEach(((v, i) => {
+                return unwrapped.forEach((v, i) => {
                     if (i !== expectIndex) {
                         throw qError(3, [ unwrapped ]);
                     }
                     _verifySerializable(v, seen, ctx + "[" + i + "]"), expectIndex = i + 1;
-                })), value;
+                }), value;
             }
             if (isSerializableObject(unwrapped)) {
                 for (const [key, item] of Object.entries(unwrapped)) {
@@ -5876,21 +6356,19 @@ const _verifySerializable = (value, seen, ctx, preMessage) => {
 
 const noSerializeSet = /*#__PURE__*/ new WeakSet;
 
-const weakSerializeSet = /*#__PURE__*/ new WeakSet;
-
 const shouldSerialize = obj => !isObject(obj) && !isFunction(obj) || !noSerializeSet.has(obj);
 
-const fastSkipSerialize = obj => obj && ("object" == typeof obj || "function" == typeof obj) && (NoSerializeSymbol in obj || noSerializeSet.has(obj));
+const fastSkipSerialize = obj => obj && (isObject(obj) || "function" == typeof obj) && (NoSerializeSymbol in obj || noSerializeSet.has(obj));
 
-const noSerialize = input => (("object" == typeof input && null !== input || "function" == typeof input) && noSerializeSet.add(input), 
+const noSerialize = input => ((isObject(input) && null !== input || "function" == typeof input) && noSerializeSet.add(input), 
 input);
 
-const _weakSerialize = input => (weakSerializeSet.add(input), input);
-
 const NoSerializeSymbol = Symbol("noSerialize");
 
 const SerializerSymbol = Symbol("serialize");
 
+const resolvedSymbol = Symbol("resolved");
+
 const createQRL = (chunk, symbol, symbolRef, symbolFn, capture, captureRef) => {
     let _containerEl;
     const qrl = async function(...args) {
@@ -5901,12 +6379,12 @@ const createQRL = (chunk, symbol, symbolRef, symbolFn, capture, captureRef) => {
     function bindFnToContext(currentCtx, beforeFn) {
         const bound = (...args) => {
             if (!qrl.resolved) {
-                return retryOnPromise((() => qrl.resolve())).then((fn => {
+                return retryOnPromise(() => qrl.resolve()).then(fn => {
                     if (!isFunction(fn)) {
                         throw qError(5);
                     }
                     return bound(...args);
-                }));
+                });
             }
             if (beforeFn && !1 === beforeFn()) {
                 return;
@@ -5940,7 +6418,8 @@ const createQRL = (chunk, symbol, symbolRef, symbolFn, capture, captureRef) => {
         return context = newInvokeContext(), context.$qrl$ = qrl, context.$event$ = this, 
         invoke.call(this, context, fn, ...args);
     };
-    const resolve = async containerEl => {
+    symbolFn && resolvedSymbol in symbolFn && (symbolRef = symbolFn[resolvedSymbol]);
+    const resolve = symbolRef ? async () => symbolRef : async containerEl => {
         if (null !== symbolRef) {
             return symbolRef;
         }
@@ -5954,14 +6433,17 @@ const createQRL = (chunk, symbol, symbolRef, symbolFn, capture, captureRef) => {
         const start = now();
         const ctx = tryGetInvokeContext();
         if (null !== symbolFn) {
-            symbolRef = symbolFn().then((module => qrl.resolved = wrapFn(symbolRef = module[symbol])));
+            symbolRef = symbolFn().then(module => {
+                const resolved = wrapFn(symbolRef = module[symbol]);
+                return symbolFn[resolvedSymbol] = resolved, qrl.resolved = resolved, resolved;
+            });
         } else {
             const imported = getPlatform().importSymbol(_containerEl, chunk, symbol);
-            symbolRef = maybeThen(imported, (ref => qrl.resolved = wrapFn(symbolRef = ref)));
+            symbolRef = maybeThen(imported, ref => qrl.resolved = wrapFn(symbolRef = ref));
         }
-        return "object" == typeof symbolRef && isPromise(symbolRef) && symbolRef.then((() => emitUsedSymbol(symbol, ctx?.$element$, start)), (err => {
+        return isPromise(symbolRef) && symbolRef.then(() => emitUsedSymbol(symbol, ctx?.$element$, start), err => {
             console.error(`qrl ${symbol} failed to load`, err), symbolRef = null;
-        })), symbolRef;
+        }), symbolRef;
     };
     const createOrReuseInvocationContext = invoke => null == invoke ? newInvokeContext() : isArray(invoke) ? newInvokeContextFromTuple(invoke) : invoke;
     const hash = getSymbolHash(symbol);
@@ -5970,7 +6452,6 @@ const createQRL = (chunk, symbol, symbolRef, symbolFn, capture, captureRef) => {
         getHash: () => hash,
         getCaptured: () => captureRef,
         resolve,
-        $resolveLazy$: containerEl => null !== symbolRef ? symbolRef : resolve(containerEl),
         $setContainer$: setContainer,
         $chunk$: chunk,
         $symbol$: symbol,
@@ -5980,7 +6461,7 @@ const createQRL = (chunk, symbol, symbolRef, symbolFn, capture, captureRef) => {
         $captureRef$: captureRef,
         dev: null,
         resolved: void 0
-    }), symbolRef && (symbolRef = maybeThen(symbolRef, (resolved => qrl.resolved = wrapFn(symbolRef = resolved)))), 
+    }), symbolRef && (symbolRef = maybeThen(symbolRef, resolved => qrl.resolved = wrapFn(symbolRef = resolved))), 
     isDev && Object.defineProperty(qrl, "_devOnlySymbolRef", {
         get: () => symbolRef
     }), isBrowser && symbol && p(symbol, .8), qrl;
@@ -6050,7 +6531,7 @@ const render = async (parent, jsxNode, opts = {}) => {
     const container = getDomContainer(parent);
     container.$serverData$ = opts.serverData || {};
     const host = container.rootVNode;
-    return container.$scheduler$(4, host, host, jsxNode), await container.$scheduler$(255), 
+    return container.$scheduler$(4, host, host, jsxNode), await container.$scheduler$(255).$returnValue$, 
     {
         cleanup: () => {
             cleanup(container, container.rootVNode);
@@ -6295,7 +6776,7 @@ const STRINGS_COMMENTS = [ [ ANY, 39, 14 ], [ ANY, 34, 15 ], [ ANY, 47, 16, "*"
 const STATE_MACHINE = [ [ [ ANY, 42, starSelector ], [ ANY, OPEN_BRACKET, 7 ], [ ANY, COLON, pseudoElement, ":", "before", "after", "first-letter", "first-line" ], [ ANY, COLON, pseudoGlobal, "global" ], [ ANY, COLON, 3, "has", "host-context", "not", "where", "is", "matches", "any" ], [ ANY, COLON, 4 ], [ ANY, IDENT, 1 ], [ ANY, DOT, 1 ], [ ANY, HASH, 1 ], [ ANY, 64, atRuleSelector, "keyframe" ], [ ANY, 64, atRuleBlock, "media", "supports", "container" ], [ ANY, 64, atRuleInert ], [ ANY, 123, 13 ], [ 47, 42, 16 ], [ ANY, 59, EXIT ], [ ANY, 125, EXIT ], [ ANY, CLOSE_PARENTHESIS, EXIT ], ...STRINGS_COMMENTS ], [ [ ANY, NOT_IDENT, EXIT_INSERT_SCOPE ] ], [ [ ANY, NOT_IDENT, EXIT_INSERT_SCOPE ] ], [ [ ANY, 40, rule ], [ ANY, NOT_IDENT, EXIT_INSERT_SCOPE ] ], [ [ ANY, 40, 8 ], [ ANY, NOT_IDENT, EXIT_INSERT_SCOPE ] ], [ [ ANY, 40, rule ], [ ANY, NOT_IDENT, EXIT ] ], [ [ ANY, NOT_IDENT, EXIT ] ], [ [ ANY, 93, EXIT_INSERT_SCOPE ], [ ANY, 39, 14 ], [ ANY, 34, 15 ] ], [ [ ANY, CLOSE_PARENTHESIS, EXIT ], ...STRINGS_COMMENTS ], [ [ ANY, 125, EXIT ], ...STRINGS_COMMENTS ], [ [ ANY, 125, EXIT ], [ WHITESPACE, IDENT, 1 ], [ ANY, COLON, pseudoGlobal, "global" ], [ ANY, 123, 13 ], ...STRINGS_COMMENTS ], [ [ ANY, 123, rule ], [ ANY, 59, EXIT ], ...STRINGS_COMMENTS ], [ [ ANY, 59, EXIT ], [ ANY, 123, 9 ], ...STRINGS_COMMENTS ], [ [ ANY, 125, EXIT ], [ ANY, 123, 13 ], [ ANY, 40, 8 ], ...STRINGS_COMMENTS ], [ [ ANY, 39, EXIT ] ], [ [ ANY, 34, EXIT ] ], [ [ 42, 47, EXIT ] ] ];
 
 const useStylesQrl = styles => ({
-    styleId: _useStyles(styles, (str => str), !1)
+    styleId: _useStyles(styles, str => str, !1)
 });
 
 const useStyles$ = /*#__PURE__*/ implicit$FirstArg(useStylesQrl);
@@ -6314,13 +6795,10 @@ const _useStyles = (styleQrl, transform, scoped) => {
     }
     const styleId = styleKey(styleQrl, i);
     const host = iCtx.$hostElement$;
-    set(styleId);
-    const value = styleQrl.$resolveLazy$(iCtx.$element$);
-    if (isPromise(value)) {
-        throw value.then((val => iCtx.$container$.$appendStyle$(transform(val, styleId), styleId, host, scoped))), 
-        value;
+    if (set(styleId), !styleQrl.resolved) {
+        throw styleQrl.resolve().then(val => iCtx.$container$.$appendStyle$(transform(val, styleId), styleId, host, scoped));
     }
-    return iCtx.$container$.$appendStyle$(transform(value, styleId), styleId, host, scoped), 
+    return iCtx.$container$.$appendStyle$(transform(styleQrl.resolved, styleId), styleId, host, scoped), 
     styleId;
 };
 
@@ -6346,7 +6824,7 @@ const createEventName = (event, eventScope) => {
 
 const _useOn = (eventName, eventQrl) => {
     const {isAdded, addEvent} = useOnEventsSequentialScope();
-    isAdded || eventQrl && (Array.isArray(eventName) ? eventName.forEach((event => addEvent(event, eventQrl))) : addEvent(eventName, eventQrl));
+    isAdded || eventQrl && (Array.isArray(eventName) ? eventName.forEach(event => addEvent(event, eventQrl)) : addEvent(eventName, eventQrl));
 };
 
 const useOnEventsSequentialScope = () => {
@@ -6370,31 +6848,31 @@ const useOnEventsSequentialScope = () => {
     };
 };
 
-const useSignal = initialState => useConstant((() => {
+const useSignal = initialState => useConstant(() => {
     const value = isFunction(initialState) && !isQwikComponent(initialState) ? invoke(void 0, initialState) : initialState;
     return createSignal(value);
-}));
+});
 
 const useConstant = value => {
     const {val, set} = useSequentialScope();
     return null != val ? val : set(value = isFunction(value) && !isQwikComponent(value) ? value() : value);
 };
 
-const useComputedCommon = (qrl, Class) => {
+const useComputedCommon = (qrl, createFn, options) => {
     const {val, set} = useSequentialScope();
     if (val) {
         return val;
     }
     assertQrl(qrl);
-    const signal = new Class(null, qrl);
+    const signal = createFn(qrl, options);
     return set(signal), throwIfQRLNotResolved(qrl), signal;
 };
 
-const useComputedQrl = qrl => useComputedCommon(qrl, ComputedSignalImpl);
+const useComputedQrl = (qrl, options) => useComputedCommon(qrl, createComputedSignal, options);
 
 const useComputed$ = implicit$FirstArg(useComputedQrl);
 
-const useSerializerQrl = qrl => useComputedCommon(qrl, SerializerSignalImpl);
+const useSerializerQrl = qrl => useComputedCommon(qrl, createSerializerSignal);
 
 const useSerializer$ = implicit$FirstArg(useSerializerQrl);
 
@@ -6406,8 +6884,8 @@ const useVisibleTaskQrl = (qrl, opts) => {
     }
     assertQrl(qrl);
     const task = new Task(1, i, iCtx.$hostElement$, qrl, void 0, null);
-    set(task), useRunTask(task, eagerness), isServerPlatform() || (qrl.$resolveLazy$(iCtx.$element$), 
-    iCtx.$container$.$scheduler$(32, task));
+    set(task), useRunTask(task, eagerness), isServerPlatform() || (qrl.resolve(iCtx.$element$), 
+    iCtx.$container$.$scheduler$(16, task));
 };
 
 const useRunTask = (task, eagerness) => {
@@ -6422,7 +6900,7 @@ const useTask$ = /*#__PURE__*/ implicit$FirstArg(useTaskQrl);
 
 const useVisibleTask$ = /*#__PURE__*/ implicit$FirstArg(useVisibleTaskQrl);
 
-const useAsyncComputedQrl = qrl => useComputedCommon(qrl, AsyncComputedSignalImpl);
+const useAsyncComputedQrl = (qrl, options) => useComputedCommon(qrl, createAsyncComputedSignal, options);
 
 const useAsyncComputed$ = implicit$FirstArg(useAsyncComputedQrl);
 
@@ -6445,7 +6923,7 @@ const PrefetchServiceWorker = opts => {
         ...opts
     };
     resolvedOpts.path = opts?.path?.startsWith?.("/") ? opts.path : baseUrl + resolvedOpts.path;
-    let code = PREFETCH_CODE.replace("'_URL_'", JSON.stringify(resolvedOpts.path));
+    let code = PREFETCH_CODE.replace('"_URL_"', JSON.stringify(resolvedOpts.path.split("/").pop()));
     isDev || (code = code.replaceAll(/\s\s+/gm, ""));
     const props = {
         dangerouslySetInnerHTML: [ "(" + code + ")(", [ "navigator.serviceWorker" ].join(","), ");" ].join(""),
@@ -6455,13 +6933,19 @@ const PrefetchServiceWorker = opts => {
 };
 
 const PREFETCH_CODE = /*#__PURE__*/ (c => {
-    "getRegistrations" in c && c.getRegistrations().then((registrations => {
-        registrations.forEach((registration => {
+    "getRegistrations" in c && c.getRegistrations().then(registrations => {
+        registrations.forEach(registration => {
             registration.active && registration.active.scriptURL.endsWith("_URL_") && registration.unregister().catch(console.error);
-        }));
-    }));
+        });
+    }), "caches" in window && caches.keys().then(names => {
+        const cacheName = names.find(name => name.startsWith("QwikBundles"));
+        cacheName && caches.delete(cacheName).catch(console.error);
+    }).catch(console.error);
 }).toString();
 
 const PrefetchGraph = () => null;
 
-export { $, Fragment, NoSerializeSymbol, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SerializerSymbol, SkipRender, Slot, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, EMPTY_ARRAY as _EMPTY_ARRAY, _IMMUTABLE, _SharedContainer, SubscriptionData as _SubscriptionData, _VAR_PROPS, _deserialize, dumpState as _dumpState, _fnSignal, _getContextElement, _getContextEvent, getDomContainer as _getDomContainer, _getQContainerElement, isJSXNode as _isJSXNode, isStringifiable as _isStringifiable, _jsxBranch, _jsxC, _jsxQ, _jsxS, _jsxSorted, _jsxSplit, _noopQrl, _noopQrlDEV, preprocessState as _preprocessState, _qrlSync, _regSymbol, _restProps, queueQRL as _run, _serialize, scheduleTask as _task, verifySerializable as _verifySerializable, vnode_toString as _vnode_toString, _waitUntilRendered, _walkJSX, _weakSerialize, _wrapProp, _wrapSignal, _wrapStore, component$, componentQrl, createComputed$, createComputedSignal as createComputedQrl, createContextId, h as createElement, createSerializer$, createSerializerSignal as createSerializerQrl, createSignal, event$, eventQrl, getDomContainer, getLocale, getPlatform, h, implicit$FirstArg, inlinedQrl, inlinedQrlDEV, isSignal, jsx, jsxDEV, jsx as jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useAsyncComputed$, useAsyncComputedQrl, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, useErrorBoundary, useId, useLexicalScope, useOn, useOnDocument, useOnWindow, useResource$, useResourceQrl, useSerializer$, useSerializerQrl, useServerData, useSignal, useStore, useStyles$, useStylesQrl, useStylesScoped$, useStylesScopedQrl, useTask$, useTaskQrl, useVisibleTask$, useVisibleTaskQrl, version, withLocale };
+globalThis.__qwik && console.error(`==============================================\nQwik version ${globalThis.__qwik} already imported while importing ${version}. Verify external vs bundled imports etc. This can lead to issues due to duplicated shared structures.\n==============================================\n`), 
+globalThis.__qwik = version;
+
+export { $, Fragment, NoSerializeSymbol, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SerializerSymbol, SkipRender, Slot, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, EMPTY_ARRAY as _EMPTY_ARRAY, _IMMUTABLE, _SharedContainer, SubscriptionData as _SubscriptionData, _UNINITIALIZED, _VAR_PROPS, _deserialize, dumpState as _dumpState, _fnSignal, _getConstProps, _getContextContainer, _getContextElement, _getContextEvent, getDomContainer as _getDomContainer, _getQContainerElement, _getVarProps, _hasStoreEffects, isJSXNode as _isJSXNode, isStore as _isStore, isStringifiable as _isStringifiable, isTask as _isTask, _jsxBranch, _jsxC, _jsxQ, _jsxS, _jsxSorted, _jsxSplit, mapApp_findIndx as _mapApp_findIndx, mapArray_get as _mapArray_get, mapArray_set as _mapArray_set, _noopQrl, _noopQrlDEV, preprocessState as _preprocessState, _qrlSync, _regSymbol, _resolveContextWithoutSequentialScope, _restProps, _run, _serializationWeakRef, _serialize, scheduleTask as _task, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttr as _vnode_getAttr, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getFirstChild as _vnode_getFirstChild, vnode_getNextSibling as _vnode_getNextSibling, vnode_getPropStartIndex as _vnode_getPropStartIndex, vnode_getProps as _vnode_getProps, vnode_isMaterialized as _vnode_isMaterialized, vnode_isTextVNode as _vnode_isTextVNode, vnode_isVirtualVNode as _vnode_isVirtualVNode, vnode_toString as _vnode_toString, _waitUntilRendered, _walkJSX, _wrapProp, _wrapSignal, component$, componentQrl, createAsyncComputed$, createAsyncComputedSignal as createAsyncComputedQrl, createComputed$, createComputedSignal as createComputedQrl, createContextId, h as createElement, createSerializer$, createSerializerSignal as createSerializerQrl, createSignal, event$, eventQrl, forceStoreEffects, getDomContainer, getLocale, getPlatform, h, implicit$FirstArg, inlinedQrl, inlinedQrlDEV, isSignal, jsx, jsxDEV, jsx as jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useAsyncComputed$, useAsyncComputedQrl, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, useErrorBoundary, useId, useLexicalScope, useOn, useOnDocument, useOnWindow, useResource$, useResourceQrl, useSerializer$, useSerializerQrl, useServerData, useSignal, useStore, useStyles$, useStylesQrl, useStylesScoped$, useStylesScopedQrl, useTask$, useTaskQrl, useVisibleTask$, useVisibleTaskQrl, version, withLocale };