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

package/dist/core.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
@@ -14,7 +14,7 @@ import { p } from '@qwik.dev/core/preloader';
  *
  * @public
  */
-const version = "2.0.0-beta.21-dev+c008e88";
+const version = "2.0.0-beta.23-dev+03de42d";
 
 // same as isDev but separate so we can test
 const qDev = globalThis.qDev !== false;
@@ -230,7 +230,6 @@ const MATH_NS = 'http://www.w3.org/1998/Math/MathML';
 // Attributes namespaces
 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';
 /** `<q:slot name="...">` */
@@ -396,11 +395,6 @@ const maybeThen = (valueOrPromise, thenFn) => {
         ? valueOrPromise.then(thenFn)
         : thenFn(valueOrPromise);
 };
-const delay = (timeout) => {
-    return new Promise((resolve) => {
-        setTimeout(resolve, timeout);
-    });
-};
 const checkError = (e) => {
     if (isServer && e instanceof ReferenceError && e.message.includes('window')) {
         e.message = 'It seems like you forgot to add "if (isBrowser) {...}" here:' + e.message;
@@ -577,40 +571,6 @@ const vnode_getElementNamespaceFlags = (element) => {
             return 0 /* VNodeFlags.NS_html */;
     }
 };
-function vnode_getDomChildrenWithCorrectNamespacesToInsert(journal, domParentVNode, newChild) {
-    const { elementNamespace, elementNamespaceFlag } = getNewElementNamespaceData(domParentVNode, newChild);
-    let domChildren = [];
-    if (elementNamespace === HTML_NS) {
-        // parent is in the default namespace, so just get the dom children. This is the fast path.
-        domChildren = vnode_getDOMChildNodes(journal, newChild, true);
-    }
-    else {
-        // parent is in a different namespace, so we need to clone the children with the correct namespace.
-        // The namespace cannot be changed on nodes, so we need to clone these nodes
-        const children = vnode_getDOMChildNodes(journal, newChild, true);
-        for (let i = 0; i < children.length; i++) {
-            const childVNode = children[i];
-            if (vnode_isTextVNode(childVNode)) {
-                // text nodes are always in the default namespace
-                domChildren.push(childVNode);
-                continue;
-            }
-            if ((childVNode.flags & 1536 /* VNodeFlags.NAMESPACE_MASK */) ===
-                (domParentVNode.flags & 1536 /* VNodeFlags.NAMESPACE_MASK */)) {
-                // if the child and parent have the same namespace, we don't need to clone the element
-                domChildren.push(childVNode);
-                continue;
-            }
-            // clone the element with the correct namespace
-            const newChildElement = vnode_cloneElementWithNamespace(childVNode, domParentVNode, elementNamespace, elementNamespaceFlag);
-            if (newChildElement) {
-                childVNode.node = newChildElement;
-                domChildren.push(childVNode);
-            }
-        }
-    }
-    return domChildren;
-}
 /** This function clones an element with a different namespace, including the children */
 function cloneDomTreeWithNamespace(element, elementName, namespace, deep = false) {
     const newElement = element.ownerDocument.createElementNS(namespace, elementName);
@@ -963,8 +923,7 @@ class TextVNode extends VNode {
 const globalCursorQueue = [];
 const pausedCursorQueue = [];
 /**
- * Adds a cursor to the global queue. If the cursor already exists, it's removed and re-added to
- * maintain correct priority order.
+ * Adds a cursor to the global queue.
  *
  * @param cursor - The cursor to add
  */
@@ -979,7 +938,7 @@ function addCursorToQueue(container, cursor) {
         }
     }
     globalCursorQueue.splice(insertIndex, 0, cursor);
-    container.$cursorCount$++;
+    container.$pendingCount$++;
     container.$renderPromise$ ||= new Promise((r) => (container.$resolveRenderPromise$ = r));
 }
 /**
@@ -1007,7 +966,7 @@ function getHighestPriorityCursor() {
 function pauseCursor(cursor, container) {
     pausedCursorQueue.push(cursor);
     removeCursorFromQueue(cursor, container, true);
-    container.$pausedCursorCount$++;
+    container.$pendingCount$++;
 }
 function resumeCursor(cursor, container) {
     const index = pausedCursorQueue.indexOf(cursor);
@@ -1017,7 +976,7 @@ function resumeCursor(cursor, container) {
             pausedCursorQueue[index] = pausedCursorQueue[lastIndex];
         }
         pausedCursorQueue.pop();
-        container.$pausedCursorCount$--;
+        container.$pendingCount$--;
     }
     addCursorToQueue(container, cursor);
 }
@@ -1040,7 +999,7 @@ function removeCursorFromQueue(cursor, container, keepCursorFlag) {
         // }
         // globalCursorQueue.pop();
         globalCursorQueue.splice(index, 1);
-        container.$cursorCount$--;
+        container.$pendingCount$--;
     }
 }
 
@@ -1129,7 +1088,7 @@ class SignalImpl {
     $container$ = null;
     $wrappedSignal$ = null;
     constructor(container, value) {
-        this.$container$ = container;
+        this.$container$ = container || tryGetInvokeContext()?.$container$ || null;
         this.$untrackedValue$ = value;
     }
     /**
@@ -1147,14 +1106,13 @@ class SignalImpl {
         this.$untrackedValue$ = value;
     }
     get value() {
+        // Important: first read, then subscribe. Otherwise, initial compute invalidation will cause the reading subscriber to be marked invalid.
+        const val = this.untrackedValue;
         const ctx = tryGetInvokeContext();
         if (!ctx) {
-            return this.untrackedValue;
+            return val;
         }
         if (this.$container$ === null) {
-            if (!ctx.$container$) {
-                return this.untrackedValue;
-            }
             // Grab the container now we have access to it
             this.$container$ = ctx.$container$;
         }
@@ -1175,7 +1133,7 @@ class SignalImpl {
             (import.meta.env.TEST ? !isDomContainer(this.$container$) : isServer) &&
                 addQrlToSerializationCtx(effectSubscriber, this.$container$);
         }
-        return this.untrackedValue;
+        return val;
     }
     set value(value) {
         if (value !== this.$untrackedValue$) {
@@ -1191,10 +1149,15 @@ class SignalImpl {
     }
     toString() {
         if (isDev) {
-            return (`[${this.constructor.name}${this.$flags$ & 1 /* SignalFlags.INVALID */ ? ' INVALID' : ''} ${String(this.$untrackedValue$)}]` +
-                (Array.from(this.$effects$ || [])
-                    .map((e) => '\n -> ' + pad(qwikDebugToString(e.consumer), '    '))
-                    .join('\n') || ''));
+            try {
+                return (`[${this.constructor.name}${this.$flags$ & 1 /* SignalFlags.INVALID */ ? ' INVALID' : ''} ${this.$untrackedValue$}]` +
+                    (Array.from(this.$effects$ || [])
+                        .map((e) => '\n -> ' + pad(qwikDebugToString(e.consumer), '    '))
+                        .join('\n') || ''));
+            }
+            catch (e) {
+                return `[${this.constructor.name} <cannot stringify>]`;
+            }
         }
         else {
             return this.constructor.name;
@@ -1204,35 +1167,27 @@ class SignalImpl {
         return { value: this.$untrackedValue$ };
     }
 }
-const setupSignalValueAccess = (target, effectsFn, returnValueFn) => {
+const setupSignalValueAccess = (target, effectsProp, valueProp) => {
     const ctx = tryGetInvokeContext();
-    if (!ctx) {
-        return returnValueFn();
-    }
-    if (target.$container$ === null) {
-        if (!ctx.$container$) {
-            return returnValueFn();
-        }
-        // Grab the container now we have access to it
-        target.$container$ = ctx.$container$;
-    }
-    else {
+    // We need a container for this
+    // Grab the container if we have access to it
+    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$;
+        if (effectSubscriber) {
+            // Let's make sure that we have a reference to this effect.
+            // Adding reference is essentially adding a subscription, so if the signal
+            // changes we know who to notify.
+            ensureContainsSubscription((target[effectsProp] ||= new Set()), effectSubscriber);
+            // But when effect is scheduled in needs to be able to know which signals
+            // to unsubscribe from. So we need to store the reference from the effect back
+            // to this signal.
+            ensureContainsBackRef(effectSubscriber, target);
+            addQrlToSerializationCtx(effectSubscriber, target.$container$);
+        }
     }
-    const effectSubscriber = ctx.$effectSubscriber$;
-    if (effectSubscriber) {
-        // Let's make sure that we have a reference to this effect.
-        // Adding reference is essentially adding a subscription, so if the signal
-        // changes we know who to notify.
-        ensureContainsSubscription(effectsFn(), effectSubscriber);
-        // But when effect is scheduled in needs to be able to know which signals
-        // to unsubscribe from. So we need to store the reference from the effect back
-        // to this signal.
-        ensureContainsBackRef(effectSubscriber, target);
-        addQrlToSerializationCtx(effectSubscriber, target.$container$);
-    }
-    return returnValueFn();
+    return target[valueProp];
 };
 
 /** @internal */
@@ -1461,19 +1416,6 @@ const isPropsProxy = (obj) => {
     return obj && _VAR_PROPS in obj;
 };
 
-const cleanupDestroyable = (destroyable) => {
-    const destroy = destroyable.$destroy$;
-    if (destroy) {
-        destroyable.$destroy$ = null;
-        try {
-            destroy();
-        }
-        catch (err) {
-            logError(err);
-        }
-    }
-};
-
 /**
  * # ================================
  *
@@ -1594,14 +1536,19 @@ const trackFn = (target, container) => (obj, prop) => {
         }
     });
 };
+/**
+ * This adds $destroy$ to the target if a cleanup function is registered. It must be called before
+ * running any computations again.
+ */
 const cleanupFn = (target, handleError) => {
     let cleanupFns = null;
     const cleanup = (fn) => {
         if (typeof fn == 'function') {
             if (!cleanupFns) {
                 cleanupFns = [];
-                target.$destroy$ = noSerialize(() => {
+                target.$destroy$ = () => {
                     target.$destroy$ = null;
+                    // TODO handle promises
                     for (const fn of cleanupFns) {
                         try {
                             fn();
@@ -1610,7 +1557,7 @@ const cleanupFn = (target, handleError) => {
                             handleError(err);
                         }
                     }
-                });
+                };
             }
             cleanupFns.push(fn);
         }
@@ -1618,9 +1565,9 @@ const cleanupFn = (target, handleError) => {
     return [cleanup, cleanupFns ?? []];
 };
 
-const DEBUG = false;
+const DEBUG$1 = false;
 // eslint-disable-next-line no-console
-const log = (...args) => console.log('COMPUTED SIGNAL', ...args.map(qwikDebugToString));
+const log$1 = (...args) => console.log('COMPUTED SIGNAL', ...args.map(qwikDebugToString));
 /**
  * A signal which is computed from other signals.
  *
@@ -1643,7 +1590,7 @@ class ComputedSignalImpl extends SignalImpl {
         16 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */) {
         // The value is used for comparison when signals trigger, which can only happen
         // when it was calculated before. Therefore we can pass whatever we like.
-        super(container, NEEDS_COMPUTATION);
+        super(container || fn.$container$, NEEDS_COMPUTATION);
         this.$computeQrl$ = fn;
         this.$flags$ = flags;
     }
@@ -1651,20 +1598,18 @@ class ComputedSignalImpl extends SignalImpl {
         this.$flags$ |= 1 /* SignalFlags.INVALID */;
         const ctx = newInvokeContext();
         ctx.$container$ = this.$container$ || undefined;
-        maybeThen(retryOnPromise(() => invoke.call(this, ctx, this.$computeIfNeeded$)), () => {
-            if (this.$flags$ & 2 /* SignalFlags.RUN_EFFECTS */) {
-                this.$flags$ &= -3 /* SignalFlags.RUN_EFFECTS */;
-                scheduleEffects(this.$container$, this, this.$effects$);
-            }
-        });
-    }
-    /**
-     * Use this to force running subscribers, for example when the calculated value has mutated but
-     * remained the same object
-     */
-    force() {
-        this.$flags$ |= 2 /* SignalFlags.RUN_EFFECTS */;
-        super.force();
+        // @ts-expect-error it's confused about args any[] vs []
+        const running = retryOnPromise(invokeApply.bind(this, ctx, this.$computeIfNeeded$));
+        if (running) {
+            running.catch((err) => {
+                if (this.$container$) {
+                    this.$container$.handleError(err, null);
+                }
+                else {
+                    console.error('Error during computation', err);
+                }
+            });
+        }
     }
     get untrackedValue() {
         this.$computeIfNeeded$();
@@ -1692,16 +1637,9 @@ class ComputedSignalImpl extends SignalImpl {
                     computeQrl.$hash$,
                 ]);
             }
-            DEBUG && log('Signal.$compute$', untrackedValue);
+            DEBUG$1 && log$1('Signal.$compute$', untrackedValue);
             this.$flags$ &= ~1 /* SignalFlags.INVALID */;
-            const didChange = untrackedValue !== this.$untrackedValue$;
-            if (didChange) {
-                // skip first computation when value is not changed
-                if (this.$untrackedValue$ !== NEEDS_COMPUTATION) {
-                    this.$flags$ |= 2 /* SignalFlags.RUN_EFFECTS */;
-                }
-                this.$untrackedValue$ = untrackedValue;
-            }
+            super.value = untrackedValue;
         }
         finally {
             if (ctx) {
@@ -1711,6 +1649,51 @@ class ComputedSignalImpl extends SignalImpl {
     }
 }
 
+/**
+ * Planned features:
+ *
+ * - `eagerCleanup`: boolean - whether to run cleanups eagerly when there are no more subscribers, or
+ *   to wait until the next computation/destroy.
+ */
+const DEBUG = false;
+const log = (...args) => 
+// eslint-disable-next-line no-console
+console.log('ASYNC COMPUTED SIGNAL', ...args.map(qwikDebugToString));
+/** Retains job metadata and also serves as the argument for the compute function */
+class AsyncJob {
+    $signal$;
+    /** First holds the compute promise and then the cleanup promise */
+    $promise$ = null;
+    $cleanupRequested$ = false;
+    $canWrite$ = true;
+    $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;
+    }
+    /** Backward compatible cache method for resource */
+    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) {
+        if (typeof callback === 'function') {
+            (this.$cleanups$ ||= []).push(callback);
+        }
+    }
+}
 /**
  * # ================================
  *
@@ -1723,19 +1706,45 @@ class AsyncSignalImpl extends ComputedSignalImpl {
     $untrackedError$ = undefined;
     $loadingEffects$ = undefined;
     $errorEffects$ = undefined;
-    $destroy$;
-    $promiseValue$ = NEEDS_COMPUTATION;
-    $promise$ = null;
+    $current$ = null;
+    // TODO only create the array if concurrency > 1
+    $jobs$ = [];
+    $concurrency$ = 1;
+    $interval$ = 0;
+    $pollTimeoutId$ = undefined;
+    $timeoutMs$;
+    $computationTimeoutId$;
     [_EFFECT_BACK_REF] = undefined;
-    constructor(container, fn, flags = 1 /* SignalFlags.INVALID */) {
+    constructor(container, fn, flags = 1 /* SignalFlags.INVALID */ |
+        16 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */, 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;
+        // Handle initial value - eagerly evaluate if function, set $untrackedValue$ and $promiseValue$
+        // Do NOT call setValue() which would clear the INVALID flag and prevent async computation
+        if (initial !== undefined) {
+            const initialValue = typeof initial === 'function' ? initial() : initial;
+            this.$untrackedValue$ = initialValue;
+        }
+        this.$concurrency$ = concurrency;
+        this.$timeoutMs$ = timeout;
+        if (eagerCleanup) {
+            this.$flags$ |= 32 /* AsyncSignalFlags.EAGER_CLEANUP */;
+        }
+        this.interval = interval;
     }
     /**
      * Loading is true if the signal is still waiting for the promise to resolve, false if the promise
      * has resolved or rejected.
+     *
+     * Accessing .loading will trigger computation if needed, since it's often used like
+     * `signal.loading ? <Loading /> : signal.value`.
      */
     get loading() {
-        return setupSignalValueAccess(this, () => (this.$loadingEffects$ ||= new Set()), () => this.untrackedLoading);
+        return setupSignalValueAccess(this, '$loadingEffects$', 'untrackedLoading');
     }
     set untrackedLoading(value) {
         if (value !== this.$untrackedLoading$) {
@@ -1744,11 +1753,17 @@ class AsyncSignalImpl extends ComputedSignalImpl {
         }
     }
     get untrackedLoading() {
+        // reading `.loading` means someone is interested in the result, so we should trigger the computation. The alternative is eager computation or imperative calls to invalidate; this seems nicer.
+        this.$computeIfNeeded$();
+        // During SSR there's no such thing as loading state, we must render complete results
+        if ((import.meta.env.TEST ? isServerPlatform() : isServer) && this.$current$?.$promise$) {
+            throw this.$current$?.$promise$;
+        }
         return this.$untrackedLoading$;
     }
     /** The error that occurred when the signal was resolved. */
     get error() {
-        return setupSignalValueAccess(this, () => (this.$errorEffects$ ||= new Set()), () => this.untrackedError);
+        return setupSignalValueAccess(this, '$errorEffects$', 'untrackedError');
     }
     set untrackedError(value) {
         if (value !== this.$untrackedError$) {
@@ -1759,123 +1774,205 @@ class AsyncSignalImpl extends ComputedSignalImpl {
     get untrackedError() {
         return this.$untrackedError$;
     }
-    invalidate() {
-        // clear the promise, we need to get function again
-        this.$promise$ = null;
-        super.invalidate();
+    get interval() {
+        return this.$interval$;
+    }
+    set interval(value) {
+        this.$clearNextPoll$();
+        this.$interval$ = value;
+        if (this.$interval$ > 0 && this.$effects$?.size) {
+            this.$scheduleNextPoll$();
+        }
+    }
+    /** Invalidates the signal, causing it to re-compute its value. */
+    async invalidate() {
+        this.$flags$ |= 1 /* SignalFlags.INVALID */;
+        this.$clearNextPoll$();
+        if (this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size) {
+            // compute in next microtask
+            await true;
+            this.$computeIfNeeded$();
+        }
     }
+    /** Abort the current computation and run cleanups if needed. */
+    abort(reason) {
+        if (this.$current$) {
+            this.$requestCleanups$(this.$current$, reason);
+        }
+    }
+    /** Schedule eager cleanup on next macro task if no subscribers remain. */
+    $scheduleEagerCleanup$() {
+        if (!(this.$flags$ & 32 /* AsyncSignalFlags.EAGER_CLEANUP */) || this.$hasSubscribers$()) {
+            return;
+        }
+        if (!(import.meta.env.TEST ? !isServerPlatform() : isBrowser)) {
+            return;
+        }
+        setTimeout(() => {
+            if (!this.$hasSubscribers$()) {
+                this.abort();
+            }
+        });
+    }
+    /** Returns a promise resolves when the signal finished computing. */
     async promise() {
-        // make sure we get a new promise during the next computation
-        this.$promise$ = null;
-        await retryOnPromise(this.$computeIfNeeded$.bind(this));
-        return this.$untrackedValue$;
+        this.$computeIfNeeded$();
+        // Wait for the current computation to finish, but if we became invalid while running, we need to wait for the new computation instead. So we loop until we are no longer invalid
+        while (this.$current$?.$promise$) {
+            await this.$current$?.$promise$;
+        }
     }
+    /** Run the computation if needed */
     $computeIfNeeded$() {
         if (!(this.$flags$ & 1 /* SignalFlags.INVALID */)) {
             return;
         }
-        const untrackedValue = 
-        // first time
-        this.$promiseValue$ === NEEDS_COMPUTATION ||
-            // or after invalidation
-            this.$promise$ === null
-            ? this.$promiseComputation$()
-            : this.$promiseValue$;
-        if (isPromise(untrackedValue)) {
-            const isFirstComputation = this.$promiseValue$ === NEEDS_COMPUTATION;
-            this.untrackedLoading = true;
-            this.untrackedError = undefined;
-            if (this.$promiseValue$ !== NEEDS_COMPUTATION) {
-                // skip cleanup after resuming
-                cleanupDestroyable(this);
-            }
-            const promise = untrackedValue
-                .then((promiseValue) => {
-                this.$promiseValue$ = promiseValue;
-                this.untrackedLoading = false;
-                this.untrackedError = undefined;
-                if (this.setValue(promiseValue)) {
-                    this.$flags$ &= -3 /* SignalFlags.RUN_EFFECTS */;
-                    scheduleEffects(this.$container$, this, this.$effects$);
-                }
-            })
-                .catch((err) => {
-                if (isPromise(err)) {
-                    // ignore promise errors, they will be handled
-                    return;
+        this.$clearNextPoll$();
+        if (this.$current$) {
+            this.$requestCleanups$(this.$current$);
+        }
+        const limit = this.$concurrency$ === 0 ? Number.POSITIVE_INFINITY : this.$concurrency$;
+        if (this.$jobs$.length >= limit) {
+            // We requested cleanups for all the previous jobs, once one finishes it will be removed from the jobs array and trigger computeIfNeeded
+            return;
+        }
+        this.$flags$ &= -2 /* SignalFlags.INVALID */;
+        // We put the actual computation in a separate method so we can easily retain the promise
+        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 = true;
+        const fn = this.$computeQrl$.resolved || (await this.$computeQrl$.resolve());
+        try {
+            if (this.$timeoutMs$) {
+                this.$computationTimeoutId$ = setTimeout(() => {
+                    running.$abortController$?.abort();
+                    const error = new Error(`timeout`);
+                    if (isCurrent()) {
+                        this.untrackedError = error;
+                        running.$canWrite$ = false;
+                    }
+                }, this.$timeoutMs$);
+            }
+            const value = await retryOnPromise(fn.bind(null, running));
+            running.$promise$ = null;
+            if (running.$canWrite$) {
+                const index = this.$jobs$.indexOf(running);
+                if (index !== -1) {
+                    for (let i = 0; i < index; i++) {
+                        this.$jobs$[i].$canWrite$ = false;
+                    }
                 }
-                this.$promiseValue$ = err;
-                this.untrackedLoading = false;
+                DEBUG && log('Promise resolved', value);
+                // we leave error as-is until result
+                // Note that these assignments run setters
+                this.untrackedError = undefined;
+                this.value = value;
+            }
+        }
+        catch (err) {
+            running.$promise$ = null;
+            if (isCurrent()) {
                 this.untrackedError = err;
-            });
-            if (isFirstComputation) {
-                // we want to throw only the first time
-                // the next time we will return stale value
-                throw promise;
+            }
+        }
+        if (isCurrent()) {
+            clearTimeout(this.$computationTimeoutId$);
+            if (this.$flags$ & 1 /* SignalFlags.INVALID */) {
+                // we became invalid again while running, so we need to re-run the computation to get the new promise
+                this.$computeIfNeeded$();
             }
             else {
-                // Return the promise so the scheduler can track it as a running chore
-                return promise;
+                this.untrackedLoading = false;
+                this.$scheduleNextPoll$();
             }
         }
-        else {
-            this.setValue(untrackedValue);
+    }
+    /** Called after SSR/unmount */
+    async $destroy$() {
+        this.$clearNextPoll$();
+        clearTimeout(this.$computationTimeoutId$);
+        if (this.$current$) {
+            await this.$requestCleanups$(this.$current$);
         }
+        await Promise.all(this.$jobs$.map((job) => job.$promise$));
     }
-    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,
-            });
-            // TODO implement these
-            // const arg: {
-            //   track: Tracker;
-            //   cleanup: ReturnType<typeof cleanupFn>[0];
-            //   poll: (ms: number) => void;
-            // } = {
-            //   poll: (ms: number) => {
-            //     setTimeout(() => {
-            //       super.invalidate();
-            //       if (this.$effects$?.size) {
-            //         this.$computeIfNeeded$();
-            //       }
-            //     }, ms);
-            //   },
-            // } as any;
-            // Object.defineProperty(arg, 'track', {
-            //   get() {
-            //     const fn = trackFn(this, this.$container$);
-            //     arg.track = fn;
-            //     return fn;
-            //   },
-            //   configurable: true,
-            //   enumerable: true,
-            //   writable: true,
-            // });
-            // Object.defineProperty(arg, 'cleanup', {
-            //   get() {
-            //     const [fn] = cleanupFn(this, (err) => this.$container$?.handleError(err, null!));
-            //     arg.cleanup = fn;
-            //     return fn;
-            //   },
-            //   configurable: true,
-            //   enumerable: true,
-            //   writable: true,
-            // });
-            // this.$promise$ = this.$computeQrl$.getFn()(arg) as ValueOrPromise<T>;
-        }
-        return this.$promise$;
-    }
-    setValue(value) {
-        this.$flags$ &= -2 /* SignalFlags.INVALID */;
-        const didChange = value !== this.$untrackedValue$;
-        if (didChange) {
-            this.$untrackedValue$ = value;
-            this.$flags$ |= 2 /* SignalFlags.RUN_EFFECTS */;
+    get untrackedValue() {
+        this.$computeIfNeeded$();
+        if (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.$untrackedValue$;
+    }
+    $clearNextPoll$() {
+        if (this.$pollTimeoutId$ !== undefined) {
+            clearTimeout(this.$pollTimeoutId$);
+            this.$pollTimeoutId$ = undefined;
+        }
+    }
+    $scheduleNextPoll$() {
+        if ((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$ = true;
+        job.$abortController$?.abort(reason);
+        job.$promise$ = Promise.resolve(job.$promise$).then(() => (job.$promise$ = this.$runCleanups$(job)));
+    }
+    /** Clean up and trigger signal compute once complete */
+    async $runCleanups$(job) {
+        const cleanups = job.$cleanups$;
+        if (cleanups?.length) {
+            const onError = (err) => {
+                const handleError = this.$container$?.handleError;
+                if (handleError) {
+                    handleError(err, null);
+                }
+                else {
+                    console.error('Error in async signal cleanup', err);
+                }
+            };
+            // Keep this sync-ish so sync functions run immediately.
+            await Promise.all(cleanups.map((fn) => {
+                try {
+                    const result = fn();
+                    if (isPromise(result)) {
+                        return result.catch(onError);
+                    }
+                }
+                catch (err) {
+                    onError(err);
+                }
+            }));
+            cleanups.length = 0;
+        }
+        // Now trigger compute
+        const jobs = this.$jobs$;
+        const idx = jobs.indexOf(job);
+        if (idx !== -1) {
+            jobs.splice(idx, 1);
         }
-        return didChange;
+        this.$computeIfNeeded$();
     }
 }
 
@@ -1941,6 +2038,7 @@ class SerializerSignalImpl extends ComputedSignalImpl {
             return;
         }
         throwIfQRLNotResolved(this.$computeQrl$);
+        this.$flags$ &= -2 /* SignalFlags.INVALID */;
         let arg = this.$computeQrl$.resolved;
         if (typeof arg === 'function') {
             arg = arg();
@@ -1951,13 +2049,13 @@ class SerializerSignalImpl extends ComputedSignalImpl {
         const untrackedValue = trackSignal(() => this.$didInitialize$
             ? update?.(currentValue) || currentValue
             : deserialize(currentValue), this, "." /* EffectProperty.VNODE */, this.$container$);
+        this.$didInitialize$ = true;
+        // We allow forcing the update of the signal without changing the value, for example when the deserialized value is the same reference as the old value but its internals have changed. In that case we want to trigger effects that depend on this signal, even though the value is the same.
         const didChange = (this.$didInitialize$ && untrackedValue !== 'undefined') ||
             untrackedValue !== this.$untrackedValue$;
-        this.$flags$ &= -2 /* SignalFlags.INVALID */;
-        this.$didInitialize$ = true;
         if (didChange) {
-            this.$flags$ |= 2 /* SignalFlags.RUN_EFFECTS */;
             this.$untrackedValue$ = untrackedValue;
+            scheduleEffects(this.$container$, this, this.$effects$);
         }
     }
 }
@@ -1972,7 +2070,7 @@ const createComputedSignal = (qrl, options) => {
 };
 /** @internal */
 const createAsyncSignal = (qrl, options) => {
-    return new AsyncSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || 'never'));
+    return new AsyncSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || 'always'), options);
 };
 /** @internal */
 const createSerializerSignal = (arg) => {
@@ -1994,23 +2092,18 @@ const createSignal = createSignal$1;
  * The QRL must be a function which returns the value of the signal. The function must not have side
  * effects, and it must be synchronous.
  *
- * If you need the function to be async, use `useAsync$` instead.
+ * If you need the function to be async, use `createAsync$` instead (don't forget to use `track()`).
  *
  * @public
  */
 const createComputed$ = /*#__PURE__*/ implicit$FirstArg(createComputedSignal);
 /**
- * Create an async computed signal which is calculated from the given QRL. A computed signal is a
- * signal which is calculated from other signals or async operation. When the signals change, the
- * computed signal is recalculated.
- *
- * The QRL must be a function which returns the value of the signal. The function must not have side
- * effects, and it can be async.
+ * Create a signal holding a `.value` which is calculated from the given async function (QRL). The
+ * standalone version of `useAsync$`.
  *
  * @public
  */
-const createAsync$ = 
-/*#__PURE__*/ implicit$FirstArg(createAsyncSignal);
+const createAsync$ = /*#__PURE__*/ implicit$FirstArg(createAsyncSignal);
 /**
  * Create a signal that holds a custom serializable value. See {@link useSerializer$} for more
  * details.
@@ -2135,17 +2228,6 @@ class WrappedSignalImpl extends SignalImpl {
             scheduleEffects(this.$container$, this, this.$effects$);
         }
     }
-    /**
-     * Use this to force running subscribers, for example when the calculated value has mutated but
-     * remained the same object.
-     */
-    force() {
-        this.$flags$ |= 2 /* SignalFlags.RUN_EFFECTS */;
-        if (this.$container$ && this.$hostElement$) {
-            this.$container$.setHostProp(this.$hostElement$, HOST_SIGNAL, this);
-            markVNodeDirty(this.$container$, this.$hostElement$, 16 /* ChoreBits.COMPUTE */);
-        }
-    }
     get untrackedValue() {
         this.$computeIfNeeded$();
         isDev && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, 'Invalid state');
@@ -2243,6 +2325,11 @@ function clearAsyncSignal(producer, effect) {
     if (pendingEffects && pendingEffects.has(effect)) {
         pendingEffects.delete(effect);
     }
+    const errorEffects = producer.$errorEffects$;
+    if (errorEffects && errorEffects.has(effect)) {
+        errorEffects.delete(effect);
+    }
+    producer.$scheduleEagerCleanup$();
 }
 function clearStoreOrProps(producer, effect) {
     const effects = producer?.$effects$;
@@ -2298,6 +2385,25 @@ function _chk(_, element) {
     const signal = _captures[0];
     signal.value = element.checked;
 }
+/**
+ * Resumes selected state (e.g. polling AsyncSignals) by deserializing captures. Used for
+ * document:onQIdle to resume async signals with active polling.
+ *
+ * @internal
+ */
+function _res(_, element) {
+    maybeScopeFromQL(this, element);
+    // Captures are deserialized, signals are now resumed
+}
+
+const isObjectEmpty = (obj) => {
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            return false;
+        }
+    }
+    return true;
+};
 
 const _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
 // TODO store props as the arrays the vnodes also use?
@@ -2315,8 +2421,8 @@ class JSXNodeImpl {
         this.children = children;
         this.toSort = !!toSort;
         this.key = key === null || key === undefined ? null : typeof key === 'string' ? 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;
         if (qDev && dev) {
             this.dev = {
                 ...dev,
@@ -2365,9 +2471,6 @@ const isJSXNode = (n) => {
         return n instanceof JSXNodeImpl;
     }
 };
-const isEmpty = (obj) => {
-    return Object.keys(obj).length === 0;
-};
 
 const BIND_VALUE = 'bind:value';
 const BIND_CHECKED = 'bind:checked';
@@ -2811,7 +2914,7 @@ function addUseOnEvent(jsxElement, key, value) {
         props[key] = undefined;
     }
 }
-const getValue$1 = (o) => o.value;
+const getValue = (o) => o.value;
 /**
  * Finds the first element node in the JSX output.
  *
@@ -2835,7 +2938,7 @@ function findFirstElementNode(jsx) {
             return maybeThen(jsx, (jsx) => findFirstElementNode(jsx));
         }
         else if (isSignal(jsx)) {
-            return findFirstElementNode(untrack(getValue$1, jsx));
+            return findFirstElementNode(untrack(getValue, jsx));
         }
     }
     return null;
@@ -3263,6 +3366,18 @@ const createSetTextOperation = (target, text) => new SetTextOperation(target, te
 const createInsertOrMoveOperation = (target, parent, beforeTarget) => new InsertOrMoveOperation(target, parent, beforeTarget);
 const createSetAttributeOperation = (target, attrName, attrValue, scopedStyleIdPrefix = null, isSvg = false) => new SetAttributeOperation(target, attrName, attrValue, scopedStyleIdPrefix, isSvg);
 
+const cleanupDestroyable = (destroyable) => {
+    if (destroyable.$destroy$) {
+        try {
+            destroyable.$destroy$();
+        }
+        catch (err) {
+            logError(err);
+        }
+        destroyable.$destroy$ = null;
+    }
+};
+
 /**
  * This safely calls an event handler, handling errors and retrying on thrown Promises, and
  * providing extra parameters defined on the elements as arguments (used for loop optimization)
@@ -3747,25 +3862,24 @@ function expectSlot(diffContext) {
         )
         : null;
     if (vProjectedNode == null) {
-        // Nothing to project, so render content of the slot.
-        vnode_insertBefore(diffContext.journal, diffContext.vParent, (diffContext.vNewNode = vnode_newVirtual()), diffContext.vCurrent && getInsertBefore(diffContext));
+        diffContext.vNewNode = vnode_newVirtual();
         vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey);
         vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
         isDev &&
-            vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* VirtualType.Projection */);
-        isDev && vnode_setProp(diffContext.vNewNode, 'q:code', 'expectSlot' + count++);
+            vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* VirtualType.Projection */); // Nothing to project, so render content of the slot.
+        vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent && getInsertBefore(diffContext));
         return false;
     }
     else if (vProjectedNode === diffContext.vCurrent) ;
     else {
         // move from q:template to the target node
         const oldParent = vProjectedNode.parent;
-        vnode_insertBefore(diffContext.journal, diffContext.vParent, (diffContext.vNewNode = vProjectedNode), diffContext.vCurrent && getInsertBefore(diffContext));
+        diffContext.vNewNode = vProjectedNode;
         vnode_setProp(diffContext.vNewNode, QSlot, slotNameKey);
         vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
         isDev &&
             vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* VirtualType.Projection */);
-        isDev && vnode_setProp(diffContext.vNewNode, 'q:code', 'expectSlot' + count++);
+        vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent && getInsertBefore(diffContext));
         // If we moved from a q:template and it's now empty, remove it
         if (oldParent &&
             vnode_isElementVNode(oldParent) &&
@@ -3942,20 +4056,34 @@ function createNewElement(diffContext, jsx, elementName, currentFile) {
             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);
-    if (!Array.isArray(value)) {
-        value = [value];
-    }
-    const handlers = [];
-    for (const handler of value.flat(2)) {
-        if (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];
+                    if (handler) {
+                        handlers.push(runEventHandlerQRL.bind(null, handler));
+                    }
+                }
+            }
+            else if (item) {
+                handlers.push(runEventHandlerQRL.bind(null, item));
+            }
         }
+        (element._qDispatch ||= {})[scopedKebabName] = handlers;
+    }
+    else if (value) {
+        (element._qDispatch ||= {})[scopedKebabName] = [
+            runEventHandlerQRL.bind(null, value),
+        ];
     }
-    (element._qDispatch ||= {})[scopedKebabName] = handlers;
     // window and document events need attrs so qwik loader can find them
     // TODO only do these when not already present
     if (key.charAt(2) !== 'e') {
@@ -4274,13 +4402,13 @@ function expectVirtual(diffContext, type, jsxKey) {
     }
     // For fragments without a key, always create a new virtual node (ensures rerender semantics)
     if (jsxKey === null || diffContext.isCreationMode) {
-        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));
         diffContext.vNewNode.key = jsxKey;
         isDev && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
         return;
     }
     if (moveOrCreateKeyedNode(diffContext, null, jsxKey, getSideBufferKey(null, jsxKey), diffContext.vParent, true)) {
-        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));
         diffContext.vNewNode.key = jsxKey;
         isDev && vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, type);
     }
@@ -4374,7 +4502,7 @@ function insertNewComponent(diffContext, host, componentQRL, jsxProps) {
     if (host) {
         clearAllEffects(diffContext.container, host);
     }
-    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, DEBUG_TYPE, "C" /* VirtualType.Component */);
     vnode_setProp(diffContext.vNewNode, OnRenderProp, componentQRL);
@@ -4382,7 +4510,7 @@ function insertNewComponent(diffContext, host, componentQRL, 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, DEBUG_TYPE, "I" /* VirtualType.InlineComponent */);
@@ -4402,7 +4530,7 @@ function expectText(diffContext, text) {
             return;
         }
     }
-    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);
 }
 /**
  * Retrieve the key from the VNode.
@@ -4531,7 +4659,7 @@ function isPropsEmpty(props) {
     if (!props) {
         return true;
     }
-    return Object.keys(props).length === 0;
+    return isObjectEmpty(props);
 }
 /**
  * If vnode is removed, it is necessary to release all subscriptions associated with it.
@@ -4570,7 +4698,7 @@ function cleanup(container, journal, vNode, cursorRoot = null) {
                         if (isObject(obj)) {
                             const objIsTask = isTask(obj);
                             if (objIsTask && obj.$flags$ & 1 /* TaskFlags.VISIBLE_TASK */) {
-                                obj.$flags$ |= 32 /* TaskFlags.NEEDS_CLEANUP */;
+                                obj.$flags$ |= 16 /* TaskFlags.NEEDS_CLEANUP */;
                                 markVNodeDirty(container, vCursor, 64 /* ChoreBits.CLEANUP */, cursorRoot);
                                 // don't call cleanupDestroyable yet, do it by the scheduler
                                 continue;
@@ -4724,281 +4852,6 @@ function containsWrappedSignal(data, signal) {
     }
     return false;
 }
-let count = 0;
-
-/**
- * @internal
- * The storage provider for hooks. Each invocation increases index i. Data is stored in an array.
- */
-const useSequentialScope = () => {
-    const iCtx = useInvokeContext();
-    const hostElement = iCtx.$hostElement$;
-    const host = hostElement;
-    let seq = iCtx.$container$.getHostProp(host, ELEMENT_SEQ);
-    if (seq === null) {
-        seq = [];
-        iCtx.$container$.setHostProp(host, ELEMENT_SEQ, seq);
-    }
-    let seqIdx = iCtx.$container$.getHostProp(host, ELEMENT_SEQ_IDX);
-    if (seqIdx === null) {
-        seqIdx = 0;
-    }
-    iCtx.$container$.setHostProp(host, ELEMENT_SEQ_IDX, seqIdx + 1);
-    while (seq.length <= seqIdx) {
-        seq.push(undefined);
-    }
-    const set = (value) => {
-        if (qDev && qSerialize) {
-            verifySerializable(value);
-        }
-        return (seq[seqIdx] = value);
-    };
-    return {
-        val: seq[seqIdx],
-        set,
-        i: seqIdx,
-        iCtx,
-    };
-};
-
-/** @internal */
-const useResourceQrl = (qrl, opts) => {
-    const { val, set, i, iCtx } = useSequentialScope();
-    if (val != null) {
-        return val.$state$;
-    }
-    assertQrl(qrl);
-    const container = iCtx.$container$;
-    const resource = createResourceReturn(container, opts);
-    const el = iCtx.$hostElement$;
-    const task = new Task(8 /* TaskFlags.DIRTY */ | 4 /* TaskFlags.RESOURCE */, i, el, qrl, resource, null);
-    set(task);
-    runResource(task, container, el);
-    return resource;
-};
-// <docs markdown="../readme.md#useResource">
-// !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
-// (edit ../readme.md#useResource instead and run `pnpm docs.sync`)
-/**
- * This method works like an async memoized function that runs whenever some tracked value changes
- * and returns some data.
- *
- * `useResource` however returns immediate a `ResourceReturn` object that contains the data and a
- * state that indicates if the data is available or not.
- *
- * The status can be one of the following:
- *
- * - `pending` - the data is not yet available.
- * - `resolved` - the data is available.
- * - `rejected` - the data is not available due to an error or timeout.
- *
- * Be careful when using a `try/catch` statement in `useResource$`. If you catch the error and don't
- * re-throw it (or a new Error), the resource status will never be `rejected`.
- *
- * ### Example
- *
- * Example showing how `useResource` to perform a fetch to request the weather, whenever the input
- * city name changes.
- *
- * ```tsx
- * const Cmp = component$(() => {
- *   const cityS = useSignal('');
- *
- *   const weatherResource = useResource$(async ({ track, cleanup }) => {
- *     const cityName = track(cityS);
- *     const abortController = new AbortController();
- *     cleanup(() => abortController.abort('cleanup'));
- *     const res = await fetch(`http://weatherdata.com?city=${cityName}`, {
- *       signal: abortController.signal,
- *     });
- *     const data = await res.json();
- *     return data as { temp: number };
- *   });
- *
- *   return (
- *     <div>
- *       <input name="city" bind:value={cityS} />
- *       <Resource
- *         value={weatherResource}
- *         onResolved={(weather) => {
- *           return <div>Temperature: {weather.temp}</div>;
- *         }}
- *       />
- *     </div>
- *   );
- * });
- * ```
- *
- * @public
- * @see Resource
- * @see ResourceReturn
- */
-// </docs>
-const Resource = (props) => {
-    // Resource path
-    return _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)) {
-        // create a subscription for the resource._state changes
-        const state = resource._state;
-        const isBrowser = !isServerPlatform();
-        if (isBrowser) {
-            if (state === 'pending' && props.onPending) {
-                resource.value.catch(() => { });
-                return Promise.resolve().then(useBindInvokeContext(props.onPending));
-            }
-            else if (state === 'rejected' && props.onRejected) {
-                return Promise.resolve(resource._error).then(useBindInvokeContext(props.onRejected));
-            }
-            else {
-                const resolvedValue = untrack(getResolved, resource);
-                if (resolvedValue !== undefined) {
-                    // resolved, pending without onPending prop or rejected without onRejected prop
-                    return Promise.resolve(resolvedValue).then(useBindInvokeContext(props.onResolved));
-                }
-            }
-        }
-        return untrack(getValue, resource).then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
-    }
-    else if (isPromise(resource)) {
-        return resource.then(useBindInvokeContext(props.onResolved), useBindInvokeContext(props.onRejected));
-    }
-    else if (isSignal(resource)) {
-        const value = retryOnPromise(() => resource.value);
-        const promise = isPromise(value) ? value : Promise.resolve(value);
-        return promise.then(useBindInvokeContext(props.onResolved));
-    }
-    else {
-        return Promise.resolve(resource).then(useBindInvokeContext(props.onResolved));
-    }
-}
-const _createResourceReturn = (opts) => {
-    const resource = {
-        __brand: 'resource',
-        value: undefined,
-        loading: !isServerPlatform(),
-        _resolved: undefined,
-        _error: undefined,
-        _state: 'pending',
-        _timeout: opts?.timeout ?? -1,
-        _cache: 0,
-        _generation: 0,
-    };
-    return resource;
-};
-const createResourceReturn = (container, opts, initialPromise) => {
-    const result = _createResourceReturn(opts);
-    result.value = initialPromise;
-    return createStore(container, result, 1 /* StoreFlags.RECURSIVE */);
-};
-const isResourceReturn = (obj) => {
-    return isObject(obj) && (getStoreTarget(obj) || obj).__brand === 'resource';
-};
-const runResource = (task, container, host) => {
-    task.$flags$ &= -9 /* TaskFlags.DIRTY */;
-    cleanupDestroyable(task);
-    const iCtx = newInvokeContext(container.$locale$, host, ResourceEvent);
-    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;
-            if (policy === 'immutable') {
-                milliseconds = Infinity;
-            }
-            else {
-                milliseconds = policy;
-            }
-            resource._cache = milliseconds;
-        },
-        previous: resourceTarget._resolved,
-    };
-    let resolve;
-    let reject;
-    let done = false;
-    // Increment generation to track this execution
-    const currentGeneration = ++resourceTarget._generation;
-    const setState = (resolved, value) => {
-        // Ignore results from outdated executions
-        if (done || resourceTarget._generation !== currentGeneration) {
-            return false;
-        }
-        done = true;
-        if (resolved) {
-            resourceTarget.loading = false;
-            resourceTarget._state = 'resolved';
-            resourceTarget._resolved = value;
-            resourceTarget._error = undefined;
-            resolve(value);
-        }
-        else {
-            resourceTarget.loading = false;
-            resourceTarget._state = 'rejected';
-            resourceTarget._error = value;
-            reject(value);
-        }
-        if (!isServerPlatform()) {
-            forceStoreEffects(resource, '_state');
-        }
-        return true;
-    };
-    /**
-     * Add cleanup to resolve the resource if we are trying to run the same resource again while the
-     * previous one is not resolved yet. The next `runResource` run will call this cleanup
-     */
-    cleanups.push(() => {
-        if (untrack(getLoading, resource) === true) {
-            const value = untrack(getResolved, resource);
-            setState(true, value);
-        }
-    });
-    // Execute mutation inside empty invocation
-    // TODO: is it right? why we need to invoke inside context and trigger effects?
-    invoke(iCtx, () => {
-        // console.log('RESOURCE.pending: ');
-        resource._state = 'pending';
-        resource.loading = !isServerPlatform();
-        resource.value = new Promise((r, re) => {
-            resolve = r;
-            reject = re;
-        });
-    });
-    const promise = safeCall(() => taskFn(opts), (value) => {
-        setState(true, value);
-    }, (err) => {
-        if (isPromise(err)) {
-            return err.then(() => runResource(task, container, host));
-        }
-        else {
-            setState(false, err);
-        }
-    });
-    const timeout = resourceTarget._timeout;
-    if (timeout > 0) {
-        return Promise.race([
-            promise,
-            delay(timeout).then(() => {
-                if (setState(false, new Error('timeout'))) {
-                    cleanupDestroyable(task);
-                }
-            }),
-        ]);
-    }
-    return promise;
-};
 
 /**
  * Executes tasks for a vNode if the TASKS dirty bit is set. Tasks are stored in the ELEMENT_SEQ
@@ -5030,21 +4883,16 @@ function executeTasks(vNode, container, cursorData) {
         if (item instanceof Task) {
             const task = item;
             // Skip if task is not dirty
-            if (!(task.$flags$ & 8 /* TaskFlags.DIRTY */)) {
+            if (!(task.$flags$ & 4 /* TaskFlags.DIRTY */)) {
                 continue;
             }
-            // Check if it's a resource
-            if (task.$flags$ & 4 /* TaskFlags.RESOURCE */) {
-                // Resources: just run, don't save promise anywhere
-                runResource(task, container, vNode);
-            }
-            else if (task.$flags$ & 1 /* TaskFlags.VISIBLE_TASK */) {
+            if (task.$flags$ & 1 /* TaskFlags.VISIBLE_TASK */) {
                 // VisibleTasks: store for execution after flush (don't execute now)
                 (cursorData.afterFlushTasks ||= []).push(task);
             }
             else {
                 // Regular tasks: chain promises only between each other
-                const isRenderBlocking = !!(task.$flags$ & 16 /* TaskFlags.RENDER_BLOCKING */);
+                const isRenderBlocking = !!(task.$flags$ & 8 /* TaskFlags.RENDER_BLOCKING */);
                 const result = runTask(task, container, vNode);
                 if (isPromise(result)) {
                     if (isRenderBlocking) {
@@ -5204,8 +5052,8 @@ function executeCleanup(vNode, container) {
     }
     for (const item of elementSeq) {
         if (item instanceof Task) {
-            if (item.$flags$ & 32 /* TaskFlags.NEEDS_CLEANUP */) {
-                item.$flags$ &= -33 /* TaskFlags.NEEDS_CLEANUP */;
+            if (item.$flags$ & 16 /* TaskFlags.NEEDS_CLEANUP */) {
+                item.$flags$ &= -17 /* TaskFlags.NEEDS_CLEANUP */;
                 const task = item;
                 cleanupDestroyable(task);
             }
@@ -5273,8 +5121,8 @@ function _flushJournal(journal) {
             else {
                 const doc = batchParent.ownerDocument || batchParent;
                 const fragment = doc.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);
             }
@@ -5284,7 +5132,8 @@ function _flushJournal(journal) {
             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) {
                 if (!batchNodes) {
@@ -5642,12 +5491,7 @@ function finishWalk(container, cursor, cursorData, isServer) {
     }
 }
 function resolveCursor(container) {
-    // TODO streaming as a cursor? otherwise we need to wait separately for it
-    // or just ignore and resolve manually
-    if (container.$cursorCount$ === 0 && container.$pausedCursorCount$ === 0) {
-        container.$resolveRenderPromise$();
-        container.$renderPromise$ = null;
-    }
+    container.$checkPendingCount$();
 }
 /**
  * Partitions dirtyChildren array so non-projections come first, projections last. Uses in-place
@@ -5820,17 +5664,10 @@ function executeTasksChore(container, ssrNode) {
         if (item instanceof Task) {
             const task = item;
             // Skip if task is not dirty
-            if (!(task.$flags$ & 8 /* TaskFlags.DIRTY */)) {
+            if (!(task.$flags$ & 4 /* TaskFlags.DIRTY */)) {
                 continue;
             }
-            let result;
-            // Check if it's a resource
-            if (task.$flags$ & 4 /* TaskFlags.RESOURCE */) {
-                result = runResource(task, container, ssrNode);
-            }
-            else {
-                result = runTask(task, container, ssrNode);
-            }
+            const result = runTask(task, container, ssrNode);
             promise = promise ? promise.then(() => result) : result;
         }
     }
@@ -6334,6 +6171,24 @@ function registerQrlHandlers(attr, key, container, element) {
     });
     (element._qDispatch ||= {})[scopedKebabName] = handlers;
 }
+/** Walks the direct children of a parent node and calls the callback for each child. */
+function vnode_walkDirectChildren(journal, vParent, callback) {
+    let vNode = vnode_getFirstChild(vParent);
+    while (vNode) {
+        if (vnode_isTextVNode(vNode)) {
+            vnode_ensureTextInflated(journal, vNode);
+            callback(vNode, vParent);
+        }
+        else if (vnode_isElementVNode(vNode)) {
+            callback(vNode, vParent);
+        }
+        else {
+            // for virtual nodes, we need to walk their children
+            vnode_walkDirectChildren(journal, vNode, callback);
+        }
+        vNode = vNode.nextSibling;
+    }
+}
 /** Walks the VNode tree and materialize it using `vnode_getFirstChild`. */
 function vnode_walkVNode(vNode, callback) {
     let vCursor = vNode;
@@ -6383,52 +6238,15 @@ function vnode_walkVNode(vNode, callback) {
         }
     } while (true);
 }
-function vnode_getDOMChildNodes(journal, root, isVNode = false, childNodes = []) {
-    if (vnode_isElementOrTextVNode(root)) {
-        if (vnode_isTextVNode(root)) {
-            /**
-             * If we are collecting text nodes, we need to ensure that they are inflated. If not inflated
-             * we would return a single text node which represents many actual text nodes, or removing a
-             * single text node would remove many text nodes.
-             */
-            vnode_ensureTextInflated(journal, root);
-        }
-        childNodes.push(isVNode ? root : vnode_getNode(root));
-        return childNodes;
-    }
-    let vNode = vnode_getFirstChild(root);
-    while (vNode) {
-        if (vnode_isElementVNode(vNode)) {
-            childNodes.push(isVNode ? vNode : vnode_getNode(vNode));
-        }
-        else if (vnode_isTextVNode(vNode)) {
-            /**
-             * If we are collecting text nodes, we need to ensure that they are inflated. If not inflated
-             * we would return a single text node which represents many actual text nodes, or removing a
-             * single text node would remove many text nodes.
-             */
-            vnode_ensureTextInflated(journal, vNode);
-            childNodes.push(isVNode ? vNode : vnode_getNode(vNode));
-        }
-        else {
-            isVNode
-                ? vnode_getDOMChildNodes(journal, vNode, true, childNodes)
-                : vnode_getDOMChildNodes(journal, vNode, false, childNodes);
-        }
-        vNode = vNode.nextSibling;
-    }
-    return childNodes;
-}
 function vnode_getDOMContainer(vNode) {
     let cursor = vNode;
     while (cursor) {
         if (vnode_isElementVNode(cursor)) {
-            try {
-                return getDomContainer(cursor.node);
-            }
-            catch {
+            const qContainerElement = _getQContainerElement(cursor.node);
+            if (!qContainerElement) {
                 return null;
             }
+            return getDomContainerFromQContainerElement(qContainerElement);
         }
         cursor = cursor.parent;
     }
@@ -6696,27 +6514,71 @@ const indexOfAlphanumeric = (id, length) => {
             idx++;
         }
         else {
-            return idx;
+            return idx;
+        }
+    }
+    return length;
+};
+const vnode_createErrorDiv = (journal, document, host, err) => {
+    const errorDiv = document.createElement('errored-host');
+    if (err && err instanceof Error) {
+        errorDiv.props = { error: err };
+    }
+    errorDiv.setAttribute('q:key', '_error_');
+    const vErrorDiv = vnode_newElement(errorDiv, 'errored-host');
+    if (vnode_isElementOrTextVNode(host)) {
+        vnode_insertBefore(journal, vErrorDiv, host, null);
+    }
+    else {
+        // first collect all the children, we can't move them while walking the children
+        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_insertElementBefore = (journal, parent, newChild, insertBefore) => {
+    ensureElementOrVirtualVNode(parent);
+    const parentIsElement = vnode_isElementVNode(parent);
+    if (parentIsElement) {
+        ensureMaterialized(parent);
+    }
+    const newChildCurrentParent = newChild.parent;
+    if (newChild === insertBefore) {
+        // invalid insertBefore. We can't insert before self reference
+        // prevent infinity loop and putting self reference to next sibling
+        if (newChildCurrentParent) {
+            // early return, as the newChild is already in the tree and we are already in the correct position
+            return;
+        }
+        else {
+            // if the newChild is not in the tree, than we insert it at the end of the list
+            insertBefore = null;
         }
     }
-    return length;
-};
-const vnode_createErrorDiv = (journal, document, host, err) => {
-    const errorDiv = document.createElement('errored-host');
-    if (err && err instanceof Error) {
-        errorDiv.props = { error: err };
+    vnode_unlinkFromOldParent(journal, newChildCurrentParent, parent, newChild);
+    const childNode = newChild.node;
+    const parentIsDeleted = parent.flags & 32 /* VNodeFlags.Deleted */;
+    const parentNode = parentIsElement ? parent.node : vnode_getDomParent(parent, false);
+    if (parentNode && !parentIsDeleted) {
+        addVNodeOperation(journal, createInsertOrMoveOperation(childNode, parentNode, vnode_findInsertBefore(journal, parent, insertBefore)?.node ?? null));
+    }
+    // link newChild into the previous/next list
+    vnode_connectSiblings(parent, newChild, insertBefore);
+    if (parentIsDeleted) {
+        // if the parent is deleted, then the new child is also deleted
+        newChild.flags |= 32 /* VNodeFlags.Deleted */;
     }
-    errorDiv.setAttribute('q:key', '_error_');
-    const vErrorDiv = vnode_newElement(errorDiv, 'errored-host');
-    vnode_getDOMChildNodes(journal, host, true).forEach((child) => {
-        vnode_insertBefore(journal, vErrorDiv, child, null);
-    });
-    return vErrorDiv;
 };
-//////////////////////////////////////////////////////////////////////////////////////////////////////
-const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
+const vnode_insertVirtualBefore = (journal, parent, newChild, insertBefore) => {
     ensureElementOrVirtualVNode(parent);
-    if (vnode_isElementVNode(parent)) {
+    const parentIsElement = vnode_isElementVNode(parent);
+    if (parentIsElement) {
         ensureMaterialized(parent);
     }
     const newChildCurrentParent = newChild.parent;
@@ -6732,32 +6594,106 @@ const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
             insertBefore = null;
         }
     }
-    /**
-     * Find the parent node and the dom children with the correct namespaces before we unlink the
-     * previous node. If we don't do this, we will end up with situations where we inflate text nodes
-     * from shared text node not correctly.
-     *
-     * Example:
-     *
-     * ```
-     * <Component>
-     *   <Projection>a</Projection>
-     *   <Projection>b</Projection>
-     * </Component>
-     * ```
-     *
-     * Projection nodes are virtual nodes, so they don't have a dom parent. They will be written to
-     * the q:template element if not visible at the start. Inside the q:template element, the
-     * projection nodes will be streamed as single text node "ab". We need to split it, but if we
-     * unlink the previous or next sibling, we don't know that after "a" node is "b". So we need to
-     * find children first (and inflate them).
-     */
-    const domParentVNode = vnode_getDomParentVNode(parent, false);
-    const parentNode = domParentVNode && domParentVNode.node;
-    let domChildren = null;
-    if (domParentVNode) {
-        domChildren = vnode_getDomChildrenWithCorrectNamespacesToInsert(journal, domParentVNode, newChild);
+    vnode_unlinkFromOldParent(journal, newChildCurrentParent, parent, newChild);
+    const parentIsDeleted = parent.flags & 32 /* VNodeFlags.Deleted */;
+    const domParentVNode = parentIsElement ? parent : vnode_getDomParentVNode(parent, false);
+    const parentNode = domParentVNode?.node;
+    const adjustedInsertBefore = vnode_findInsertBefore(journal, parent, insertBefore);
+    const adjustedInsertBeforeNode = adjustedInsertBefore?.node ?? null;
+    const isProjection = vnode_isProjection(newChild);
+    if (isProjection && domParentVNode && (domParentVNode.flags & 1536 /* VNodeFlags.NAMESPACE_MASK */) !== 0) {
+        const domParentVNode = vnode_getDomParentVNode(parent, false);
+        const adjustedInsertBeforeNode = vnode_findInsertBefore(journal, parent, insertBefore)?.node ?? null;
+        /**
+         * Find the parent node and the dom children with the correct namespaces before we unlink the
+         * previous node. If we don't do this, we will end up with situations where we inflate text
+         * nodes from shared text node not correctly.
+         *
+         * Example:
+         *
+         * ```
+         * <Component>
+         *   <Projection>a</Projection>
+         *   <Projection>b</Projection>
+         * </Component>
+         * ```
+         *
+         * Projection nodes are virtual nodes, so they don't have a dom parent. They will be written to
+         * the q:template element if not visible at the start. Inside the q:template element, the
+         * projection nodes will be streamed as single text node "ab". We need to split it, but if we
+         * unlink the previous or next sibling, we don't know that after "a" node is "b". So we need to
+         * find children first (and inflate them).
+         */
+        const { elementNamespace, elementNamespaceFlag } = getNewElementNamespaceData(domParentVNode, newChild);
+        vnode_walkDirectChildren(journal, newChild, (vNode) => {
+            if (vnode_isTextVNode(vNode)) {
+                addVNodeOperation(journal, createInsertOrMoveOperation(vNode.node, parentNode, adjustedInsertBeforeNode));
+            }
+            else {
+                if ((vNode.flags & 1536 /* VNodeFlags.NAMESPACE_MASK */) !== elementNamespaceFlag) {
+                    const newChildElement = vnode_cloneElementWithNamespace(vNode, domParentVNode, elementNamespace, elementNamespaceFlag);
+                    if (newChildElement) {
+                        vNode.node = newChildElement;
+                    }
+                }
+                addVNodeOperation(journal, createInsertOrMoveOperation(vNode.node, parentNode, adjustedInsertBeforeNode));
+            }
+        });
+    }
+    else if (
+    // for projection there can be no parent node
+    parentNode &&
+        !parentIsDeleted) {
+        vnode_walkDirectChildren(journal, newChild, (vNode) => {
+            addVNodeOperation(journal, createInsertOrMoveOperation(vNode.node, parentNode, adjustedInsertBeforeNode));
+        });
+    }
+    vnode_connectSiblings(parent, newChild, insertBefore);
+    if (parentIsDeleted) {
+        // if the parent is deleted, then the new child is also deleted
+        newChild.flags |= 32 /* VNodeFlags.Deleted */;
+    }
+};
+const vnode_findInsertBefore = (journal, parent, insertBefore) => {
+    let adjustedInsertBefore = null;
+    if (insertBefore == null) {
+        if (vnode_isVirtualVNode(parent)) {
+            // If `insertBefore` is null, than we need to insert at the end of the list.
+            // Well, not quite. If the parent is a virtual node, our "last node" is not the same
+            // as the DOM "last node". So in that case we need to look for the "next node" from
+            // our parent.
+            adjustedInsertBefore = vnode_getDomSibling(parent, true, false);
+        }
+    }
+    else if (vnode_isVirtualVNode(insertBefore)) {
+        // If the `insertBefore` is virtual, than we need to descend into the virtual and find e actual
+        adjustedInsertBefore = vnode_getDomSibling(insertBefore, true, true);
+    }
+    else {
+        adjustedInsertBefore = insertBefore;
+    }
+    adjustedInsertBefore && vnode_ensureInflatedIfText(journal, adjustedInsertBefore);
+    return adjustedInsertBefore;
+};
+const vnode_connectSiblings = (parent, vNode, vNext) => {
+    const vPrevious = vNext ? vNext.previousSibling : parent.lastChild;
+    if (vNext) {
+        vNext.previousSibling = vNode;
+    }
+    else {
+        parent.lastChild = vNode;
+    }
+    if (vPrevious) {
+        vPrevious.nextSibling = vNode;
+    }
+    else {
+        parent.firstChild = vNode;
     }
+    vNode.previousSibling = vPrevious;
+    vNode.nextSibling = vNext;
+    vNode.parent = parent;
+};
+const vnode_unlinkFromOldParent = (journal, currentParent, newParent, newChild) => {
     /**
      * Ensure that the previous node is unlinked.
      *
@@ -6795,58 +6731,17 @@ const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
      * <p>Test content</p> // <-- to remove
      * ```
      */
-    if (newChildCurrentParent &&
-        (newChild.previousSibling || newChild.nextSibling || newChildCurrentParent !== parent)) {
-        vnode_remove(journal, newChildCurrentParent, newChild, false);
-    }
-    const parentIsDeleted = parent.flags & 32 /* VNodeFlags.Deleted */;
-    let adjustedInsertBefore = null;
-    // if the parent is deleted, then we don't need to insert the new child
-    if (!parentIsDeleted) {
-        if (insertBefore == null) {
-            if (vnode_isVirtualVNode(parent)) {
-                // If `insertBefore` is null, than we need to insert at the end of the list.
-                // Well, not quite. If the parent is a virtual node, our "last node" is not the same
-                // as the DOM "last node". So in that case we need to look for the "next node" from
-                // our parent.
-                adjustedInsertBefore = vnode_getDomSibling(parent, true, false);
-            }
-        }
-        else if (vnode_isVirtualVNode(insertBefore)) {
-            // If the `insertBefore` is virtual, than we need to descend into the virtual and find e actual
-            adjustedInsertBefore = vnode_getDomSibling(insertBefore, true, true);
-        }
-        else {
-            adjustedInsertBefore = insertBefore;
-        }
-        adjustedInsertBefore && vnode_ensureInflatedIfText(journal, adjustedInsertBefore);
-        if (domChildren && domChildren.length) {
-            for (const child of domChildren) {
-                addVNodeOperation(journal, createInsertOrMoveOperation(child.node, parentNode, vnode_getNode(adjustedInsertBefore)));
-            }
-        }
-    }
-    // link newChild into the previous/next list
-    const vNext = insertBefore;
-    const vPrevious = vNext ? vNext.previousSibling : parent.lastChild;
-    if (vNext) {
-        vNext.previousSibling = newChild;
+    if (currentParent &&
+        (newChild.previousSibling || newChild.nextSibling || currentParent !== newParent)) {
+        vnode_remove(journal, currentParent, newChild, false);
     }
-    else {
-        parent.lastChild = newChild;
-    }
-    if (vPrevious) {
-        vPrevious.nextSibling = newChild;
+};
+const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
+    if (vnode_isElementOrTextVNode(newChild)) {
+        vnode_insertElementBefore(journal, parent, newChild, insertBefore);
     }
     else {
-        parent.firstChild = newChild;
-    }
-    newChild.previousSibling = vPrevious;
-    newChild.nextSibling = vNext;
-    newChild.parent = parent;
-    if (parentIsDeleted) {
-        // if the parent is deleted, then the new child is also deleted
-        newChild.flags |= 32 /* VNodeFlags.Deleted */;
+        vnode_insertVirtualBefore(journal, parent, newChild, insertBefore);
     }
 };
 const vnode_getDomParent = (vnode, includeProjection) => {
@@ -6865,18 +6760,18 @@ const vnode_remove = (journal, vParent, vToRemove, removeDOM) => {
         vnode_ensureTextInflated(journal, vToRemove);
     }
     if (removeDOM) {
-        const domParent = vnode_getDomParent(vParent, false);
         const isInnerHTMLParent = vnode_getProp(vParent, dangerouslySetInnerHTML, null) !== null;
         if (isInnerHTMLParent) {
             // ignore children, as they are inserted via innerHTML
             return;
         }
-        const children = vnode_getDOMChildNodes(journal, vToRemove, true);
-        //&& //journal.push(VNodeOperationType.Remove, domParent, ...children);
-        if (domParent && children.length) {
-            for (const child of children) {
-                addVNodeOperation(journal, createDeleteOperation(child.node));
-            }
+        if (vnode_isElementOrTextVNode(vToRemove)) {
+            addVNodeOperation(journal, createDeleteOperation(vToRemove.node));
+        }
+        else {
+            vnode_walkDirectChildren(journal, vToRemove, (vNode) => {
+                addVNodeOperation(journal, createDeleteOperation(vNode.node));
+            });
         }
     }
     const vPrevious = vToRemove.previousSibling;
@@ -6900,16 +6795,13 @@ const vnode_truncate = (journal, vParent, vDelete, removeDOM = true) => {
     isDev && assertDefined(vDelete, 'Missing vDelete.');
     const parent = vnode_getDomParent(vParent, true);
     if (parent && removeDOM) {
-        if (vnode_isElementVNode(vParent)) {
+        if (vnode_isElementOrTextVNode(vParent)) {
             addVNodeOperation(journal, createRemoveAllChildrenOperation(vParent.node));
         }
         else {
-            const children = vnode_getDOMChildNodes(journal, vParent, true);
-            if (children.length) {
-                for (const child of children) {
-                    addVNodeOperation(journal, createDeleteOperation(child.node));
-                }
-            }
+            vnode_walkDirectChildren(journal, vParent, (vNode) => {
+                addVNodeOperation(journal, createDeleteOperation(vNode.node));
+            });
         }
     }
     const vPrevious = vDelete.previousSibling;
@@ -7284,7 +7176,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) {
                 if (!key.startsWith(Q_PROPS_SEPARATOR)) {
                     keys.push(key);
                 }
@@ -7314,7 +7206,15 @@ const vnode_getNode = (vnode) => {
     return vnode.node;
 };
 /** @internal */
-function vnode_toString(depth = 20, offset = '', materialize = false, siblings = false, colorize = true, container = this && vnode_getDOMContainer(this)) {
+function vnode_toString(depth = 20, offset = '', materialize = false, siblings = false, colorize = true, container = null) {
+    if (this && !container) {
+        try {
+            container = vnode_getDOMContainer(this);
+        }
+        catch {
+            // ignore, as this is only for debugging
+        }
+    }
     let vnode = this;
     if (depth === 0) {
         return '...';
@@ -7338,12 +7238,14 @@ function vnode_toString(depth = 20, offset = '', materialize = false, siblings =
             if (vnode.dirty) {
                 attrs.push(` dirty:${vnode.dirty}`);
             }
-            vnode_getAttrKeys(container, vnode).forEach((key) => {
-                if (key !== DEBUG_TYPE && key !== debugStyleScopeIdPrefixAttr) {
-                    const value = vnode_getProp(vnode, key, null);
-                    attrs.push(' ' + key + '=' + qwikDebugToString(value));
-                }
-            });
+            if (container) {
+                vnode_getAttrKeys(container, vnode).forEach((key) => {
+                    if (key !== DEBUG_TYPE && key !== debugStyleScopeIdPrefixAttr) {
+                        const value = vnode_getProp(vnode, key, null);
+                        attrs.push(' ' + key + '=' + qwikDebugToString(value));
+                    }
+                });
+            }
             const name = (colorize ? NAME_COL_PREFIX : '') +
                 (VirtualTypeName[vnode_getProp(vnode, DEBUG_TYPE, null) || "V" /* VirtualType.Virtual */] ||
                     VirtualTypeName["V" /* VirtualType.Virtual */]) +
@@ -7366,7 +7268,7 @@ function vnode_toString(depth = 20, offset = '', materialize = false, siblings =
             if (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));
@@ -7566,8 +7468,8 @@ function materializeFromVNodeData(vParent, vData, element, child) {
         if (!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;
     }
@@ -7723,15 +7625,6 @@ const useInvokeContext = () => {
     isDev && assertDefined(ctx.$effectSubscriber$, `invoke: $effectSubscriber$ must be defined`, ctx);
     return ctx;
 };
-function useBindInvokeContext(fn) {
-    if (fn == null) {
-        return fn;
-    }
-    const ctx = getInvokeContext();
-    return function (...args) {
-        return (invokeApply).call(this, ctx, fn, args);
-    };
-}
 /** Call a function with the given InvokeContext and given arguments. */
 function invoke(context, fn, ...args) {
     return invokeApply.call(this, context, fn, args);
@@ -7831,7 +7724,7 @@ const trackSignal = (fn, subscriber, property, container, data) => {
     try {
         trackInvocation.$effectSubscriber$ = getSubscriber(subscriber, property, data);
         trackInvocation.$container$ = container;
-        return invoke(trackInvocation, fn);
+        return invokeApply(trackInvocation, fn);
     }
     finally {
         trackInvocation.$effectSubscriber$ = previousSubscriber;
@@ -7875,6 +7768,41 @@ const _waitUntilRendered = (container) => {
     return container.$renderPromise$ || Promise.resolve();
 };
 
+/**
+ * @internal
+ * The storage provider for hooks. Each invocation increases index i. Data is stored in an array.
+ */
+const useSequentialScope = () => {
+    const iCtx = useInvokeContext();
+    const hostElement = iCtx.$hostElement$;
+    const host = hostElement;
+    let seq = iCtx.$container$.getHostProp(host, ELEMENT_SEQ);
+    if (seq === null) {
+        seq = [];
+        iCtx.$container$.setHostProp(host, ELEMENT_SEQ, seq);
+    }
+    let seqIdx = iCtx.$container$.getHostProp(host, ELEMENT_SEQ_IDX);
+    if (seqIdx === null) {
+        seqIdx = 0;
+    }
+    iCtx.$container$.setHostProp(host, ELEMENT_SEQ_IDX, seqIdx + 1);
+    while (seq.length <= seqIdx) {
+        seq.push(undefined);
+    }
+    const set = (value) => {
+        if (qDev && qSerialize) {
+            verifySerializable(value);
+        }
+        return (seq[seqIdx] = value);
+    };
+    return {
+        val: seq[seqIdx],
+        set,
+        i: seqIdx,
+        iCtx,
+    };
+};
+
 // <docs markdown="../readme.md#createContextId">
 // !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
 // (edit ../readme.md#createContextId instead and run `pnpm docs.sync`)
@@ -8165,7 +8093,6 @@ const _typeIdNames = [
     'Map',
     'Uint8Array',
     'Task',
-    'Resource',
     'Component',
     'Signal',
     'WrappedSignal',
@@ -8300,13 +8227,6 @@ const allocate = (container, typeId, value) => {
         }
         case 20 /* TypeIds.Task */:
             return new Task(-1, -1, null, null, null, null);
-        case 21 /* TypeIds.Resource */: {
-            const res = createResourceReturn(container, 
-            // we don't care about the timeout value
-            undefined, undefined);
-            res.loading = false;
-            return res;
-        }
         case 6 /* TypeIds.URL */:
             return new URL(value);
         case 7 /* TypeIds.Date */:
@@ -8316,19 +8236,19 @@ const allocate = (container, typeId, value) => {
             return new RegExp(value.slice(1, idx), value.slice(idx + 1));
         case 15 /* TypeIds.Error */:
             return new Error();
-        case 22 /* TypeIds.Component */:
+        case 21 /* TypeIds.Component */:
             return componentQrl(null);
-        case 23 /* TypeIds.Signal */:
+        case 22 /* TypeIds.Signal */:
             return new SignalImpl(container, 0);
-        case 24 /* TypeIds.WrappedSignal */:
+        case 23 /* TypeIds.WrappedSignal */:
             return new WrappedSignalImpl(container, null, null, null);
-        case 25 /* TypeIds.ComputedSignal */:
+        case 24 /* TypeIds.ComputedSignal */:
             return new ComputedSignalImpl(container, null);
-        case 26 /* TypeIds.AsyncSignal */:
-            return new AsyncSignalImpl(container, null);
-        case 27 /* TypeIds.SerializerSignal */:
+        case 25 /* TypeIds.AsyncSignal */:
+            return new AsyncSignalImpl(container, null, undefined, { interval: 0 });
+        case 26 /* TypeIds.SerializerSignal */:
             return new SerializerSignalImpl(container, null);
-        case 28 /* TypeIds.Store */: {
+        case 27 /* TypeIds.Store */: {
             const data = value;
             // We need to allocate the store first, before we inflate its data, because the data can
             // reference the store itself (circular)
@@ -8347,9 +8267,9 @@ const allocate = (container, typeId, value) => {
         }
         case 13 /* TypeIds.URLSearchParams */:
             return new URLSearchParams(value);
-        case 29 /* TypeIds.FormData */:
+        case 28 /* TypeIds.FormData */:
             return new FormData();
-        case 30 /* TypeIds.JSXNode */:
+        case 29 /* TypeIds.JSXNode */:
             return new JSXNodeImpl(null, null, null, null, null);
         case 12 /* TypeIds.BigInt */:
             return BigInt(value);
@@ -8374,7 +8294,7 @@ const allocate = (container, typeId, value) => {
             const rest = encodedLength & 3;
             const decodedLength = blocks * 3 + (rest ? rest - 1 : 0);
             return new Uint8Array(decodedLength);
-        case 31 /* TypeIds.PropsProxy */:
+        case 30 /* TypeIds.PropsProxy */:
             return createPropsProxy(null);
         case 10 /* TypeIds.VNode */:
             return retrieveVNodeOrDocument(container, value);
@@ -8412,9 +8332,9 @@ const allocate = (container, typeId, value) => {
             else {
                 throw qError(17 /* QError.serializeErrorExpectedVNode */, [typeof vNode]);
             }
-        case 32 /* TypeIds.SubscriptionData */:
+        case 31 /* TypeIds.SubscriptionData */:
             return new SubscriptionData({});
-        case 33 /* TypeIds.EffectSubscription */:
+        case 32 /* TypeIds.EffectSubscription */:
             return new EffectSubscription(null, null, null, null);
         default:
             throw qError(18 /* QError.serializeErrorCannotAllocate */, [typeId]);
@@ -8759,7 +8679,7 @@ async function serialize(serializationContext) {
                     else if (isQwikComponent(value)) {
                         const [qrl] = value[SERIALIZABLE_STATE];
                         serializationContext.$renderSymbols$.add(qrl.$symbol$);
-                        output(22 /* TypeIds.Component */, [qrl]);
+                        output(21 /* TypeIds.Component */, [qrl]);
                     }
                     else {
                         throw qError(34 /* QError.serializeErrorCannotSerializeFunction */, [value.toString()]);
@@ -8797,7 +8717,7 @@ async function serialize(serializationContext) {
     const writeObjectValue = (value) => {
         if (isPropsProxy(value)) {
             const owner = value[_OWNER];
-            output(31 /* TypeIds.PropsProxy */, [
+            output(30 /* TypeIds.PropsProxy */, [
                 _serializationWeakRef(owner),
                 owner.varProps,
                 owner.constProps,
@@ -8805,10 +8725,10 @@ async function serialize(serializationContext) {
             ]);
         }
         else if (value instanceof SubscriptionData) {
-            output(32 /* TypeIds.SubscriptionData */, [value.data.$scopedStyleIdPrefix$, value.data.$isConst$]);
+            output(31 /* TypeIds.SubscriptionData */, [value.data.$scopedStyleIdPrefix$, value.data.$isConst$]);
         }
         else if (value instanceof EffectSubscription) {
-            output(33 /* TypeIds.EffectSubscription */, [
+            output(32 /* TypeIds.EffectSubscription */, [
                 value.consumer,
                 value.property,
                 value.backRef,
@@ -8816,41 +8736,30 @@ async function serialize(serializationContext) {
             ]);
         }
         else if (isStore(value)) {
-            if (isResource(value)) {
-                // let render know about the resource
-                serializationContext.$resources$.add(value);
-                // TODO the effects include the resource return which has duplicate data
-                const forwardRefId = resolvePromise(value.value, $addRoot$, (resolved, resolvedValue) => {
-                    return new PromiseResult(21 /* TypeIds.Resource */, resolved, resolvedValue, getStoreHandler(value).$effects$);
-                });
-                output(2 /* TypeIds.ForwardRef */, forwardRefId);
-            }
-            else {
-                const storeHandler = getStoreHandler(value);
-                const storeTarget = getStoreTarget(value);
-                const flags = storeHandler.$flags$;
-                const effects = storeHandler.$effects$;
-                // We need to retain the nested stores too, they won't be found from the target
-                const innerStores = [];
-                for (const prop in storeTarget) {
-                    const propValue = storeTarget[prop];
-                    const innerStore = $storeProxyMap$.get(propValue);
-                    if (innerStore) {
-                        innerStores.push(innerStore);
-                    }
-                }
-                const out = [storeTarget, flags, effects, ...innerStores];
-                while (out[out.length - 1] === undefined) {
-                    out.pop();
-                }
-                output(28 /* TypeIds.Store */, out);
+            const storeHandler = getStoreHandler(value);
+            const storeTarget = getStoreTarget(value);
+            const flags = storeHandler.$flags$;
+            const effects = storeHandler.$effects$;
+            // We need to retain the nested stores too, they won't be found from the target
+            const innerStores = [];
+            for (const prop in storeTarget) {
+                const propValue = storeTarget[prop];
+                const innerStore = $storeProxyMap$.get(propValue);
+                if (innerStore) {
+                    innerStores.push(innerStore);
+                }
+            }
+            const out = [storeTarget, flags, effects, ...innerStores];
+            while (out[out.length - 1] === undefined) {
+                out.pop();
             }
+            output(27 /* TypeIds.Store */, out);
         }
         else if (isSerializerObj(value)) {
             const result = value[SerializerSymbol](value);
             if (isPromise(result)) {
                 const forwardRef = resolvePromise(result, $addRoot$, (resolved, resolvedValue) => {
-                    return new PromiseResult(27 /* TypeIds.SerializerSignal */, resolved, resolvedValue, undefined, undefined);
+                    return new PromiseResult(26 /* TypeIds.SerializerSignal */, resolved, resolvedValue, undefined, undefined);
                 });
                 output(2 /* TypeIds.ForwardRef */, forwardRef);
             }
@@ -8887,12 +8796,12 @@ async function serialize(serializationContext) {
                 const maybeValue = getCustomSerializerPromise(value, value.$untrackedValue$);
                 if (isPromise(maybeValue)) {
                     const forwardRefId = resolvePromise(maybeValue, $addRoot$, (resolved, resolvedValue) => {
-                        return new PromiseResult(27 /* TypeIds.SerializerSignal */, resolved, resolvedValue, value.$effects$, value.$computeQrl$);
+                        return new PromiseResult(26 /* TypeIds.SerializerSignal */, resolved, resolvedValue, value.$effects$, value.$computeQrl$);
                     });
                     output(2 /* TypeIds.ForwardRef */, forwardRefId);
                 }
                 else {
-                    output(27 /* TypeIds.SerializerSignal */, [
+                    output(26 /* TypeIds.SerializerSignal */, [
                         value.$computeQrl$,
                         filterEffectBackRefs(value[_EFFECT_BACK_REF]),
                         value.$effects$,
@@ -8902,7 +8811,7 @@ async function serialize(serializationContext) {
                 return;
             }
             if (value instanceof WrappedSignalImpl) {
-                output(24 /* TypeIds.WrappedSignal */, [
+                output(23 /* TypeIds.WrappedSignal */, [
                     ...serializeWrappingFn(serializationContext, value),
                     filterEffectBackRefs(value[_EFFECT_BACK_REF]),
                     value.$flags$,
@@ -8916,28 +8825,36 @@ async function serialize(serializationContext) {
                 const shouldNeverSerialize = value.$flags$ & 8 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_NEVER */;
                 const isInvalid = value.$flags$ & 1 /* SignalFlags.INVALID */;
                 const isSkippable = fastSkipSerialize(value.$untrackedValue$);
-                if (shouldAlwaysSerialize) {
+                const isAsync = value instanceof AsyncSignalImpl;
+                const interval = isAsync && value.$interval$ > 0 ? value.$interval$ : undefined;
+                const concurrency = isAsync && value.$concurrency$ !== 1 ? value.$concurrency$ : undefined;
+                const timeout = isAsync && value.$timeoutMs$ !== 0 ? value.$timeoutMs$ : undefined;
+                const eagerCleanup = isAsync && value.$flags$ & 32 /* AsyncSignalFlags.EAGER_CLEANUP */ ? true : undefined;
+                if (isInvalid || isSkippable) {
+                    v = NEEDS_COMPUTATION;
+                }
+                else if (shouldAlwaysSerialize) {
                     v = value.$untrackedValue$;
                 }
                 else if (shouldNeverSerialize) {
                     v = NEEDS_COMPUTATION;
                 }
-                else if (isInvalid || isSkippable) {
-                    v = NEEDS_COMPUTATION;
-                }
                 const out = [
                     value.$computeQrl$,
                     filterEffectBackRefs(value[_EFFECT_BACK_REF]),
                     value.$effects$,
                 ];
-                const isAsync = value instanceof AsyncSignalImpl;
                 if (isAsync) {
-                    out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedLoading$, value.$untrackedError$);
+                    // After SSR, the signal is never loading, so no need to send it
+                    out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedError$);
                 }
                 let keepUndefined = false;
-                if (v !== NEEDS_COMPUTATION) {
+                if (v !== NEEDS_COMPUTATION ||
+                    interval !== undefined ||
+                    concurrency !== undefined ||
+                    timeout !== undefined) {
                     out.push(v);
-                    if (!isAsync && v === undefined) {
+                    if (v === undefined) {
                         /**
                          * If value is undefined, we need to keep it in the output. If we don't do that, later
                          * during resuming, the value will be set to symbol(invalid) with flag invalid, and
@@ -8946,7 +8863,13 @@ async function serialize(serializationContext) {
                         keepUndefined = true;
                     }
                 }
-                output(isAsync ? 26 /* TypeIds.AsyncSignal */ : 25 /* TypeIds.ComputedSignal */, out, keepUndefined);
+                if (isAsync) {
+                    out.push(interval);
+                    out.push(concurrency);
+                    out.push(timeout);
+                    out.push(eagerCleanup);
+                }
+                output(isAsync ? 25 /* TypeIds.AsyncSignal */ : 24 /* TypeIds.ComputedSignal */, out, keepUndefined);
             }
             else {
                 const v = value.$untrackedValue$;
@@ -8955,7 +8878,7 @@ async function serialize(serializationContext) {
                 if (value.$effects$) {
                     out.push(...value.$effects$);
                 }
-                output(23 /* TypeIds.Signal */, out, keepUndefined);
+                output(22 /* TypeIds.Signal */, out, keepUndefined);
             }
         }
         else if (value instanceof URL) {
@@ -9017,7 +8940,7 @@ async function serialize(serializationContext) {
                     array.push(key, value.name);
                 }
             });
-            output(29 /* TypeIds.FormData */, array);
+            output(28 /* TypeIds.FormData */, array);
         }
         else if (value instanceof URLSearchParams) {
             output(13 /* TypeIds.URLSearchParams */, value.toString());
@@ -9044,7 +8967,7 @@ async function serialize(serializationContext) {
             while (out[out.length - 1] === undefined) {
                 out.pop();
             }
-            output(30 /* TypeIds.JSXNode */, out);
+            output(29 /* TypeIds.JSXNode */, out);
         }
         else if (value instanceof Task) {
             const out = [
@@ -9067,12 +8990,9 @@ async function serialize(serializationContext) {
             output(2 /* TypeIds.ForwardRef */, forwardRefId);
         }
         else if (value instanceof PromiseResult) {
-            if (value.$type$ === 21 /* TypeIds.Resource */) {
-                output(21 /* TypeIds.Resource */, [value.$resolved$, value.$value$, value.$effects$]);
-            }
-            else if (value.$type$ === 27 /* TypeIds.SerializerSignal */) {
+            if (value.$type$ === 26 /* TypeIds.SerializerSignal */) {
                 if (value.$qrl$) {
-                    output(27 /* TypeIds.SerializerSignal */, [value.$qrl$, value.$effects$, value.$value$]);
+                    output(26 /* TypeIds.SerializerSignal */, [value.$qrl$, value.$effects$, value.$value$]);
                 }
                 else if (value.$resolved$) {
                     // We replace ourselves with this value
@@ -9247,9 +9167,6 @@ function isObjectLiteral(obj) {
     const prototype = Object.getPrototypeOf(obj);
     return prototype == null || prototype === Object.prototype || prototype === Array.prototype;
 }
-function isResource(value) {
-    return '__brand' in value && value.__brand === 'resource';
-}
 function serializeWrappingFn(serializationContext, value) {
     // if value is an object then we need to wrap this in ()
     if (value.$funcStr$ && value.$funcStr$[0] === '{') {
@@ -9313,6 +9230,7 @@ DomRefConstructor, symbolToChunkResolver, getProp, setProp, storeProxyMap, write
     const syncFnMap = new Map();
     const syncFns = [];
     const roots = [];
+    const eagerResume = new Set();
     const getSeenRef = (obj) => seenObjsMap.get(obj);
     const $markSeen$ = (obj, parent, index) => {
         const ref = { $index$: index, $parent$: parent };
@@ -9408,9 +9326,10 @@ DomRefConstructor, symbolToChunkResolver, getProp, setProp, storeProxyMap, write
         $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,
     };
@@ -9430,8 +9349,7 @@ class _SharedContainer {
     $buildBase$ = null;
     $renderPromise$ = null;
     $resolveRenderPromise$ = null;
-    $cursorCount$ = 0;
-    $pausedCursorCount$ = 0;
+    $pendingCount$ = 0;
     constructor(serverData, locale) {
         this.$serverData$ = serverData;
         this.$locale$ = locale;
@@ -9447,6 +9365,12 @@ class _SharedContainer {
     serializationCtxFactory(NodeConstructor, DomRefConstructor, symbolToChunkResolver, writer) {
         return createSerializationContext(NodeConstructor, DomRefConstructor, symbolToChunkResolver, this.getHostProp.bind(this), this.setHostProp.bind(this), this.$storeProxyMap$, writer);
     }
+    $checkPendingCount$() {
+        if (this.$pendingCount$ === 0) {
+            this.$resolveRenderPromise$?.();
+            this.$renderPromise$ = null;
+        }
+    }
 }
 
 function isAsyncGenerator(value) {
@@ -9540,6 +9464,7 @@ function processJSXNode(ssr, enqueue, value, options) {
             }
         }
         else if (isSignal(value)) {
+            maybeAddPollingAsyncSignalToEagerResume(ssr.serializationCtx, value);
             ssr.openFragment(isDev ? [DEBUG_TYPE, "S" /* VirtualType.WrappedSignal */] : EMPTY_ARRAY);
             const signalNode = ssr.getOrCreateLastNode();
             const unwrappedSignal = value instanceof WrappedSignalImpl ? value.$unwrapIfSignal$() : value;
@@ -9728,6 +9653,7 @@ function toSsrAttrs(record, options) {
             return;
         }
         if (isSignal(value)) {
+            maybeAddPollingAsyncSignalToEagerResume(options.serializationCtx, value);
             // write signal as is. We will track this signal inside `writeAttrs`
             if (isClassAttr(key)) {
                 // additionally append styleScopedId for class attr
@@ -9816,6 +9742,19 @@ function addPreventDefaultEventToSerializationContext(serializationCtx, key) {
         serializationCtx.$eventNames$.add(eventName);
     }
 }
+function maybeAddPollingAsyncSignalToEagerResume(serializationCtx, signal) {
+    // Unwrap if it's a WrappedSignalImpl
+    const unwrappedSignal = signal instanceof WrappedSignalImpl ? signal.$unwrapIfSignal$() : signal;
+    if (unwrappedSignal instanceof AsyncSignalImpl) {
+        const interval = unwrappedSignal.$interval$;
+        // Don't check for $effects$ here - effects are added later during tracking.
+        // The AsyncSignal's polling mechanism will check for effects before scheduling.
+        if (interval > 0) {
+            serializationCtx.$addRoot$(unwrappedSignal);
+            serializationCtx.$eagerResume$.add(unwrappedSignal);
+        }
+    }
+}
 function getSlotName(host, jsx, ssr) {
     const constProps = jsx.constProps;
     if (constProps && typeof constProps == 'object' && 'name' in constProps) {
@@ -9853,7 +9792,7 @@ function appendClassIfScopedStyleExists(jsx, styleScoped) {
  * NOTE: `useLexicalScope` method can only be used in the synchronous portion of the callback
  * (before any `await` statements.)
  *
- * @deprecated Read from `_captures` directly instead.
+ * @deprecated Use `_captures` instead.
  * @internal
  */
 // </docs>
@@ -9862,6 +9801,117 @@ const useLexicalScope = () => {
     return _captures;
 };
 
+/**
+ * The resource function wrapper
+ *
+ * @internal
+ */
+const _rsc = async (arg) => {
+    const [fn, ref] = _captures;
+    const result = await fn(arg);
+    if (result && typeof result === 'object') {
+        if (ref.r) {
+            Object.assign(ref.r, result);
+        }
+        else {
+            // We need lazy creation because we don't know if it will be an array or an object, and we want to preserve the original reference for reactivity to work
+            ref.r = createStore(fn.$container$, result, 1 /* StoreFlags.RECURSIVE */);
+        }
+    }
+    else {
+        ref.r = result;
+    }
+    return { r: ref.r };
+};
+/** @internal */
+const useResourceQrl = (qrl, opts) => {
+    assertQrl(qrl);
+    const { val, set, iCtx } = useSequentialScope();
+    if (val) {
+        return val;
+    }
+    const ref = {};
+    // Wrap the function so we can maintain a stable reference to the store
+    const wrapped = createQRL(null, '_rsc', _rsc, null, [qrl, ref]);
+    qrl.$container$ = iCtx.$container$;
+    const asyncSignal = createAsyncSignal(wrapped, {
+        timeout: opts?.timeout,
+        container: iCtx.$container$,
+        concurrency: 0,
+    });
+    // Resource is eager
+    asyncSignal.$computeIfNeeded$();
+    // Create a wrapper that presents the Promise-based ResourceReturn API
+    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;
+        },
+    };
+    set(resource);
+    return resource;
+};
+/**
+ * ```tsx
+ * const Cmp = component$(() => {
+ *   const city = useSignal('');
+ *
+ *   const weather = useAsync$(async ({ track, cleanup, abortSignal }) => {
+ *     const cityName = track(city);
+ *     const res = await fetch(`http://weatherdata.com?city=${cityName}`, {
+ *       signal: abortSignal,
+ *     });
+ *     const temp = (await res.json()) as { temp: number };
+ *     return temp;
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <input name="city" bind:value={city} />
+ *       <div>
+ *         Temperature:{' '}
+ *         {weather.loading
+ *           ? 'Loading...'
+ *           : weather.error
+ *             ? `Error: ${weather.error.message}`
+ *             : weather.value.temp}
+ *       </div>
+ *     </div>
+ *   );
+ * });
+ * ```
+ *
+ * @deprecated Use `useAsync$` instead, which is more efficient, and has a more flexible API. Just
+ *   read the `loading` and `error` properties from the returned signal to determine the status.
+ * @public
+ */
+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) => {
+    return obj && obj.__brand === 'resource';
+};
+
 let loading = Promise.resolve();
 const inflate = (container, target, typeId, data) => {
     if (typeId === 0 /* TypeIds.Plain */) {
@@ -9898,25 +9948,10 @@ const inflate = (container, target, typeId, data) => {
             task[_EFFECT_BACK_REF] = v[4];
             task.$state$ = v[5];
             break;
-        case 21 /* TypeIds.Resource */:
-            const [resolved, result, effects] = data;
-            const resource = target;
-            if (resolved) {
-                resource.value = Promise.resolve(result);
-                resource._resolved = result;
-                resource._state = 'resolved';
-            }
-            else {
-                resource.value = Promise.reject(result);
-                resource._error = result;
-                resource._state = 'rejected';
-            }
-            getStoreHandler(target).$effects$ = effects;
-            break;
-        case 22 /* TypeIds.Component */:
+        case 21 /* TypeIds.Component */:
             target[SERIALIZABLE_STATE][0] = data[0];
             break;
-        case 28 /* TypeIds.Store */: {
+        case 27 /* TypeIds.Store */: {
             // Inflate the store target
             const store = unwrapStore(target);
             const storeTarget = pendingStoreTargets.get(store);
@@ -9934,14 +9969,14 @@ const inflate = (container, target, typeId, data) => {
             storeHandler.$effects$ = effects;
             break;
         }
-        case 23 /* TypeIds.Signal */: {
+        case 22 /* TypeIds.Signal */: {
             const signal = target;
             const d = data;
             signal.$untrackedValue$ = d[0];
             signal.$effects$ = new Set(d.slice(1));
             break;
         }
-        case 24 /* TypeIds.WrappedSignal */: {
+        case 23 /* TypeIds.WrappedSignal */: {
             const signal = target;
             const d = data;
             signal.$func$ = container.getSyncFn(d[0]);
@@ -9955,7 +9990,7 @@ const inflate = (container, target, typeId, data) => {
             inflateWrappedSignalValue(signal);
             break;
         }
-        case 26 /* TypeIds.AsyncSignal */: {
+        case 25 /* TypeIds.AsyncSignal */: {
             const asyncSignal = target;
             const d = data;
             asyncSignal.$computeQrl$ = d[0];
@@ -9963,19 +9998,27 @@ const inflate = (container, target, typeId, data) => {
             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];
-            const hasValue = d.length > 7;
+            asyncSignal.$untrackedError$ = d[5];
+            const hasValue = d.length > 6;
             if (hasValue) {
-                asyncSignal.$untrackedValue$ = d[7];
-                asyncSignal.$promiseValue$ = d[7];
+                asyncSignal.$untrackedValue$ = d[6];
+            }
+            if (asyncSignal.$untrackedValue$ !== NEEDS_COMPUTATION) {
+                // If we have a value after SSR, it will always be mean the signal was not invalid
+                asyncSignal.$flags$ &= -2 /* SignalFlags.INVALID */;
+            }
+            // Note, we use the setter so that it schedules polling if needed
+            asyncSignal.interval = d[7] ?? 0;
+            asyncSignal.$concurrency$ = d[8] ?? 1;
+            asyncSignal.$timeoutMs$ = d[9] ?? 0;
+            if (d[10]) {
+                asyncSignal.$flags$ |= 32 /* AsyncSignalFlags.EAGER_CLEANUP */;
             }
-            asyncSignal.$flags$ |= 1 /* SignalFlags.INVALID */;
             break;
         }
         // Inflating a SerializerSignal is the same as inflating a ComputedSignal
-        case 27 /* TypeIds.SerializerSignal */:
-        case 25 /* TypeIds.ComputedSignal */: {
+        case 26 /* TypeIds.SerializerSignal */:
+        case 24 /* TypeIds.ComputedSignal */: {
             const computed = target;
             const d = data;
             computed.$computeQrl$ = d[0];
@@ -9995,13 +10038,11 @@ const inflate = (container, target, typeId, data) => {
             const hasValue = d.length > 3;
             if (hasValue) {
                 computed.$untrackedValue$ = d[3];
-                // The serialized signal is always invalid so it can recreate the custom object
-                if (typeId === 27 /* TypeIds.SerializerSignal */) {
-                    computed.$flags$ |= 1 /* SignalFlags.INVALID */;
-                }
             }
-            else {
-                computed.$flags$ |= 1 /* SignalFlags.INVALID */;
+            if (typeId !== 26 /* TypeIds.SerializerSignal */ && computed.$untrackedValue$ !== NEEDS_COMPUTATION) {
+                // If we have a value after SSR, it will always be mean the signal was not invalid
+                // The serialized signal is always left invalid so it can recreate the custom object
+                computed.$flags$ &= -2 /* SignalFlags.INVALID */;
             }
             break;
         }
@@ -10013,7 +10054,7 @@ const inflate = (container, target, typeId, data) => {
             }
             break;
         }
-        case 29 /* TypeIds.FormData */: {
+        case 28 /* TypeIds.FormData */: {
             const formData = target;
             const d = data;
             for (let i = 0; i < d.length; i++) {
@@ -10021,7 +10062,7 @@ const inflate = (container, target, typeId, data) => {
             }
             break;
         }
-        case 30 /* TypeIds.JSXNode */: {
+        case 29 /* TypeIds.JSXNode */: {
             const jsx = target;
             const [type, key, varProps, constProps, children, toSort] = data;
             jsx.type = type;
@@ -10068,7 +10109,7 @@ const inflate = (container, target, typeId, data) => {
                 bytes[i++] = s.charCodeAt(0);
             }
             break;
-        case 31 /* TypeIds.PropsProxy */:
+        case 30 /* TypeIds.PropsProxy */:
             const propsProxy = target;
             const d = data;
             let owner = d[0];
@@ -10079,13 +10120,13 @@ const inflate = (container, target, typeId, data) => {
             propsProxy[_OWNER] = owner;
             propsProxy[_PROPS_HANDLER].$effects$ = d[3];
             break;
-        case 32 /* TypeIds.SubscriptionData */: {
+        case 31 /* TypeIds.SubscriptionData */: {
             const effectData = target;
             effectData.data.$scopedStyleIdPrefix$ = data[0];
             effectData.data.$isConst$ = data[1];
             break;
         }
-        case 33 /* TypeIds.EffectSubscription */: {
+        case 32 /* TypeIds.EffectSubscription */: {
             const effectSub = target;
             const d = data;
             effectSub.consumer = d[0];
@@ -10658,7 +10699,7 @@ class DomContainer extends _SharedContainer {
                     const insertHost = vnode_isElementVNode(vHost) ? vHostParent || vHost : vHost;
                     // If the host is different then we need to insert errored-host in the same position as the host.
                     const insertBefore = insertHost === vHost ? null : vHostNextSibling;
-                    vnode_insertBefore(journal, insertHost, vErrorDiv, insertBefore);
+                    vnode_insertElementBefore(journal, insertHost, vErrorDiv, insertBefore);
                 };
                 this.$renderPromise$ ? this.$renderPromise$.then(createErrorWrapper) : createErrorWrapper();
             }
@@ -10808,8 +10849,8 @@ const useTaskQrl = (qrl, opts) => {
     set(1);
     const taskFlags = 
     // enabled by default
-    opts?.deferUpdates === false ? 0 : 16 /* TaskFlags.RENDER_BLOCKING */;
-    const task = new Task(8 /* TaskFlags.DIRTY */ | 2 /* TaskFlags.TASK */ | taskFlags, i, iCtx.$hostElement$, qrl, undefined, null);
+    opts?.deferUpdates === false ? 0 : 8 /* TaskFlags.RENDER_BLOCKING */;
+    const task = new Task(4 /* TaskFlags.DIRTY */ | 2 /* TaskFlags.TASK */ | taskFlags, i, iCtx.$hostElement$, qrl, undefined, null);
     // In V2 we add the task to the sequential scope. We need to do this
     // in order to be able to retrieve it later when the parent element is
     // deleted and we need to be able to release the task subscriptions.
@@ -10822,7 +10863,7 @@ const useTaskQrl = (qrl, opts) => {
     }
 };
 const runTask = (task, container, host) => {
-    task.$flags$ &= -9 /* TaskFlags.DIRTY */;
+    task.$flags$ &= -5 /* TaskFlags.DIRTY */;
     cleanupDestroyable(task);
     const iCtx = newInvokeContext(container.$locale$, host, TaskEvent);
     iCtx.$container$ = container;
@@ -10873,7 +10914,7 @@ function scheduleTask(_event, element) {
         setCaptures(deserializeCaptures(container, this));
     }
     const task = _captures[0];
-    task.$flags$ |= 8 /* TaskFlags.DIRTY */;
+    task.$flags$ |= 4 /* TaskFlags.DIRTY */;
     markVNodeDirty(container, task.$el$, 1 /* ChoreBits.TASKS */);
 }
 
@@ -10900,7 +10941,7 @@ const ensureContainsBackRef = (array, value) => {
     (array.backRef ||= new Set()).add(value);
 };
 const addQrlToSerializationCtx = (effectSubscriber, container) => {
-    if (container) {
+    if (container?.serializationCtx) {
         const effect = effectSubscriber.consumer;
         const property = effectSubscriber.property;
         let qrl = null;
@@ -10926,7 +10967,7 @@ const scheduleEffects = (container, signal, effects) => {
             const property = effectSubscription.property;
             isDev && assertDefined(container, 'Container must be defined.');
             if (isTask(consumer)) {
-                consumer.$flags$ |= 8 /* TaskFlags.DIRTY */;
+                consumer.$flags$ |= 4 /* TaskFlags.DIRTY */;
                 markVNodeDirty(container, consumer.$el$, 1 /* ChoreBits.TASKS */);
             }
             else if (consumer instanceof SignalImpl) {
@@ -11605,14 +11646,11 @@ function preprocessState(data, container) {
 /**
  * Serialize data to string using SerializationContext.
  *
- * @param data - Data to serialize
  * @internal
  */
 async function _serialize(data) {
     const serializationContext = createSerializationContext(null, null, () => '', () => '', () => { }, new WeakMap());
-    for (const root of data) {
-        serializationContext.$addRoot$(root);
-    }
+    serializationContext.$addRoot$(data);
     await serializationContext.$serialize$();
     return serializationContext.$writer$.toString();
 }
@@ -11624,18 +11662,14 @@ async function _serialize(data) {
  */
 function _deserialize(rawStateData) {
     if (rawStateData == null) {
-        return [];
+        throw new Error('No state data to deserialize');
     }
     const stateData = JSON.parse(rawStateData);
-    if (!Array.isArray(stateData)) {
-        return [];
+    if (!Array.isArray(stateData) || stateData.length < 2 || typeof stateData[0] !== 'number') {
+        throw new Error('Invalid state data');
     }
     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]);
-    }
-    return output;
+    return deserializeData(container, stateData[0], stateData[1]);
 }
 function getObjectById(id, stateData) {
     if (typeof id === 'string') {
@@ -11709,6 +11743,10 @@ const _verifySerializable = (value, seen, ctx, preMessage) => {
                     });
                     return value;
                 }
+                // We don't want to walk internal objects, assume we already checked the contents
+                if (unwrapped.__brand) {
+                    return value;
+                }
                 if (isSerializableObject(unwrapped)) {
                     for (const [key, item] of Object.entries(unwrapped)) {
                         _verifySerializable(item, seen, ctx + '.' + key);
@@ -13166,8 +13204,8 @@ const useVisibleTaskQrl = (qrl, opts) => {
     const { val, set, i, iCtx } = useSequentialScope();
     const eagerness = opts?.strategy ?? 'intersection-observer';
     if (val) {
-        if (!(val.$flags$ & 64 /* TaskFlags.EVENTS_REGISTERED */) && !isServerPlatform()) {
-            val.$flags$ |= 64 /* TaskFlags.EVENTS_REGISTERED */;
+        if (!(val.$flags$ & 32 /* TaskFlags.EVENTS_REGISTERED */) && !isServerPlatform()) {
+            val.$flags$ |= 32 /* TaskFlags.EVENTS_REGISTERED */;
             useRegisterTaskEvents(val, eagerness);
         }
         return;
@@ -13176,7 +13214,7 @@ const useVisibleTaskQrl = (qrl, opts) => {
     let flags;
     if (!isServerPlatform()) {
         // In DOM we immediately execute
-        flags = 1 /* TaskFlags.VISIBLE_TASK */ | 8 /* TaskFlags.DIRTY */;
+        flags = 1 /* TaskFlags.VISIBLE_TASK */ | 4 /* TaskFlags.DIRTY */;
         qrl.resolve();
         markVNodeDirty(iCtx.$container$, iCtx.$hostElement$, 1 /* ChoreBits.TASKS */);
     }
@@ -13222,48 +13260,16 @@ const getTaskHandlerQrl = (task) => {
  * Be careful when using a `try/catch` statement in `useResource$`. If you catch the error and don't
  * re-throw it (or a new Error), the resource status will never be `rejected`.
  *
- * ### Example
- *
- * Example showing how `useResource` to perform a fetch to request the weather, whenever the input
- * city name changes.
- *
- * ```tsx
- * const Cmp = component$(() => {
- *   const cityS = useSignal('');
- *
- *   const weatherResource = useResource$(async ({ track, cleanup }) => {
- *     const cityName = track(cityS);
- *     const abortController = new AbortController();
- *     cleanup(() => abortController.abort('cleanup'));
- *     const res = await fetch(`http://weatherdata.com?city=${cityName}`, {
- *       signal: abortController.signal,
- *     });
- *     const data = await res.json();
- *     return data as { temp: number };
- *   });
- *
- *   return (
- *     <div>
- *       <input name="city" bind:value={cityS} />
- *       <Resource
- *         value={weatherResource}
- *         onResolved={(weather) => {
- *           return <div>Temperature: {weather.temp}</div>;
- *         }}
- *       />
- *     </div>
- *   );
- * });
- * ```
- *
+ * @deprecated Use `useAsync$` instead, which is more powerful and flexible. `useResource$` is still
+ *   available for backward compatibility but it is recommended to migrate to `useAsync$` for new
+ *   code and when updating existing code.
  * @public
+ * @see useAsync$
  * @see Resource
  * @see ResourceReturn
  */
 // </docs>
-const useResource$ = (generatorFn, opts) => {
-    return useResourceQrl(dollar(generatorFn), opts);
-};
+const useResource$ = implicit$FirstArg(useResourceQrl);
 
 // <docs markdown="../readme.md#useTask">
 // !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
@@ -13495,5 +13501,5 @@ if (import.meta.hot) {
     });
 }
 
-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 };
 //# sourceMappingURL=core.mjs.map