@qwik.dev/core 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/core.prod.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.21-dev+c008e88
+ * @qwik.dev/core 2.0.0-beta.23-dev+03de42d
  * 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,7 +11,7 @@ export { isBrowser, isDev, isServer } from "@qwik.dev/core/build";
 
 import { p } from "@qwik.dev/core/preloader";
 
-const version = "2.0.0-beta.21-dev+c008e88";
+const version = "2.0.0-beta.23-dev+03de42d";
 
 const qDev = !1;
 
@@ -158,8 +158,6 @@ 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";
 
 const TaskEvent = "qTask";
@@ -266,10 +264,6 @@ const safeCall = (call, thenFn, rejectFn) => {
 
 const maybeThen = (valueOrPromise, thenFn) => isPromise(valueOrPromise) ? valueOrPromise.then(thenFn) : thenFn(valueOrPromise);
 
-const delay = timeout => new Promise(resolve => {
-    setTimeout(resolve, timeout);
-});
-
 const checkError = e => {
     isServer && e instanceof ReferenceError && e.message.includes("window") && (e.message = 'It seems like you forgot to add "if (isBrowser) {...}" here:' + e.message);
 };
@@ -389,30 +383,6 @@ const vnode_getElementNamespaceFlags = element => {
     }
 };
 
-function vnode_getDomChildrenWithCorrectNamespacesToInsert(journal, domParentVNode, newChild) {
-    const {elementNamespace, elementNamespaceFlag} = getNewElementNamespaceData(domParentVNode, newChild);
-    let domChildren = [];
-    if (elementNamespace === HTML_NS) {
-        domChildren = vnode_getDOMChildNodes(journal, newChild, !0);
-    } else {
-        const children = vnode_getDOMChildNodes(journal, newChild, !0);
-        for (let i = 0; i < children.length; i++) {
-            const childVNode = children[i];
-            if (vnode_isTextVNode(childVNode)) {
-                domChildren.push(childVNode);
-                continue;
-            }
-            if ((1536 & childVNode.flags) == (1536 & domParentVNode.flags)) {
-                domChildren.push(childVNode);
-                continue;
-            }
-            const newChildElement = vnode_cloneElementWithNamespace(childVNode, domParentVNode, elementNamespace, elementNamespaceFlag);
-            newChildElement && (childVNode.node = newChildElement, domChildren.push(childVNode));
-        }
-    }
-    return domChildren;
-}
-
 function cloneDomTreeWithNamespace(element, elementName, namespace, deep = !1) {
     const newElement = element.ownerDocument.createElementNS(namespace, elementName);
     for (const attr of element.attributes) {
@@ -650,7 +620,7 @@ function addCursorToQueue(container, cursor) {
             break;
         }
     }
-    globalCursorQueue.splice(insertIndex, 0, cursor), container.$cursorCount$++, container.$renderPromise$ ||= new Promise(r => container.$resolveRenderPromise$ = r);
+    globalCursorQueue.splice(insertIndex, 0, cursor), container.$pendingCount$++, container.$renderPromise$ ||= new Promise(r => container.$resolveRenderPromise$ = r);
 }
 
 function getHighestPriorityCursor() {
@@ -671,7 +641,7 @@ function getHighestPriorityCursor() {
 }
 
 function pauseCursor(cursor, container) {
-    pausedCursorQueue.push(cursor), removeCursorFromQueue(cursor, container, !0), container.$pausedCursorCount$++;
+    pausedCursorQueue.push(cursor), removeCursorFromQueue(cursor, container, !0), container.$pendingCount$++;
 }
 
 function resumeCursor(cursor, container) {
@@ -679,7 +649,7 @@ function resumeCursor(cursor, container) {
     if (-1 !== index) {
         const lastIndex = pausedCursorQueue.length - 1;
         index !== lastIndex && (pausedCursorQueue[index] = pausedCursorQueue[lastIndex]), 
-        pausedCursorQueue.pop(), container.$pausedCursorCount$--;
+        pausedCursorQueue.pop(), container.$pendingCount$--;
     }
     addCursorToQueue(container, cursor);
 }
@@ -687,7 +657,7 @@ function resumeCursor(cursor, container) {
 function removeCursorFromQueue(cursor, container, keepCursorFlag) {
     keepCursorFlag || (cursor.flags &= -257);
     const index = globalCursorQueue.indexOf(cursor);
-    -1 !== index && (globalCursorQueue.splice(index, 1), container.$cursorCount$--);
+    -1 !== index && (globalCursorQueue.splice(index, 1), container.$pendingCount$--);
 }
 
 const cursorDatas = new WeakMap;
@@ -739,7 +709,7 @@ class SignalImpl {
     $container$=null;
     $wrappedSignal$=null;
     constructor(container, value) {
-        this.$container$ = container, this.$untrackedValue$ = value;
+        this.$container$ = container || tryGetInvokeContext()?.$container$ || null, this.$untrackedValue$ = value;
     }
     force() {
         scheduleEffects(this.$container$, this, this.$effects$);
@@ -751,22 +721,16 @@ class SignalImpl {
         this.$untrackedValue$ = value;
     }
     get value() {
+        const val = this.untrackedValue;
         const ctx = tryGetInvokeContext();
         if (!ctx) {
-            return this.untrackedValue;
-        }
-        if (null === this.$container$) {
-            if (!ctx.$container$) {
-                return this.untrackedValue;
-            }
-            this.$container$ = ctx.$container$;
-        } else {
-            isDev && assertTrue(!ctx.$container$ || ctx.$container$ === this.$container$, "Do not use signals across containers");
+            return val;
         }
+        null === this.$container$ ? this.$container$ = ctx.$container$ : isDev && assertTrue(!ctx.$container$ || ctx.$container$ === this.$container$, "Do not use signals across containers");
         const effectSubscriber = ctx.$effectSubscriber$;
         return effectSubscriber && (ensureContainsSubscription(this.$effects$ ||= new Set, effectSubscriber), 
         ensureContainsBackRef(effectSubscriber, this), (import.meta.env.TEST ? !isDomContainer(this.$container$) : isServer) && addQrlToSerializationCtx(effectSubscriber, this.$container$)), 
-        this.untrackedValue;
+        val;
     }
     set value(value) {
         value !== this.$untrackedValue$ && (this.$untrackedValue$ = value, scheduleEffects(this.$container$, this, this.$effects$));
@@ -775,7 +739,14 @@ class SignalImpl {
         qDev;
     }
     toString() {
-        return isDev ? `[${this.constructor.name}${1 & this.$flags$ ? " INVALID" : ""} ${String(this.$untrackedValue$)}]` + (Array.from(this.$effects$ || []).map(e => "\n -> " + pad(qwikDebugToString(e.consumer), "    ")).join("\n") || "") : this.constructor.name;
+        if (!isDev) {
+            return this.constructor.name;
+        }
+        try {
+            return `[${this.constructor.name}${1 & this.$flags$ ? " INVALID" : ""} ${this.$untrackedValue$}]` + (Array.from(this.$effects$ || []).map(e => "\n -> " + pad(qwikDebugToString(e.consumer), "    ")).join("\n") || "");
+        } catch (e) {
+            return `[${this.constructor.name} <cannot stringify>]`;
+        }
     }
     toJSON() {
         return {
@@ -784,23 +755,15 @@ class SignalImpl {
     }
 }
 
-const setupSignalValueAccess = (target, effectsFn, returnValueFn) => {
+const setupSignalValueAccess = (target, effectsProp, valueProp) => {
     const ctx = tryGetInvokeContext();
-    if (!ctx) {
-        return returnValueFn();
-    }
-    if (null === target.$container$) {
-        if (!ctx.$container$) {
-            return returnValueFn();
-        }
-        target.$container$ = ctx.$container$;
-    } else {
+    if (ctx && (target.$container$ ||= ctx.$container$ || null)) {
         isDev && assertTrue(!ctx.$container$ || ctx.$container$ === target.$container$, "Do not use signals across containers");
+        const effectSubscriber = ctx.$effectSubscriber$;
+        effectSubscriber && (ensureContainsSubscription(target[effectsProp] ||= new Set, effectSubscriber), 
+        ensureContainsBackRef(effectSubscriber, target), addQrlToSerializationCtx(effectSubscriber, target.$container$));
     }
-    const effectSubscriber = ctx.$effectSubscriber$;
-    return effectSubscriber && (ensureContainsSubscription(effectsFn(), effectSubscriber), 
-    ensureContainsBackRef(effectSubscriber, target), addQrlToSerializationCtx(effectSubscriber, target.$container$)), 
-    returnValueFn();
+    return target[valueProp];
 };
 
 const _CONST_PROPS = Symbol("CONST");
@@ -943,18 +906,6 @@ const _getConstProps = props => props && _CONST_PROPS in props ? props[_CONST_PR
 
 const isPropsProxy = obj => obj && _VAR_PROPS in obj;
 
-const cleanupDestroyable = destroyable => {
-    const destroy = destroyable.$destroy$;
-    if (destroy) {
-        destroyable.$destroy$ = null;
-        try {
-            destroy();
-        } catch (err) {
-            logError(err);
-        }
-    }
-};
-
 const NEEDS_COMPUTATION = Symbol("invalid");
 
 class EffectSubscription {
@@ -1009,7 +960,7 @@ const trackFn = (target, container) => (obj, prop) => {
 const cleanupFn = (target, handleError) => {
     let cleanupFns = null;
     return [ fn => {
-        "function" == typeof fn && (cleanupFns || (cleanupFns = [], target.$destroy$ = noSerialize(() => {
+        "function" == typeof fn && (cleanupFns || (cleanupFns = [], target.$destroy$ = () => {
             target.$destroy$ = null;
             for (const fn of cleanupFns) {
                 try {
@@ -1018,31 +969,30 @@ const cleanupFn = (target, handleError) => {
                     handleError(err);
                 }
             }
-        })), cleanupFns.push(fn));
+        }), cleanupFns.push(fn));
     }, cleanupFns ?? [] ];
 };
 
-const DEBUG = !1;
+const DEBUG$1 = !1;
 
-const log = (...args) => console.log("COMPUTED SIGNAL", ...args.map(qwikDebugToString));
+const log$1 = (...args) => console.log("COMPUTED SIGNAL", ...args.map(qwikDebugToString));
 
 class ComputedSignalImpl extends SignalImpl {
     $computeQrl$;
     $flags$;
     [_EFFECT_BACK_REF]=void 0;
     constructor(container, fn, flags = 17) {
-        super(container, NEEDS_COMPUTATION), this.$computeQrl$ = fn, this.$flags$ = flags;
+        super(container || fn.$container$, NEEDS_COMPUTATION), this.$computeQrl$ = fn, this.$flags$ = flags;
     }
     invalidate() {
         this.$flags$ |= 1;
         const ctx = newInvokeContext();
-        ctx.$container$ = this.$container$ || void 0, maybeThen(retryOnPromise(() => invoke.call(this, ctx, this.$computeIfNeeded$)), () => {
-            2 & this.$flags$ && (this.$flags$ &= -3, scheduleEffects(this.$container$, this, this.$effects$));
+        ctx.$container$ = this.$container$ || void 0;
+        const running = retryOnPromise(invokeApply.bind(this, ctx, this.$computeIfNeeded$));
+        running && running.catch(err => {
+            this.$container$ ? this.$container$.handleError(err, null) : console.error("Error during computation", err);
         });
     }
-    force() {
-        this.$flags$ |= 2, super.force();
-    }
     get untrackedValue() {
         return this.$computeIfNeeded$(), isDev && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state"), 
         this.$untrackedValue$;
@@ -1064,38 +1014,89 @@ class ComputedSignalImpl extends SignalImpl {
             if (isPromise(untrackedValue)) {
                 throw qError(29, [ computeQrl.dev ? computeQrl.dev.file : "", computeQrl.$hash$ ]);
             }
-            this.$flags$ &= -2;
-            untrackedValue !== this.$untrackedValue$ && (this.$untrackedValue$ !== NEEDS_COMPUTATION && (this.$flags$ |= 2), 
-            this.$untrackedValue$ = untrackedValue);
+            this.$flags$ &= -2, super.value = untrackedValue;
         } finally {
             ctx && (ctx.$effectSubscriber$ = previousEffectSubscription);
         }
     }
 }
 
+const DEBUG = !1;
+
+const log = (...args) => console.log("ASYNC COMPUTED SIGNAL", ...args.map(qwikDebugToString));
+
+class AsyncJob {
+    $signal$;
+    $promise$=null;
+    $cleanupRequested$=!1;
+    $canWrite$=!0;
+    $track$;
+    $cleanups$;
+    $abortController$;
+    constructor($signal$) {
+        this.$signal$ = $signal$;
+    }
+    get track() {
+        return this.$track$ ||= trackFn(this.$signal$, this.$signal$.$container$);
+    }
+    get abortSignal() {
+        return (this.$abortController$ ||= new AbortController).signal;
+    }
+    cache() {
+        console.error("useResource cache() method does not do anything. Use `useAsync$` instead of `useResource$`, use the `interval` option for polling behavior.");
+    }
+    get previous() {
+        const val = this.$signal$.$untrackedValue$;
+        if (val !== NEEDS_COMPUTATION) {
+            return val;
+        }
+    }
+    cleanup(callback) {
+        "function" == typeof callback && (this.$cleanups$ ||= []).push(callback);
+    }
+}
+
 class AsyncSignalImpl extends ComputedSignalImpl {
     $untrackedLoading$=!1;
     $untrackedError$=void 0;
     $loadingEffects$=void 0;
     $errorEffects$=void 0;
-    $destroy$;
-    $promiseValue$=NEEDS_COMPUTATION;
-    $promise$=null;
+    $current$=null;
+    $jobs$=[];
+    $concurrency$=1;
+    $interval$=0;
+    $pollTimeoutId$=void 0;
+    $timeoutMs$;
+    $computationTimeoutId$;
     [_EFFECT_BACK_REF]=void 0;
-    constructor(container, fn, flags = 1) {
+    constructor(container, fn, flags = 17, options) {
         super(container, fn, flags);
+        const interval = options?.interval || 0;
+        const concurrency = options?.concurrency ?? 1;
+        const initial = options?.initial;
+        const timeout = options?.timeout;
+        const eagerCleanup = options?.eagerCleanup;
+        if (void 0 !== initial) {
+            const initialValue = "function" == typeof initial ? initial() : initial;
+            this.$untrackedValue$ = initialValue;
+        }
+        this.$concurrency$ = concurrency, this.$timeoutMs$ = timeout, eagerCleanup && (this.$flags$ |= 32), 
+        this.interval = interval;
     }
     get loading() {
-        return setupSignalValueAccess(this, () => this.$loadingEffects$ ||= new Set, () => this.untrackedLoading);
+        return setupSignalValueAccess(this, "$loadingEffects$", "untrackedLoading");
     }
     set untrackedLoading(value) {
         value !== this.$untrackedLoading$ && (this.$untrackedLoading$ = value, scheduleEffects(this.$container$, this, this.$loadingEffects$));
     }
     get untrackedLoading() {
+        if (this.$computeIfNeeded$(), (import.meta.env.TEST ? isServerPlatform() : isServer) && this.$current$?.$promise$) {
+            throw this.$current$?.$promise$;
+        }
         return this.$untrackedLoading$;
     }
     get error() {
-        return setupSignalValueAccess(this, () => this.$errorEffects$ ||= new Set, () => this.untrackedError);
+        return setupSignalValueAccess(this, "$errorEffects$", "untrackedError");
     }
     set untrackedError(value) {
         value !== this.$untrackedError$ && (this.$untrackedError$ = value, scheduleEffects(this.$container$, this, this.$errorEffects$));
@@ -1103,48 +1104,121 @@ class AsyncSignalImpl extends ComputedSignalImpl {
     get untrackedError() {
         return this.$untrackedError$;
     }
-    invalidate() {
-        this.$promise$ = null, super.invalidate();
+    get interval() {
+        return this.$interval$;
+    }
+    set interval(value) {
+        this.$clearNextPoll$(), this.$interval$ = value, this.$interval$ > 0 && this.$effects$?.size && this.$scheduleNextPoll$();
+    }
+    async invalidate() {
+        this.$flags$ |= 1, this.$clearNextPoll$(), (this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size) && (await !0, 
+        this.$computeIfNeeded$());
+    }
+    abort(reason) {
+        this.$current$ && this.$requestCleanups$(this.$current$, reason);
+    }
+    $scheduleEagerCleanup$() {
+        32 & this.$flags$ && !this.$hasSubscribers$() && (import.meta.env.TEST ? !isServerPlatform() : isBrowser) && setTimeout(() => {
+            this.$hasSubscribers$() || this.abort();
+        });
     }
     async promise() {
-        return this.$promise$ = null, await retryOnPromise(this.$computeIfNeeded$.bind(this)), 
-        this.$untrackedValue$;
+        for (this.$computeIfNeeded$(); this.$current$?.$promise$; ) {
+            await (this.$current$?.$promise$);
+        }
     }
     $computeIfNeeded$() {
         if (!(1 & this.$flags$)) {
             return;
         }
-        const untrackedValue = this.$promiseValue$ === NEEDS_COMPUTATION || null === this.$promise$ ? this.$promiseComputation$() : this.$promiseValue$;
-        if (isPromise(untrackedValue)) {
-            const isFirstComputation = this.$promiseValue$ === NEEDS_COMPUTATION;
-            this.untrackedLoading = !0, this.untrackedError = void 0, this.$promiseValue$ !== NEEDS_COMPUTATION && cleanupDestroyable(this);
-            const promise = untrackedValue.then(promiseValue => {
-                this.$promiseValue$ = promiseValue, this.untrackedLoading = !1, this.untrackedError = void 0, 
-                this.setValue(promiseValue) && (this.$flags$ &= -3, scheduleEffects(this.$container$, this, this.$effects$));
-            }).catch(err => {
-                isPromise(err) || (this.$promiseValue$ = err, this.untrackedLoading = !1, this.untrackedError = err);
-            });
-            if (isFirstComputation) {
-                throw promise;
+        this.$clearNextPoll$(), this.$current$ && this.$requestCleanups$(this.$current$);
+        if (this.$jobs$.length >= (0 === this.$concurrency$ ? Number.POSITIVE_INFINITY : this.$concurrency$)) {
+            return;
+        }
+        this.$flags$ &= -2;
+        const running = new AsyncJob(this);
+        this.$current$ = running, this.$jobs$.push(running), running.$promise$ = this.$runComputation$(running);
+    }
+    async $runComputation$(running) {
+        const isCurrent = () => running === this.$current$;
+        this.untrackedLoading = !0;
+        const fn = this.$computeQrl$.resolved || await this.$computeQrl$.resolve();
+        try {
+            this.$timeoutMs$ && (this.$computationTimeoutId$ = setTimeout(() => {
+                running.$abortController$?.abort();
+                const error = new Error("timeout");
+                isCurrent() && (this.untrackedError = error, running.$canWrite$ = !1);
+            }, this.$timeoutMs$));
+            const value = await retryOnPromise(fn.bind(null, running));
+            if (running.$promise$ = null, running.$canWrite$) {
+                const index = this.$jobs$.indexOf(running);
+                if (-1 !== index) {
+                    for (let i = 0; i < index; i++) {
+                        this.$jobs$[i].$canWrite$ = !1;
+                    }
+                }
+                this.untrackedError = void 0, this.value = value;
             }
-            return promise;
+        } catch (err) {
+            running.$promise$ = null, isCurrent() && (this.untrackedError = err);
         }
-        this.setValue(untrackedValue);
+        isCurrent() && (clearTimeout(this.$computationTimeoutId$), 1 & this.$flags$ ? this.$computeIfNeeded$() : (this.untrackedLoading = !1, 
+        this.$scheduleNextPoll$()));
     }
-    async $promiseComputation$() {
-        if (!this.$promise$) {
-            const [cleanup] = cleanupFn(this, err => this.$container$?.handleError(err, null));
-            this.$promise$ = this.$computeQrl$.getFn()({
-                track: trackFn(this, this.$container$),
-                cleanup
-            });
+    async $destroy$() {
+        this.$clearNextPoll$(), clearTimeout(this.$computationTimeoutId$), this.$current$ && await this.$requestCleanups$(this.$current$), 
+        await Promise.all(this.$jobs$.map(job => job.$promise$));
+    }
+    get untrackedValue() {
+        if (this.$computeIfNeeded$(), this.$current$?.$promise$) {
+            if (this.$untrackedValue$ === NEEDS_COMPUTATION || (import.meta.env.TEST ? isServerPlatform() : isServer)) {
+                throw this.$current$?.$promise$;
+            }
+            return this.$untrackedValue$;
+        }
+        if (this.$untrackedError$) {
+            throw this.$untrackedError$;
         }
-        return this.$promise$;
+        return this.$untrackedValue$;
     }
-    setValue(value) {
-        this.$flags$ &= -2;
-        const didChange = value !== this.$untrackedValue$;
-        return didChange && (this.$untrackedValue$ = value, this.$flags$ |= 2), didChange;
+    $clearNextPoll$() {
+        void 0 !== this.$pollTimeoutId$ && (clearTimeout(this.$pollTimeoutId$), this.$pollTimeoutId$ = void 0);
+    }
+    $scheduleNextPoll$() {
+        (import.meta.env.TEST ? !isServerPlatform() : isBrowser) && this.$interval$ > 0 && (this.$clearNextPoll$(), 
+        this.$pollTimeoutId$ = setTimeout(this.invalidate.bind(this), this.$interval$), 
+        this.$pollTimeoutId$?.unref?.());
+    }
+    $hasSubscribers$() {
+        return !!(this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size);
+    }
+    async $requestCleanups$(job, reason) {
+        if (job.$cleanupRequested$) {
+            return job.$promise$;
+        }
+        job.$cleanupRequested$ = !0, job.$abortController$?.abort(reason), job.$promise$ = Promise.resolve(job.$promise$).then(() => job.$promise$ = this.$runCleanups$(job));
+    }
+    async $runCleanups$(job) {
+        const cleanups = job.$cleanups$;
+        if (cleanups?.length) {
+            const onError = err => {
+                const handleError = this.$container$?.handleError;
+                handleError ? handleError(err, null) : console.error("Error in async signal cleanup", err);
+            };
+            await Promise.all(cleanups.map(fn => {
+                try {
+                    const result = fn();
+                    if (isPromise(result)) {
+                        return result.catch(onError);
+                    }
+                } catch (err) {
+                    onError(err);
+                }
+            })), cleanups.length = 0;
+        }
+        const jobs = this.$jobs$;
+        const idx = jobs.indexOf(job);
+        -1 !== idx && jobs.splice(idx, 1), this.$computeIfNeeded$();
     }
 }
 
@@ -1161,16 +1235,16 @@ class SerializerSignalImpl extends ComputedSignalImpl {
         if (!(1 & this.$flags$)) {
             return;
         }
-        throwIfQRLNotResolved(this.$computeQrl$);
+        throwIfQRLNotResolved(this.$computeQrl$), this.$flags$ &= -2;
         let arg = this.$computeQrl$.resolved;
         "function" == typeof arg && (arg = arg());
         const {deserialize, initial} = arg;
         const update = arg.update;
         const currentValue = this.$untrackedValue$ === NEEDS_COMPUTATION ? initial : this.$untrackedValue$;
         const untrackedValue = trackSignal(() => this.$didInitialize$ ? update?.(currentValue) || currentValue : deserialize(currentValue), this, ".", this.$container$);
-        const didChange = this.$didInitialize$ && "undefined" !== untrackedValue || untrackedValue !== this.$untrackedValue$;
-        this.$flags$ &= -2, this.$didInitialize$ = !0, didChange && (this.$flags$ |= 2, 
-        this.$untrackedValue$ = untrackedValue);
+        this.$didInitialize$ = !0;
+        (this.$didInitialize$ && "undefined" !== untrackedValue || untrackedValue !== this.$untrackedValue$) && (this.$untrackedValue$ = untrackedValue, 
+        scheduleEffects(this.$container$, this, this.$effects$));
     }
 }
 
@@ -1178,7 +1252,7 @@ const createSignal$1 = value => new SignalImpl(null, value);
 
 const createComputedSignal = (qrl, options) => new ComputedSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || "always"));
 
-const createAsyncSignal = (qrl, options) => new AsyncSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || "never"));
+const createAsyncSignal = (qrl, options) => new AsyncSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || "always"), options);
 
 const createSerializerSignal = arg => new SerializerSignalImpl(null, arg);
 
@@ -1186,8 +1260,7 @@ const createSignal = createSignal$1;
 
 const createComputed$ = /*#__PURE__*/ implicit$FirstArg(createComputedSignal);
 
-const createAsync$ = 
-/*#__PURE__*/ implicit$FirstArg(createAsyncSignal);
+const createAsync$ = /*#__PURE__*/ implicit$FirstArg(createAsyncSignal);
 
 const createSerializer$ = implicit$FirstArg(createSerializerSignal);
 
@@ -1253,10 +1326,6 @@ class WrappedSignalImpl extends SignalImpl {
         }
         2 & this.$flags$ && (this.$flags$ &= -3, scheduleEffects(this.$container$, this, this.$effects$));
     }
-    force() {
-        this.$flags$ |= 2, this.$container$ && this.$hostElement$ && (this.$container$.setHostProp(this.$hostElement$, ":signal", this), 
-        markVNodeDirty(this.$container$, this.$hostElement$, 16));
-    }
     get untrackedValue() {
         return this.$computeIfNeeded$(), isDev && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, "Invalid state"), 
         this.$untrackedValue$;
@@ -1321,6 +1390,8 @@ function clearAsyncSignal(producer, effect) {
     effects && effects.has(effect) && effects.delete(effect);
     const pendingEffects = producer.$loadingEffects$;
     pendingEffects && pendingEffects.has(effect) && pendingEffects.delete(effect);
+    const errorEffects = producer.$errorEffects$;
+    errorEffects && errorEffects.has(effect) && errorEffects.delete(effect), producer.$scheduleEagerCleanup$();
 }
 
 function clearStoreOrProps(producer, effect) {
@@ -1357,6 +1428,19 @@ function _chk(_, element) {
     _captures[0].value = element.checked;
 }
 
+function _res(_, element) {
+    maybeScopeFromQL(this, element);
+}
+
+const isObjectEmpty = obj => {
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            return !1;
+        }
+    }
+    return !0;
+};
+
 const _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
 
 class JSXNodeImpl {
@@ -1370,7 +1454,7 @@ class JSXNodeImpl {
     _proxy=null;
     constructor(type, varProps, constProps, children, key, toSort, dev) {
         this.type = type, this.children = children, this.toSort = !!toSort, this.key = null == key ? null : "string" == typeof key ? key : "" + key, 
-        this.varProps = !varProps || isEmpty(varProps) ? EMPTY_OBJ : varProps, this.constProps = !constProps || isEmpty(constProps) ? null : constProps, 
+        this.varProps = !varProps || isObjectEmpty(varProps) ? EMPTY_OBJ : varProps, this.constProps = !constProps || isObjectEmpty(constProps) ? null : constProps, 
         seal();
     }
     get props() {
@@ -1388,8 +1472,6 @@ const mergeHandlers = (obj, event, handler) => {
 
 const isJSXNode = n => n instanceof JSXNodeImpl;
 
-const isEmpty = obj => 0 === Object.keys(obj).length;
-
 const BIND_VALUE = "bind:value";
 
 const BIND_CHECKED = "bind:checked";
@@ -1589,7 +1671,7 @@ function addUseOnEvent(jsxElement, key, value) {
     props[key] = void 0);
 }
 
-const getValue$1 = o => o.value;
+const getValue = o => o.value;
 
 function findFirstElementNode(jsx) {
     const queue = [ jsx ];
@@ -1607,7 +1689,7 @@ function findFirstElementNode(jsx) {
                 return maybeThen(jsx, jsx => findFirstElementNode(jsx));
             }
             if (isSignal(jsx)) {
-                return findFirstElementNode(untrack(getValue$1, jsx));
+                return findFirstElementNode(untrack(getValue, jsx));
             }
         }
     }
@@ -1903,6 +1985,17 @@ const createInsertOrMoveOperation = (target, parent, beforeTarget) => new Insert
 
 const createSetAttributeOperation = (target, attrName, attrValue, scopedStyleIdPrefix = null, isSvg = !1) => new SetAttributeOperation(target, attrName, attrValue, scopedStyleIdPrefix, isSvg);
 
+const cleanupDestroyable = destroyable => {
+    if (destroyable.$destroy$) {
+        try {
+            destroyable.$destroy$();
+        } catch (err) {
+            logError(err);
+        }
+        destroyable.$destroy$ = null;
+    }
+};
+
 function runEventHandlerQRL(handler, event, element, ctx = newInvokeContextFromDOM(event, element)) {
     const container = ctx.$container$;
     const hostElement = ctx.$hostElement$;
@@ -2173,16 +2266,16 @@ function expectSlot(diffContext) {
     const slotNameKey = getSlotNameKey(diffContext, vHost);
     const vProjectedNode = vHost ? vnode_getProp(vHost, slotNameKey, null) : null;
     if (null == vProjectedNode) {
-        return vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newVirtual(), diffContext.vCurrent && getInsertBefore(diffContext)), 
-        vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey), vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode), 
-        isDev && vnode_setProp(diffContext.vNewNode, "q:type", "P"), isDev && vnode_setProp(diffContext.vNewNode, "q:code", "expectSlot" + count++), 
+        return diffContext.vNewNode = vnode_newVirtual(), vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey), 
+        vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode), isDev && vnode_setProp(diffContext.vNewNode, "q:type", "P"), 
+        vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent && getInsertBefore(diffContext)), 
         !1;
     }
     if (vProjectedNode === diffContext.vCurrent) {} else {
         const oldParent = vProjectedNode.parent;
-        vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vProjectedNode, diffContext.vCurrent && getInsertBefore(diffContext)), 
-        vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey), vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode), 
-        isDev && vnode_setProp(diffContext.vNewNode, "q:type", "P"), isDev && vnode_setProp(diffContext.vNewNode, "q:code", "expectSlot" + count++), 
+        diffContext.vNewNode = vProjectedNode, vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey), 
+        vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode), isDev && vnode_setProp(diffContext.vNewNode, "q:type", "P"), 
+        vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent && getInsertBefore(diffContext)), 
         oldParent && vnode_isElementVNode(oldParent) && !oldParent.firstChild && vnode_getElementName(oldParent) === QTemplate && vnode_remove(diffContext.journal, oldParent.parent, oldParent, !0);
     }
     return !0;
@@ -2318,18 +2411,30 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
     if (key && (diffContext.vNewNode.key = key), diffContext.scopedStyleIdPrefix) {
         _hasOwnProperty.call(jsx.varProps, "class") || jsx.constProps && _hasOwnProperty.call(jsx.constProps, "class") || element.setAttribute("class", diffContext.scopedStyleIdPrefix);
     }
-    vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent);
+    vnode_insertElementBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent);
 }
 
 function registerEventHandlers(key, value, element, vnode, diffContext) {
     const scopedKebabName = key.slice(2);
-    Array.isArray(value) || (value = [ value ]);
-    const handlers = [];
-    for (const handler of value.flat(2)) {
-        handler && handlers.push(runEventHandlerQRL.bind(null, handler));
+    if (Array.isArray(value)) {
+        const arr = value;
+        const handlers = [];
+        for (let i = 0; i < arr.length; i++) {
+            const item = arr[i];
+            if (Array.isArray(item)) {
+                for (let j = 0; j < item.length; j++) {
+                    const handler = item[j];
+                    handler && handlers.push(runEventHandlerQRL.bind(null, handler));
+                }
+            } else {
+                item && handlers.push(runEventHandlerQRL.bind(null, item));
+            }
+        }
+        (element._qDispatch ||= {})[scopedKebabName] = handlers;
+    } else {
+        value && ((element._qDispatch ||= {})[scopedKebabName] = [ runEventHandlerQRL.bind(null, value) ]);
     }
-    (element._qDispatch ||= {})[scopedKebabName] = handlers, "e" !== key.charAt(2) && vnode_setAttr(diffContext.journal, vnode, key, ""), 
-    registerQwikLoaderEvent(diffContext, scopedKebabName);
+    "e" !== key.charAt(2) && vnode_setAttr(diffContext.journal, vnode, key, ""), registerQwikLoaderEvent(diffContext, scopedKebabName);
 }
 
 function createElementWithNamespace(diffContext, elementName) {
@@ -2522,8 +2627,8 @@ function expectVirtual(diffContext, type, jsxKey) {
     const checkKey = "F" === type;
     const currentKey = getKey(diffContext.vCurrent);
     if (!diffContext.vCurrent || !vnode_isVirtualVNode(diffContext.vCurrent) || currentKey !== jsxKey || checkKey && !jsxKey) {
-        return null === jsxKey || diffContext.isCreationMode ? (vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newVirtual(), diffContext.vCurrent && getInsertBefore(diffContext)), 
-        diffContext.vNewNode.key = jsxKey, void (isDev && vnode_setProp(diffContext.vNewNode, "q:type", type))) : void (moveOrCreateKeyedNode(diffContext, null, jsxKey, getSideBufferKey(null, jsxKey), diffContext.vParent, !0) && (vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newVirtual(), diffContext.vCurrent && getInsertBefore(diffContext)), 
+        return null === jsxKey || diffContext.isCreationMode ? (vnode_insertVirtualBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newVirtual(), diffContext.vCurrent && getInsertBefore(diffContext)), 
+        diffContext.vNewNode.key = jsxKey, void (isDev && vnode_setProp(diffContext.vNewNode, "q:type", type))) : void (moveOrCreateKeyedNode(diffContext, null, jsxKey, getSideBufferKey(null, jsxKey), diffContext.vParent, !0) && (vnode_insertVirtualBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newVirtual(), diffContext.vCurrent && getInsertBefore(diffContext)), 
         diffContext.vNewNode.key = jsxKey, isDev && vnode_setProp(diffContext.vNewNode, "q:type", type)));
     }
     deleteFromSideBuffer(diffContext, null, currentKey);
@@ -2567,14 +2672,14 @@ function expectComponent(diffContext, component) {
 }
 
 function insertNewComponent(diffContext, host, componentQRL, jsxProps) {
-    host && clearAllEffects(diffContext.container, host), vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newVirtual(), diffContext.vCurrent && getInsertBefore(diffContext));
+    host && clearAllEffects(diffContext.container, host), vnode_insertVirtualBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newVirtual(), diffContext.vCurrent && getInsertBefore(diffContext));
     const jsxNode = diffContext.jsxValue;
     isDev && vnode_setProp(diffContext.vNewNode, "q:type", "C"), vnode_setProp(diffContext.vNewNode, "q:renderFn", componentQRL), 
     vnode_setProp(diffContext.vNewNode, "q:props", jsxProps), diffContext.vNewNode.key = jsxNode.key;
 }
 
 function insertNewInlineComponent(diffContext) {
-    vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newVirtual(), diffContext.vCurrent && getInsertBefore(diffContext));
+    vnode_insertVirtualBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newVirtual(), diffContext.vCurrent && getInsertBefore(diffContext));
     const jsxNode = diffContext.jsxValue;
     isDev && vnode_setProp(diffContext.vNewNode, "q:type", "I"), vnode_setProp(diffContext.vNewNode, "q:props", jsxNode.props), 
     jsxNode.key && (diffContext.vNewNode.key = jsxNode.key);
@@ -2586,7 +2691,7 @@ function expectText(diffContext, text) {
             return text !== vnode_getText(diffContext.vCurrent) ? void vnode_setText(diffContext.journal, diffContext.vCurrent, text) : void 0;
         }
     }
-    vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newText((import.meta.env.TEST ? diffContext.container.document : document).createTextNode(text), text), diffContext.vCurrent);
+    vnode_insertElementBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode = vnode_newText((import.meta.env.TEST ? diffContext.container.document : document).createTextNode(text), text), diffContext.vCurrent);
 }
 
 function getKey(vNode) {
@@ -2645,7 +2750,7 @@ function handleChangedProps(src, dst, propsHandler, container, triggerEffects =
 }
 
 function isPropsEmpty(props) {
-    return !props || 0 === Object.keys(props).length;
+    return !props || isObjectEmpty(props);
 }
 
 function cleanup(container, journal, vNode, cursorRoot = null) {
@@ -2666,7 +2771,7 @@ function cleanup(container, journal, vNode, cursorRoot = null) {
                         if (isObject(obj)) {
                             const objIsTask = isTask(obj);
                             if (objIsTask && 1 & obj.$flags$) {
-                                obj.$flags$ |= 32, markVNodeDirty(container, vCursor, 64, cursorRoot);
+                                obj.$flags$ |= 16, markVNodeDirty(container, vCursor, 64, cursorRoot);
                                 continue;
                             }
                             (obj instanceof SignalImpl || isStore(obj)) && clearAllEffects(container, obj), 
@@ -2776,147 +2881,6 @@ function containsWrappedSignal(data, signal) {
     return !1;
 }
 
-let count = 0;
-
-const useSequentialScope = () => {
-    const iCtx = useInvokeContext();
-    const host = iCtx.$hostElement$;
-    let seq = iCtx.$container$.getHostProp(host, "q:seq");
-    null === seq && (seq = [], iCtx.$container$.setHostProp(host, "q:seq", seq));
-    let seqIdx = iCtx.$container$.getHostProp(host, "q:seqIdx");
-    for (null === seqIdx && (seqIdx = 0), iCtx.$container$.setHostProp(host, "q:seqIdx", seqIdx + 1); seq.length <= seqIdx; ) {
-        seq.push(void 0);
-    }
-    return {
-        val: seq[seqIdx],
-        set: value => seq[seqIdx] = value,
-        i: seqIdx,
-        iCtx
-    };
-};
-
-const useResourceQrl = (qrl, opts) => {
-    const {val, set, i, iCtx} = useSequentialScope();
-    if (null != val) {
-        return val.$state$;
-    }
-    assertQrl(qrl);
-    const container = iCtx.$container$;
-    const resource = createResourceReturn(container, opts);
-    const el = iCtx.$hostElement$;
-    const task = new Task(12, i, el, qrl, resource, null);
-    return set(task), runResource(task, container, el), resource;
-};
-
-const Resource = props => _jsxSorted(Fragment, null, null, getResourceValueAsPromise(props), 0, null);
-
-const getResolved = resource => resource._resolved;
-
-const getValue = resource => resource.value;
-
-const getLoading = resource => resource.loading;
-
-function getResourceValueAsPromise(props) {
-    const resource = props.value;
-    if (isResourceReturn(resource)) {
-        const state = resource._state;
-        if (!isServerPlatform()) {
-            if ("pending" === state && props.onPending) {
-                return resource.value.catch(() => {}), Promise.resolve().then(useBindInvokeContext(props.onPending));
-            }
-            if ("rejected" === state && props.onRejected) {
-                return Promise.resolve(resource._error).then(useBindInvokeContext(props.onRejected));
-            }
-            {
-                const resolvedValue = untrack(getResolved, resource);
-                if (void 0 !== resolvedValue) {
-                    return Promise.resolve(resolvedValue).then(useBindInvokeContext(props.onResolved));
-                }
-            }
-        }
-        return untrack(getValue, resource).then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
-    }
-    if (isPromise(resource)) {
-        return 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 => ({
-    __brand: "resource",
-    value: void 0,
-    loading: !isServerPlatform(),
-    _resolved: void 0,
-    _error: void 0,
-    _state: "pending",
-    _timeout: opts?.timeout ?? -1,
-    _cache: 0,
-    _generation: 0
-});
-
-const createResourceReturn = (container, opts, initialPromise) => {
-    const result = _createResourceReturn(opts);
-    return result.value = initialPromise, createStore(container, result, 1);
-};
-
-const isResourceReturn = obj => isObject(obj) && "resource" === (getStoreTarget(obj) || obj).__brand;
-
-const runResource = (task, container, host) => {
-    task.$flags$ &= -9, cleanupDestroyable(task);
-    const iCtx = newInvokeContext(container.$locale$, host, "qResource");
-    iCtx.$container$ = container;
-    const taskFn = task.$qrl$.getFn(iCtx, () => clearAllEffects(container, task));
-    const resource = task.$state$;
-    isDev && 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 resourceTarget = unwrapStore(resource);
-    const opts = {
-        track,
-        cleanup,
-        cache(policy) {
-            let milliseconds = 0;
-            milliseconds = "immutable" === policy ? 1 / 0 : policy, resource._cache = milliseconds;
-        },
-        previous: resourceTarget._resolved
-    };
-    let resolve;
-    let reject;
-    let done = !1;
-    const currentGeneration = ++resourceTarget._generation;
-    const setState = (resolved, value) => !done && resourceTarget._generation === currentGeneration && (done = !0, 
-    resolved ? (resourceTarget.loading = !1, resourceTarget._state = "resolved", resourceTarget._resolved = value, 
-    resourceTarget._error = void 0, resolve(value)) : (resourceTarget.loading = !1, 
-    resourceTarget._state = "rejected", resourceTarget._error = value, reject(value)), 
-    isServerPlatform() || forceStoreEffects(resource, "_state"), !0);
-    cleanups.push(() => {
-        if (!0 === untrack(getLoading, resource)) {
-            const value = untrack(getResolved, resource);
-            setState(!0, value);
-        }
-    }), invoke(iCtx, () => {
-        resource._state = "pending", resource.loading = !isServerPlatform(), resource.value = new Promise((r, re) => {
-            resolve = r, reject = re;
-        });
-    });
-    const promise = safeCall(() => taskFn(opts), value => {
-        setState(!0, value);
-    }, err => {
-        if (isPromise(err)) {
-            return err.then(() => runResource(task, container, host));
-        }
-        setState(!1, err);
-    });
-    const timeout = resourceTarget._timeout;
-    return timeout > 0 ? Promise.race([ promise, delay(timeout).then(() => {
-        setState(!1, new Error("timeout")) && cleanupDestroyable(task);
-    }) ]) : promise;
-};
-
 function executeTasks(vNode, container, cursorData) {
     vNode.dirty &= -2;
     const elementSeq = container.getHostProp(vNode, "q:seq");
@@ -2927,15 +2891,13 @@ function executeTasks(vNode, container, cursorData) {
     for (const item of elementSeq) {
         if (item instanceof Task) {
             const task = item;
-            if (!(8 & task.$flags$)) {
+            if (!(4 & task.$flags$)) {
                 continue;
             }
-            if (4 & task.$flags$) {
-                runResource(task, container, vNode);
-            } else if (1 & task.$flags$) {
+            if (1 & task.$flags$) {
                 (cursorData.afterFlushTasks ||= []).push(task);
             } else {
-                const isRenderBlocking = !!(16 & task.$flags$);
+                const isRenderBlocking = !!(8 & task.$flags$);
                 const result = runTask(task, container, vNode);
                 isPromise(result) && (isRenderBlocking ? taskPromise = taskPromise ? taskPromise.then(() => result) : result : (cursorData.extraPromises ||= []).push(result));
             }
@@ -3020,8 +2982,8 @@ function executeCleanup(vNode, container) {
     const elementSeq = container.getHostProp(vNode, "q:seq");
     if (elementSeq && 0 !== elementSeq.length) {
         for (const item of elementSeq) {
-            if (item instanceof Task && 32 & item.$flags$) {
-                item.$flags$ &= -33;
+            if (item instanceof Task && 16 & item.$flags$) {
+                item.$flags$ &= -17;
                 cleanupDestroyable(item);
             }
         }
@@ -3067,15 +3029,16 @@ function _flushJournal(journal) {
                 fastInsertBefore(batchParent, batchNodes[0], batchBefore);
             } else {
                 const fragment = (batchParent.ownerDocument || batchParent).createDocumentFragment();
-                for (const node of batchNodes) {
-                    fragment.appendChild(node);
+                for (let i = 0; i < batchNodes.length; i++) {
+                    fragment.appendChild(batchNodes[i]);
                 }
                 fastInsertBefore(batchParent, fragment, batchBefore);
             }
             batchNodes = null, batchParent = null, batchBefore = null, batchSet.clear();
         }
     };
-    for (const operation of journal) {
+    for (let i = 0; i < journal.length; i++) {
+        const operation = journal[i];
         if (operation instanceof InsertOrMoveOperation) {
             if (batchParent === operation.parent && batchBefore === operation.beforeTarget) {
                 batchNodes || (batchNodes = []), batchNodes.push(operation.target), batchSet.add(operation.target);
@@ -3260,8 +3223,7 @@ function finishWalk(container, cursor, cursorData, isServer) {
 }
 
 function resolveCursor(container) {
-    0 === container.$cursorCount$ && 0 === container.$pausedCursorCount$ && (container.$resolveRenderPromise$(), 
-    container.$renderPromise$ = null);
+    container.$checkPendingCount$();
 }
 
 function partitionDirtyChildren(dirtyChildren, parent) {
@@ -3360,11 +3322,10 @@ function executeTasksChore(container, ssrNode) {
     for (const item of elementSeq) {
         if (item instanceof Task) {
             const task = item;
-            if (!(8 & task.$flags$)) {
+            if (!(4 & task.$flags$)) {
                 continue;
             }
-            let result;
-            result = 4 & task.$flags$ ? runResource(task, container, ssrNode) : runTask(task, container, ssrNode), 
+            const result = runTask(task, container, ssrNode);
             promise = promise ? promise.then(() => result) : result;
         }
     }
@@ -3631,6 +3592,14 @@ function registerQrlHandlers(attr, key, container, element) {
     (element._qDispatch ||= {})[scopedKebabName] = handlers;
 }
 
+function vnode_walkDirectChildren(journal, vParent, callback) {
+    let vNode = vnode_getFirstChild(vParent);
+    for (;vNode; ) {
+        vnode_isTextVNode(vNode) ? (vnode_ensureTextInflated(journal, vNode), callback(vNode, vParent)) : vnode_isElementVNode(vNode) ? callback(vNode, vParent) : vnode_walkDirectChildren(journal, vNode, callback), 
+        vNode = vNode.nextSibling;
+    }
+}
+
 function vnode_walkVNode(vNode, callback) {
     let vCursor = vNode;
     if (vnode_isTextVNode(vNode)) {
@@ -3671,29 +3640,12 @@ function vnode_walkVNode(vNode, callback) {
     }
 }
 
-function vnode_getDOMChildNodes(journal, root, isVNode = !1, childNodes = []) {
-    if (vnode_isElementOrTextVNode(root)) {
-        return vnode_isTextVNode(root) && vnode_ensureTextInflated(journal, root), childNodes.push(isVNode ? root : vnode_getNode(root)), 
-        childNodes;
-    }
-    let vNode = vnode_getFirstChild(root);
-    for (;vNode; ) {
-        vnode_isElementVNode(vNode) ? childNodes.push(isVNode ? vNode : vnode_getNode(vNode)) : vnode_isTextVNode(vNode) ? (vnode_ensureTextInflated(journal, vNode), 
-        childNodes.push(isVNode ? vNode : vnode_getNode(vNode))) : vnode_getDOMChildNodes(journal, vNode, !!isVNode, childNodes), 
-        vNode = vNode.nextSibling;
-    }
-    return childNodes;
-}
-
 function vnode_getDOMContainer(vNode) {
     let cursor = vNode;
     for (;cursor; ) {
         if (vnode_isElementVNode(cursor)) {
-            try {
-                return getDomContainer(cursor.node);
-            } catch {
-                return null;
-            }
+            const qContainerElement = _getQContainerElement(cursor.node);
+            return qContainerElement ? getDomContainerFromQContainerElement(qContainerElement) : null;
         }
         cursor = cursor.parent;
     }
@@ -3878,13 +3830,24 @@ const vnode_createErrorDiv = (journal, document, host, err) => {
         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;
+    if (vnode_isElementOrTextVNode(host)) {
+        vnode_insertBefore(journal, vErrorDiv, host, null);
+    } else {
+        const children = [];
+        vnode_walkDirectChildren(journal, host, vNode => {
+            children.push(vNode);
+        });
+        for (let i = 0; i < children.length; i++) {
+            vnode_insertBefore(journal, vErrorDiv, children[i], null);
+        }
+    }
+    return vErrorDiv;
 };
 
-const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
-    ensureElementOrVirtualVNode(parent), vnode_isElementVNode(parent) && ensureMaterialized(parent);
+const vnode_insertElementBefore = (journal, parent, newChild, insertBefore) => {
+    ensureElementOrVirtualVNode(parent);
+    const parentIsElement = vnode_isElementVNode(parent);
+    parentIsElement && ensureMaterialized(parent);
     const newChildCurrentParent = newChild.parent;
     if (newChild === insertBefore) {
         if (newChildCurrentParent) {
@@ -3892,25 +3855,73 @@ const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
         }
         insertBefore = null;
     }
-    const domParentVNode = vnode_getDomParentVNode(parent, !1);
-    const parentNode = domParentVNode && domParentVNode.node;
-    let domChildren = null;
-    domParentVNode && (domChildren = vnode_getDomChildrenWithCorrectNamespacesToInsert(journal, domParentVNode, newChild)), 
-    newChildCurrentParent && (newChild.previousSibling || newChild.nextSibling || newChildCurrentParent !== parent) && vnode_remove(journal, newChildCurrentParent, newChild, !1);
+    vnode_unlinkFromOldParent(journal, newChildCurrentParent, parent, newChild);
+    const childNode = newChild.node;
     const parentIsDeleted = 32 & parent.flags;
-    let adjustedInsertBefore = null;
-    if (!parentIsDeleted && (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)) {
-        for (const child of domChildren) {
-            addVNodeOperation(journal, createInsertOrMoveOperation(child.node, parentNode, vnode_getNode(adjustedInsertBefore)));
+    const parentNode = parentIsElement ? parent.node : vnode_getDomParent(parent, !1);
+    parentNode && !parentIsDeleted && addVNodeOperation(journal, createInsertOrMoveOperation(childNode, parentNode, vnode_findInsertBefore(journal, parent, insertBefore)?.node ?? null)), 
+    vnode_connectSiblings(parent, newChild, insertBefore), parentIsDeleted && (newChild.flags |= 32);
+};
+
+const vnode_insertVirtualBefore = (journal, parent, newChild, insertBefore) => {
+    ensureElementOrVirtualVNode(parent);
+    const parentIsElement = vnode_isElementVNode(parent);
+    parentIsElement && ensureMaterialized(parent);
+    const newChildCurrentParent = newChild.parent;
+    if (newChild === insertBefore) {
+        if (newChildCurrentParent) {
+            return;
         }
+        insertBefore = null;
+    }
+    vnode_unlinkFromOldParent(journal, newChildCurrentParent, parent, newChild);
+    const parentIsDeleted = 32 & parent.flags;
+    const domParentVNode = parentIsElement ? parent : vnode_getDomParentVNode(parent, !1);
+    const parentNode = domParentVNode?.node;
+    const adjustedInsertBefore = vnode_findInsertBefore(journal, parent, insertBefore);
+    const adjustedInsertBeforeNode = adjustedInsertBefore?.node ?? null;
+    if (vnode_isProjection(newChild) && domParentVNode && 1536 & domParentVNode.flags) {
+        const domParentVNode = vnode_getDomParentVNode(parent, !1);
+        const adjustedInsertBeforeNode = vnode_findInsertBefore(journal, parent, insertBefore)?.node ?? null;
+        const {elementNamespace, elementNamespaceFlag} = getNewElementNamespaceData(domParentVNode, newChild);
+        vnode_walkDirectChildren(journal, newChild, vNode => {
+            if (vnode_isTextVNode(vNode)) {
+                addVNodeOperation(journal, createInsertOrMoveOperation(vNode.node, parentNode, adjustedInsertBeforeNode));
+            } else {
+                if ((1536 & vNode.flags) !== elementNamespaceFlag) {
+                    const newChildElement = vnode_cloneElementWithNamespace(vNode, domParentVNode, elementNamespace, elementNamespaceFlag);
+                    newChildElement && (vNode.node = newChildElement);
+                }
+                addVNodeOperation(journal, createInsertOrMoveOperation(vNode.node, parentNode, adjustedInsertBeforeNode));
+            }
+        });
+    } else {
+        parentNode && !parentIsDeleted && vnode_walkDirectChildren(journal, newChild, vNode => {
+            addVNodeOperation(journal, createInsertOrMoveOperation(vNode.node, parentNode, adjustedInsertBeforeNode));
+        });
     }
-    const vNext = insertBefore;
+    vnode_connectSiblings(parent, newChild, insertBefore), parentIsDeleted && (newChild.flags |= 32);
+};
+
+const vnode_findInsertBefore = (journal, parent, insertBefore) => {
+    let adjustedInsertBefore = null;
+    return 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), 
+    adjustedInsertBefore;
+};
+
+const vnode_connectSiblings = (parent, vNode, vNext) => {
     const vPrevious = vNext ? vNext.previousSibling : parent.lastChild;
-    vNext ? vNext.previousSibling = newChild : parent.lastChild = newChild, vPrevious ? vPrevious.nextSibling = newChild : parent.firstChild = newChild, 
-    newChild.previousSibling = vPrevious, newChild.nextSibling = vNext, newChild.parent = parent, 
-    parentIsDeleted && (newChild.flags |= 32);
+    vNext ? vNext.previousSibling = vNode : parent.lastChild = vNode, vPrevious ? vPrevious.nextSibling = vNode : parent.firstChild = vNode, 
+    vNode.previousSibling = vPrevious, vNode.nextSibling = vNext, vNode.parent = parent;
+};
+
+const vnode_unlinkFromOldParent = (journal, currentParent, newParent, newChild) => {
+    currentParent && (newChild.previousSibling || newChild.nextSibling || currentParent !== newParent) && vnode_remove(journal, currentParent, newChild, !1);
+};
+
+const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
+    vnode_isElementOrTextVNode(newChild) ? vnode_insertElementBefore(journal, parent, newChild, insertBefore) : vnode_insertVirtualBefore(journal, parent, newChild, insertBefore);
 };
 
 const vnode_getDomParent = (vnode, includeProjection) => (vnode = vnode_getDomParentVNode(vnode, includeProjection)) && vnode.node;
@@ -3925,16 +3936,12 @@ const vnode_getDomParentVNode = (vnode, includeProjection) => {
 const vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
     if (isDev && assertEqual(vParent, vToRemove.parent, "Parent mismatch."), vnode_isTextVNode(vToRemove) && vnode_ensureTextInflated(journal, vToRemove), 
     removeDOM) {
-        const domParent = vnode_getDomParent(vParent, !1);
         if (null !== vnode_getProp(vParent, dangerouslySetInnerHTML, null)) {
             return;
         }
-        const children = vnode_getDOMChildNodes(journal, vToRemove, !0);
-        if (domParent && children.length) {
-            for (const child of children) {
-                addVNodeOperation(journal, createDeleteOperation(child.node));
-            }
-        }
+        vnode_isElementOrTextVNode(vToRemove) ? addVNodeOperation(journal, createDeleteOperation(vToRemove.node)) : vnode_walkDirectChildren(journal, vToRemove, vNode => {
+            addVNodeOperation(journal, createDeleteOperation(vNode.node));
+        });
     }
     const vPrevious = vToRemove.previousSibling;
     const vNext = vToRemove.nextSibling;
@@ -3944,18 +3951,9 @@ const vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
 
 const vnode_truncate = (journal, vParent, vDelete, removeDOM = !0) => {
     isDev && assertDefined(vDelete, "Missing vDelete.");
-    if (vnode_getDomParent(vParent, !0) && removeDOM) {
-        if (vnode_isElementVNode(vParent)) {
-            addVNodeOperation(journal, createRemoveAllChildrenOperation(vParent.node));
-        } else {
-            const children = vnode_getDOMChildNodes(journal, vParent, !0);
-            if (children.length) {
-                for (const child of children) {
-                    addVNodeOperation(journal, createDeleteOperation(child.node));
-                }
-            }
-        }
-    }
+    vnode_getDomParent(vParent, !0) && removeDOM && (vnode_isElementOrTextVNode(vParent) ? addVNodeOperation(journal, createRemoveAllChildrenOperation(vParent.node)) : vnode_walkDirectChildren(journal, vParent, vNode => {
+        addVNodeOperation(journal, createDeleteOperation(vNode.node));
+    }));
     const vPrevious = vDelete.previousSibling;
     vPrevious ? vPrevious.nextSibling = null : vParent.firstChild = null, vParent.lastChild = vPrevious;
 };
@@ -4203,7 +4201,7 @@ const vnode_getAttrKeys = (container, vnode) => {
         const keys = [];
         const props = vnode.props;
         if (props) {
-            for (const key of Object.keys(props)) {
+            for (const key in props) {
                 key.startsWith(":") || keys.push(key);
             }
         }
@@ -4227,7 +4225,12 @@ const vnode_getProjectionParentOrParent = vnode => vnode.parent || vnode.slotPar
 
 const vnode_getNode = vnode => null === vnode || vnode_isVirtualVNode(vnode) ? null : vnode.node;
 
-function vnode_toString(depth = 20, offset = "", materialize = !1, siblings = !1, colorize = !0, container = this && vnode_getDOMContainer(this)) {
+function vnode_toString(depth = 20, offset = "", materialize = !1, siblings = !1, colorize = !0, container = null) {
+    if (this && !container) {
+        try {
+            container = vnode_getDOMContainer(this);
+        } catch {}
+    }
     let vnode = this;
     if (0 === depth) {
         return "...";
@@ -4244,7 +4247,7 @@ 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.flags >>> 11) + "]" ];
-            vnode.dirty && attrs.push(` dirty:${vnode.dirty}`), vnode_getAttrKeys(container, vnode).forEach(key => {
+            vnode.dirty && attrs.push(` dirty:${vnode.dirty}`), container && vnode_getAttrKeys(container, vnode).forEach(key => {
                 if ("q:type" !== key && "__scopedStyleIdPrefix__" !== key) {
                     const value = vnode_getProp(vnode, key, null);
                     attrs.push(" " + key + "=" + qwikDebugToString(value));
@@ -4260,7 +4263,7 @@ function vnode_toString(depth = 20, offset = "", materialize = !1, siblings = !1
             const attrs = [];
             isCursor(vnode) && attrs.push(" cursor"), vnode.dirty && attrs.push(` dirty:${vnode.dirty}`), 
             vnode.dirtyChildren && attrs.push(` dirtyChildren[${vnode.dirtyChildren.length}]`);
-            const keys = vnode_getAttrKeys(container, vnode);
+            const keys = container ? vnode_getAttrKeys(container, vnode) : [];
             for (const key of keys) {
                 const value = vnode_getProp(vnode, key, null);
                 attrs.push(" " + key + "=" + qwikDebugToString(value));
@@ -4386,8 +4389,8 @@ function materializeFromVNodeData(vParent, vData, element, child) {
         }
     }), components) {
         container || (container = getDomContainer(element));
-        for (const component of components) {
-            container.ensureProjectionResolved(component);
+        for (let i = 0; i < components.length; i++) {
+            container.ensureProjectionResolved(components[i]);
         }
         components = null;
     }
@@ -4489,16 +4492,6 @@ const useInvokeContext = () => {
     ctx;
 };
 
-function useBindInvokeContext(fn) {
-    if (null == fn) {
-        return fn;
-    }
-    const ctx = getInvokeContext();
-    return function(...args) {
-        return invokeApply.call(this, ctx, fn, args);
-    };
-}
-
 function invoke(context, fn, ...args) {
     return invokeApply.call(this, context, fn, args);
 }
@@ -4568,7 +4561,7 @@ const trackSignal = (fn, subscriber, property, container, data) => {
     const previousContainer = trackInvocation.$container$;
     try {
         return trackInvocation.$effectSubscriber$ = getSubscriber(subscriber, property, data), 
-        trackInvocation.$container$ = container, invoke(trackInvocation, fn);
+        trackInvocation.$container$ = container, invokeApply(trackInvocation, fn);
     } finally {
         trackInvocation.$effectSubscriber$ = previousSubscriber, trackInvocation.$container$ = previousContainer;
     }
@@ -4597,6 +4590,23 @@ const _jsxBranch = input => input;
 
 const _waitUntilRendered = container => container.$renderPromise$ || Promise.resolve();
 
+const useSequentialScope = () => {
+    const iCtx = useInvokeContext();
+    const host = iCtx.$hostElement$;
+    let seq = iCtx.$container$.getHostProp(host, "q:seq");
+    null === seq && (seq = [], iCtx.$container$.setHostProp(host, "q:seq", seq));
+    let seqIdx = iCtx.$container$.getHostProp(host, "q:seqIdx");
+    for (null === seqIdx && (seqIdx = 0), iCtx.$container$.setHostProp(host, "q:seqIdx", seqIdx + 1); seq.length <= seqIdx; ) {
+        seq.push(void 0);
+    }
+    return {
+        val: seq[seqIdx],
+        set: value => seq[seqIdx] = value,
+        i: seqIdx,
+        iCtx
+    };
+};
+
 const createContextId = name => (isDev && assertTrue(/^[\w/.-]+$/.test(name), "Context name must only contain A-Z,a-z,0-9,_,.,-", name), 
 /*#__PURE__*/ Object.freeze({
     id: fromCamelToKebabCase(name)
@@ -4648,7 +4658,7 @@ const _constants = [ void 0, null, !0, !1, "", EMPTY_ARRAY, EMPTY_OBJ, NEEDS_COM
 
 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 _typeIdNames = [ "Plain", "RootRef", "ForwardRef", "Constant", "Array", "Object", "URL", "Date", "Regex", "QRL", "VNode", "RefVNode", "BigInt", "URLSearchParams", "ForwardRefs", "Error", "Promise", "Set", "Map", "Uint8Array", "Task", "Resource", "Component", "Signal", "WrappedSignal", "ComputedSignal", "AsyncSignal", "SerializerSignal", "Store", "FormData", "JSXNode", "PropsProxy", "SubscriptionData", "EffectSubscription" ];
+const _typeIdNames = [ "Plain", "RootRef", "ForwardRef", "Constant", "Array", "Object", "URL", "Date", "Regex", "QRL", "VNode", "RefVNode", "BigInt", "URLSearchParams", "ForwardRefs", "Error", "Promise", "Set", "Map", "Uint8Array", "Task", "Component", "Signal", "WrappedSignal", "ComputedSignal", "AsyncSignal", "SerializerSignal", "Store", "FormData", "JSXNode", "PropsProxy", "SubscriptionData", "EffectSubscription" ];
 
 function qrlToString(serializationContext, qrl, raw) {
     let symbol = qrl.$symbol$;
@@ -4745,12 +4755,6 @@ const allocate = (container, typeId, value) => {
       case 20:
         return new Task(-1, -1, null, null, null, null);
 
-      case 21:
-        {
-            const res = createResourceReturn(container, void 0, void 0);
-            return res.loading = !1, res;
-        }
-
       case 6:
         return new URL(value);
 
@@ -4764,25 +4768,27 @@ const allocate = (container, typeId, value) => {
       case 15:
         return new Error;
 
-      case 22:
+      case 21:
         return componentQrl(null);
 
-      case 23:
+      case 22:
         return new SignalImpl(container, 0);
 
-      case 24:
+      case 23:
         return new WrappedSignalImpl(container, null, null, null);
 
-      case 25:
+      case 24:
         return new ComputedSignalImpl(container, null);
 
-      case 26:
-        return new AsyncSignalImpl(container, null);
+      case 25:
+        return new AsyncSignalImpl(container, null, void 0, {
+            interval: 0
+        });
 
-      case 27:
+      case 26:
         return new SerializerSignalImpl(container, null);
 
-      case 28:
+      case 27:
         {
             const data = value;
             const t = data[0];
@@ -4798,10 +4804,10 @@ const allocate = (container, typeId, value) => {
       case 13:
         return new URLSearchParams(value);
 
-      case 29:
+      case 28:
         return new FormData;
 
-      case 30:
+      case 29:
         return new JSXNodeImpl(null, null, null, null, null);
 
       case 12:
@@ -4826,7 +4832,7 @@ const allocate = (container, typeId, value) => {
         const rest = 3 & encodedLength;
         return new Uint8Array(3 * (encodedLength >>> 2) + (rest ? rest - 1 : 0));
 
-      case 31:
+      case 30:
         return createPropsProxy(null);
 
       case 10:
@@ -4839,10 +4845,10 @@ const allocate = (container, typeId, value) => {
         }
         throw qError(17, [ typeof vNode ]);
 
-      case 32:
+      case 31:
         return new SubscriptionData({});
 
-      case 33:
+      case 32:
         return new EffectSubscription(null, null, null, null);
 
       default:
@@ -5040,7 +5046,7 @@ async function serialize(serializationContext) {
                     }
                     {
                         const [qrl] = value[SERIALIZABLE_STATE];
-                        serializationContext.$renderSymbols$.add(qrl.$symbol$), output(22, [ qrl ]);
+                        serializationContext.$renderSymbols$.add(qrl.$symbol$), output(21, [ qrl ]);
                     }
                 }
                 break;
@@ -5071,36 +5077,30 @@ async function serialize(serializationContext) {
     const writeObjectValue = value => {
         if (isPropsProxy(value)) {
             const owner = value[_OWNER];
-            output(31, [ _serializationWeakRef(owner), owner.varProps, owner.constProps, value[_PROPS_HANDLER].$effects$ ]);
+            output(30, [ _serializationWeakRef(owner), owner.varProps, owner.constProps, value[_PROPS_HANDLER].$effects$ ]);
         } else if (value instanceof SubscriptionData) {
-            output(32, [ value.data.$scopedStyleIdPrefix$, value.data.$isConst$ ]);
+            output(31, [ value.data.$scopedStyleIdPrefix$, value.data.$isConst$ ]);
         } else if (value instanceof EffectSubscription) {
-            output(33, [ value.consumer, value.property, value.backRef, value.data ]);
+            output(32, [ value.consumer, value.property, value.backRef, value.data ]);
         } else if (isStore(value)) {
-            if (isResource(value)) {
-                serializationContext.$resources$.add(value);
-                const forwardRefId = resolvePromise(value.value, $addRoot$, (resolved, resolvedValue) => new PromiseResult(21, resolved, resolvedValue, getStoreHandler(value).$effects$));
-                output(2, forwardRefId);
-            } else {
-                const storeHandler = getStoreHandler(value);
-                const storeTarget = getStoreTarget(value);
-                const flags = storeHandler.$flags$;
-                const effects = storeHandler.$effects$;
-                const innerStores = [];
-                for (const prop in storeTarget) {
-                    const innerStore = $storeProxyMap$.get(storeTarget[prop]);
-                    innerStore && innerStores.push(innerStore);
-                }
-                const out = [ storeTarget, flags, effects, ...innerStores ];
-                for (;void 0 === out[out.length - 1]; ) {
-                    out.pop();
-                }
-                output(28, out);
+            const storeHandler = getStoreHandler(value);
+            const storeTarget = getStoreTarget(value);
+            const flags = storeHandler.$flags$;
+            const effects = storeHandler.$effects$;
+            const innerStores = [];
+            for (const prop in storeTarget) {
+                const innerStore = $storeProxyMap$.get(storeTarget[prop]);
+                innerStore && innerStores.push(innerStore);
+            }
+            const out = [ storeTarget, flags, effects, ...innerStores ];
+            for (;void 0 === out[out.length - 1]; ) {
+                out.pop();
             }
+            output(27, out);
         } else if (isSerializerObj(value)) {
             const result = value[SerializerSymbol](value);
             if (isPromise(result)) {
-                const forwardRef = resolvePromise(result, $addRoot$, (resolved, resolvedValue) => new PromiseResult(27, resolved, resolvedValue, void 0, void 0));
+                const forwardRef = resolvePromise(result, $addRoot$, (resolved, resolvedValue) => new PromiseResult(26, resolved, resolvedValue, void 0, void 0));
                 output(2, forwardRef);
             } else {
                 const index = parent.$index$;
@@ -5125,33 +5125,38 @@ async function serialize(serializationContext) {
             if (value instanceof SerializerSignalImpl) {
                 const maybeValue = getCustomSerializerPromise(value, value.$untrackedValue$);
                 if (isPromise(maybeValue)) {
-                    const forwardRefId = resolvePromise(maybeValue, $addRoot$, (resolved, resolvedValue) => new PromiseResult(27, resolved, resolvedValue, value.$effects$, value.$computeQrl$));
+                    const forwardRefId = resolvePromise(maybeValue, $addRoot$, (resolved, resolvedValue) => new PromiseResult(26, resolved, resolvedValue, value.$effects$, value.$computeQrl$));
                     output(2, forwardRefId);
                 } else {
-                    output(27, [ value.$computeQrl$, filterEffectBackRefs(value[_EFFECT_BACK_REF]), value.$effects$, maybeValue ]);
+                    output(26, [ value.$computeQrl$, filterEffectBackRefs(value[_EFFECT_BACK_REF]), value.$effects$, maybeValue ]);
                 }
                 return;
             }
             if (value instanceof WrappedSignalImpl) {
-                output(24, [ ...serializeWrappingFn(serializationContext, value), filterEffectBackRefs(value[_EFFECT_BACK_REF]), value.$flags$, value.$hostElement$, ...value.$effects$ || [] ]);
+                output(23, [ ...serializeWrappingFn(serializationContext, value), filterEffectBackRefs(value[_EFFECT_BACK_REF]), value.$flags$, value.$hostElement$, ...value.$effects$ || [] ]);
             } else if (value instanceof ComputedSignalImpl) {
                 let v = value.$untrackedValue$;
                 const shouldAlwaysSerialize = 16 & value.$flags$;
                 const shouldNeverSerialize = 8 & value.$flags$;
                 const isInvalid = 1 & value.$flags$;
                 const isSkippable = fastSkipSerialize(value.$untrackedValue$);
-                shouldAlwaysSerialize ? v = value.$untrackedValue$ : (shouldNeverSerialize || isInvalid || isSkippable) && (v = NEEDS_COMPUTATION);
-                const out = [ value.$computeQrl$, filterEffectBackRefs(value[_EFFECT_BACK_REF]), value.$effects$ ];
                 const isAsync = value instanceof AsyncSignalImpl;
-                isAsync && out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedLoading$, value.$untrackedError$);
+                const interval = isAsync && value.$interval$ > 0 ? value.$interval$ : void 0;
+                const concurrency = isAsync && 1 !== value.$concurrency$ ? value.$concurrency$ : void 0;
+                const timeout = isAsync && 0 !== value.$timeoutMs$ ? value.$timeoutMs$ : void 0;
+                const eagerCleanup = !!(isAsync && 32 & value.$flags$) || void 0;
+                isInvalid || isSkippable ? v = NEEDS_COMPUTATION : shouldAlwaysSerialize ? v = value.$untrackedValue$ : shouldNeverSerialize && (v = NEEDS_COMPUTATION);
+                const out = [ value.$computeQrl$, filterEffectBackRefs(value[_EFFECT_BACK_REF]), value.$effects$ ];
+                isAsync && out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedError$);
                 let keepUndefined = !1;
-                v !== NEEDS_COMPUTATION && (out.push(v), isAsync || void 0 !== v || (keepUndefined = !0)), 
-                output(isAsync ? 26 : 25, out, keepUndefined);
+                v === NEEDS_COMPUTATION && void 0 === interval && void 0 === concurrency && void 0 === timeout || (out.push(v), 
+                void 0 === v && (keepUndefined = !0)), isAsync && (out.push(interval), out.push(concurrency), 
+                out.push(timeout), out.push(eagerCleanup)), output(isAsync ? 25 : 24, out, keepUndefined);
             } else {
                 const v = value.$untrackedValue$;
                 const keepUndefined = void 0 === v;
                 const out = [ v ];
-                value.$effects$ && out.push(...value.$effects$), output(23, out, keepUndefined);
+                value.$effects$ && out.push(...value.$effects$), output(22, out, keepUndefined);
             }
         } else if (value instanceof URL) {
             output(6, value.href);
@@ -5186,7 +5191,7 @@ async function serialize(serializationContext) {
             const array = [];
             value.forEach((value, key) => {
                 array.push(key, "string" == typeof value ? value : value.name);
-            }), output(29, array);
+            }), output(28, array);
         } else if (value instanceof URLSearchParams) {
             output(13, value.toString());
         } else if (value instanceof Set) {
@@ -5202,7 +5207,7 @@ async function serialize(serializationContext) {
             for (;void 0 === out[out.length - 1]; ) {
                 out.pop();
             }
-            output(30, out);
+            output(29, out);
         } else if (value instanceof Task) {
             const out = [ value.$qrl$, value.$flags$, value.$index$, value.$el$, value[_EFFECT_BACK_REF], value.$state$ ];
             for (;void 0 === out[out.length - 1]; ) {
@@ -5213,11 +5218,9 @@ async function serialize(serializationContext) {
             const forwardRefId = resolvePromise(value, $addRoot$, (resolved, resolvedValue) => new PromiseResult(16, resolved, resolvedValue));
             output(2, forwardRefId);
         } else if (value instanceof PromiseResult) {
-            if (21 === value.$type$) {
-                output(21, [ value.$resolved$, value.$value$, value.$effects$ ]);
-            } else if (27 === value.$type$) {
+            if (26 === value.$type$) {
                 if (value.$qrl$) {
-                    output(27, [ value.$qrl$, value.$effects$, value.$value$ ]);
+                    output(26, [ value.$qrl$, value.$effects$, value.$value$ ]);
                 } else {
                     if (!value.$resolved$) {
                         throw console.error(value.$value$), qError(33);
@@ -5329,10 +5332,6 @@ function isObjectLiteral(obj) {
     return null == prototype || prototype === Object.prototype || prototype === Array.prototype;
 }
 
-function isResource(value) {
-    return "__brand" in value && "resource" === value.__brand;
-}
-
 function serializeWrappingFn(serializationContext, value) {
     value.$funcStr$ && "{" === value.$funcStr$[0] && (value.$funcStr$ = `(${value.$funcStr$})`);
     return [ serializationContext.$addSyncFn$(value.$funcStr$, value.$args$.length, value.$func$), value.$args$ ];
@@ -5378,6 +5377,7 @@ const createSerializationContext = (NodeConstructor, DomRefConstructor, symbolTo
     const syncFnMap = new Map;
     const syncFns = [];
     const roots = [];
+    const eagerResume = new Set;
     const $promoteToRoot$ = (ref, index) => {
         const path = (ref => {
             const path = [];
@@ -5441,9 +5441,10 @@ const createSerializationContext = (NodeConstructor, DomRefConstructor, symbolTo
         $writer$: writer,
         $eventQrls$: new Set,
         $eventNames$: new Set,
-        $resources$: new Set,
         $renderSymbols$: new Set,
         $storeProxyMap$: storeProxyMap,
+        $eagerResume$: eagerResume,
+        $resources$: new Set,
         $getProp$: getProp,
         $setProp$: setProp
     };
@@ -5460,8 +5461,7 @@ class _SharedContainer {
     $buildBase$=null;
     $renderPromise$=null;
     $resolveRenderPromise$=null;
-    $cursorCount$=0;
-    $pausedCursorCount$=0;
+    $pendingCount$=0;
     constructor(serverData, locale) {
         this.$serverData$ = serverData, this.$locale$ = locale, this.$version$ = version, 
         this.$storeProxyMap$ = new WeakMap, this.$getObjectById$ = () => {
@@ -5474,6 +5474,9 @@ class _SharedContainer {
     serializationCtxFactory(NodeConstructor, DomRefConstructor, symbolToChunkResolver, writer) {
         return createSerializationContext(NodeConstructor, DomRefConstructor, symbolToChunkResolver, this.getHostProp.bind(this), this.setHostProp.bind(this), this.$storeProxyMap$, writer);
     }
+    $checkPendingCount$() {
+        0 === this.$pendingCount$ && (this.$resolveRenderPromise$?.(), this.$renderPromise$ = null);
+    }
 }
 
 function isAsyncGenerator(value) {
@@ -5550,7 +5553,7 @@ function processJSXNode(ssr, enqueue, value, options) {
                 enqueue(value[i]);
             }
         } else if (isSignal(value)) {
-            ssr.openFragment(isDev ? [ "q:type", "S" ] : EMPTY_ARRAY);
+            maybeAddPollingAsyncSignalToEagerResume(ssr.serializationCtx, value), ssr.openFragment(isDev ? [ "q:type", "S" ] : EMPTY_ARRAY);
             const signalNode = ssr.getOrCreateLastNode();
             const unwrappedSignal = value instanceof WrappedSignalImpl ? value.$unwrapIfSignal$() : value;
             enqueue(ssr.closeFragment), enqueue(() => trackSignalAndAssignHost(unwrappedSignal, signalNode, ".", ssr)), 
@@ -5668,8 +5671,12 @@ function toSsrAttrs(record, options) {
                 const eventValue = setEvent(options.serializationCtx, key, value);
                 return void (eventValue && ssrAttrs.push(key, eventValue));
             }
-            isSignal(value) ? isClassAttr(key) ? ssrAttrs.push(key, [ value, options.styleScopedId ]) : ssrAttrs.push(key, value) : (isPreventDefault(key) ? addPreventDefaultEventToSerializationContext(options.serializationCtx, key) : "q:p" !== key && "q:ps" !== key || (value = options.serializationCtx.$addRoot$(value)), 
-            value = serializeAttribute(key, value, options.styleScopedId), ssrAttrs.push(key, value));
+            if (isSignal(value)) {
+                return maybeAddPollingAsyncSignalToEagerResume(options.serializationCtx, value), 
+                void (isClassAttr(key) ? ssrAttrs.push(key, [ value, options.styleScopedId ]) : ssrAttrs.push(key, value));
+            }
+            isPreventDefault(key) ? addPreventDefaultEventToSerializationContext(options.serializationCtx, key) : "q:p" !== key && "q:ps" !== key || (value = options.serializationCtx.$addRoot$(value)), 
+            value = serializeAttribute(key, value, options.styleScopedId), ssrAttrs.push(key, value);
         }
     };
     if (options.toSort) {
@@ -5723,6 +5730,14 @@ function addPreventDefaultEventToSerializationContext(serializationCtx, key) {
     eventName && serializationCtx.$eventNames$.add(eventName);
 }
 
+function maybeAddPollingAsyncSignalToEagerResume(serializationCtx, signal) {
+    const unwrappedSignal = signal instanceof WrappedSignalImpl ? signal.$unwrapIfSignal$() : signal;
+    if (unwrappedSignal instanceof AsyncSignalImpl) {
+        unwrappedSignal.$interval$ > 0 && (serializationCtx.$addRoot$(unwrappedSignal), 
+        serializationCtx.$eagerResume$.add(unwrappedSignal));
+    }
+}
+
 function getSlotName(host, jsx, ssr) {
     const constProps = jsx.constProps;
     if (constProps && "object" == typeof constProps && "name" in constProps) {
@@ -5746,6 +5761,60 @@ function appendClassIfScopedStyleExists(jsx, styleScoped) {
 const useLexicalScope = () => (isDev && assertDefined(_captures, "invoke: captures must be defined for useLexicalScope()"), 
 _captures);
 
+const _rsc = async arg => {
+    const [fn, ref] = _captures;
+    const result = await fn(arg);
+    return result && "object" == typeof result ? ref.r ? Object.assign(ref.r, result) : ref.r = createStore(fn.$container$, result, 1) : ref.r = result, 
+    {
+        r: ref.r
+    };
+};
+
+const useResourceQrl = (qrl, opts) => {
+    assertQrl(qrl);
+    const {val, set, iCtx} = useSequentialScope();
+    if (val) {
+        return val;
+    }
+    const wrapped = createQRL(null, "_rsc", _rsc, null, [ qrl, {} ]);
+    qrl.$container$ = iCtx.$container$;
+    const asyncSignal = createAsyncSignal(wrapped, {
+        timeout: opts?.timeout,
+        container: iCtx.$container$,
+        concurrency: 0
+    });
+    asyncSignal.$computeIfNeeded$();
+    const resource = {
+        __brand: "resource",
+        signal: asyncSignal,
+        get value() {
+            return asyncSignal.promise().then(() => asyncSignal.error ? Promise.reject(asyncSignal.error) : asyncSignal.value.r);
+        },
+        get loading() {
+            return asyncSignal.loading;
+        }
+    };
+    return set(resource), resource;
+};
+
+const Resource = ({value, onResolved, onPending, onRejected}) => {
+    if (isPromise(value)) {
+        return value.then(onResolved, onRejected);
+    }
+    const isRes = isResourceReturn(value);
+    const signal = isRes ? value.signal : value;
+    if (onPending && signal.loading) {
+        return onPending();
+    }
+    if (onRejected && signal.error) {
+        return onRejected(signal.error);
+    }
+    const val = isRes ? signal.value?.r : signal.value;
+    return isPromise(val) ? val.then(onResolved, onRejected) : onResolved(val);
+};
+
+const isResourceReturn = obj => obj && "resource" === obj.__brand;
+
 let loading = Promise.resolve();
 
 const inflate = (container, target, typeId, data) => {
@@ -5773,18 +5842,10 @@ const inflate = (container, target, typeId, data) => {
             break;
 
           case 21:
-            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 22:
             target[SERIALIZABLE_STATE][0] = data[0];
             break;
 
-          case 28:
+          case 27:
             {
                 const store = unwrapStore(target);
                 const storeTarget = pendingStoreTargets.get(store);
@@ -5795,7 +5856,7 @@ const inflate = (container, target, typeId, data) => {
                 break;
             }
 
-          case 23:
+          case 22:
             {
                 const signal = target;
                 const d = data;
@@ -5803,7 +5864,7 @@ const inflate = (container, target, typeId, data) => {
                 break;
             }
 
-          case 24:
+          case 23:
             {
                 const signal = target;
                 const d = data;
@@ -5813,27 +5874,28 @@ const inflate = (container, target, typeId, data) => {
                 break;
             }
 
-          case 26:
+          case 25:
             {
                 const asyncSignal = target;
                 const d = data;
                 asyncSignal.$computeQrl$ = d[0], asyncSignal[_EFFECT_BACK_REF] = d[1], asyncSignal.$effects$ = new Set(d[2]), 
                 asyncSignal.$loadingEffects$ = new Set(d[3]), asyncSignal.$errorEffects$ = new Set(d[4]), 
-                asyncSignal.$untrackedLoading$ = d[5], asyncSignal.$untrackedError$ = d[6];
-                d.length > 7 && (asyncSignal.$untrackedValue$ = d[7], asyncSignal.$promiseValue$ = d[7]), 
-                asyncSignal.$flags$ |= 1;
+                asyncSignal.$untrackedError$ = d[5];
+                d.length > 6 && (asyncSignal.$untrackedValue$ = d[6]), asyncSignal.$untrackedValue$ !== NEEDS_COMPUTATION && (asyncSignal.$flags$ &= -2), 
+                asyncSignal.interval = d[7] ?? 0, asyncSignal.$concurrency$ = d[8] ?? 1, asyncSignal.$timeoutMs$ = d[9] ?? 0, 
+                d[10] && (asyncSignal.$flags$ |= 32);
                 break;
             }
 
-          case 27:
-          case 25:
+          case 26:
+          case 24:
             {
                 const computed = target;
                 const d = data;
                 computed.$computeQrl$ = d[0];
                 const p = computed.$computeQrl$.resolve(container).catch(() => {});
                 loading = loading.finally(() => p), computed[_EFFECT_BACK_REF] = d[1], d[2] && (computed.$effects$ = new Set(d[2]));
-                d.length > 3 ? (computed.$untrackedValue$ = d[3], 27 === typeId && (computed.$flags$ |= 1)) : computed.$flags$ |= 1;
+                d.length > 3 && (computed.$untrackedValue$ = d[3]), 26 !== typeId && computed.$untrackedValue$ !== NEEDS_COMPUTATION && (computed.$flags$ &= -2);
                 break;
             }
 
@@ -5847,7 +5909,7 @@ const inflate = (container, target, typeId, data) => {
                 break;
             }
 
-          case 29:
+          case 28:
             {
                 const formData = target;
                 const d = data;
@@ -5857,7 +5919,7 @@ const inflate = (container, target, typeId, data) => {
                 break;
             }
 
-          case 30:
+          case 29:
             {
                 const jsx = target;
                 const [type, key, varProps, constProps, children, toSort] = data;
@@ -5904,7 +5966,7 @@ const inflate = (container, target, typeId, data) => {
             }
             break;
 
-          case 31:
+          case 30:
             const propsProxy = target;
             const d = data;
             let owner = d[0];
@@ -5912,14 +5974,14 @@ const inflate = (container, target, typeId, data) => {
             owner._proxy = propsProxy), propsProxy[_OWNER] = owner, propsProxy[_PROPS_HANDLER].$effects$ = d[3];
             break;
 
-          case 32:
+          case 31:
             {
                 const effectData = target;
                 effectData.data.$scopedStyleIdPrefix$ = data[0], effectData.data.$isConst$ = data[1];
                 break;
             }
 
-          case 33:
+          case 32:
             {
                 const effectSub = target;
                 const d = data;
@@ -6383,7 +6445,7 @@ const useTaskQrl = (qrl, opts) => {
         return;
     }
     assertQrl(qrl), set(1);
-    const task = new Task(10 | (!1 === opts?.deferUpdates ? 0 : 16), i, iCtx.$hostElement$, qrl, void 0, null);
+    const task = new Task(6 | (!1 === opts?.deferUpdates ? 0 : 8), i, iCtx.$hostElement$, qrl, void 0, null);
     set(task);
     const container = iCtx.$container$;
     const {$waitOn$: waitOn} = iCtx;
@@ -6392,7 +6454,7 @@ const useTaskQrl = (qrl, opts) => {
 };
 
 const runTask = (task, container, host) => {
-    task.$flags$ &= -9, cleanupDestroyable(task);
+    task.$flags$ &= -5, cleanupDestroyable(task);
     const iCtx = newInvokeContext(container.$locale$, host, "qTask");
     iCtx.$container$ = container;
     const taskFn = task.$qrl$.getFn(iCtx, () => clearAllEffects(container, task));
@@ -6429,7 +6491,7 @@ function scheduleTask(_event, element) {
     const container = getDomContainer(element);
     "string" == typeof this && setCaptures(deserializeCaptures(container, this));
     const task = _captures[0];
-    task.$flags$ |= 8, markVNodeDirty(container, task.$el$, 1);
+    task.$flags$ |= 4, markVNodeDirty(container, task.$el$, 1);
 }
 
 const throwIfQRLNotResolved = qrl => {
@@ -6449,7 +6511,7 @@ const ensureContainsBackRef = (array, value) => {
 };
 
 const addQrlToSerializationCtx = (effectSubscriber, container) => {
-    if (container) {
+    if (container?.serializationCtx) {
         const effect = effectSubscriber.consumer;
         const property = effectSubscriber.property;
         let qrl = null;
@@ -6465,7 +6527,7 @@ const scheduleEffects = (container, signal, effects) => {
             const consumer = effectSubscription.consumer;
             const property = effectSubscription.property;
             if (isDev && assertDefined(container, "Container must be defined."), isTask(consumer)) {
-                consumer.$flags$ |= 8, markVNodeDirty(container, consumer.$el$, 1);
+                consumer.$flags$ |= 4, markVNodeDirty(container, consumer.$el$, 1);
             } else if (consumer instanceof SignalImpl) {
                 consumer.invalidate();
             } else if (":" === property) {
@@ -6907,26 +6969,19 @@ function preprocessState(data, container) {
 
 async function _serialize(data) {
     const serializationContext = createSerializationContext(null, null, () => "", () => "", () => {}, new WeakMap);
-    for (const root of data) {
-        serializationContext.$addRoot$(root);
-    }
-    return await serializationContext.$serialize$(), serializationContext.$writer$.toString();
+    return serializationContext.$addRoot$(data), await serializationContext.$serialize$(), 
+    serializationContext.$writer$.toString();
 }
 
 function _deserialize(rawStateData) {
     if (null == rawStateData) {
-        return [];
+        throw new Error("No state data to deserialize");
     }
     const stateData = JSON.parse(rawStateData);
-    if (!Array.isArray(stateData)) {
-        return [];
-    }
-    const container = _createDeserializeContainer(stateData);
-    const output = [];
-    for (let i = 0; i < stateData.length; i += 2) {
-        output[i / 2] = deserializeData(container, stateData[i], stateData[i + 1]);
+    if (!Array.isArray(stateData) || stateData.length < 2 || "number" != typeof stateData[0]) {
+        throw new Error("Invalid state data");
     }
-    return output;
+    return deserializeData(_createDeserializeContainer(stateData), stateData[0], stateData[1]);
 }
 
 function getObjectById(id, stateData) {
@@ -6987,6 +7042,9 @@ const _verifySerializable = (value, seen, ctx, preMessage) => {
                     _verifySerializable(v, seen, ctx + "[" + i + "]"), expectIndex = i + 1;
                 }), value;
             }
+            if (unwrapped.__brand) {
+                return value;
+            }
             if (isSerializableObject(unwrapped)) {
                 for (const [key, item] of Object.entries(unwrapped)) {
                     _verifySerializable(item, seen, ctx + "." + key);
@@ -7545,10 +7603,10 @@ const useVisibleTaskQrl = (qrl, opts) => {
     const {val, set, i, iCtx} = useSequentialScope();
     const eagerness = opts?.strategy ?? "intersection-observer";
     if (val) {
-        return void (64 & val.$flags$ || isServerPlatform() || (val.$flags$ |= 64, useRegisterTaskEvents(val, eagerness)));
+        return void (32 & val.$flags$ || isServerPlatform() || (val.$flags$ |= 32, useRegisterTaskEvents(val, eagerness)));
     }
     let flags;
-    assertQrl(qrl), isServerPlatform() ? flags = 1 : (flags = 9, qrl.resolve(), markVNodeDirty(iCtx.$container$, iCtx.$hostElement$, 1));
+    assertQrl(qrl), isServerPlatform() ? flags = 1 : (flags = 5, qrl.resolve(), markVNodeDirty(iCtx.$container$, iCtx.$hostElement$, 1));
     const task = new Task(flags, i, iCtx.$hostElement$, qrl, void 0, null);
     set(task), useRegisterTaskEvents(task, eagerness);
 };
@@ -7559,7 +7617,7 @@ const useRegisterTaskEvents = (task, eagerness) => {
 
 const getTaskHandlerQrl = task => createQRL(null, "_task", scheduleTask, null, [ task ]);
 
-const useResource$ = (generatorFn, opts) => useResourceQrl(dollar(generatorFn), opts);
+const useResource$ = implicit$FirstArg(useResourceQrl);
 
 const useTask$ = /*#__PURE__*/ implicit$FirstArg(useTaskQrl);
 
@@ -7617,4 +7675,4 @@ globalThis.__qwik = version, import.meta.hot && import.meta.hot.dispose(() => {
     globalThis.__qwik = void 0;
 });
 
-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, _captures, _chk, _deserialize, _dumpState, _executeSsrChores, _fnSignal, _getConstProps, _getContextContainer, _getContextEvent, _getContextHostElement, 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, _serialize, scheduleTask as _task, _val, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getFirstChild as _vnode_getFirstChild, 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, createAsync$, createAsyncSignal as createAsyncQrl, 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, jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useAsync$, useAsyncQrl, 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 };
+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, _captures, _chk, createQRL as _createQRL, _deserialize, _dumpState, _executeSsrChores, _fnSignal, _getConstProps, _getContextContainer, _getContextEvent, _getContextHostElement, 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, qrlToString as _qrlToString, _regSymbol, _res, _resolveContextWithoutSequentialScope, _restProps, _rsc, _run, _serialize, scheduleTask as _task, _val, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getFirstChild as _vnode_getFirstChild, 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, createAsync$, createAsyncSignal as createAsyncQrl, 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, jsxs, noSerialize, qrl, qrlDEV, render, setPlatform, sync$, untrack, unwrapStore, useAsync$, useAsyncQrl, 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 };