@qwik.dev/core 2.0.0-beta.37 → 2.0.0-beta.39

package/dist/core.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.37-dev+82dc74d
+ * @qwik.dev/core 2.0.0-beta.39-dev+6fb620f
  * 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
@@ -225,13 +225,16 @@ const codeToText = (code, ...parts) => {
             'Unknown vnode type {{0}}.', // 26
             'Materialize error: missing element: {{0}} {{1}} {{2}}', // 27
             'Cannot coerce a Signal, use `.value` instead', // 28
-            'useComputed$ QRL {{0}} {{1}} cannot return a Promise', // 29
+            '', // 29 (cleared: useComputed$ now supports async functions)
             '===\nQwik version {{0}} already imported while importing {{1}}.\nThis can lead to issues due to duplicated shared structures.\nVerify that the Qwik libraries you\'re using are in "resolve.noExternal[]" and in "optimizeDeps.exclude".\n===\n', // 30
             'WrappedSignal is read-only', // 31
             'Attribute value is unsafe for SSR {{0}}', // 32
             'SerializerSymbol function returned rejected promise', // 33
             'Serialization Error: Cannot serialize function: {{0}}', // 34
             'Cannot read .value of a clientOnly async signal during SSR. Use .loading to check state, or provide an initial value.', // 35
+            'Invalid element name for SSR {{0}}', // 36
+            'Invalid serialized Promise dependency', // 37
+            'Invalid serialized Uint8Array payload', // 38
         ];
         let text = MAP[code] ?? '';
         if (parts.length) {
@@ -318,6 +321,7 @@ const VNodeDataChar = {
     CLOSE: /* ************* */ 125, // `}` is the end of the VNodeData for a virtual element.
     SCOPED_STYLE: /* ******* */ 59, // `;` - `q:sstyle` - Style attribute.
     RENDER_FN: /* ********** */ 60, // `<` - `q:renderFn' - Component QRL render function (body)
+    RENDER_HASH_PREFIX: /* **/ 95, // `_` after `<` identifies a component hash.
     ID: /* ***************** */ 61, // `=` - `q:id` - ID of the element.
     PROPS: /* ************** */ 62, // `>` - `q:props' - Component Props
     SLOT_PARENT: /* ******** */ 63, // `?` - `q:sparent` - Slot parent.
@@ -402,6 +406,7 @@ function decodeVNodeDataString(str) {
 
 /** State factory of the component. */
 const OnRenderProp = 'q:renderFn';
+const QComponentHash = 'q:componentHash';
 /** Target DOM element for external projection rendering. */
 const QTargetElement = 'q:targetEl';
 /** Component style content prefix */
@@ -428,13 +433,13 @@ const QBaseAttr = 'q:base';
 const QLocaleAttr = 'q:locale';
 const QManifestHashAttr = 'q:manifest-hash';
 const QInstanceAttr = 'q:instance';
+const QStatePrewarmAttr = 'q:prewarm';
 const QContainerIsland = 'q:container-island';
 const QContainerIslandEnd = '/' + QContainerIsland;
 const QIgnore = 'q:ignore';
 const QIgnoreEnd = '/' + QIgnore;
 const QContainerAttr = 'q:container';
 const QContainerAttrEnd = '/' + QContainerAttr;
-const QCursorBoundary = 'q:cursorBoundary';
 const QTemplate = 'q:template';
 // the same selector should be inside the qwik loader
 // and the same selector should be inside the qwik router spa-shim and spa-init
@@ -475,6 +480,7 @@ const NON_SERIALIZABLE_MARKER_PREFIX = ':';
 const USE_ON_LOCAL = NON_SERIALIZABLE_MARKER_PREFIX + 'on';
 const USE_ON_LOCAL_SEQ_IDX = NON_SERIALIZABLE_MARKER_PREFIX + 'onIdx';
 const USE_ON_LOCAL_FLAGS = NON_SERIALIZABLE_MARKER_PREFIX + 'onFlags';
+const QCursorBoundary = NON_SERIALIZABLE_MARKER_PREFIX + 'cursorBoundary';
 const NEAREST_CURSOR_BOUNDARY = NON_SERIALIZABLE_MARKER_PREFIX + 'nearestCursorBoundary';
 const Q_PROPS_SEPARATOR = ':';
 const dangerouslySetInnerHTML = 'dangerouslySetInnerHTML';
@@ -842,8 +848,21 @@ const createMacroTask = (fn) => {
     let macroTask;
     if (typeof MessageChannel !== 'undefined') {
         const channel = new MessageChannel();
+        let active = true;
         channel.port1.onmessage = () => fn();
-        macroTask = () => channel.port2.postMessage(null);
+        macroTask = () => {
+            if (active) {
+                channel.port2.postMessage(null);
+            }
+        };
+        macroTask.$destroy$ = () => {
+            if (active) {
+                active = false;
+                channel.port1.onmessage = null;
+                channel.port1.close();
+                channel.port2.close();
+            }
+        };
     }
     else {
         macroTask = () => setTimeout(fn);
@@ -963,7 +982,7 @@ const rel = isBrowser && doc.createElement('link').relList?.supports?.('modulepr
     ? 'modulePreload'
     : 'preload';
 const isJSRegex = /\.[mc]?js$/;
-const yieldInterval = 1000 / 60;
+const yieldInterval = 10;
 
 const BundleImportState_None = 0;
 const BundleImportState_Preload = 2;
@@ -1219,6 +1238,8 @@ const writeStringRootRef = (writer, id) => writer.write(String(id));
 /** @internal */
 const writeStringRootRefPath = (writer, path) => writer.write(stringifyRootRefPath(path));
 /** @internal */
+const writeStringRootRefDelta = (writer, id, base) => writer.write(String(id - base));
+/** @internal */
 const createStringStreamWriter = (write) => ({
     write,
     writeRootRef(id) {
@@ -1227,6 +1248,9 @@ const createStringStreamWriter = (write) => ({
     writeRootRefPath(path) {
         return writeStringRootRefPath(this, path);
     },
+    writeRootRefDelta(id, base) {
+        return writeStringRootRefDelta(this, id, base);
+    },
 });
 
 // Pre-allocated common strings to reduce allocation overhead
@@ -1242,7 +1266,7 @@ const COMMA = ',';
  *
  * @public
  */
-const version = "2.0.0-beta.37-dev+82dc74d";
+const version = "2.0.0-beta.39-dev+6fb620f";
 
 const isNode = (value) => {
     return value && typeof value.nodeType === 'number';
@@ -1698,9 +1722,12 @@ function setCursorPosition(container, cursorData, position) {
     }
 }
 function mergeCursors(container, newCursorData, oldCursor) {
+    const oldCursorData = getCursorData(oldCursor);
+    if (!oldCursorData || oldCursorData === newCursorData) {
+        return;
+    }
     // delete from global cursors queue
     removeCursorFromQueue(oldCursor, container);
-    const oldCursorData = getCursorData(oldCursor);
     mergeCursorData(newCursorData, oldCursorData);
 }
 function mergeCursorData(newCursorData, oldCursorData) {
@@ -1778,6 +1805,234 @@ function setCursorData(vNode, cursorData) {
     cursorDatas.set(vNode, cursorData);
 }
 
+/** @internal */
+const _CONST_PROPS = Symbol('CONST');
+/** @internal */
+const _VAR_PROPS = Symbol('VAR');
+/** @internal */
+const _OWNER = Symbol('OWNER');
+/** @internal */
+const _PROPS_HANDLER = Symbol('PROPS_HANDLER');
+/** @internal @deprecated v1 compat */
+const _IMMUTABLE = Symbol('IMMUTABLE');
+/** @internal */
+const _UNINITIALIZED = Symbol('UNINITIALIZED');
+
+/** @internal */
+const EMPTY_ARRAY = [];
+/** @internal */
+const EMPTY_OBJ = {};
+Object.freeze(EMPTY_ARRAY);
+Object.freeze(EMPTY_OBJ);
+
+function createPropsProxy(owner) {
+    // TODO don't make a proxy but populate getters? benchmark
+    return new Proxy({}, new PropsProxyHandler(owner));
+}
+class PropsProxyHandler {
+    owner;
+    $effects$ = undefined;
+    $container$ = null;
+    constructor(owner) {
+        this.owner = owner;
+    }
+    get(_, prop) {
+        // escape hatch to get the separated props from a component
+        if (prop === _CONST_PROPS) {
+            return this.owner.constProps;
+        }
+        else if (prop === _VAR_PROPS) {
+            return this.owner.varProps;
+        }
+        else if (prop === _OWNER) {
+            return this.owner;
+        }
+        else if (prop === _PROPS_HANDLER) {
+            return this;
+        }
+        let value;
+        if (prop === 'children') {
+            value = this.owner.children;
+        }
+        else {
+            if (typeof prop === 'string' && typeof this.owner.type === 'string') {
+                const attr = jsxEventToHtmlAttribute(prop);
+                if (attr) {
+                    prop = attr;
+                }
+            }
+            value = directGetPropsProxyProp(this.owner, prop);
+            if (prop in this.owner.varProps) {
+                addPropsProxyEffect(this, prop);
+            }
+        }
+        // a proxied value that the optimizer made
+        return value instanceof WrappedSignalImpl ? value.value : value;
+    }
+    set(_, prop, value) {
+        if (prop === _OWNER) {
+            // used for deserialization
+            this.owner = value;
+        }
+        else if (prop === 'children') {
+            this.owner.children = value;
+        }
+        else if (prop === _CONST_PROPS) {
+            this.owner.constProps = value;
+        }
+        else if (prop === _VAR_PROPS) {
+            this.owner.varProps = value;
+        }
+        else {
+            if (typeof prop === 'string' && typeof this.owner.type === 'string') {
+                const attr = jsxEventToHtmlAttribute(prop);
+                if (attr) {
+                    prop = attr;
+                }
+            }
+            if (this.owner.constProps && prop in this.owner.constProps) {
+                // delete the prop from the const props first
+                delete this.owner.constProps[prop];
+            }
+            if (this.owner.varProps === EMPTY_OBJ) {
+                this.owner.varProps = {};
+            }
+            else if (!(prop in this.owner.varProps)) {
+                this.owner.toSort = true;
+            }
+            if (this.owner.varProps[prop] !== value) {
+                this.owner.varProps[prop] = value;
+                triggerPropsProxyEffect(this, prop);
+            }
+        }
+        return true;
+    }
+    deleteProperty(_, prop) {
+        let didDelete = delete this.owner.varProps[prop];
+        if (didDelete) {
+            triggerPropsProxyEffect(this, prop);
+        }
+        if (this.owner.constProps) {
+            didDelete = delete this.owner.constProps[prop] || didDelete;
+        }
+        if (this.owner.children != null && prop === 'children') {
+            this.owner.children = null;
+            didDelete = true;
+        }
+        return didDelete;
+    }
+    has(_, prop) {
+        if (prop === 'children') {
+            return this.owner.children != null;
+        }
+        else if (prop === _CONST_PROPS || prop === _VAR_PROPS) {
+            return true;
+        }
+        const inVarProps = prop in this.owner.varProps;
+        if (typeof prop === 'string') {
+            if (inVarProps) {
+                addPropsProxyEffect(this, prop);
+            }
+            if (typeof this.owner.type === 'string') {
+                const attr = jsxEventToHtmlAttribute(prop);
+                if (attr) {
+                    prop = attr;
+                }
+            }
+        }
+        return inVarProps || (this.owner.constProps ? prop in this.owner.constProps : false);
+    }
+    getOwnPropertyDescriptor(_, p) {
+        const value = p === 'children'
+            ? this.owner.children
+            : this.owner.constProps && p in this.owner.constProps
+                ? this.owner.constProps[p]
+                : this.owner.varProps[p];
+        return {
+            configurable: true,
+            enumerable: true,
+            value: value,
+        };
+    }
+    ownKeys() {
+        const out = Object.keys(this.owner.varProps);
+        if (this.owner.children != null) {
+            out.push('children');
+        }
+        if (this.owner.constProps) {
+            for (const key in this.owner.constProps) {
+                if (out.indexOf(key) === -1) {
+                    out.push(key);
+                }
+            }
+        }
+        return out;
+    }
+}
+const addPropsProxyEffect = (propsProxy, prop) => {
+    // Lazily grab the container from the invoke context
+    const ctx = tryGetInvokeContext();
+    if (ctx) {
+        if (propsProxy.$container$ === null) {
+            if (ctx.$container$) {
+                propsProxy.$container$ = ctx.$container$;
+            }
+        }
+        else {
+            isDev &&
+                assertTrue(!ctx.$container$ || ctx.$container$ === propsProxy.$container$, 'Do not use props across containers');
+        }
+    }
+    const effectSubscriber = ctx?.$effectSubscriber$;
+    if (effectSubscriber) {
+        addStoreEffect(propsProxy.owner._proxy, prop, propsProxy, effectSubscriber);
+    }
+};
+const triggerPropsProxyEffect = (propsProxy, prop) => {
+    const effects = getEffects$1(propsProxy.$effects$, prop);
+    if (effects) {
+        scheduleEffects(propsProxy.$container$, propsProxy, effects);
+    }
+    return !!effects;
+};
+function getEffects$1(effects, prop) {
+    // TODO: Handle STORE_ALL_PROPS
+    return effects?.get(prop);
+}
+/**
+ * Instead of using PropsProxyHandler getter (which could create a component-level subscription).
+ * Use this function to get the props directly from a const or var props.
+ *
+ * This does not convert jsx event names.
+ */
+const directGetPropsProxyProp = (jsx, prop) => {
+    return (jsx.constProps && prop in jsx.constProps ? jsx.constProps[prop] : jsx.varProps[prop]);
+};
+const _getProps = (props, prop) => {
+    return _getVarProps(props)?.[prop] || _getConstProps(props)?.[prop] || null;
+};
+/** Used by the optimizer for spread props operations @internal */
+const _getVarProps = (props) => {
+    if (!props) {
+        return null;
+    }
+    return _VAR_PROPS in props
+        ? 'children' in props
+            ? { ...props[_VAR_PROPS], children: props.children }
+            : props[_VAR_PROPS]
+        : props;
+};
+/** Used by the optimizer for spread props operations @internal */
+const _getConstProps = (props) => {
+    if (!props) {
+        return null;
+    }
+    return _CONST_PROPS in props ? props[_CONST_PROPS] : null;
+};
+const isPropsProxy = (obj) => {
+    return obj && _VAR_PROPS in obj;
+};
+
 /**
  * # ================================
  *
@@ -2017,7 +2272,7 @@ class SignalImpl {
     toString() {
         if (isDev) {
             try {
-                return (`[${this.constructor.name}${this.$flags$ & 1 /* SignalFlags.INVALID */ ? ' INVALID' : ''} ${this.$untrackedValue$}]` +
+                return (`[${this.constructor.name}${this.$flags$ & 1 /* ComputedSignalFlags.INVALID */ ? ' INVALID' : ''} ${this.$untrackedValue$}]` +
                     (Array.from(this.$effects$ || [])
                         .map((e) => '\n -> ' + pad(qwikDebugToString(e.consumer), '    '))
                         .join('\n') || ''));
@@ -2035,99 +2290,11 @@ class SignalImpl {
     }
 }
 
-const DEBUG$1 = false;
+const DEBUG = false;
 // eslint-disable-next-line no-console
-const log$1 = (...args) => console.log('COMPUTED SIGNAL', ...args.map(qwikDebugToString));
-/**
- * A signal which is computed from other signals.
- *
- * The value is available synchronously, but the computation is done lazily.
- */
-class ComputedSignalImpl extends SignalImpl {
-    /**
-     * The compute function is stored here.
-     *
-     * The computed functions must be executed synchronously (because of this we need to eagerly
-     * resolve the QRL during the mark dirty phase so that any call to it will be synchronous). )
-     */
-    $computeQrl$;
-    $flags$;
-    [_EFFECT_BACK_REF] = undefined;
-    constructor(container, fn, 
-    // We need a separate flag to know when the computation needs running because
-    // we need the old value to know if effects need running after computation
-    flags = 1 /* SignalFlags.INVALID */ |
-        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 || tryGetInvokeContext()?.$container$, NEEDS_COMPUTATION);
-        this.$computeQrl$ = fn;
-        this.$flags$ = flags;
-    }
-    invalidate() {
-        this.$flags$ |= 1 /* SignalFlags.INVALID */;
-        const ctx = newInvokeContext();
-        ctx.$container$ = this.$container$ || undefined;
-        // @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$();
-        isDev && assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, 'Invalid state');
-        return this.$untrackedValue$;
-    }
-    set untrackedValue(value) {
-        this.$untrackedValue$ = value;
-    }
-    $computeIfNeeded$() {
-        if (!(this.$flags$ & 1 /* SignalFlags.INVALID */)) {
-            return;
-        }
-        const computeQrl = this.$computeQrl$;
-        throwIfQRLNotResolved(computeQrl);
-        const ctx = tryGetInvokeContext();
-        const previousEffectSubscription = ctx?.$effectSubscriber$;
-        if (ctx) {
-            const effectSubscriber = getSubscriber(this, "." /* EffectProperty.VNODE */);
-            clearEffectSubscription(this.$container$, effectSubscriber);
-            ctx.$effectSubscriber$ = effectSubscriber;
-        }
-        try {
-            const untrackedValue = computeQrl.getFn(ctx)();
-            if (isPromise(untrackedValue)) {
-                throw qError(29 /* QError.computedNotSync */, [
-                    computeQrl.dev ? computeQrl.dev.file : '',
-                    computeQrl.$hash$,
-                ]);
-            }
-            DEBUG$1 && log$1('Signal.$compute$', untrackedValue);
-            this.$flags$ &= ~1 /* SignalFlags.INVALID */;
-            super.value = untrackedValue;
-        }
-        finally {
-            if (ctx) {
-                ctx.$effectSubscriber$ = previousEffectSubscription;
-            }
-        }
-    }
-}
-
-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 {
+const log = (...args) => console.log('COMPUTED SIGNAL', ...args.map(qwikDebugToString));
+/** Retains job metadata and also serves as the argument for CTX_ARG compute functions */
+class Job {
     $signal$;
     /** First holds the compute promise and then the cleanup promise */
     $promise$ = null;
@@ -2149,7 +2316,7 @@ class AsyncJob {
     /** Backward compatible cache method for resource */
     cache() {
         isDev &&
-            console.error('useResource cache() method does not do anything. Use `useAsync$` instead of `useResource$`, use the `expires` option for polling behavior.');
+            console.error('useResource cache() method does not do anything. Use `useComputed$` instead of `useResource$`; for polling use the `usePoll` hook from `@qwik.dev/utils`.');
     }
     get previous() {
         const val = this.$signal$.$untrackedValue$;
@@ -2164,62 +2331,123 @@ class AsyncJob {
     }
 }
 /**
- * # ================================
- *
- * AsyncSignalImpl
- *
- * # ================================
+ * A signal which is computed from other signals.
  *
- * @internal
+ * Sync compute functions resolve synchronously and every read they perform is auto-tracked. When
+ * the compute function turns out to be async (it returned a promise), the signal lazily switches on
+ * the async engine — jobs, `loading`, `error` — giving it the same API as an AsyncSignal.
+ * Auto-tracking only covers reads before the first await point (the invoke context is lost after
+ * it); later reads must use the ComputeCtx `track()`.
  */
-class AsyncSignalImpl extends ComputedSignalImpl {
-    $untrackedLoading$ = false;
-    $untrackedError$ = undefined;
-    $current$ = null;
+// TODO when we make core lazy async, lazy load the async engine part of this class
+class ComputedSignalImpl extends SignalImpl {
+    /**
+     * The compute function is stored here.
+     *
+     * Sync computed functions must be executed synchronously (because of this we need to eagerly
+     * resolve the QRL during the mark dirty phase so that any call to it will be synchronous).
+     */
+    $computeQrl$;
+    $flags$;
     [_EFFECT_BACK_REF] = undefined;
-    constructor(container, fn, flags = 1 /* SignalFlags.INVALID */ |
+    constructor(container, fn, 
+    // We need a separate flag to know when the computation needs running because
+    // we need the old value to know if effects need running after computation
+    flags = 1 /* ComputedSignalFlags.INVALID */ |
         16 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */, options) {
-        super(container, fn, flags);
+        // 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 || tryGetInvokeContext()?.$container$, NEEDS_COMPUTATION);
+        this.$computeQrl$ = fn;
+        this.$flags$ = flags;
         if (!options) {
             return;
         }
-        // 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
+        // Eagerly evaluate an initial value without clearing INVALID, so the compute still runs
         const initial = options.initial;
         if (initial !== undefined) {
-            const initialValue = typeof initial === 'function' ? initial() : initial;
-            this.$untrackedValue$ = initialValue;
+            this.$untrackedValue$ = typeof initial === 'function' ? initial() : initial;
         }
         const concurrency = options.concurrency;
         if (concurrency !== undefined && concurrency >= 0 && concurrency !== 1) {
             this.$concurrency$ = concurrency;
             this.$jobs$ = [];
         }
-        const timeout = options.timeout;
-        if (timeout) {
-            this.$timeoutMs$ = timeout;
+        if (options.timeout) {
+            this.$timeoutMs$ = options.timeout;
         }
         if (options.eagerCleanup) {
             this.$flags$ |= 32 /* AsyncSignalFlags.EAGER_CLEANUP */;
         }
         if (options.clientOnly) {
-            this.$flags$ |= 64 /* AsyncSignalFlags.CLIENT_ONLY */;
+            // clientOnly can never resolve during SSR, so it must be async from the start
+            this.$flags$ |= 64 /* AsyncSignalFlags.CLIENT_ONLY */ | 512 /* AsyncSignalFlags.ASYNC_MODE */;
         }
-        if (options.allowStale === false) {
-            if (isDev && initial !== undefined) {
-                throw new Error('allowStale: false and initial cannot be used together. ' +
-                    'allowStale: false clears the value on invalidation, which conflicts with providing an initial value.');
-            }
-            this.$flags$ |= 128 /* AsyncSignalFlags.CLEAR_ON_INVALIDATE */;
+    }
+    /** Clear the value so readers see the loading state, then recompute. */
+    clear() {
+        this.$untrackedValue$ = NEEDS_COMPUTATION;
+        this.invalidate();
+    }
+    invalidate(info) {
+        if (arguments.length > 0) {
+            this.$info$ = info;
+            this.$infoVersion$ = this.$infoVersion$ === undefined ? 1 : this.$infoVersion$ + 1;
         }
-        const expires = options.expires ?? (options.interval ? Math.abs(options.interval) : undefined);
-        if (expires) {
-            this.expires = expires;
+        if (this.$flags$ & 512 /* AsyncSignalFlags.ASYNC_MODE */) {
+            this.$setInvalid$(true);
+            return;
         }
-        if (options.poll === false || (options.interval !== undefined && options.interval < 0)) {
-            this.$flags$ |= 256 /* AsyncSignalFlags.NO_POLL */;
+        this.$flags$ |= 1 /* ComputedSignalFlags.INVALID */;
+        const ctx = newInvokeContext();
+        ctx.$container$ = this.$container$ || undefined;
+        // @ts-expect-error it's confused about args any[] vs []
+        const running = retryOnPromise(invokeApply.bind(this, ctx, this.$computeIfNeeded$));
+        if (isPromise(running)) {
+            running.catch((err) => {
+                if (this.$container$) {
+                    this.$container$.handleError(err, null);
+                }
+                else {
+                    console.error('Error during computation', err);
+                }
+            });
         }
     }
+    /**
+     * Read the value, subscribing if in a tracking context. Triggers computation if needed.
+     *
+     * Setting the value will mark the signal as not loading and clear any error, and prevent any
+     * pending computations from writing their results.
+     *
+     * If you want to set the value without affecting loading or error state, set `untrackedValue`
+     * instead and make sure to trigger effects manually if needed.
+     *
+     * If you want to abort pending computations when setting, you have to call `abort()` manually.
+     */
+    get value() {
+        return super.value;
+    }
+    set value(value) {
+        this.$flags$ &= -2 /* ComputedSignalFlags.INVALID */;
+        this.untrackedError = undefined;
+        if (this.$flags$ & 512 /* AsyncSignalFlags.ASYNC_MODE */) {
+            this.untrackedPending = false;
+            this.$info$ = undefined;
+            // Prevent pending computations from overwriting this value
+            if (this.$jobs$) {
+                for (let i = 0; i < this.$jobs$.length; i++) {
+                    this.$jobs$[i].$canWrite$ = false;
+                }
+            }
+            else if (this.$current$) {
+                this.$current$.$canWrite$ = false;
+            }
+            super.value = value;
+            return;
+        }
+        super.value = value;
+    }
     get untrackedValue() {
         this.$computeIfNeeded$();
         if (this.$current$?.$promise$) {
@@ -2238,52 +2466,26 @@ class AsyncSignalImpl extends ComputedSignalImpl {
             this.$untrackedValue$ === NEEDS_COMPUTATION) {
             throw qError(35 /* QError.asyncClientOnlyValueDuringSSR */);
         }
+        isDev &&
+            !(this.$flags$ & 512 /* AsyncSignalFlags.ASYNC_MODE */) &&
+            assertFalse(this.$untrackedValue$ === NEEDS_COMPUTATION, 'Invalid state');
         return this.$untrackedValue$;
     }
     set untrackedValue(value) {
         this.$untrackedValue$ = value;
     }
-    /**
-     * Read the value, subscribing if in a tracking context. Triggers computation if needed.
-     *
-     * Setting the value will mark the signal as not loading and clear any error, and prevent any
-     * pending computations from writing their results.
-     *
-     * If you want to set the value without affecting loading or error state, set `untrackedValue`
-     * instead and make sure to trigger effects manually if needed.
-     *
-     * If you want to abort pending computations when setting, you have to call `abort()` manually.
-     */
-    get value() {
-        return super.value;
-    }
-    set value(value) {
-        this.$flags$ &= -2 /* SignalFlags.INVALID */;
-        this.untrackedLoading = false;
-        this.untrackedError = undefined;
-        this.$info$ = undefined;
-        // Prevent pending computations from overwriting this value
-        if (this.$jobs$) {
-            for (let i = 0; i < this.$jobs$.length; i++) {
-                this.$jobs$[i].$canWrite$ = false;
-            }
-        }
-        else if (this.$current$) {
-            this.$current$.$canWrite$ = false;
-        }
-        this.$clearNextPoll$();
-        super.value = value;
-        this.$scheduleNextPoll$();
-    }
     /**
      * Loading is true if the signal is still waiting for the promise to resolve, false if the promise
-     * has resolved or rejected.
+     * has resolved or rejected (or the compute function is synchronous).
+     *
+     * Accessing `.pending` will trigger computation if needed, since it's often used like
      *
-     * Accessing .loading will trigger computation if needed, since it's often used like
-     * `signal.loading ? <Loading /> : signal.value`.
+     * ```ts
+     * signal.pending ? <Loading /> : signal.value
+     * ```
      */
-    get loading() {
-        const val = this.untrackedLoading;
+    get pending() {
+        const val = this.untrackedPending;
         const ctx = tryGetInvokeContext();
         if (ctx && (this.$container$ ||= ctx.$container$ || null)) {
             isDev &&
@@ -2297,22 +2499,41 @@ class AsyncSignalImpl extends ComputedSignalImpl {
         }
         return val;
     }
-    set untrackedLoading(value) {
-        if (value !== this.$untrackedLoading$) {
-            this.$untrackedLoading$ = value;
+    set untrackedPending(value) {
+        if (value !== !!this.$untrackedPending$) {
+            this.$untrackedPending$ = value;
             scheduleEffects(this.$container$, this, this.$loadingEffects$);
         }
     }
-    get untrackedLoading() {
+    get untrackedPending() {
         // 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 ((qTest ? isServerPlatform() : isServer) && this.$current$?.$promise$) {
             throw this.$current$?.$promise$;
         }
-        return this.$untrackedLoading$;
+        return !!this.$untrackedPending$;
     }
-    /** The error that occurred when the signal was resolved. */
+    /** @deprecated Use `pending` instead */
+    get loading() {
+        return this.pending;
+    }
+    /** @deprecated Use `untrackedPending` instead */
+    get untrackedLoading() {
+        return this.untrackedPending;
+    }
+    set untrackedLoading(value) {
+        this.untrackedPending = value;
+    }
+    /**
+     * The error the compute function threw or rejected with.
+     *
+     * Accessing .error will trigger computation if needed, since it's often used like
+     *
+     * ```ts
+     * signal.error ? <Failed /> : signal.value
+     * ```
+     */
     get error() {
         const val = this.untrackedError;
         const ctx = tryGetInvokeContext();
@@ -2335,62 +2556,15 @@ class AsyncSignalImpl extends ComputedSignalImpl {
         }
     }
     get untrackedError() {
-        return this.$untrackedError$;
-    }
-    get expires() {
-        return this.$expires$ || 0;
-    }
-    set expires(value) {
-        this.$clearNextPoll$();
-        this.$expires$ = value;
-        if (this.$expires$ && this.$hasSubscribers$()) {
-            this.$scheduleNextPoll$();
-        }
-    }
-    get poll() {
-        return !(this.$flags$ & 256 /* AsyncSignalFlags.NO_POLL */);
-    }
-    set poll(value) {
-        if (value) {
-            this.$flags$ &= -257 /* AsyncSignalFlags.NO_POLL */;
-        }
-        else {
-            this.$flags$ |= 256 /* AsyncSignalFlags.NO_POLL */;
-        }
-        // Reschedule since poll behavior changed
-        if (this.$expires$ && this.$hasSubscribers$()) {
-            this.$clearNextPoll$();
-            this.$scheduleNextPoll$();
-        }
-    }
-    /** @deprecated Use `expires` and `poll` instead. */
-    get interval() {
-        const expires = this.$expires$ || 0;
-        return this.$flags$ & 256 /* AsyncSignalFlags.NO_POLL */ ? -expires : expires;
-    }
-    set interval(value) {
-        if (value < 0) {
-            this.$flags$ |= 256 /* AsyncSignalFlags.NO_POLL */;
-        }
-        else {
-            this.$flags$ &= -257 /* AsyncSignalFlags.NO_POLL */;
-        }
-        this.expires = Math.abs(value);
-    }
-    /** Invalidates the signal, causing it to re-compute its value. */
-    async invalidate(info) {
-        if (arguments.length > 0) {
-            this.$info$ = info;
-            this.$infoVersion$ = this.$infoVersion$ === undefined ? 1 : this.$infoVersion$ + 1;
+        this.$computeIfNeeded$();
+        // During SSR we must render settled results
+        if ((qTest ? isServerPlatform() : isServer) && this.$current$?.$promise$) {
+            throw this.$current$?.$promise$;
         }
-        this.$setInvalid$(true, this.$flags$ & 128 /* AsyncSignalFlags.CLEAR_ON_INVALIDATE */);
+        return this.$untrackedError$;
     }
-    $setInvalid$(allowRecalc, mustClear) {
-        this.$flags$ |= 1 /* SignalFlags.INVALID */;
-        this.$clearNextPoll$();
-        if (mustClear) {
-            this.$untrackedValue$ = NEEDS_COMPUTATION;
-        }
+    $setInvalid$(allowRecalc) {
+        this.$flags$ |= 1 /* ComputedSignalFlags.INVALID */;
         if (allowRecalc &&
             (this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size)) {
             // compute in next microtask
@@ -2427,19 +2601,96 @@ class AsyncSignalImpl extends ComputedSignalImpl {
     }
     /** Run the computation if needed */
     $computeIfNeeded$() {
-        if (!(this.$flags$ & 1 /* SignalFlags.INVALID */)) {
+        if (!(this.$flags$ & 1 /* ComputedSignalFlags.INVALID */)) {
             return;
         }
+        if (this.$flags$ & 512 /* AsyncSignalFlags.ASYNC_MODE */) {
+            return this.$computeAsync$();
+        }
+        const computeQrl = this.$computeQrl$;
+        throwIfQRLNotResolved(computeQrl);
+        // The previous compute's cleanups run before the new compute, like the async engine
+        const prevJob = this.$current$;
+        if (prevJob && !prevJob.$cleanupRequested$) {
+            prevJob.$cleanupRequested$ = true;
+            prevJob.$abortController$?.abort();
+            this.$runCleanupCallbacks$(prevJob);
+        }
+        const running = new Job(this, this.$info$, this.$infoVersion$);
+        this.$current$ = running;
+        let result;
+        try {
+            result = this.$invokeComputeFn$(computeQrl.resolved, running);
+        }
+        catch (err) {
+            // A thrown promise is a retry request, not a failure
+            if (isPromise(err)) {
+                throw err;
+            }
+            if (running.$infoVersion$ === this.$infoVersion$) {
+                this.$info$ = undefined;
+            }
+            this.$flags$ &= -2 /* ComputedSignalFlags.INVALID */;
+            this.$setError$(running, err);
+            return;
+        }
+        if (isPromise(result)) {
+            // The compute fn is async: hand the in-flight computation to the async engine
+            this.$flags$ |= 512 /* AsyncSignalFlags.ASYNC_MODE */;
+            this.$flags$ &= -2 /* ComputedSignalFlags.INVALID */;
+            // Consume the in-flight promise first; retries re-invoke the compute fn
+            let first = result;
+            const compute = () => {
+                const r = first ?? this.$invokeComputeFn$(this.$computeQrl$.resolved, running);
+                first = undefined;
+                return r;
+            };
+            running.$promise$ = this.$settleComputation$(running, () => retryOnPromise(compute));
+            return;
+        }
+        if (running.$infoVersion$ === this.$infoVersion$) {
+            this.$info$ = undefined;
+        }
+        this.$flags$ &= -2 /* ComputedSignalFlags.INVALID */;
+        this.untrackedError = undefined;
+        super.value = result;
+    }
+    /**
+     * Invoke the compute fn with the ComputeCtx argument. CTX_ARG signals (useAsync$, useResource$)
+     * only track via its explicit track(). Computeds auto-track every synchronous read instead; after
+     * the first await they must use the explicit track() too.
+     */
+    $invokeComputeFn$(fn, job) {
+        const computeFn = fn;
+        if (this.$flags$ & 1024 /* AsyncSignalFlags.CTX_ARG */) {
+            // Strip the ambient effect subscriber: these compute fns track only via their track()
+            let iCtx = tryGetInvokeContext();
+            if (iCtx?.$effectSubscriber$) {
+                iCtx = { ...iCtx, $effectSubscriber$: undefined };
+            }
+            return invokeApply(iCtx, computeFn, [job]);
+        }
+        const container = (this.$container$ ||= tryGetInvokeContext()?.$container$ || null);
+        const subscriber = getSubscriber(this, "." /* EffectProperty.VNODE */);
+        if (container) {
+            clearEffectSubscription(container, subscriber);
+        }
+        const ctx = newInvokeContext();
+        ctx.$container$ = container || undefined;
+        ctx.$effectSubscriber$ = subscriber;
+        return invokeApply(ctx, computeFn, [job]);
+    }
+    /** Start an async computation (the async engine; assumes the INVALID flag is set) */
+    $computeAsync$() {
         // Skip computation on SSR for clientOnly signals
         if ((qTest ? isServerPlatform() : isServer) && this.$flags$ & 64 /* AsyncSignalFlags.CLIENT_ONLY */) {
             // We must pretend to load, and register as a listener for the captures
-            this.$untrackedLoading$ = true;
+            this.$untrackedPending$ = true;
             this.$container$?.serializationCtx.$eagerResume$.add(this);
             return;
         }
-        this.$clearNextPoll$();
         // Clear flag here to make sure the cleanups don't start another compute
-        this.$flags$ &= -2 /* SignalFlags.INVALID */;
+        this.$flags$ &= -2 /* ComputedSignalFlags.INVALID */;
         const current = this.$current$;
         if (current) {
             this.$requestCleanups$(current);
@@ -2449,12 +2700,12 @@ class AsyncSignalImpl extends ComputedSignalImpl {
         if (this.$jobs$ ? this.$jobs$.length >= limit : current?.$promise$) {
             // We requested cleanups for all the previous jobs, once one finishes it will be removed from the jobs array and trigger computeIfNeeded
             // Restore invalid state
-            this.$flags$ |= 1 /* SignalFlags.INVALID */;
+            this.$flags$ |= 1 /* ComputedSignalFlags.INVALID */;
             return;
         }
         // We put the actual computation in a separate method so we can easily retain the promise
         const infoVersion = this.$infoVersion$;
-        const running = new AsyncJob(this, this.$info$, infoVersion);
+        const running = new Job(this, this.$info$, infoVersion);
         this.$current$ = running;
         if (this.$jobs$) {
             this.$jobs$.push(running);
@@ -2462,35 +2713,39 @@ class AsyncSignalImpl extends ComputedSignalImpl {
         running.$promise$ = this.$runComputation$(running);
     }
     async $runComputation$(running) {
-        const isCurrent = () => running === this.$current$;
         let fn = this.$computeQrl$.resolved;
         if (!fn) {
             // QRL resolution is async — we have to publish loading=true before awaiting so
             // subscribers know the value isn't ready yet.
-            this.untrackedLoading = true;
+            this.untrackedPending = true;
             fn = await this.$computeQrl$.resolve();
             if (running.$abortController$?.signal.aborted) {
                 running.$promise$ = null;
                 return;
             }
         }
+        if (this.$timeoutMs$) {
+            this.$computationTimeoutId$ = setTimeout(() => {
+                const error = new Error(`timeout ${this.$timeoutMs$}ms`);
+                this.$setError$(running, error);
+                running.$abortController$?.abort(error);
+            }, this.$timeoutMs$);
+        }
+        return this.$settleComputation$(running, () => retryOnPromise(() => this.$invokeComputeFn$(fn, running)));
+    }
+    /** Await the computation and publish its result, error, and loading transitions. */
+    async $settleComputation$(running, compute) {
+        const isCurrent = () => running === this.$current$;
         try {
-            if (this.$timeoutMs$) {
-                this.$computationTimeoutId$ = setTimeout(() => {
-                    const error = new Error(`timeout ${this.$timeoutMs$}ms`);
-                    this.$setError$(running, error);
-                    running.$abortController$?.abort(error);
-                }, this.$timeoutMs$);
-            }
             // Try to stay sync if possible. Only publish loading=true to subscribers when
             // the compute is actually asynchronous — a synchronous resolve (e.g. pre-loaded
             // values injected via _injectAsyncSignalValue) should never transition through a
             // visible loading state, which on SSR would fire the loading-effect subscribers
             // (tasks) while the value is still "loading" from their perspective.
-            const valuePromise = retryOnPromise(fn.bind(null, running));
+            const valuePromise = compute();
             let value;
             if (isPromise(valuePromise)) {
-                this.untrackedLoading = true;
+                this.untrackedPending = true;
                 value = await valuePromise;
             }
             else {
@@ -2515,7 +2770,7 @@ class AsyncSignalImpl extends ComputedSignalImpl {
                 // Note that these assignments run setters
                 this.untrackedError = undefined;
                 /**
-                 * Use super.value instead of this.value to persist invalid state, so that invalidation
+                 * Use SignalImpl.value instead of this.value to persist invalid state, so that invalidation
                  * during computation recomputes
                  */
                 super.value = value;
@@ -2530,13 +2785,12 @@ class AsyncSignalImpl extends ComputedSignalImpl {
             if (running.$infoVersion$ === this.$infoVersion$) {
                 this.$info$ = undefined;
             }
-            if (this.$flags$ & 1 /* SignalFlags.INVALID */) {
+            if (this.$flags$ & 1 /* ComputedSignalFlags.INVALID */) {
                 // we became invalid again while running, so we need to re-run the computation to get the new promise
                 this.$computeIfNeeded$();
             }
             else {
-                this.untrackedLoading = false;
-                this.$scheduleNextPoll$();
+                this.untrackedPending = false;
             }
         }
     }
@@ -2559,341 +2813,82 @@ class AsyncSignalImpl extends ComputedSignalImpl {
     }
     /** Called after SSR/unmount */
     async $destroy$() {
-        this.$clearNextPoll$();
         clearTimeout(this.$computationTimeoutId$);
         const current = this.$current$;
         if (current) {
-            this.$requestCleanups$(current);
-        }
-        if (this.$jobs$) {
-            await Promise.all(this.$jobs$.map((job) => job.$promise$));
-        }
-        else {
-            await current?.$promise$;
-        }
-    }
-    $clearNextPoll$() {
-        if (this.$pollTimeoutId$ !== undefined) {
-            clearTimeout(this.$pollTimeoutId$);
-            this.$pollTimeoutId$ = undefined;
-        }
-    }
-    $scheduleNextPoll$() {
-        if ((qTest ? isServerPlatform() : isServer) || !this.$expires$) {
-            return;
-        }
-        this.$clearNextPoll$();
-        const allowRecalc = !(this.$flags$ & 256 /* AsyncSignalFlags.NO_POLL */);
-        // Even when clear on invalidate, we don't clear if we're merely re-running due to polling
-        // We expect to get the new value soon, so we can avoid showing a loading state
-        const mustClear = this.$flags$ & 128 /* AsyncSignalFlags.CLEAR_ON_INVALIDATE */ && !allowRecalc;
-        this.$pollTimeoutId$ = setTimeout(() => this.$setInvalid$(allowRecalc, mustClear), this.$expires$);
-        this.$pollTimeoutId$?.unref?.();
-    }
-    $hasSubscribers$() {
-        return !!(this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size);
-    }
-    $requestCleanups$(job, reason) {
-        if (job.$cleanupRequested$) {
-            return;
-        }
-        job.$cleanupRequested$ = true;
-        job.$abortController$?.abort(reason);
-        job.$promise$ = maybeThen(job.$promise$, () => this.$runCleanups$(job));
-    }
-    /** Clean up and trigger signal compute once complete */
-    $runCleanups$(job) {
-        const cleanups = job.$cleanups$;
-        const onError = (err) => {
-            const handleError = this.$container$?.handleError;
-            if (handleError) {
-                handleError(err, null);
-            }
-            else {
-                console.error('Error in async signal cleanup', err);
-            }
-        };
-        const onDone = () => {
-            job.$promise$ = null;
-            if (cleanups) {
-                cleanups.length = 0;
-            }
-            // Now trigger compute
-            const jobs = this.$jobs$;
-            if (jobs) {
-                const idx = jobs.indexOf(job);
-                if (idx !== -1) {
-                    jobs.splice(idx, 1);
-                }
-            }
-            this.$computeIfNeeded$();
-        };
-        let promiseChain = undefined;
-        if (cleanups) {
-            // Keep this sync-ish so sync functions run immediately.
-            for (let i = 0; i < cleanups.length; i++) {
-                try {
-                    const result = cleanups[i]();
-                    if (isPromise(result)) {
-                        promiseChain = (promiseChain ? promiseChain.then(() => result) : result).catch(onError);
-                    }
-                }
-                catch (err) {
-                    onError(err);
-                }
-            }
-        }
-        if (promiseChain) {
-            return promiseChain.then(onDone);
-        }
-        else {
-            onDone();
-        }
-    }
-}
-/**
- * Inject a pre-loaded value into an AsyncSignal while preserving track() subscriptions. Calls
- * `invalidate({ __v })` so the compute function reads the value from `info`, then triggers an
- * immediate synchronous compute via the private $computeIfNeeded$() method (which is mangled in
- * core builds, so callers from other packages must go through this helper).
- *
- * @internal
- */
-const _injectAsyncSignalValue = (signal, value) => {
-    const impl = signal;
-    impl.invalidate({ __v: value });
-    impl.$computeIfNeeded$();
-};
-
-/** @internal */
-const _CONST_PROPS = Symbol('CONST');
-/** @internal */
-const _VAR_PROPS = Symbol('VAR');
-/** @internal */
-const _OWNER = Symbol('OWNER');
-/** @internal */
-const _PROPS_HANDLER = Symbol('PROPS_HANDLER');
-/** @internal @deprecated v1 compat */
-const _IMMUTABLE = Symbol('IMMUTABLE');
-/** @internal */
-const _UNINITIALIZED = Symbol('UNINITIALIZED');
-
-/** @internal */
-const EMPTY_ARRAY = [];
-/** @internal */
-const EMPTY_OBJ = {};
-Object.freeze(EMPTY_ARRAY);
-Object.freeze(EMPTY_OBJ);
-
-function createPropsProxy(owner) {
-    // TODO don't make a proxy but populate getters? benchmark
-    return new Proxy({}, new PropsProxyHandler(owner));
-}
-class PropsProxyHandler {
-    owner;
-    $effects$ = undefined;
-    $container$ = null;
-    constructor(owner) {
-        this.owner = owner;
-    }
-    get(_, prop) {
-        // escape hatch to get the separated props from a component
-        if (prop === _CONST_PROPS) {
-            return this.owner.constProps;
-        }
-        else if (prop === _VAR_PROPS) {
-            return this.owner.varProps;
-        }
-        else if (prop === _OWNER) {
-            return this.owner;
-        }
-        else if (prop === _PROPS_HANDLER) {
-            return this;
-        }
-        let value;
-        if (prop === 'children') {
-            value = this.owner.children;
-        }
-        else {
-            if (typeof prop === 'string' && typeof this.owner.type === 'string') {
-                const attr = jsxEventToHtmlAttribute(prop);
-                if (attr) {
-                    prop = attr;
-                }
-            }
-            value = directGetPropsProxyProp(this.owner, prop);
-            if (prop in this.owner.varProps) {
-                addPropsProxyEffect(this, prop);
-            }
-        }
-        // a proxied value that the optimizer made
-        return value instanceof WrappedSignalImpl && value.$flags$ & 4 /* WrappedSignalFlags.UNWRAP */
-            ? value.value
-            : value;
-    }
-    set(_, prop, value) {
-        if (prop === _OWNER) {
-            // used for deserialization
-            this.owner = value;
-        }
-        else if (prop === 'children') {
-            this.owner.children = value;
-        }
-        else if (prop === _CONST_PROPS) {
-            this.owner.constProps = value;
-        }
-        else if (prop === _VAR_PROPS) {
-            this.owner.varProps = value;
-        }
-        else {
-            if (typeof prop === 'string' && typeof this.owner.type === 'string') {
-                const attr = jsxEventToHtmlAttribute(prop);
-                if (attr) {
-                    prop = attr;
-                }
-            }
-            if (this.owner.constProps && prop in this.owner.constProps) {
-                // delete the prop from the const props first
-                delete this.owner.constProps[prop];
-            }
-            if (this.owner.varProps === EMPTY_OBJ) {
-                this.owner.varProps = {};
-            }
-            else if (!(prop in this.owner.varProps)) {
-                this.owner.toSort = true;
-            }
-            if (this.owner.varProps[prop] !== value) {
-                this.owner.varProps[prop] = value;
-                triggerPropsProxyEffect(this, prop);
-            }
-        }
-        return true;
-    }
-    deleteProperty(_, prop) {
-        let didDelete = delete this.owner.varProps[prop];
-        if (didDelete) {
-            triggerPropsProxyEffect(this, prop);
-        }
-        if (this.owner.constProps) {
-            didDelete = delete this.owner.constProps[prop] || didDelete;
-        }
-        if (this.owner.children != null && prop === 'children') {
-            this.owner.children = null;
-            didDelete = true;
-        }
-        return didDelete;
-    }
-    has(_, prop) {
-        if (prop === 'children') {
-            return this.owner.children != null;
-        }
-        else if (prop === _CONST_PROPS || prop === _VAR_PROPS) {
-            return true;
-        }
-        const inVarProps = prop in this.owner.varProps;
-        if (typeof prop === 'string') {
-            if (inVarProps) {
-                addPropsProxyEffect(this, prop);
-            }
-            if (typeof this.owner.type === 'string') {
-                const attr = jsxEventToHtmlAttribute(prop);
-                if (attr) {
-                    prop = attr;
-                }
-            }
+            this.$requestCleanups$(current);
+        }
+        if (this.$jobs$) {
+            await Promise.all(this.$jobs$.map((job) => job.$promise$));
+        }
+        else {
+            await current?.$promise$;
         }
-        return inVarProps || (this.owner.constProps ? prop in this.owner.constProps : false);
     }
-    getOwnPropertyDescriptor(_, p) {
-        const value = p === 'children'
-            ? this.owner.children
-            : this.owner.constProps && p in this.owner.constProps
-                ? this.owner.constProps[p]
-                : this.owner.varProps[p];
-        return {
-            configurable: true,
-            enumerable: true,
-            value: value,
-        };
+    $hasSubscribers$() {
+        return !!(this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size);
     }
-    ownKeys() {
-        const out = Object.keys(this.owner.varProps);
-        if (this.owner.children != null) {
-            out.push('children');
+    $requestCleanups$(job, reason) {
+        if (job.$cleanupRequested$) {
+            return;
         }
-        if (this.owner.constProps) {
-            for (const key in this.owner.constProps) {
-                if (out.indexOf(key) === -1) {
-                    out.push(key);
+        job.$cleanupRequested$ = true;
+        job.$abortController$?.abort(reason);
+        job.$promise$ = maybeThen(job.$promise$, () => this.$runCleanups$(job));
+    }
+    /** Run a job's cleanup callbacks, returning a promise when any of them are async. */
+    $runCleanupCallbacks$(job) {
+        const cleanups = job.$cleanups$;
+        const onError = (err) => {
+            const handleError = this.$container$?.handleError;
+            if (handleError) {
+                handleError(err, null);
+            }
+            else {
+                console.error('Error in async signal cleanup', err);
+            }
+        };
+        let promiseChain = undefined;
+        if (cleanups) {
+            // Keep this sync-ish so sync functions run immediately.
+            for (let i = 0; i < cleanups.length; i++) {
+                try {
+                    const result = cleanups[i]();
+                    if (isPromise(result)) {
+                        promiseChain = (promiseChain ? promiseChain.then(() => result) : result).catch(onError);
+                    }
+                }
+                catch (err) {
+                    onError(err);
                 }
             }
+            cleanups.length = 0;
         }
-        return out;
+        return promiseChain;
     }
-}
-const addPropsProxyEffect = (propsProxy, prop) => {
-    // Lazily grab the container from the invoke context
-    const ctx = tryGetInvokeContext();
-    if (ctx) {
-        if (propsProxy.$container$ === null) {
-            if (ctx.$container$) {
-                propsProxy.$container$ = ctx.$container$;
+    /** Clean up and trigger signal compute once complete */
+    $runCleanups$(job) {
+        const onDone = () => {
+            job.$promise$ = null;
+            // Now trigger compute
+            const jobs = this.$jobs$;
+            if (jobs) {
+                const idx = jobs.indexOf(job);
+                if (idx !== -1) {
+                    jobs.splice(idx, 1);
+                }
             }
+            this.$computeIfNeeded$();
+        };
+        const promiseChain = this.$runCleanupCallbacks$(job);
+        if (promiseChain) {
+            return promiseChain.then(onDone);
         }
         else {
-            isDev &&
-                assertTrue(!ctx.$container$ || ctx.$container$ === propsProxy.$container$, 'Do not use props across containers');
+            onDone();
         }
     }
-    const effectSubscriber = ctx?.$effectSubscriber$;
-    if (effectSubscriber) {
-        addStoreEffect(propsProxy.owner._proxy, prop, propsProxy, effectSubscriber);
-    }
-};
-const triggerPropsProxyEffect = (propsProxy, prop) => {
-    const effects = getEffects$1(propsProxy.$effects$, prop);
-    if (effects) {
-        scheduleEffects(propsProxy.$container$, propsProxy, effects);
-    }
-    return !!effects;
-};
-function getEffects$1(effects, prop) {
-    // TODO: Handle STORE_ALL_PROPS
-    return effects?.get(prop);
 }
-/**
- * Instead of using PropsProxyHandler getter (which could create a component-level subscription).
- * Use this function to get the props directly from a const or var props.
- *
- * This does not convert jsx event names.
- */
-const directGetPropsProxyProp = (jsx, prop) => {
-    return (jsx.constProps && prop in jsx.constProps ? jsx.constProps[prop] : jsx.varProps[prop]);
-};
-const _getProps = (props, prop) => {
-    return _getVarProps(props)?.[prop] || _getConstProps(props)?.[prop] || null;
-};
-/** Used by the optimizer for spread props operations @internal */
-const _getVarProps = (props) => {
-    if (!props) {
-        return null;
-    }
-    return _VAR_PROPS in props
-        ? 'children' in props
-            ? { ...props[_VAR_PROPS], children: props.children }
-            : props[_VAR_PROPS]
-        : props;
-};
-/** Used by the optimizer for spread props operations @internal */
-const _getConstProps = (props) => {
-    if (!props) {
-        return null;
-    }
-    return _CONST_PROPS in props ? props[_CONST_PROPS] : null;
-};
-const isPropsProxy = (obj) => {
-    return obj && _VAR_PROPS in obj;
-};
 
 // <docs markdown="../../readme.md#implicit$FirstArg">
 // !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
@@ -2949,11 +2944,11 @@ const implicit$FirstArg = (fn) => {
  */
 class SerializerSignalImpl extends ComputedSignalImpl {
     constructor(container, argQrl) {
-        super(container, argQrl, 1 /* SignalFlags.INVALID */ | 16 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */);
+        super(container, argQrl, 1 /* ComputedSignalFlags.INVALID */ | 16 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */);
     }
     $didInitialize$ = false;
     $computeIfNeeded$() {
-        if (!(this.$flags$ & 1 /* SignalFlags.INVALID */)) {
+        if (!(this.$flags$ & 1 /* ComputedSignalFlags.INVALID */)) {
             return;
         }
         throwIfQRLNotResolved(this.$computeQrl$);
@@ -2966,7 +2961,7 @@ class SerializerSignalImpl extends ComputedSignalImpl {
             : deserialize(currentValue), this, "." /* EffectProperty.VNODE */, this.$container$);
         this.$didInitialize$ = true;
         // Needs to invalidate only after all possible Promise throws happened
-        this.$flags$ &= -2 /* SignalFlags.INVALID */;
+        this.$flags$ &= -2 /* ComputedSignalFlags.INVALID */;
         // 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$;
@@ -2977,13 +2972,46 @@ class SerializerSignalImpl extends ComputedSignalImpl {
     }
 }
 
+/**
+ * # ================================
+ *
+ * AsyncSignalImpl
+ *
+ * # ================================
+ *
+ * The async engine (jobs, loading, error) lives in ComputedSignalImpl; this subclass configures it
+ * from options and switches the compute invocation to CTX_ARG mode: the compute fn receives the
+ * ComputeCtx argument and tracks only via its explicit `track()` (no auto-tracking).
+ *
+ * @internal
+ */
+class AsyncSignalImpl extends ComputedSignalImpl {
+    constructor(container, fn, flags = 1 /* ComputedSignalFlags.INVALID */ |
+        16 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */, options) {
+        super(container, fn, flags | 512 /* AsyncSignalFlags.ASYNC_MODE */ | 1024 /* AsyncSignalFlags.CTX_ARG */, options);
+    }
+}
+/**
+ * Inject a pre-loaded value into a signal while preserving subscriptions. Calls `invalidate({__v})`
+ * so the compute function reads the value from `info`, then triggers an immediate synchronous
+ * compute via the private `$computeIfNeeded$()` method (which is mangled in core builds, so callers
+ * from other packages must go through this helper).
+ *
+ * @internal
+ */
+const _injectAsyncSignalValue = (signal, value) => {
+    const impl = signal;
+    impl.invalidate({ __v: value });
+    impl.$computeIfNeeded$();
+};
+
 /** @internal */
 const createSignal$1 = (value) => {
     return new SignalImpl(null, value);
 };
 /** @internal */
 const createComputedSignal = (qrl, options) => {
-    return new ComputedSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || 'always'));
+    return new ComputedSignalImpl(options?.container || null, qrl, getComputedSignalFlags(options?.serializationStrategy || 'always'), options);
 };
 /** @internal */
 const createAsyncSignal = (qrl, options) => {
@@ -3007,9 +3035,10 @@ const createSignal = createSignal$1;
  * recalculated.
  *
  * 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 `createAsync$` instead (don't forget to use `track()`).
+ * effects. Every synchronous signal or store read is tracked automatically; reads after the first
+ * `await` must use the `track()` provided on the context argument. When the function is async, the
+ * returned signal exposes the async API (`.pending`, `.error`, `.promise()`), and reading an
+ * unresolved `.value` throws the computation promise.
  *
  * @public
  */
@@ -3018,6 +3047,7 @@ const createComputed$ = /*#__PURE__*/ implicit$FirstArg(createComputedSignal);
  * Create a signal holding a `.value` which is calculated from the given async function (QRL). The
  * standalone version of `useAsync$`.
  *
+ * @deprecated Use `createComputed$` instead, it has async support now.
  * @public
  */
 const createAsync$ = /*#__PURE__*/ implicit$FirstArg(createAsyncSignal);
@@ -3064,10 +3094,10 @@ const _wrapProp = (...args) => {
         return obj[prop];
     }
     if (isSignal(obj)) {
-        if (!(obj instanceof AsyncSignalImpl)) {
+        if (!(obj instanceof ComputedSignalImpl)) {
             isDev && assertEqual(prop, 'value', 'Left side is a signal, prop must be value');
         }
-        if (obj instanceof WrappedSignalImpl && obj.$flags$ & 4 /* WrappedSignalFlags.UNWRAP */) {
+        if (obj instanceof WrappedSignalImpl) {
             return obj;
         }
         return getWrapped(args);
@@ -3121,7 +3151,7 @@ class WrappedSignalImpl extends SignalImpl {
     constructor(container, fn, args, fnStr, 
     // We need a separate flag to know when the computation needs running because
     // we need the old value to know if effects need running after computation
-    flags = 1 /* SignalFlags.INVALID */ | 4 /* WrappedSignalFlags.UNWRAP */) {
+    flags = 1 /* ComputedSignalFlags.INVALID */) {
         super(container, NEEDS_COMPUTATION);
         this.$args$ = args;
         this.$func$ = fn;
@@ -3129,7 +3159,7 @@ class WrappedSignalImpl extends SignalImpl {
         this.$flags$ = flags;
     }
     invalidate() {
-        this.$flags$ |= 1 /* SignalFlags.INVALID */;
+        this.$flags$ |= 1 /* ComputedSignalFlags.INVALID */;
         // we are trying to run computation without creating a chore, which can be expensive
         // for many signals. If it fails, we schedule a chore to run the computation.
         try {
@@ -3142,8 +3172,8 @@ class WrappedSignalImpl extends SignalImpl {
             }
         }
         // if the computation not failed, we can run the effects directly
-        if (this.$flags$ & 2 /* SignalFlags.RUN_EFFECTS */) {
-            this.$flags$ &= -3 /* SignalFlags.RUN_EFFECTS */;
+        if (this.$flags$ & 2 /* ComputedSignalFlags.RUN_EFFECTS */) {
+            this.$flags$ &= -3 /* ComputedSignalFlags.RUN_EFFECTS */;
             scheduleEffects(this.$container$, this, this.$effects$);
         }
     }
@@ -3153,7 +3183,7 @@ class WrappedSignalImpl extends SignalImpl {
         return this.$untrackedValue$;
     }
     $computeIfNeeded$() {
-        if (!(this.$flags$ & 1 /* SignalFlags.INVALID */)) {
+        if (!(this.$flags$ & 1 /* ComputedSignalFlags.INVALID */)) {
             return;
         }
         const untrackedValue = trackSignal(() => this.$func$(...this.$args$), this, "." /* EffectProperty.VNODE */, this.$container$);
@@ -3164,10 +3194,10 @@ class WrappedSignalImpl extends SignalImpl {
         // this.$flags$ &= ~SignalFlags.INVALID;
         // reset flag in case we call computedIfNeeded twice and the value was changed only the first time
         // TODO: change to version number?
-        this.$flags$ &= -3 /* SignalFlags.RUN_EFFECTS */;
+        this.$flags$ &= -3 /* ComputedSignalFlags.RUN_EFFECTS */;
         const didChange = untrackedValue !== this.$untrackedValue$;
         if (didChange) {
-            this.$flags$ |= 2 /* SignalFlags.RUN_EFFECTS */;
+            this.$flags$ |= 2 /* ComputedSignalFlags.RUN_EFFECTS */;
             this.$untrackedValue$ = untrackedValue;
         }
     }
@@ -3271,12 +3301,15 @@ const isJSXNode = (n) => {
  * load the QRL captured scope ourselves. Otherwise, we are being called as a QRL and the captures
  * are already set.
  */
-const maybeScopeFromQL = (captureIds, element) => {
-    if (typeof captureIds === 'string') {
+const withScopeFromQL = (captureDeltas, element, callback) => {
+    if (typeof captureDeltas === 'string') {
         const container = getDomContainer(element);
-        setCaptures(deserializeCaptures(container, captureIds));
+        return whenContainerDataReady(container, () => {
+            setCaptures(deserializeCaptureDeltas(container, captureDeltas));
+            return callback();
+        });
     }
-    return null;
+    return callback();
 };
 /**
  * Handles events for bind:value
@@ -3284,9 +3317,10 @@ const maybeScopeFromQL = (captureIds, element) => {
  * @internal
  */
 function _val(_, element) {
-    maybeScopeFromQL(this, element);
-    const signal = _captures[0];
-    signal.value = element.type === 'number' ? element.valueAsNumber : element.value;
+    return withScopeFromQL(this, element, () => {
+        const signal = _captures[0];
+        signal.value = element.type === 'number' ? element.valueAsNumber : element.value;
+    });
 }
 /**
  * Handles events for bind:checked
@@ -3294,9 +3328,10 @@ function _val(_, element) {
  * @internal
  */
 function _chk(_, element) {
-    maybeScopeFromQL(this, element);
-    const signal = _captures[0];
-    signal.value = element.checked;
+    return withScopeFromQL(this, element, () => {
+        const signal = _captures[0];
+        signal.value = element.checked;
+    });
 }
 /**
  * Resumes selected state (e.g. polling AsyncSignals) by deserializing captures. Used for
@@ -3305,17 +3340,18 @@ function _chk(_, element) {
  * @internal
  */
 function _res(_, element) {
-    maybeScopeFromQL(this, element);
-    // Captures are deserialized, now trigger computation on AsyncSignals
-    if (_captures) {
-        for (let i = 0; i < _captures.length; i++) {
-            const capture = _captures[i];
-            if (capture instanceof AsyncSignalImpl && capture.$flags$ & 64 /* AsyncSignalFlags.CLIENT_ONLY */) {
-                capture.$computeIfNeeded$();
+    return withScopeFromQL(this, element, () => {
+        // Captures are deserialized, now trigger computation on AsyncSignals
+        if (_captures) {
+            for (let i = 0; i < _captures.length; i++) {
+                const capture = _captures[i];
+                if (capture instanceof AsyncSignalImpl && capture.$flags$ & 64 /* AsyncSignalFlags.CLIENT_ONLY */) {
+                    capture.$computeIfNeeded$();
+                }
+                // note that polling async signals will automatically schedule themselves so no action needed
             }
-            // note that polling async signals will automatically schedule themselves so no action needed
         }
-    }
+    });
 }
 
 const BIND_VALUE = 'bind:value';
@@ -3956,31 +3992,25 @@ const useConstant = (value, ...args) => {
     return set(value);
 };
 
-const createCursorBoundary = () => {
-    return {
-        pending: createSignal(0),
-        version: createSignal(0),
-    };
-};
 /** @internal */
 const useCursorBoundary = () => {
     if (!__EXPERIMENTAL__.suspense) {
         throw new Error('useCursorBoundary is experimental and must be enabled with `experimental: ["suspense"]` in the `qwikVite` plugin.');
     }
-    return useConstant(createCursorBoundary);
+    return useSignal(0);
 };
 function addCursorBoundary(cursorData, vNode) {
     if (!__EXPERIMENTAL__.suspense) {
         return;
     }
-    const boundary = getNearestCursorBoundary(cursorData.container, vNode);
+    const boundary = getNearestCursorBoundary(vNode);
     if (!boundary) {
         return;
     }
     const boundaries = (cursorData.boundaries ||= []);
     if (!boundaries.includes(boundary)) {
         boundaries.push(boundary);
-        boundary.pending.value++;
+        boundary.value++;
     }
 }
 function resolveCursorBoundaries(cursorData) {
@@ -3994,40 +4024,35 @@ function resolveCursorBoundaries(cursorData) {
     cursorData.boundaries = null;
     for (let i = 0; i < boundaries.length; i++) {
         const boundary = boundaries[i];
-        boundary.pending.value = Math.max(0, boundary.pending.value - 1);
-        boundary.version.value++;
-    }
-}
-function getOwnCursorBoundary(container, vNode) {
-    if (!__EXPERIMENTAL__.suspense) {
-        return null;
+        boundary.value = Math.max(0, boundary.value - 1);
     }
-    return container.getHostProp(vNode, QCursorBoundary);
 }
-function getNearestCursorBoundaryProp(vNode) {
+function getOwnCursorBoundary(vNode) {
     if (!__EXPERIMENTAL__.suspense) {
         return null;
     }
-    return (vnode_getProp(vNode, NEAREST_CURSOR_BOUNDARY, null) ||
-        null);
+    return vnode_getProp(vNode, QCursorBoundary, null) || null;
 }
 function clearNearestCursorBoundary(vNode) {
-    if (!__EXPERIMENTAL__.suspense) {
-        return;
-    }
-    vnode_setProp(vNode, NEAREST_CURSOR_BOUNDARY, null);
+    setNearestCursorBoundary(vNode, null);
 }
-function getNearestCursorBoundary(container, vNode) {
+function getNearestCursorBoundary(vNode) {
     if (!__EXPERIMENTAL__.suspense) {
         return null;
     }
-    return getNearestCursorBoundaryProp(vNode) || getOwnCursorBoundary(container, vNode);
+    return (vnode_getProp(vNode, NEAREST_CURSOR_BOUNDARY, null) ||
+        getOwnCursorBoundary(vNode));
 }
 function setNearestCursorBoundary(vNode, boundary) {
     __EXPERIMENTAL__.suspense && vnode_setProp(vNode, NEAREST_CURSOR_BOUNDARY, boundary);
 }
+function clearCursorBoundary(vNode) {
+    if (__EXPERIMENTAL__.suspense && vNode.props && QCursorBoundary in vNode.props) {
+        vnode_setProp(vNode, QCursorBoundary, null);
+    }
+}
 /** Updates the nearest cursor boundary cache on a vnode and any already-dirty descendants. */
-function updateDirtySubtreeCursorBoundary(container, vNode, boundary) {
+function updateDirtySubtreeCursorBoundary(vNode, boundary) {
     if (!__EXPERIMENTAL__.suspense) {
         return;
     }
@@ -4038,7 +4063,7 @@ function updateDirtySubtreeCursorBoundary(container, vNode, boundary) {
     }
     for (let i = 0; i < dirtyChildren.length; i++) {
         const child = dirtyChildren[i];
-        updateDirtySubtreeCursorBoundary(container, child, getOwnCursorBoundary(container, child) || boundary);
+        updateDirtySubtreeCursorBoundary(child, getOwnCursorBoundary(child) || boundary);
     }
 }
 
@@ -4095,7 +4120,8 @@ function runEventHandlerQRL(handler, event, element, ctx) {
         return;
     }
     if (!ctx) {
-        ctx = newInvokeContextFromDOM(event, element);
+        const container = getDomContainer(element);
+        return whenContainerDataReady(container, () => runEventHandlerQRL(handler, event, element, newInvokeContextFromDOM(event, element, container)));
     }
     const container = ctx.$container$;
     const hostElement = ctx.$hostElement$;
@@ -4136,13 +4162,16 @@ function _run(event, element) {
         // ignore events on disconnected elements, this can happen when the event is triggered while the element is being removed
         return;
     }
-    const ctx = newInvokeContextFromDOM(event, element);
-    if (typeof this === 'string') {
-        setCaptures(deserializeCaptures(ctx.$container$, this));
-    }
-    const qrlToRun = _captures[0];
-    isDev && assertQrl(qrlToRun);
-    return runEventHandlerQRL(qrlToRun, event, element, ctx);
+    const container = getDomContainer(element);
+    return whenContainerDataReady(container, () => {
+        const ctx = newInvokeContextFromDOM(event, element, container);
+        if (typeof this === 'string') {
+            setCaptures(deserializeCaptureDeltas(ctx.$container$, this));
+        }
+        const qrlToRun = _captures[0];
+        isDev && assertQrl(qrlToRun);
+        return runEventHandlerQRL(qrlToRun, event, element, ctx);
+    });
 }
 
 function peekNextSibling(vCurrent) {
@@ -4303,9 +4332,7 @@ function diff(diffContext, jsxNode, vStartNode, vCurrent = vnode_getFirstChild(v
                             else if (type === Projection) {
                                 expectProjection(diffContext);
                                 descend(diffContext, diffContext.$jsxValue$.children, true, 
-                                // special case for projection, we don't want to expect no children
-                                // because the projection's children are not removed
-                                false);
+                                /* isProjection */ true);
                             }
                             else if (type === SSRComment) {
                                 expectNoMore(diffContext);
@@ -4418,9 +4445,11 @@ function advance(diffContext) {
  *
  *   In the above example all nodes are on same level so we don't `descendVNode` even thought there is
  *   an array produced by the `map` function.
+ * @param isProjection - True when descending into a Projection, whose children survive re-renders:
+ *   they are diffed against (never re-created) and kept when the new JSX has no children.
  */
-function descend(diffContext, children, descendVNode, shouldExpectNoChildren = true) {
-    if (shouldExpectNoChildren &&
+function descend(diffContext, children, descendVNode, isProjection = false) {
+    if (!isProjection &&
         (children == null || (descendVNode && isArray(children) && children.length === 0))) {
         expectNoChildren(diffContext);
         return;
@@ -4429,7 +4458,10 @@ function descend(diffContext, children, descendVNode, shouldExpectNoChildren = t
     if (descendVNode) {
         isDev &&
             assertDefined(diffContext.$vCurrent$ || diffContext.$vNewNode$, 'Expecting vCurrent to be defined.');
-        const creationMode = diffContext.$isCreationMode$ ||
+        const creationMode = 
+        // a projection keeps its children across re-renders, so it never inherits
+        // creation mode from a not-yet-rendered host; create only if new or empty
+        (!isProjection && diffContext.$isCreationMode$) ||
             !!diffContext.$vNewNode$ ||
             !vnode_getFirstChild(diffContext.$vCurrent$);
         diffContext.$isCreationMode$ = creationMode;
@@ -4581,7 +4613,7 @@ function expectSlot(diffContext) {
         diffContext.$vNewNode$ = vnode_newVirtual();
         vnode_setProp(diffContext.$vNewNode$, QSlot, slotNameKey);
         vnode_setProp(diffContext.$vNewNode$, QCursorBoundary, cursorBoundary);
-        updateDirtySubtreeCursorBoundary(diffContext.$container$, diffContext.$vNewNode$, cursorBoundary);
+        updateDirtySubtreeCursorBoundary(diffContext.$vNewNode$, cursorBoundary);
         vHost && vnode_setProp(vHost, slotNameKey, diffContext.$vNewNode$);
         isDev &&
             vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* VirtualType.Projection */); // Nothing to project, so render content of the slot.
@@ -4595,7 +4627,7 @@ function expectSlot(diffContext) {
         diffContext.$vNewNode$ = vProjectedNode;
         vnode_setProp(diffContext.$vNewNode$, QSlot, slotNameKey);
         vnode_setProp(diffContext.$vNewNode$, QCursorBoundary, cursorBoundary);
-        updateDirtySubtreeCursorBoundary(diffContext.$container$, diffContext.$vNewNode$, cursorBoundary);
+        updateDirtySubtreeCursorBoundary(diffContext.$vNewNode$, cursorBoundary);
         vHost && vnode_setProp(vHost, slotNameKey, diffContext.$vNewNode$);
         isDev &&
             vnode_setProp(diffContext.$vNewNode$, DEBUG_TYPE, "P" /* VirtualType.Projection */);
@@ -4862,18 +4894,20 @@ function diffProps(diffContext, vnode, newAttrs, currentFile) {
         vnode_ensureElementInflated(diffContext.$container$, vnode);
     }
     const oldAttrs = vnode.props;
+    const isHtml = (vnode.flags & 1536 /* VNodeFlags.NAMESPACE_MASK */) === 0 /* VNodeFlags.NS_html */;
     // Actual diffing logic
     // Apply all new attributes
     for (const key in newAttrs) {
         const newValue = newAttrs[key];
-        if (oldAttrs && _hasOwnProperty.call(oldAttrs, key)) {
-            const oldValue = oldAttrs[key];
-            if (newValue !== oldValue) {
-                if (newValue instanceof WrappedSignalImpl &&
-                    oldValue instanceof WrappedSignalImpl &&
-                    areWrappedSignalsEqual(newValue, oldValue)) {
-                    continue;
-                }
+        // HTML parsers lowercase attribute names.
+        const oldKey = oldAttrs && isHtml && !_hasOwnProperty.call(oldAttrs, key) ? key.toLowerCase() : key;
+        if (oldAttrs && _hasOwnProperty.call(oldAttrs, oldKey)) {
+            const oldValue = oldAttrs[oldKey];
+            if (oldKey !== key) {
+                vnode_setProp(vnode, oldKey, null);
+                vnode_setProp(vnode, key, oldValue);
+            }
+            if (!areDiffValuesEqual(newValue, oldValue)) {
                 patchProperty(diffContext, vnode, key, newValue, currentFile);
             }
         }
@@ -5285,7 +5319,9 @@ function getComponentHash(vNode, getObject) {
         return null;
     }
     const qrl = vnode_getProp(vNode, OnRenderProp, getObject);
-    return qrl ? qrl.$hash$ : null;
+    return qrl
+        ? qrl.$hash$
+        : vnode_getProp(vNode, QComponentHash, null);
 }
 /**
  * Marker class for JSX projection.
@@ -5343,13 +5379,26 @@ function handleChangedProps(src, dst, propsHandler, container, triggerEffects =
             if (key === 'children' || key === QBackRefs) {
                 continue;
             }
-            if (!dst || src[key] !== dst[key]) {
+            const newValue = src[key];
+            const oldValue = dst?.[key];
+            if (!dst ||
+                !(areDiffValuesEqual(newValue, oldValue) || areSignalValuesEqual(newValue, oldValue))) {
+                if (key === 'class') {
+                    if (areClassValuesEqual(newValue, oldValue)) {
+                        continue;
+                    }
+                }
+                else if (key === 'style') {
+                    if (areStyleValuesEqual(newValue, oldValue)) {
+                        continue;
+                    }
+                }
                 if (triggerEffects) {
                     if (dst) {
                         // Update the value in dst BEFORE triggering effects
                         // so effects see the new value
                         // Note: Value is not triggering effects, because we are modyfing direct VAR_PROPS object
-                        dst[key] = src[key];
+                        dst[key] = newValue;
                     }
                     const didTigger = triggerPropsProxyEffect(propsHandler, key);
                     if (!didTigger) {
@@ -5436,10 +5485,16 @@ function cleanup(container, journal, vNode, cursorRoot = null) {
                                 // don't call cleanupDestroyable yet, do it by the scheduler
                                 continue;
                             }
-                            else if (obj instanceof SignalImpl || isStore(obj)) {
-                                clearAllEffects(container, obj);
+                            // Stores and plain signals are only producers; their subscriptions are removed
+                            // when cleaning the consumers that read them. They don't own reactive backrefs.
+                            else if (obj instanceof ComputedSignalImpl || obj instanceof WrappedSignalImpl) {
+                                if (!(obj.$flags$ & 4 /* ComputedSignalFlags.PRESERVE_ON_SEQ_CLEANUP */)) {
+                                    clearAllEffects(container, obj);
+                                }
                             }
-                            if (objIsTask || obj instanceof AsyncSignalImpl) {
+                            if (objIsTask ||
+                                (obj instanceof ComputedSignalImpl &&
+                                    (obj.$flags$ & 512 /* AsyncSignalFlags.ASYNC_MODE */ || obj.$current$))) {
                                 cleanupDestroyable(obj);
                             }
                         }
@@ -5558,6 +5613,37 @@ function markVNodeAsDeleted(vCursor) {
      */
     vCursor.flags |= 32 /* VNodeFlags.Deleted */;
 }
+function areDiffValuesEqual(newValue, oldValue) {
+    if (newValue === oldValue) {
+        return true;
+    }
+    return (newValue instanceof WrappedSignalImpl &&
+        oldValue instanceof WrappedSignalImpl &&
+        areWrappedSignalsEqual(oldValue, newValue));
+}
+function areSignalValuesEqual(newValue, oldValue) {
+    if (newValue === oldValue) {
+        return true;
+    }
+    if (isSignal(newValue) && isSignal(oldValue)) {
+        const unwrappedNew = newValue instanceof WrappedSignalImpl ? newValue.$unwrapIfSignal$() : newValue;
+        const unwrappedOld = oldValue instanceof WrappedSignalImpl ? oldValue.$unwrapIfSignal$() : oldValue;
+        return untrack(() => unwrappedNew.value === unwrappedOld.value);
+    }
+    return false;
+}
+function areStyleValuesEqual(newValue, oldValue) {
+    if (newValue === oldValue) {
+        return true;
+    }
+    return stringifyStyle(newValue) === stringifyStyle(oldValue);
+}
+function areClassValuesEqual(newValue, oldValue) {
+    if (newValue === oldValue) {
+        return true;
+    }
+    return serializeClass(newValue) === serializeClass(oldValue);
+}
 function areWrappedSignalsEqual(oldSignal, newSignal) {
     if (oldSignal === newSignal) {
         return true;
@@ -5860,8 +5946,8 @@ function findFirstElementNode(jsx) {
 function injectPlaceholderElement(jsx, placeholder) {
     // For regular JSX nodes, we can append the placeholder to its children.
     if (isJSXNode(jsx)) {
-        // Inline components don't always render children, so we wrap them in Fragment which does.
-        if (jsx.type !== Fragment && !isQwikComponent(jsx.type)) {
+        // Inline components may ignore children, while component$ children become projections.
+        if (jsx.type !== Fragment) {
             return _jsxSorted(Fragment, null, null, [jsx, placeholder], 0, null);
         }
         if (jsx.children == null) {
@@ -6406,8 +6492,8 @@ function executeCompute(vNode, container) {
     ctx.$container$ = container;
     // needed for computed signals and throwing QRLs
     return maybeThen(retryOnPromise(() => invoke.call(target, ctx, target.$computeIfNeeded$)), () => {
-        if (target.$flags$ & 2 /* SignalFlags.RUN_EFFECTS */) {
-            target.$flags$ &= -3 /* SignalFlags.RUN_EFFECTS */;
+        if (target.$flags$ & 2 /* ComputedSignalFlags.RUN_EFFECTS */) {
+            target.$flags$ &= -3 /* ComputedSignalFlags.RUN_EFFECTS */;
             return scheduleEffects(container, target, effects);
         }
     });
@@ -6825,6 +6911,7 @@ function finishWalk(container, cursor, cursorData, isServer) {
             executeFlushPhase(cursor, container);
         }
         resolveCursorBoundaries(cursorData);
+        clearCursorBoundary(cursor);
         if (cursorData.extraPromises) {
             Promise.all(cursorData.extraPromises).then(() => {
                 resolveCursor(container);
@@ -6925,12 +7012,7 @@ function getNextVNode(vNode, cursor, container) {
     return getNextVNode(parent, cursor, container);
 }
 function splitCursorBoundary(container, vNode) {
-    if (!__EXPERIMENTAL__.suspense) {
-        return false;
-    }
-    if (!vNode.props ||
-        !(QCursorBoundary in vNode.props) ||
-        !container.getHostProp(vNode, QCursorBoundary)) {
+    if (!getOwnCursorBoundary(vNode)) {
         return false;
     }
     if (!isCursor(vNode)) {
@@ -6948,6 +7030,10 @@ function splitCursorBoundary(container, vNode) {
  * @returns The vNode itself, now acting as a cursor
  */
 function addCursor(container, root, priority) {
+    if (isCursor(root)) {
+        triggerCursors();
+        return root;
+    }
     const cursorData = {
         afterFlushTasks: null,
         extraPromises: null,
@@ -7000,7 +7086,11 @@ function _executeSsrChores(container, ssrNode) {
         if (ssrNode.dirty & 32 /* ChoreBits.COMPUTE */) {
             executeCompute(ssrNode, container);
         }
-        if (isDev && ssrNode.dirty & 1023 /* ChoreBits.DIRTY_MASK */) {
+        if (isDev &&
+            ssrNode.dirty & 1023 /* ChoreBits.DIRTY_MASK */ &&
+            !(ssrNode.flags & 2 /* SsrNodeFlags.WarnedStreamedChore */)) {
+            // Warn once per host; a re-dirtied streamed host would otherwise spam every tick.
+            ssrNode.flags |= 2 /* SsrNodeFlags.WarnedStreamedChore */;
             // We are running on the server.
             // On server we can't schedule task for a different host!
             // Server is SSR, and therefore scheduling for anything but the current host
@@ -7123,17 +7213,16 @@ function propagatePath(target) {
  * Propagates dirty bits from vNode up to the specified cursorRoot. Used during diff when we know
  * the cursor root to merge with. Also updates cursor position if we pass through any cursors.
  */
-function propagateToCursorRoot(container, vNode, cursorRoot) {
+function propagateToCursorRoot(vNode, cursorRoot) {
     reusablePath.push(vNode);
-    let cursorBoundary = getOwnCursorBoundary(container, vNode);
+    let cursorBoundary = getOwnCursorBoundary(vNode);
     let current = vNode.slotParent || vNode.parent;
     while (current) {
         const isDirty = current.dirty & 1023 /* ChoreBits.DIRTY_MASK */;
         const currentIsCursor = isCursor(current);
         if (__EXPERIMENTAL__.suspense) {
             cursorBoundary ||=
-                getOwnCursorBoundary(container, current) ||
-                    (isDirty ? getNearestCursorBoundary(container, current) : null);
+                getOwnCursorBoundary(current) || (isDirty ? getNearestCursorBoundary(current) : null);
         }
         // Stop when we reach the cursor root or a dirty ancestor
         if (current === cursorRoot || isDirty) {
@@ -7168,18 +7257,16 @@ function propagateToCursorRoot(container, vNode, cursorRoot) {
  * Finds a blocking cursor or dirty ancestor and propagates dirty bits to it. Returns true if found
  * and attached, false if a new cursor should be created.
  */
-function findAndPropagateToBlockingCursor(container, vNode) {
+function findAndPropagateToBlockingCursor(vNode) {
     reusablePath.push(vNode);
-    let cursorBoundary = __EXPERIMENTAL__.suspense
-        ? getOwnCursorBoundary(container, vNode)
-        : null;
+    let cursorBoundary = getOwnCursorBoundary(vNode);
     let current = vNode.slotParent || vNode.parent;
     while (current) {
         const currentIsCursor = isCursor(current);
         if (__EXPERIMENTAL__.suspense) {
             cursorBoundary ||=
-                getOwnCursorBoundary(container, current) ||
-                    (currentIsCursor ? getNearestCursorBoundary(container, current) : null);
+                getOwnCursorBoundary(current) ||
+                    (currentIsCursor ? getNearestCursorBoundary(current) : null);
         }
         if (currentIsCursor) {
             // Existing cursor case: attach this dirty vnode to the blocking cursor found above it and
@@ -7220,7 +7307,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
                 ? container.$renderPromise$.then(() => result)
                 : result;
         }
-        return;
+        return result;
     }
     const isRealDirty = bits & 1023 /* ChoreBits.DIRTY_MASK */;
     // If already dirty, no need to propagate again
@@ -7230,14 +7317,14 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     const parent = vNode.slotParent || vNode.parent;
     // If cursorRoot is provided, propagate up to it
     if (cursorRoot && isRealDirty && parent && !parent.dirty) {
-        propagateToCursorRoot(container, vNode, cursorRoot);
+        propagateToCursorRoot(vNode, cursorRoot);
         return;
     }
     // We must attach to a cursor subtree if it exists
     if (parent && parent.dirty & 1023 /* ChoreBits.DIRTY_MASK */) {
         // Dirty parent case: this vnode joins an already scheduled subtree, so inherit the parent's
         // nearest boundary unless this vnode owns a boundary itself.
-        setNearestCursorBoundary(vNode, getOwnCursorBoundary(container, vNode) || getNearestCursorBoundary(container, parent));
+        setNearestCursorBoundary(vNode, getOwnCursorBoundary(vNode) || getNearestCursorBoundary(parent));
         if (isRealDirty) {
             parent.dirty |= 64 /* ChoreBits.CHILDREN */;
         }
@@ -7269,7 +7356,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     else if (!isCursor(vNode)) {
         // Check if there's an existing cursor that is blocking (executing a render-blocking task)
         // If so, merge with it instead of creating a new cursor (single-pass find + propagate)
-        if (!findAndPropagateToBlockingCursor(container, vNode)) {
+        if (!findAndPropagateToBlockingCursor(vNode)) {
             // No blocking cursor found, create a new one
             addCursor(container, vNode, 0);
         }
@@ -7277,7 +7364,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     else {
         // Existing cursor-root case: the vnode is already the scheduled cursor, so only its own
         // boundary can be authoritative here.
-        setNearestCursorBoundary(vNode, getOwnCursorBoundary(container, vNode));
+        setNearestCursorBoundary(vNode, getOwnCursorBoundary(vNode));
     }
 }
 function addVNodeOperation(journal, operation) {
@@ -8717,8 +8804,17 @@ const processVNodeData$1 = (vData, callback) => {
         }
         return vData.substring(start, nextToConsumeIdx);
     };
+    const consumeEncodedValue = () => {
+        if (getChar(nextToConsumeIdx + 1) !== VNodeDataChar.SEPARATOR) {
+            return consumeValue();
+        }
+        consume();
+        const value = decodeURIComponent(decodeVNodeDataString(consumeValue()));
+        consume();
+        return value;
+    };
     while (peek() !== 0) {
-        callback(peek, consumeValue, consume, getChar, nextToConsumeIdx);
+        callback(peek, consumeValue, consume, getChar, nextToConsumeIdx, consumeEncodedValue);
     }
 };
 /** @internal */
@@ -8909,13 +9005,13 @@ function materializeFromVNodeData(vParent, vData, element, child, segmentId) {
         return !nodeIsElement || (nodeIsElement && shouldSkipElement(node));
     };
     let components = null;
-    processVNodeData$1(vData, (peek, consumeValue, consume, getChar, nextToConsumeIdx) => {
+    processVNodeData$1(vData, (peek, consumeValue, consume, getChar, dataIdx, consumeEncodedValue) => {
         if (isNumber(peek())) {
             // Element counts get encoded as numbers.
             while (shouldSkipNode(child)) {
                 child = fastNextSibling(child);
                 if (!child) {
-                    throw qError(27 /* QError.materializeVNodeDataError */, [vData, peek(), nextToConsumeIdx]);
+                    throw qError(27 /* QError.materializeVNodeDataError */, [vData, peek(), dataIdx]);
                 }
             }
             combinedText = null;
@@ -8936,7 +9032,7 @@ function materializeFromVNodeData(vParent, vData, element, child, segmentId) {
                     shouldSkipElement(child)) {
                     child = fastNextSibling(child);
                     if (!child && value > 0) {
-                        throw qError(27 /* QError.materializeVNodeDataError */, [vData, peek(), nextToConsumeIdx]);
+                        throw qError(27 /* QError.materializeVNodeDataError */, [vData, peek(), dataIdx]);
                     }
                 }
             }
@@ -8946,8 +9042,14 @@ function materializeFromVNodeData(vParent, vData, element, child, segmentId) {
             vnode_setProp(vParent, QScopedStyle, consumeValue());
         }
         else if (peek() === VNodeDataChar.RENDER_FN) {
-            (components ||= []).push(vParent);
-            vnode_setProp(vParent, OnRenderProp, consumeValue());
+            const renderRef = consumeValue();
+            if (renderRef.charCodeAt(0) === VNodeDataChar.RENDER_HASH_PREFIX) {
+                vnode_setProp(vParent, QComponentHash, decodeURIComponent(decodeVNodeDataString(renderRef.slice(1))));
+            }
+            else {
+                (components ||= []).push(vParent);
+                vnode_setProp(vParent, OnRenderProp, renderRef);
+            }
         }
         else if (peek() === VNodeDataChar.ID) {
             if (!container) {
@@ -8961,17 +9063,7 @@ function materializeFromVNodeData(vParent, vData, element, child, segmentId) {
             vnode_setProp(vParent, ELEMENT_PROPS, consumeValue());
         }
         else if (peek() === VNodeDataChar.KEY) {
-            const isEscapedValue = getChar(nextToConsumeIdx + 1) === VNodeDataChar.SEPARATOR;
-            let value;
-            if (isEscapedValue) {
-                consume();
-                value = decodeURIComponent(decodeVNodeDataString(consumeValue()));
-                consume();
-            }
-            else {
-                value = consumeValue();
-            }
-            vParent.key = value;
+            vParent.key = consumeEncodedValue();
         }
         else if (peek() === VNodeDataChar.SEQ) {
             vnode_setProp(vParent, ELEMENT_SEQ, consumeValue());
@@ -9005,8 +9097,8 @@ function materializeFromVNodeData(vParent, vData, element, child, segmentId) {
         else if (peek() === VNodeDataChar.SEPARATOR) {
             // Custom attribute: |key|value
             const keyValue = consumeValue();
-            const key = decodeVNodeDataString(keyValue);
-            const valueSeparatorIdx = nextToConsumeIdx + keyValue.length + 1;
+            const key = decodeURIComponent(decodeVNodeDataString(keyValue));
+            const valueSeparatorIdx = dataIdx + keyValue.length + 1;
             const isEscapedValue = getChar(valueSeparatorIdx + 1) === VNodeDataChar.SEPARATOR;
             let value;
             if (isEscapedValue) {
@@ -9029,8 +9121,7 @@ function materializeFromVNodeData(vParent, vData, element, child, segmentId) {
             vParent = stack.pop();
         }
         else if (peek() === VNodeDataChar.SLOT) {
-            const value = decodeVNodeDataString(consumeValue());
-            vnode_setProp(vParent, QSlot, value);
+            vnode_setProp(vParent, QSlot, consumeEncodedValue());
         }
         else {
             // skip over style or non-qwik elements in front of text nodes, where text node is the first child (except the style node)
@@ -9141,12 +9232,12 @@ function clearEffectSubscription(container, effect) {
         return;
     }
     for (const producer of backRefs) {
-        // Check AsyncSignalImpl before SignalImpl since it extends SignalImpl
-        if (producer instanceof AsyncSignalImpl) {
-            clearAsyncSignal(producer, effect);
-        }
-        else if (producer instanceof SignalImpl) {
+        if (producer instanceof SignalImpl) {
             clearSignal(container, producer, effect);
+            if (producer instanceof ComputedSignalImpl) {
+                // computeds can carry async engine state (loading/error subscribers)
+                clearAsyncSignalEffects(producer, effect);
+            }
         }
         else if (isPropsProxy(producer)) {
             const propsHandler = producer[_PROPS_HANDLER];
@@ -9171,11 +9262,7 @@ function clearSignal(container, producer, effect) {
         clearAllEffects(container, producer);
     }
 }
-function clearAsyncSignal(producer, effect) {
-    const effects = producer.$effects$;
-    if (effects && effects.has(effect)) {
-        effects.delete(effect);
-    }
+function clearAsyncSignalEffects(producer, effect) {
     const pendingEffects = producer.$loadingEffects$;
     if (pendingEffects && pendingEffects.has(effect)) {
         pendingEffects.delete(effect);
@@ -9211,7 +9298,7 @@ const useTaskQrl = (qrl, opts) => {
     const taskFlags = 
     // enabled by default
     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);
+    const task = new Task(4 /* TaskFlags.DIRTY */ | 2 /* TaskFlags.TASK */ | taskFlags, i, iCtx.$hostElement$, qrl, 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.
@@ -9270,17 +9357,15 @@ class Task extends BackRef {
     $index$;
     $el$;
     $qrl$;
-    $state$;
     $destroy$;
     $destroyPromise$;
     $taskPromise$ = null;
-    constructor($flags$, $index$, $el$, $qrl$, $state$, $destroy$) {
+    constructor($flags$, $index$, $el$, $qrl$, $destroy$) {
         super();
         this.$flags$ = $flags$;
         this.$index$ = $index$;
         this.$el$ = $el$;
         this.$qrl$ = $qrl$;
-        this.$state$ = $state$;
         this.$destroy$ = $destroy$;
     }
 }
@@ -9296,12 +9381,14 @@ const isTask = (value) => {
  */
 function scheduleTask(_event, element) {
     const container = getDomContainer(element);
-    if (typeof this === 'string') {
-        setCaptures(deserializeCaptures(container, this));
-    }
-    const task = _captures[0];
-    task.$flags$ |= 4 /* TaskFlags.DIRTY */;
-    markVNodeDirty(container, task.$el$, 1 /* ChoreBits.TASKS */);
+    return whenContainerDataReady(container, () => {
+        if (typeof this === 'string') {
+            setCaptures(deserializeCaptureDeltas(container, this));
+        }
+        const task = _captures[0];
+        task.$flags$ |= 4 /* TaskFlags.DIRTY */;
+        markVNodeDirty(container, task.$el$, 1 /* ChoreBits.TASKS */);
+    });
 }
 
 const throwIfQRLNotResolved = (qrl) => {
@@ -9413,7 +9500,7 @@ const isSerializerObj = (obj) => {
     return isObject(obj) && typeof obj[SerializerSymbol] === 'function';
 };
 const getComputedSignalFlags = (serializationStrategy) => {
-    let flags = 1 /* SignalFlags.INVALID */;
+    let flags = 1 /* ComputedSignalFlags.INVALID */;
     switch (serializationStrategy) {
         // TODO: implement this in the future
         // case 'auto':
@@ -9428,6 +9515,18 @@ const getComputedSignalFlags = (serializationStrategy) => {
     }
     return flags;
 };
+/**
+ * Mark this signal as owned outside of the component that read it.
+ *
+ * Externally owned signals are preserved when found in a component's sequential scope during
+ * component cleanup.
+ *
+ * @internal
+ */
+const _markSignalAsExternallyOwned = (signal) => {
+    signal.$flags$ |=
+        4 /* ComputedSignalFlags.PRESERVE_ON_SEQ_CLEANUP */;
+};
 
 const stringifyPath = [];
 function qwikDebugToString(value) {
@@ -9787,6 +9886,7 @@ function getEffects(target, prop, storeEffects) {
 
 /** Used to represent an undefined value that must be serialized */
 const explicitUndefined = Symbol('undefined');
+const EMPTY_OBJECT_PAYLOAD = 0;
 // Used for allocate, make sure they are in sync with Constants
 const _constants = [
     undefined,
@@ -9807,6 +9907,10 @@ const _constants = [
     Number.MAX_SAFE_INTEGER,
     Number.MAX_SAFE_INTEGER - 1,
     Number.MIN_SAFE_INTEGER,
+    ':',
+    '.',
+    'id',
+    'ref',
 ];
 // Used for dumpState, make sure they are in sync with Constants
 const _constantNames = [
@@ -9828,6 +9932,10 @@ const _constantNames = [
     'MAX_SAFE_INTEGER',
     'MAX_SAFE_INTEGER-1',
     'MIN_SAFE_INTEGER',
+    "':'",
+    "'.'",
+    "'id'",
+    "'ref'",
 ];
 // Used for dumpState, make sure they are in sync with TypeIds
 const _typeIdNames = [
@@ -9873,6 +9981,9 @@ const _typeIdNames = [
     'SubscriptionData',
     'EffectSubscription',
     'SubscriptionPatch',
+    'SubscriptionDataConstTrue',
+    'SubscriptionDataConstFalse',
+    'EffectSubscriptionNoData',
 ];
 
 function qrlToString(serializationContext, qrl, raw) {
@@ -9919,17 +10030,25 @@ function qrlToString(serializationContext, qrl, raw) {
         symbol = String(serializationContext.$addSyncFn$(null, 0, fn));
     }
     const captures = qrl.getCaptured();
-    let captureIds = null;
+    let captureDeltas = null;
     if (captures && captures.length > 0) {
         // We refer by id so every capture needs to be a root
-        captureIds = captures.map((ref) => `${serializationContext.$addRoot$(ref)}`).join(' ');
+        let previous = 0;
+        let output = '';
+        for (let i = 0; i < captures.length; i++) {
+            const captureId = serializationContext.$addRoot$(captures[i]);
+            const delta = captureId - previous;
+            previous = captureId;
+            output += (i === 0 ? '' : ' ') + delta;
+        }
+        captureDeltas = output;
     }
     if (raw) {
-        return [chunk, symbol, captureIds];
+        return [chunk, symbol, captureDeltas];
     }
     let qrlStringInline = `${chunk}#${symbol}`;
-    if (captureIds) {
-        qrlStringInline += `#${captureIds}`;
+    if (captureDeltas) {
+        qrlStringInline += `#${captureDeltas}`;
     }
     return qrlStringInline;
 }
@@ -9941,12 +10060,23 @@ function qrlToChunks(serializationContext, qrl) {
         return prefix;
     }
     const chunks = [prefix, '#'];
-    const captureIds = captures.split(' ');
-    for (let i = 0; i < captureIds.length; i++) {
-        if (i > 0) {
-            chunks.push(' ');
+    let previousCaptureId = 0;
+    let start = 0;
+    for (let i = 0; i <= captures.length; i++) {
+        if (i === captures.length || captures[i] === ' ') {
+            if (i > start) {
+                const captureId = previousCaptureId + Number(captures.slice(start, i));
+                if (start > 0) {
+                    chunks.push(' ');
+                    chunks.push({ id: captureId, base: previousCaptureId });
+                }
+                else {
+                    chunks.push(captureId);
+                }
+                previousCaptureId = captureId;
+            }
+            start = i + 1;
         }
-        chunks.push(Number(captureIds[i]));
     }
     return chunks;
 }
@@ -9962,10 +10092,14 @@ function createQRLWithBackChannel(chunk, symbol, captures, container) {
     }
     return createQRL(chunk, symbol, null, qrlImporter, captures, container);
 }
-/** Parses "chunk#hash#...rootRef" */
+/** Parses "chunk#hash#...captureDelta" */
 function parseQRL(qrl, container) {
-    const [chunk, symbol, captures] = qrl.split('#');
-    return createQRLWithBackChannel(chunk, symbol, captures || null, container);
+    const firstHash = qrl.indexOf('#');
+    const secondHash = qrl.indexOf('#', firstHash + 1);
+    const chunk = qrl.slice(0, firstHash);
+    const symbol = secondHash === -1 ? qrl.slice(firstHash + 1) : qrl.slice(firstHash + 1, secondHash);
+    const captures = secondHash !== -1 && secondHash + 1 < qrl.length ? qrl.slice(secondHash + 1) : null;
+    return createQRLWithBackChannel(chunk, symbol, captures, container);
 }
 const QRL_RUNTIME_CHUNK = 'mock-chunk';
 
@@ -10117,7 +10251,37 @@ class Serializer {
                 return key;
             }
         }
-        return Number(key);
+        return Number(key);
+    }
+    rebaseQrlCaptureDeltas$(baseRootId, captureDeltas) {
+        let previousCaptureId = 0;
+        let previousOutputBase = baseRootId;
+        const deltaList = captureDeltas.split(' ');
+        for (let i = 0; i < deltaList.length; i++) {
+            const captureId = previousCaptureId + Number(deltaList[i]);
+            deltaList[i] = String(captureId - previousOutputBase);
+            previousCaptureId = captureId;
+            previousOutputBase = captureId;
+        }
+        return deltaList.join(' ');
+    }
+    outputShortStringConstant$(value) {
+        switch (value) {
+            case ':':
+                this.output(3 /* TypeIds.Constant */, 18 /* Constants.Colon */);
+                return true;
+            case '.':
+                this.output(3 /* TypeIds.Constant */, 19 /* Constants.Dot */);
+                return true;
+            case 'id':
+                this.output(3 /* TypeIds.Constant */, 20 /* Constants.Id */);
+                return true;
+            case 'ref':
+                this.output(3 /* TypeIds.Constant */, 21 /* Constants.Ref */);
+                return true;
+            default:
+                return false;
+        }
     }
     outputString(value) {
         const s = this.stringNeedsJsonEscape$(value) ? JSON.stringify(value) : QUOTE + value + QUOTE;
@@ -10136,6 +10300,9 @@ class Serializer {
     writeRootRefPath(path) {
         this.$writer$.writeRootRefPath(path);
     }
+    writeRootRefDelta(id, base) {
+        this.$writer$.writeRootRefDelta(id, base);
+    }
     outputStringChunks(chunks) {
         this.$writer$.write(QUOTE);
         for (let i = 0; i < chunks.length; i++) {
@@ -10146,6 +10313,9 @@ class Serializer {
             else if (typeof chunk === 'number') {
                 this.writeRootRef(chunk);
             }
+            else if ('base' in chunk) {
+                this.writeRootRefDelta(chunk.id, chunk.base);
+            }
             else {
                 this.writeRootRefPath(chunk.path);
             }
@@ -10275,6 +10445,9 @@ class Serializer {
                     if (value.length === 0) {
                         this.output(3 /* TypeIds.Constant */, 4 /* Constants.EmptyString */);
                     }
+                    else if (this.outputShortStringConstant$(value)) {
+                        break;
+                    }
                     else {
                         // If the string is short, we output directly
                         // Very short strings add overhead to tracking
@@ -10314,27 +10487,38 @@ class Serializer {
                     }
                     else if (isQrl(value)) {
                         if (this.getSeenRefOrOutput(value, index)) {
-                            const [chunk, symbol, captures] = qrlToString(this.$serializationContext$, value, true);
+                            const [chunk, symbol, captureDeltasFromZero] = qrlToString(this.$serializationContext$, value, true);
                             let data;
                             if (chunk !== '') {
                                 // not a sync QRL, replace all parts with string references
-                                data = [
-                                    this.$serializationContext$.$addRoot$(chunk),
-                                    '#',
-                                    this.$serializationContext$.$addRoot$(symbol),
-                                ];
-                                if (captures) {
-                                    const captureIds = captures.split(' ');
+                                const chunkRootId = this.$serializationContext$.$addRoot$(chunk);
+                                const symbolRootId = this.$serializationContext$.$addRoot$(symbol);
+                                const captureDeltas = captureDeltasFromZero
+                                    ? this.rebaseQrlCaptureDeltas$(symbolRootId, captureDeltasFromZero)
+                                    : null;
+                                data = [chunkRootId, '#', { id: symbolRootId, base: chunkRootId }];
+                                if (captureDeltasFromZero) {
+                                    let previousRootId = 0;
+                                    let previousOutputBase = symbolRootId;
+                                    let start = 0;
                                     data.push('#');
-                                    for (let i = 0; i < captureIds.length; i++) {
-                                        if (i > 0) {
-                                            data.push(' ');
+                                    for (let i = 0; i <= captureDeltasFromZero.length; i++) {
+                                        if (i === captureDeltasFromZero.length || captureDeltasFromZero[i] === ' ') {
+                                            if (i > start) {
+                                                const captureId = previousRootId + Number(captureDeltasFromZero.slice(start, i));
+                                                if (start > 0) {
+                                                    data.push(' ');
+                                                }
+                                                data.push({ id: captureId, base: previousOutputBase });
+                                                previousRootId = captureId;
+                                                previousOutputBase = captureId;
+                                            }
+                                            start = i + 1;
                                         }
-                                        data.push(Number(captureIds[i]));
                                     }
                                 }
                                 // Since we map QRLs to strings, we need to keep track of this secondary mapping
-                                const qrlKey = data.join('');
+                                const qrlKey = `${chunkRootId}#${symbolRootId - chunkRootId}${captureDeltas ? '#' + captureDeltas : ''}`;
                                 const existing = this.$qrlMap$.get(qrlKey);
                                 if (existing) {
                                     // We encountered the same QRL again, make it a root
@@ -10402,15 +10586,21 @@ class Serializer {
             ]);
         }
         else if (value instanceof SubscriptionData) {
-            // TODO make everything optional or use two types
-            this.output(39 /* TypeIds.SubscriptionData */, [
-                value.data.$scopedStyleIdPrefix$,
-                value.data.$isConst$,
-            ]);
+            const { $scopedStyleIdPrefix$, $isConst$ } = value.data;
+            if ($scopedStyleIdPrefix$ === null) {
+                this.output($isConst$ ? 42 /* TypeIds.SubscriptionDataConstTrue */ : 43 /* TypeIds.SubscriptionDataConstFalse */, 0);
+            }
+            else {
+                this.output(39 /* TypeIds.SubscriptionData */, [$scopedStyleIdPrefix$, $isConst$]);
+            }
         }
         else if (value instanceof EffectSubscription) {
-            // TODO no data if [null, true]
-            this.output(40 /* TypeIds.EffectSubscription */, [value.consumer, value.property, value.data]);
+            if (value.data === null) {
+                this.output(44 /* TypeIds.EffectSubscriptionNoData */, [value.consumer, value.property]);
+            }
+            else {
+                this.output(40 /* TypeIds.EffectSubscription */, [value.consumer, value.property, value.data]);
+            }
         }
         else if (value instanceof SubscriptionPatch) {
             this.output(41 /* TypeIds.SubscriptionPatch */, [value.rootId, value.subscriptions]);
@@ -10464,7 +10654,7 @@ class Serializer {
                         }
                     }
                 }
-                this.output(5 /* TypeIds.Object */, out.length ? out : 0);
+                this.output(5 /* TypeIds.Object */, out.length ? out : EMPTY_OBJECT_PAYLOAD);
             }
         }
         else if (this.$serializationContext$.$isDomRef$(value)) {
@@ -10497,16 +10687,17 @@ class Serializer {
                 let v = value.$untrackedValue$;
                 const shouldAlwaysSerialize = value.$flags$ & 16 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_ALWAYS */;
                 const shouldNeverSerialize = value.$flags$ & 8 /* SerializationSignalFlags.SERIALIZATION_STRATEGY_NEVER */;
-                const isInvalid = value.$flags$ & 1 /* SignalFlags.INVALID */;
+                const isInvalid = value.$flags$ & 1 /* ComputedSignalFlags.INVALID */;
                 const isSkippable = fastSkipSerialize(value.$untrackedValue$);
-                const isAsync = value instanceof AsyncSignalImpl;
-                const expires = isAsync && value.$expires$ !== 0 ? value.$expires$ : undefined;
+                // async-mode computeds carry the same engine state and must round-trip like AsyncSignals
+                const isAsync = !!(value.$flags$ & 512 /* AsyncSignalFlags.ASYNC_MODE */);
+                const isErrored = isAsync && !!value.$untrackedError$;
                 const concurrency = isAsync && value.$concurrency$ !== 1 ? value.$concurrency$ : undefined;
                 const timeout = isAsync && value.$timeoutMs$ !== 0 ? value.$timeoutMs$ : undefined;
                 // Send the flags but remove the serialization bits and default to 0 when undefined
                 const asyncFlags = (isAsync && value.$flags$ & -25 /* SerializationSignalFlags.SERIALIZATION_ALL_STRATEGIES */) ||
                     undefined;
-                if (isInvalid || isSkippable) {
+                if (isInvalid || isSkippable || isErrored) {
                     v = NEEDS_COMPUTATION;
                 }
                 else if (shouldAlwaysSerialize) {
@@ -10521,10 +10712,7 @@ class Serializer {
                     out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedError$);
                     out.push(asyncFlags || undefined);
                 }
-                if (v !== NEEDS_COMPUTATION ||
-                    expires !== undefined ||
-                    concurrency !== undefined ||
-                    timeout !== undefined) {
+                if (v !== NEEDS_COMPUTATION || concurrency !== undefined || timeout !== 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 thats
@@ -10533,7 +10721,6 @@ class Serializer {
                     out.push(v === undefined ? explicitUndefined : v);
                 }
                 if (isAsync) {
-                    out.push(expires);
                     out.push(concurrency);
                     out.push(timeout);
                 }
@@ -10554,30 +10741,6 @@ class Serializer {
         else if (value instanceof Date) {
             this.output(7 /* TypeIds.Date */, Number.isNaN(value.valueOf()) ? '' : value.valueOf());
         }
-        else if (this.$hasTemporal$ && value instanceof Temporal.Duration) {
-            this.output(15 /* TypeIds.TemporalDuration */, value.toJSON());
-        }
-        else if (this.$hasTemporal$ && value instanceof Temporal.Instant) {
-            this.output(16 /* TypeIds.TemporalInstant */, value.toJSON());
-        }
-        else if (this.$hasTemporal$ && value instanceof Temporal.PlainDate) {
-            this.output(17 /* TypeIds.TemporalPlainDate */, value.toJSON());
-        }
-        else if (this.$hasTemporal$ && value instanceof Temporal.PlainDateTime) {
-            this.output(18 /* TypeIds.TemporalPlainDateTime */, value.toJSON());
-        }
-        else if (this.$hasTemporal$ && value instanceof Temporal.PlainMonthDay) {
-            this.output(19 /* TypeIds.TemporalPlainMonthDay */, value.toJSON());
-        }
-        else if (this.$hasTemporal$ && value instanceof Temporal.PlainTime) {
-            this.output(20 /* TypeIds.TemporalPlainTime */, value.toJSON());
-        }
-        else if (this.$hasTemporal$ && value instanceof Temporal.PlainYearMonth) {
-            this.output(21 /* TypeIds.TemporalPlainYearMonth */, value.toJSON());
-        }
-        else if (this.$hasTemporal$ && value instanceof Temporal.ZonedDateTime) {
-            this.output(22 /* TypeIds.TemporalZonedDateTime */, value.toJSON());
-        }
         else if (value instanceof RegExp) {
             this.output(8 /* TypeIds.Regex */, value.toString());
         }
@@ -10650,7 +10813,7 @@ class Serializer {
             this.output(37 /* TypeIds.JSXNode */, out);
         }
         else if (value instanceof Task) {
-            const out = [value.$qrl$, value.$flags$, value.$index$, value.$el$, value.$state$];
+            const out = [value.$qrl$, value.$flags$, value.$index$, value.$el$];
             while (out[out.length - 1] === undefined) {
                 out.pop();
             }
@@ -10704,6 +10867,30 @@ class Serializer {
                 this.output(2 /* TypeIds.ForwardRef */, this.getForwardRefId(forwardRefId));
             }
         }
+        else if (this.$hasTemporal$ && value instanceof Temporal.Duration) {
+            this.output(15 /* TypeIds.TemporalDuration */, value.toJSON());
+        }
+        else if (this.$hasTemporal$ && value instanceof Temporal.Instant) {
+            this.output(16 /* TypeIds.TemporalInstant */, value.toJSON());
+        }
+        else if (this.$hasTemporal$ && value instanceof Temporal.PlainDate) {
+            this.output(17 /* TypeIds.TemporalPlainDate */, value.toJSON());
+        }
+        else if (this.$hasTemporal$ && value instanceof Temporal.PlainDateTime) {
+            this.output(18 /* TypeIds.TemporalPlainDateTime */, value.toJSON());
+        }
+        else if (this.$hasTemporal$ && value instanceof Temporal.PlainMonthDay) {
+            this.output(19 /* TypeIds.TemporalPlainMonthDay */, value.toJSON());
+        }
+        else if (this.$hasTemporal$ && value instanceof Temporal.PlainTime) {
+            this.output(20 /* TypeIds.TemporalPlainTime */, value.toJSON());
+        }
+        else if (this.$hasTemporal$ && value instanceof Temporal.PlainYearMonth) {
+            this.output(21 /* TypeIds.TemporalPlainYearMonth */, value.toJSON());
+        }
+        else if (this.$hasTemporal$ && value instanceof Temporal.ZonedDateTime) {
+            this.output(22 /* TypeIds.TemporalZonedDateTime */, value.toJSON());
+        }
         else if (vnode_isVNode(value)) {
             this.output(3 /* TypeIds.Constant */, 0 /* Constants.Undefined */);
         }
@@ -10870,7 +11057,9 @@ const discoverValuesForVNodeData = (vnodeData, callback) => {
                 if (attrValue == null ||
                     typeof attrValue === 'string' ||
                     (typeof attrValue === 'number' && key === ELEMENT_ID) ||
-                    (key === ELEMENT_PROPS && isObjectEmpty(attrValue))) {
+                    (key === ELEMENT_PROPS &&
+                        (isObjectEmpty(attrValue) ||
+                            shouldSkipComponentProps(value, attrValue)))) {
                     continue;
                 }
                 callback(attrValue);
@@ -10879,6 +11068,21 @@ const discoverValuesForVNodeData = (vnodeData, callback) => {
     }
 };
 const isSsrAttrs = (value) => typeof value === 'object' && value !== null && !isObjectEmpty(value);
+const shouldSkipComponentProps = (attrs, value, isDevMode = isDev) => {
+    if (isDevMode || !Object.prototype.hasOwnProperty.call(attrs, OnRenderProp)) {
+        return false;
+    }
+    const owner = value[_OWNER];
+    return (isObjectEmpty(owner.varProps) &&
+        !hasPropsEffects(value) &&
+        !hasComponentBackRef(attrs[QBackRefs]));
+};
+const hasPropsEffects = (propsProxy) => {
+    return !!propsProxy[_PROPS_HANDLER].$effects$?.size;
+};
+const hasComponentBackRef = (backRefs) => {
+    return backRefs instanceof Map && backRefs.has(":" /* EffectProperty.COMPONENT */);
+};
 /**
  * When serializing the object we need check if it is URL, RegExp, Map, Set, etc. This is time
  * consuming. So if we could know that this is a basic object literal we could skip the check, and
@@ -11377,6 +11581,12 @@ const constantToName = (code) => {
  * @internal
  */
 function preprocessState(data, container, segmentId, startIndex = 0) {
+    const iterator = preprocessStateIterator(data, container, startIndex);
+    while (!iterator.next().done) {
+        // Run synchronously for non-browser and non-container deserialization paths.
+    }
+}
+function* preprocessStateIterator(data, container, startIndex = 0) {
     const isRootDeepRef = (type, value) => {
         return type === 1 /* TypeIds.RootRef */ && typeof value === 'string' && value.indexOf(' ') !== -1;
     };
@@ -11419,11 +11629,39 @@ function preprocessState(data, container, segmentId, startIndex = 0) {
         else if (isForwardRefsMap(data[i])) {
             container.$forwardRefs$ = data[i + 1];
         }
+        yield;
     }
 }
 
 const resolvers = new WeakMap();
-const pendingStoreTargets = new Map();
+const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const BASE64_REGEXP = /^[A-Za-z0-9+/]*$/;
+// Validate canonical unpadded base64 before its length controls allocation.
+const isCanonicalBase64 = (value) => {
+    if (typeof value !== 'string' || !BASE64_REGEXP.test(value)) {
+        return false;
+    }
+    const rest = value.length % 4;
+    if (rest === 0) {
+        return true;
+    }
+    if (rest === 1) {
+        return false;
+    }
+    const lastValue = BASE64_ALPHABET.indexOf(value[value.length - 1]);
+    return (lastValue & (rest === 2 ? 15 : 3)) === 0;
+};
+const beginDeserialization = (container) => {
+    const ownsPendingStoreTargets = container.$pendingStoreTargets$ === undefined;
+    container.$pendingStoreTargets$ ??= new Map();
+    return ownsPendingStoreTargets;
+};
+const endDeserialization = (container, ownsPendingStoreTargets) => {
+    if (ownsPendingStoreTargets) {
+        container.$pendingStoreTargets$.clear();
+        container.$pendingStoreTargets$ = undefined;
+    }
+};
 const allocate = (container, typeId, value) => {
     switch (typeId) {
         case 0 /* TypeIds.Plain */:
@@ -11449,10 +11687,17 @@ const allocate = (container, typeId, value) => {
         case 9 /* TypeIds.QRL */: {
             let qrl;
             if (typeof value === 'string') {
-                const [chunkId, symbolId, captureIds] = value.split('#');
-                const chunk = container.$getObjectById$(chunkId);
-                const symbol = container.$getObjectById$(symbolId);
-                qrl = createQRLWithBackChannel(chunk, symbol, captureIds || null, container);
+                const serializedQrl = value;
+                const firstHash = serializedQrl.indexOf('#');
+                const secondHash = serializedQrl.indexOf('#', firstHash + 1);
+                const chunkRootId = Number(serializedQrl.slice(0, firstHash));
+                const symbolDelta = secondHash === -1
+                    ? Number(serializedQrl.slice(firstHash + 1))
+                    : Number(serializedQrl.slice(firstHash + 1, secondHash));
+                const symbolRootId = chunkRootId + symbolDelta;
+                const chunk = container.$getObjectById$(chunkRootId);
+                const symbol = container.$getObjectById$(symbolRootId);
+                qrl = createQRLWithBackChannel(chunk, symbol, secondHash !== -1 ? serializedQrl : null, container);
             }
             else {
                 // Sync qrl
@@ -11461,7 +11706,7 @@ const allocate = (container, typeId, value) => {
             return qrl;
         }
         case 28 /* TypeIds.Task */:
-            return new Task(-1, -1, null, null, null, null);
+            return new Task(-1, -1, null, null, null);
         case 6 /* TypeIds.URL */:
             return new URL(value);
         case 7 /* TypeIds.Date */:
@@ -11509,7 +11754,7 @@ const allocate = (container, typeId, value) => {
             const storeValue = allocate(container, t, v);
             const store = getOrCreateStore(storeValue, 0 /* StoreFlags.NONE */, container);
             if (needsInflation(t)) {
-                pendingStoreTargets.set(storeValue, { t, v });
+                container.$pendingStoreTargets$.set(storeValue, { t, v });
             }
             // We must store the reference so it doesn't get deserialized again in inflate()
             data[0] = 0 /* TypeIds.Plain */;
@@ -11539,12 +11784,16 @@ const allocate = (container, typeId, value) => {
             // Don't leave unhandled promise rejections
             promise.catch(() => { });
             return promise;
-        case 27 /* TypeIds.Uint8Array */:
+        case 27 /* TypeIds.Uint8Array */: {
+            if (!isCanonicalBase64(value)) {
+                throw qError(38 /* QError.invalidUint8ArrayPayload */);
+            }
             const encodedLength = value.length;
-            const blocks = encodedLength >>> 2;
-            const rest = encodedLength & 3;
+            const blocks = Math.floor(encodedLength / 4);
+            const rest = encodedLength % 4;
             const decodedLength = blocks * 3 + (rest ? rest - 1 : 0);
             return new Uint8Array(decodedLength);
+        }
         case 38 /* TypeIds.PropsProxy */:
             return createPropsProxy(null);
         case 10 /* TypeIds.VNode */:
@@ -11585,7 +11834,12 @@ const allocate = (container, typeId, value) => {
             }
         case 39 /* TypeIds.SubscriptionData */:
             return new SubscriptionData({});
+        case 42 /* TypeIds.SubscriptionDataConstTrue */:
+            return new SubscriptionData({ $scopedStyleIdPrefix$: null, $isConst$: true });
+        case 43 /* TypeIds.SubscriptionDataConstFalse */:
+            return new SubscriptionData({ $scopedStyleIdPrefix$: null, $isConst$: false });
         case 40 /* TypeIds.EffectSubscription */:
+        case 44 /* TypeIds.EffectSubscriptionNoData */:
             return new EffectSubscription(null, null, null, null);
         case 41 /* TypeIds.SubscriptionPatch */:
             return new SubscriptionPatch();
@@ -11794,6 +12048,16 @@ const applyQwikComponentBody = (ssr, jsx, component) => {
 
 class MaybeAsyncSignal {
 }
+const markPromiseHandled = (ssr, promise, host = null) => {
+    promise.catch((reason) => {
+        try {
+            ssr.handleError(reason, host);
+        }
+        catch {
+            // Original promise remains awaited later.
+        }
+    });
+};
 function setParentOptions(mutable, styleScoped, parentComponentFrame) {
     return () => {
         mutable.currentStyleScoped = styleScoped;
@@ -11804,6 +12068,11 @@ function setParentOptions(mutable, styleScoped, parentComponentFrame) {
 async function _walkJSX(ssr, value, options) {
     const stack = [value];
     const enqueue = (value) => stack.push(value);
+    const enqueuePromise = (promise) => {
+        markPromiseHandled(ssr, promise);
+        stack.push(promise);
+        stack.push(Promise);
+    };
     const drain = async () => {
         while (stack.length) {
             try {
@@ -11826,7 +12095,7 @@ async function _walkJSX(ssr, value, options) {
                     }
                     continue;
                 }
-                processJSXNode(ssr, enqueue, value, options);
+                processJSXNode(ssr, enqueue, enqueuePromise, value, options);
             }
             finally {
                 const pendingFlush = ssr.streamHandler.waitForPendingFlush();
@@ -11838,7 +12107,7 @@ async function _walkJSX(ssr, value, options) {
     };
     await drain();
 }
-function processJSXNode(ssr, enqueue, value, options) {
+function processJSXNode(ssr, enqueue, enqueuePromise, value, options) {
     // console.log('processJSXNode', value);
     if (value == null) {
         ssr.textNode('');
@@ -11859,7 +12128,6 @@ function processJSXNode(ssr, enqueue, value, options) {
             }
         }
         else if (isSignal(value)) {
-            maybeAddPollingAsyncSignalToEagerResume(ssr.serializationCtx, value);
             ssr.openFragment(isDev ? { [DEBUG_TYPE]: "S" /* VirtualType.WrappedSignal */ } : EMPTY_OBJ);
             const signalNode = ssr.getOrCreateLastNode();
             const unwrappedSignal = value instanceof WrappedSignalImpl ? value.$unwrapIfSignal$() : value;
@@ -11870,8 +12138,7 @@ function processJSXNode(ssr, enqueue, value, options) {
         else if (isPromise(value)) {
             ssr.openFragment(isDev ? { [DEBUG_TYPE]: "A" /* VirtualType.Awaited */ } : EMPTY_OBJ);
             enqueue(ssr.closeFragment);
-            enqueue(value);
-            enqueue(Promise);
+            enqueuePromise(value);
             enqueue(() => ssr.streamHandler.flush());
         }
         else if (isAsyncGenerator(value)) {
@@ -11942,11 +12209,9 @@ function processJSXNode(ssr, enqueue, value, options) {
                     const componentFrame = options.parentComponentFrame;
                     if (componentFrame) {
                         const compId = componentFrame.componentNode.id || '';
-                        const projectionAttrs = isDev ? { [DEBUG_TYPE]: "P" /* VirtualType.Projection */ } : {};
-                        const cursorBoundary = directGetPropsProxyProp(jsx, QCursorBoundary);
-                        if (cursorBoundary) {
-                            projectionAttrs[QCursorBoundary] = cursorBoundary;
-                        }
+                        const projectionAttrs = isDev
+                            ? { [DEBUG_TYPE]: "P" /* VirtualType.Projection */ }
+                            : {};
                         projectionAttrs[QSlotParent] = compId;
                         ssr.openProjection(projectionAttrs);
                         const host = componentFrame.componentNode;
@@ -11994,8 +12259,12 @@ function processJSXNode(ssr, enqueue, value, options) {
                     else {
                         value = generator;
                     }
-                    enqueue(value);
-                    isPromise(value) && enqueue(Promise);
+                    if (isPromise(value)) {
+                        enqueuePromise(value);
+                    }
+                    else {
+                        enqueue(value);
+                    }
                 }
                 else if (type === SSRRaw) {
                     ssr.htmlNode(directGetPropsProxyProp(jsx, 'data'));
@@ -12019,8 +12288,10 @@ function processJSXNode(ssr, enqueue, value, options) {
                     enqueue(setParentOptions(options, options.currentStyleScoped, options.parentComponentFrame));
                     enqueue(() => ssr.closeComponent());
                     if (isPromise(jsxOutput)) {
+                        markPromiseHandled(ssr, jsxOutput, host);
                         // Defer reading QScopedStyle until after the promise resolves
                         enqueue(async () => {
+                            await ssr.streamHandler.flush();
                             const resolvedOutput = await jsxOutput;
                             const compStyleComponentId = addComponentStylePrefix(host.getProp(QScopedStyle));
                             enqueue(resolvedOutput);
@@ -12042,27 +12313,17 @@ function processJSXNode(ssr, enqueue, value, options) {
                     enqueue(ssr.closeFragment);
                     const component = ssr.getParentComponentFrame();
                     const jsxOutput = applyInlineComponent(ssr, component && component.componentNode, type, jsx);
-                    enqueue(jsxOutput);
-                    isPromise(jsxOutput) && enqueue(Promise);
+                    if (isPromise(jsxOutput)) {
+                        enqueuePromise(jsxOutput);
+                    }
+                    else {
+                        enqueue(jsxOutput);
+                    }
                 }
             }
         }
     }
 }
-function maybeAddPollingAsyncSignalToEagerResume(serializationCtx, signal) {
-    // Unwrap if it's a WrappedSignalImpl
-    const unwrappedSignal = signal instanceof WrappedSignalImpl ? signal.$unwrapIfSignal$() : signal;
-    if (unwrappedSignal instanceof AsyncSignalImpl) {
-        const expires = unwrappedSignal.$expires$;
-        // Don't check for $effects$ here - effects are added later during tracking.
-        // The AsyncSignal's polling mechanism will check for effects before scheduling.
-        // Only eager-resume for polling signals, not stale-only ones.
-        if (expires && !(unwrappedSignal.$flags$ & 256 /* AsyncSignalFlags.NO_POLL */)) {
-            serializationCtx.$addRoot$(unwrappedSignal);
-            serializationCtx.$eagerResume$.add(unwrappedSignal);
-        }
-    }
-}
 function appendQwikInspectorAttribute(jsx, qwikInspectorAttrValue) {
     if (qwikInspectorAttrValue && (!jsx.constProps || !(qwikInspectorAttr in jsx.constProps))) {
         (jsx.constProps ||= {})[qwikInspectorAttr] = qwikInspectorAttrValue;
@@ -12235,7 +12496,8 @@ function setEvent(serializationCtx, key, rawValue, hasMovedCaptures) {
          *
          * For internal qrls (starting with `_`) we assume that they do the right thing.
          */
-        if (!qrl.$symbol$.startsWith('_') && (qrl.$captures$?.length || hasMovedCaptures)) {
+        if (!qrl.$symbol$.startsWith('_') &&
+            (Array.isArray(qrl.$captures$) || (hasMovedCaptures && qrl.$hasMovedCaptures$))) {
             qrl = createQRL(null, '_run', _run, null, [qrl]);
         }
         return qrlToChunks(serializationCtx, qrl);
@@ -12449,22 +12711,24 @@ const useOnEventsSequentialScope = () => {
 const _hmr = function (event, element) {
     // Deserialize captures from `this` when called via qwikloader/attribute dispatch
     const container = getDomContainer(element);
-    if (typeof this === 'string') {
-        setCaptures(deserializeCaptures(container, this));
-    }
-    const devPath = _captures?.[1];
-    const hmrPath = devPath ?? element.getAttribute('data-qwik-inspector');
-    if (!hmrPath || !event.detail.files.some((file) => hmrPath.startsWith(file))) {
-        return;
-    }
-    const host = _captures?.[0];
-    if (!host || host.flags & 32 /* VNodeFlags.Deleted */) {
-        return;
-    }
-    markVNodeDirty(container, host, 4 /* ChoreBits.COMPONENT */);
-    // Mark HMR as handled
-    const doc = element.ownerDocument;
-    doc.__hmrDone = doc.__hmrT;
+    return whenContainerDataReady(container, () => {
+        if (typeof this === 'string') {
+            setCaptures(deserializeCaptureDeltas(container, this));
+        }
+        const devPath = _captures?.[1];
+        const hmrPath = devPath ?? element.getAttribute('data-qwik-inspector');
+        if (!hmrPath || !event.detail.files.some((file) => hmrPath.startsWith(file))) {
+            return;
+        }
+        const host = _captures?.[0];
+        if (!host || host.flags & 32 /* VNodeFlags.Deleted */) {
+            return;
+        }
+        markVNodeDirty(container, host, 4 /* ChoreBits.COMPONENT */);
+        // Mark HMR as handled
+        const doc = element.ownerDocument;
+        doc.__hmrDone = doc.__hmrT;
+    });
 };
 let hmrQrl;
 /**
@@ -12569,22 +12833,93 @@ const isSafeObjectKV = (key, value) => {
         (typeof value !== 'function' || !dangerousObjectKeys.has(key)));
 };
 const inflate = (container, target, typeId, data) => {
+    const ownsPendingStoreTargets = beginDeserialization(container);
+    try {
+        const iterator = inflateIterator(container, target, typeId, data);
+        while (!iterator.next().done) {
+            // Run synchronously for lazy deserialization paths.
+        }
+    }
+    finally {
+        endDeserialization(container, ownsPendingStoreTargets);
+    }
+};
+function* eagerDeserializeArrayIterator(container, data, output = Array(data.length / 2)) {
+    for (let i = 0; i < data.length; i += 2) {
+        output[i / 2] = yield* deserializeDataIterator(container, data[i], data[i + 1]);
+        yield;
+    }
+    return output;
+}
+function* eagerDeserializeStateIterator(container, data, output = Array(data.length / 2)) {
+    const ownsPendingStoreTargets = beginDeserialization(container);
+    const length = data.length / 2;
+    const allocated = new Uint8Array(length);
+    const previousGetObjectById = container.$getObjectById$;
+    const allocateRoot = (index) => {
+        if (!allocated[index]) {
+            allocated[index] = 1;
+            const typeIndex = index * 2;
+            const typeId = data[typeIndex];
+            const value = data[typeIndex + 1];
+            output[index] = typeId === 0 /* TypeIds.Plain */ ? value : allocate(container, typeId, value);
+        }
+        return output[index];
+    };
+    container.$getObjectById$ = (id) => allocateRoot(typeof id === 'string' ? parseInt(id, 10) : id);
+    try {
+        for (let i = 0; i < length; i++) {
+            allocateRoot(i);
+            yield;
+        }
+        for (let i = 0; i < length; i++) {
+            const typeIndex = i * 2;
+            const typeId = data[typeIndex];
+            const value = data[typeIndex + 1];
+            const propValue = output[i];
+            data[typeIndex] = 0 /* TypeIds.Plain */;
+            data[typeIndex + 1] = propValue;
+            if (needsInflation(typeId)) {
+                yield* inflateIterator(container, propValue, typeId, value);
+            }
+            yield;
+        }
+    }
+    finally {
+        container.$getObjectById$ = previousGetObjectById;
+        endDeserialization(container, ownsPendingStoreTargets);
+    }
+    return output;
+}
+function* deserializeDataIterator(container, typeId, value) {
+    if (typeId === 0 /* TypeIds.Plain */) {
+        return value;
+    }
+    const propValue = allocate(container, typeId, value);
+    if (needsInflation(typeId)) {
+        yield* inflateIterator(container, propValue, typeId, value);
+    }
+    return propValue;
+}
+function* inflateIterator(container, target, typeId, data) {
     if (typeId === 0 /* TypeIds.Plain */) {
         // Already processed
         return;
     }
+    if (typeId === 5 /* TypeIds.Object */ && data !== EMPTY_OBJECT_PAYLOAD && !Array.isArray(data)) {
+        throw new Error('Invalid Object payload');
+    }
     // Restore the complex data, special case for Array
     if (typeId !== 4 /* TypeIds.Array */ && Array.isArray(data)) {
-        data = _eagerDeserializeArray(container, data);
+        data = yield* eagerDeserializeArrayIterator(container, data);
     }
     switch (typeId) {
         case 4 /* TypeIds.Array */:
             // Arrays are special, we need to fill the array in place
-            _eagerDeserializeArray(container, data, target);
+            yield* eagerDeserializeArrayIterator(container, data, target);
             break;
         case 5 /* TypeIds.Object */:
-            if (data === 0) {
-                // Special case, was an empty object
+            if (data === EMPTY_OBJECT_PAYLOAD) {
                 break;
             }
             for (let i = 0; i < data.length; i += 2) {
@@ -12596,37 +12931,65 @@ const inflate = (container, target, typeId, data) => {
                 target[key] = value;
             }
             break;
-        case 28 /* TypeIds.Task */:
+        case 25 /* TypeIds.Set */: {
+            const set = target;
+            const d = data;
+            for (let i = 0; i < d.length; i++) {
+                set.add(d[i]);
+                yield;
+            }
+            break;
+        }
+        case 26 /* TypeIds.Map */: {
+            const map = target;
+            const d = data;
+            for (let i = 0; i < d.length; i++) {
+                map.set(d[i++], d[i]);
+                yield;
+            }
+            break;
+        }
+        case 24 /* TypeIds.Promise */: {
+            const promise = target;
+            const [resolved, result] = data;
+            const [resolve, reject] = resolvers.get(promise);
+            if (resolved) {
+                // Native Promises cannot fulfill with another Promise.
+                if (resolvers.has(result)) {
+                    throw qError(37 /* QError.invalidPromiseDependency */);
+                }
+                resolve(result);
+            }
+            else {
+                reject(result);
+            }
+            break;
+        }
+        case 23 /* TypeIds.Error */: {
+            const d = data;
+            target.message = d[0];
+            for (let i = 1; i < d.length; i += 2) {
+                const key = d[i];
+                const value = d[i + 1];
+                if (isSafeObjectKV(key, value)) {
+                    target[key] = value;
+                }
+                yield;
+            }
+            break;
+        }
+        case 28 /* TypeIds.Task */: {
             const task = target;
             const v = data;
             task.$qrl$ = v[0];
             task.$flags$ = v[1];
             task.$index$ = v[2];
             task.$el$ = v[3];
-            task.$state$ = v[4];
             break;
+        }
         case 29 /* TypeIds.Component */:
             target[SERIALIZABLE_STATE][0] = data[0];
             break;
-        case 35 /* TypeIds.Store */: {
-            // Inflate the store target
-            const store = unwrapStore(target);
-            const storeTarget = pendingStoreTargets.get(store);
-            if (storeTarget) {
-                pendingStoreTargets.delete(store);
-                inflate(container, store, storeTarget.t, storeTarget.v);
-            }
-            /**
-             * Note that we don't do anything with the innerstores we added during serialization, because
-             * they are already inflated in the deserialize of the data, above.
-             */
-            const [, flags, effects] = data;
-            const storeHandler = getStoreHandler(target);
-            storeHandler.$flags$ = flags;
-            storeHandler.$effects$ = effects;
-            restoreEffectBackRefForEffectsMap(storeHandler.$effects$, store);
-            break;
-        }
         case 30 /* TypeIds.Signal */: {
             const signal = target;
             const d = data;
@@ -12642,7 +13005,7 @@ const inflate = (container, target, typeId, data) => {
             signal.$args$ = d[1];
             signal.$untrackedValue$ = NEEDS_COMPUTATION;
             signal.$flags$ = d[2];
-            signal.$flags$ |= 1 /* SignalFlags.INVALID */;
+            signal.$flags$ |= 1 /* ComputedSignalFlags.INVALID */;
             signal.$hostElement$ = d[3];
             signal.$effects$ = new Set(d.slice(4));
             inflateWrappedSignalValue(signal);
@@ -12668,7 +13031,7 @@ const inflate = (container, target, typeId, data) => {
             asyncSignal.$flags$ = d[5] ?? 0;
             if (asyncSignal.$flags$ & 64 /* AsyncSignalFlags.CLIENT_ONLY */) {
                 // If it's client only, it was serialized because it pretended to be loading
-                asyncSignal.$untrackedLoading$ = true;
+                asyncSignal.$untrackedPending$ = true;
             }
             const hasValue = d.length > 6;
             if (hasValue) {
@@ -12676,19 +13039,13 @@ const inflate = (container, target, typeId, data) => {
             }
             // can happen when never serialize etc
             if (asyncSignal.$untrackedValue$ === NEEDS_COMPUTATION) {
-                asyncSignal.$flags$ |= 1 /* SignalFlags.INVALID */;
+                asyncSignal.$flags$ |= 1 /* ComputedSignalFlags.INVALID */;
             }
-            // Handle old format (negative = no poll) and new format (always positive, flag in d[5])
-            const rawExpires = (d[7] ?? 0);
-            asyncSignal.expires = Math.abs(rawExpires);
-            if (rawExpires < 0) {
-                asyncSignal.$flags$ |= 256 /* AsyncSignalFlags.NO_POLL */;
-            }
-            if (d[8] !== undefined && d[8] !== 1) {
-                asyncSignal.$concurrency$ = (d[8] ?? 1);
+            if (d[7] !== undefined && d[7] !== 1) {
+                asyncSignal.$concurrency$ = (d[7] ?? 1);
                 asyncSignal.$jobs$ = [];
             }
-            asyncSignal.$timeoutMs$ = (d[9] ?? 0);
+            asyncSignal.$timeoutMs$ = (d[8] ?? 0);
             restoreEffectBackRefForEffects(asyncSignal.$effects$, asyncSignal);
             restoreEffectBackRefForEffects(asyncSignal.$loadingEffects$, asyncSignal);
             restoreEffectBackRefForEffects(asyncSignal.$errorEffects$, asyncSignal);
@@ -12719,24 +13076,17 @@ const inflate = (container, target, typeId, data) => {
             if (typeId !== 34 /* 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 */;
+                computed.$flags$ &= -2 /* ComputedSignalFlags.INVALID */;
             }
             restoreEffectBackRefForEffects(computed.$effects$, computed);
             break;
         }
-        case 23 /* TypeIds.Error */: {
-            const d = data;
-            target.message = d[0];
-            for (let i = 1; i < d.length; i += 2) {
-                target[d[i]] = d[i + 1];
-            }
-            break;
-        }
         case 36 /* TypeIds.FormData */: {
             const formData = target;
             const d = data;
             for (let i = 0; i < d.length; i++) {
                 formData.append(d[i++], d[i]);
+                yield;
             }
             break;
         }
@@ -12751,49 +13101,16 @@ const inflate = (container, target, typeId, data) => {
             jsx.toSort = !!toSort;
             break;
         }
-        case 25 /* TypeIds.Set */: {
-            const set = target;
-            const d = data;
-            for (let i = 0; i < d.length; i++) {
-                set.add(d[i]);
-            }
-            break;
-        }
-        case 26 /* TypeIds.Map */: {
-            const map = target;
-            const d = data;
-            for (let i = 0; i < d.length; i++) {
-                map.set(d[i++], d[i]);
-            }
-            break;
-        }
-        case 24 /* TypeIds.Promise */: {
-            const promise = target;
-            const [resolved, result] = data;
-            const [resolve, reject] = resolvers.get(promise);
-            if (resolved) {
-                resolve(result);
-            }
-            else {
-                reject(result);
-            }
-            break;
-        }
-        case 27 /* TypeIds.Uint8Array */:
-            const bytes = target;
-            const buf = atob(data);
-            let i = 0;
-            for (let j = 0; j < buf.length; j++) {
-                const s = buf[j];
-                bytes[i++] = s.charCodeAt(0);
-            }
-            break;
-        case 38 /* TypeIds.PropsProxy */:
+        case 38 /* TypeIds.PropsProxy */: {
             const propsProxy = target;
             const d = data;
             let owner = d[0];
             if (owner === _UNINITIALIZED) {
-                owner = new JSXNodeImpl(Fragment, d[1], d[2], null, 0, null);
+                owner = new JSXNodeImpl(Fragment, null, null, null, 0, null);
+                // Important: var/const props can be eager-deserialization placeholders. (empty objects)
+                // Do not let JSXNodeImpl constructor normalize {} to EMPTY_OBJ/null.
+                owner.varProps = d[1];
+                owner.constProps = d[2];
                 owner._proxy = propsProxy;
             }
             propsProxy[_OWNER] = owner;
@@ -12801,51 +13118,69 @@ const inflate = (container, target, typeId, data) => {
             propsHandler.$effects$ = d[3];
             restoreEffectBackRefForEffectsMap(propsHandler.$effects$, propsProxy);
             break;
+        }
         case 39 /* TypeIds.SubscriptionData */: {
             const effectData = target;
             effectData.data.$scopedStyleIdPrefix$ = data[0];
             effectData.data.$isConst$ = data[1];
             break;
         }
-        case 40 /* TypeIds.EffectSubscription */: {
+        case 42 /* TypeIds.SubscriptionDataConstTrue */:
+        case 43 /* TypeIds.SubscriptionDataConstFalse */:
+            break;
+        case 40 /* TypeIds.EffectSubscription */: {
+            const effectSub = target;
+            const d = data;
+            effectSub.consumer = d[0];
+            effectSub.property = d[1];
+            effectSub.data = d[2];
+            restoreEffectBackRefForConsumer(effectSub);
+            break;
+        }
+        case 41 /* TypeIds.SubscriptionPatch */: {
+            const patch = target;
+            const d = data;
+            patch.rootId = d[0];
+            patch.subscriptions = d[1];
+            break;
+        }
+        case 44 /* TypeIds.EffectSubscriptionNoData */: {
             const effectSub = target;
             const d = data;
             effectSub.consumer = d[0];
             effectSub.property = d[1];
-            effectSub.data = d[2];
+            effectSub.data = null;
             restoreEffectBackRefForConsumer(effectSub);
             break;
         }
-        case 41 /* TypeIds.SubscriptionPatch */: {
-            const patch = target;
-            const d = data;
-            patch.rootId = d[0];
-            patch.subscriptions = d[1];
+        case 27 /* TypeIds.Uint8Array */: {
+            const bytes = target;
+            const buf = atob(data);
+            for (let j = 0; j < buf.length; j++) {
+                bytes[j] = buf.charCodeAt(j);
+                if ((j & 31) === 31) {
+                    yield;
+                }
+            }
+            break;
+        }
+        case 35 /* TypeIds.Store */: {
+            const store = unwrapStore(target);
+            const storeTarget = container.$pendingStoreTargets$.get(store);
+            if (storeTarget) {
+                container.$pendingStoreTargets$.delete(store);
+                yield* inflateIterator(container, store, storeTarget.t, storeTarget.v);
+            }
+            const [, flags, effects] = data;
+            const storeHandler = getStoreHandler(target);
+            storeHandler.$flags$ = flags;
+            storeHandler.$effects$ = effects;
+            restoreEffectBackRefForEffectsMap(storeHandler.$effects$, store);
             break;
         }
         default:
             throw qError(16 /* QError.serializeErrorNotImplemented */, [typeId]);
     }
-};
-/**
- * Restores an array eagerly. If you need it lazily, use `deserializeData(container, TypeIds.Array,
- * array)` instead
- */
-const _eagerDeserializeArray = (container, data, output = Array(data.length / 2)) => {
-    for (let i = 0; i < data.length; i += 2) {
-        output[i / 2] = deserializeData(container, data[i], data[i + 1]);
-    }
-    return output;
-};
-function deserializeData(container, typeId, value) {
-    if (typeId === 0 /* TypeIds.Plain */) {
-        return value;
-    }
-    const propValue = allocate(container, typeId, value);
-    if (needsInflation(typeId)) {
-        inflate(container, propValue, typeId, value);
-    }
-    return propValue;
 }
 function inflateWrappedSignalValue(signal) {
     if (signal.$hostElement$ !== null && vnode_isVNode(signal.$hostElement$)) {
@@ -12956,15 +13291,21 @@ class DeserializationHandler {
             return value;
         }
         const container = this.$container$;
-        const propValue = allocate(container, typeId, value);
-        Reflect.set(target, property, propValue);
-        this.$data$[idx] = 0 /* TypeIds.Plain */;
-        this.$data$[idx + 1] = propValue;
-        /** We stored the reference, so now we can inflate, allowing cycles */
-        if (needsInflation(typeId)) {
-            inflate(container, propValue, typeId, value);
+        const ownsPendingStoreTargets = beginDeserialization(container);
+        try {
+            const propValue = allocate(container, typeId, value);
+            Reflect.set(target, property, propValue);
+            this.$data$[idx] = 0 /* TypeIds.Plain */;
+            this.$data$[idx + 1] = propValue;
+            /** We stored the reference, so now we can inflate, allowing cycles */
+            if (needsInflation(typeId)) {
+                inflate(container, propValue, typeId, value);
+            }
+            return propValue;
+        }
+        finally {
+            endDeserialization(container, ownsPendingStoreTargets);
         }
-        return propValue;
     }
     has(target, property) {
         if (property === SERIALIZER_PROXY_UNWRAP) {
@@ -12988,6 +13329,54 @@ class DeserializationHandler {
     }
 }
 
+const YIELD_INTERVAL = 10;
+const scheduleYieldingIterator = (state) => {
+    if (!state.$scheduled$) {
+        state.$scheduled$ = true;
+        state.$schedule$();
+    }
+};
+const runYieldingIterator = (state, onDone, onError) => {
+    state.$scheduled$ = false;
+    const deadline = performance.now() + YIELD_INTERVAL;
+    let count = 0;
+    try {
+        while (true) {
+            const result = state.$iterator$.next();
+            if (result.done) {
+                onDone(result.value);
+                return;
+            }
+            // Sampling the clock every 32 steps keeps `performance.now()` out of the hottest path.
+            if ((++count & 31) === 0 && performance.now() >= deadline) {
+                scheduleYieldingIterator(state);
+                return;
+            }
+        }
+    }
+    catch (error) {
+        onError(error);
+    }
+};
+const createYieldingIteratorState = (iterator, onDone, onError) => {
+    const state = {
+        $iterator$: iterator,
+        $schedule$: undefined,
+        $scheduled$: false,
+    };
+    const schedule = createMacroTask(() => {
+        runYieldingIterator(state, (value) => {
+            schedule.$destroy$?.();
+            onDone(value);
+        }, (error) => {
+            schedule.$destroy$?.();
+            onError(error);
+        });
+    });
+    state.$schedule$ = schedule;
+    return state;
+};
+
 /**
  * Serialize data to string using SerializationContext.
  *
@@ -13000,12 +13389,12 @@ async function _serialize(data) {
     return serializationContext.$writer$.toString();
 }
 /**
- * Deserialize data from string to an array of objects.
+ * Deserialize data from string.
  *
  * @param rawStateData - Data to deserialize
  * @internal
  */
-function _deserialize(rawStateData) {
+async function _deserialize(rawStateData) {
     if (rawStateData == null) {
         throw new Error('No state data to deserialize');
     }
@@ -13013,9 +13402,18 @@ function _deserialize(rawStateData) {
     if (!Array.isArray(stateData) || stateData.length < 2 || typeof stateData[0] !== 'number') {
         throw new Error('Invalid state data');
     }
-    const container = _createDeserializeContainer(stateData);
-    return deserializeData(container, stateData[0], stateData[1]);
+    const state = Array(stateData.length / 2);
+    const container = createBaseDeserializeContainer(stateData, () => state);
+    container.$state$ = state;
+    await runDeserializeIterator(eagerDeserializeStateIterator(container, stateData, state));
+    return state[0];
 }
+const runDeserializeIterator = (iterator) => {
+    return new Promise((resolve, reject) => {
+        const state = createYieldingIteratorState(iterator, resolve, reject);
+        scheduleYieldingIterator(state);
+    });
+};
 function getObjectById(id, stateData) {
     if (typeof id === 'string') {
         id = parseInt(id, 10);
@@ -13029,8 +13427,14 @@ function getObjectById(id, stateData) {
 function _createDeserializeContainer(stateData) {
     // eslint-disable-next-line prefer-const
     let state;
+    const container = createBaseDeserializeContainer(stateData, () => state);
+    state = wrapDeserializerProxy(container, stateData);
+    container.$state$ = state;
+    return container;
+}
+function createBaseDeserializeContainer(stateData, getState) {
     const container = {
-        $getObjectById$: (id) => getObjectById(id, state),
+        $getObjectById$: (id) => getObjectById(id, getState()),
         $getForwardRef$: (id) => container.$forwardRefs$?.[Number(id)],
         getSyncFn: (_) => {
             const fn = () => { };
@@ -13041,8 +13445,6 @@ function _createDeserializeContainer(stateData) {
         $forwardRefs$: null,
     };
     preprocessState(stateData, container);
-    state = wrapDeserializerProxy(container, stateData);
-    container.$state$ = state;
     return container;
 }
 
@@ -13425,7 +13827,7 @@ const isRecoverable = (err) => {
 };
 
 /** @internal */
-const canRevealRegistration = (registration, isPending = (item) => item.boundary.pending.untrackedValue > 0) => {
+const canRevealRegistration = (registration, isPending = (item) => item.boundary.untrackedValue > 0) => {
     if (registration === null) {
         return true;
     }
@@ -13502,15 +13904,9 @@ class OutOfOrderRevealCoordinator {
 }
 /** @internal */
 const createOutOfOrderRevealCoordinator = (order, collapsed) => {
-    if (!isOutOfOrderStreaming()) {
-        return null;
-    }
-    const container = tryGetInvokeContext()?.$container$;
-    let id = 0;
-    if (container) {
-        id = (outOfOrderRevealIds.get(container) || 0) + 1;
-        outOfOrderRevealIds.set(container, id);
-    }
+    const container = tryGetInvokeContext().$container$;
+    const id = (outOfOrderRevealIds.get(container) || 0) + 1;
+    outOfOrderRevealIds.set(container, id);
     return new OutOfOrderRevealCoordinator(id, order, collapsed);
 };
 const getOutOfOrderRevealOrderCode = (order) => {
@@ -13534,16 +13930,7 @@ const isOutOfOrderStreaming = () => {
     return container?.outOfOrderStreaming === true && !isOutOfOrderSegmentContainer(container);
 };
 /** @internal */
-const nextOutOfOrderSuspenseId = () => {
-    if (!__EXPERIMENTAL__.suspense) {
-        return 0;
-    }
-    const container = tryGetInvokeContext()?.$container$;
-    if (container?.outOfOrderStreaming !== true) {
-        return 0;
-    }
-    return container?.nextOutOfOrderId?.() ?? 0;
-};
+const nextOutOfOrderSuspenseId = () => tryGetInvokeContext().$container$.nextOutOfOrderId();
 /** @internal */
 const applySubscriptionPatches = (container, patches) => {
     if (!__EXPERIMENTAL__.suspense || !patches) {
@@ -13594,13 +13981,12 @@ const mergeSubscriptionSet = (container, producer, backRef, rootEffects, patchEf
 };
 
 const processedStatePatchScripts = new WeakMap();
-/** @internal */
-const processSegmentStateScripts = (container, segmentId) => {
+function* processSegmentStateScriptsIterator(container, segmentId) {
     if (!__EXPERIMENTAL__.suspense) {
         return;
     }
     const stateContainer = container;
-    const qwikStates = stateContainer.element.querySelectorAll(`${stateScriptSelector(stateContainer.$instanceHash$)}${QStatePatchAttrSelector}`);
+    const qwikStates = stateContainer.element.querySelectorAll(`script[type="qwik/state"][q\\:instance="${stateContainer.$instanceHash$}"]${QStatePatchAttrSelector}`);
     const processedScripts = getProcessedStatePatchScripts(container);
     for (let i = 0; i < qwikStates.length; i++) {
         const stateScript = qwikStates[i];
@@ -13611,9 +13997,10 @@ const processSegmentStateScripts = (container, segmentId) => {
             continue;
         }
         processedScripts.add(stateScript);
-        processStatePatch(container, stateContainer, stateScript.textContent);
+        yield* processStatePatch(container, stateContainer, stateScript.textContent);
+        yield;
     }
-};
+}
 const getProcessedStatePatchScripts = (container) => {
     let processedScripts = processedStatePatchScripts.get(container);
     if (!processedScripts) {
@@ -13622,20 +14009,18 @@ const getProcessedStatePatchScripts = (container) => {
     }
     return processedScripts;
 };
-const stateScriptSelector = (instanceHash) => {
-    return `script[type="qwik/state"][q\\:instance="${instanceHash}"]`;
-};
-const processStatePatch = (container, stateContainer, textContent) => {
-    if (textContent) {
-        const [rootStart, rawStateData, forwardRefs, subscriptionPatchRootId] = JSON.parse(textContent);
-        appendStatePatchRoots(container, stateContainer, rootStart, rawStateData);
-        mergeForwardRefs(stateContainer, forwardRefs || undefined);
-        applySubscriptionPatches(container, subscriptionPatchRootId === undefined
-            ? undefined
-            : stateContainer.$getObjectById$(subscriptionPatchRootId));
+function* processStatePatch(container, stateContainer, textContent) {
+    if (!textContent) {
+        return;
     }
-};
-const appendStatePatchRoots = (container, stateContainer, rootStart, rawStateData) => {
+    const [rootStart, rawStateData, forwardRefs, subscriptionPatchRootId] = JSON.parse(textContent);
+    yield* appendStatePatchRoots(container, stateContainer, rootStart, rawStateData);
+    mergeForwardRefs(stateContainer, forwardRefs || undefined);
+    applySubscriptionPatches(container, subscriptionPatchRootId === undefined
+        ? undefined
+        : stateContainer.$getObjectById$(subscriptionPatchRootId));
+}
+function* appendStatePatchRoots(container, stateContainer, rootStart, rawStateData) {
     const currentRootCount = stateContainer.$rawStateData$.length / 2;
     if (rootStart !== currentRootCount) {
         if (qDev) {
@@ -13645,12 +14030,13 @@ const appendStatePatchRoots = (container, stateContainer, rootStart, rawStateDat
     }
     for (let i = 0; i < rawStateData.length; i++) {
         stateContainer.$rawStateData$[rootStart * 2 + i] = rawStateData[i];
+        yield;
     }
-    preprocessState(stateContainer.$rawStateData$, container, undefined, rootStart * 2);
+    yield* preprocessStateIterator(stateContainer.$rawStateData$, container, rootStart * 2);
     stateContainer.$stateData$ = wrapDeserializerProxy(container, stateContainer.$rawStateData$);
     stateContainer.$stateData$.length = stateContainer.$rawStateData$.length / 2;
     stateContainer.$rootForwardRefs$ = stateContainer.$forwardRefs$;
-};
+}
 const mergeForwardRefs = (stateContainer, forwardRefs) => {
     if (!forwardRefs) {
         return;
@@ -13665,24 +14051,172 @@ const mergeForwardRefs = (stateContainer, forwardRefs) => {
     stateContainer.$forwardRefs$ = rootForwardRefs;
 };
 
-// NOTE: we want to move this function to qwikloader, and therefore this function should not have any external dependencies
+const Q_SUSPENSE_RESOLVED = 'q:r';
+const Q_PATCH = 'q:patch';
+/**
+ * Process the VNodeData script tags and store the VNodeData in the VNodeDataMap.
+ *
+ * The end result of this function is that each DOM element has the associated `VNodeData` attached
+ * to it, to be used later `VNode` materialization. The "attachment" is done through the
+ * `VNodeDataMap`.
+ *
+ * Run this function on startup to process the `<script type="qwik/vnode">` tags. The data in the
+ * tags needs to be parsed and attached to the DOM elements. (We do this through `VNodeDataMap`)
+ * `VNodeDataMap` is then used to lazily materialize the VNodes.
+ *
+ * Only one invocation of this function is needed per document/browser session.
+ *
+ * Below is an example of the kinds of constructs which need to be handled when dealing with
+ * VNodeData deserialization.
+ *
+ * ```
+ * <html q:container="paused">
+ *   <body>
+ *     <div q:container="paused">
+ *       <script type="qwik/vnode">...</script>
+ *     </div>
+ *     <div q:container="html">...</div>
+ *     before
+ *     <!--q:container=ABC-->
+ *     ...
+ *     <!--/q:container-->
+ *     after
+ *     <!--q:ignore=FOO-->
+ *     ...
+ *        <!--q:container-island=BAR-->
+ *        <div>some interactive island</div>
+ *        <!--/q:container-island-->
+ *     ...
+ *     <!--/q:ignore-->
+ *     <textarea q:container="text">...</textarea>
+ *     <script type="qwik/vnode">...</script>
+ *   </body>
+ * </html>
+ * ```
+ *
+ * Each `qwik/vnode` script assumes that the elements are numbered in depth first order. For this
+ * reason, whenever the `processVNodeData` comes across a `q:container` it must ignore its
+ * children.
+ *
+ * IMPLEMENTATION:
+ *
+ * - Stack to keep track of the current `q:container` being processed.
+ * - Attach all `qwik/vnode` scripts (not the data contain within them) to the `q:container` element.
+ * - Walk the tree and process each `q:container` element.
+ */
+function processVNodeData(document, containerElement) {
+    const qDocument = document;
+    // Per-container gate: a walk already populated this container's refs → done.
+    if (containerElement?.qVNodeRefs) {
+        return;
+    }
+    // A document-wide walk is in flight; it will pick up this newly-added container too.
+    if (qDocument.qVNodeDataStarted && !qDocument.qVNodeDataProcessed) {
+        return;
+    }
+    qDocument.qVNodeDataStarted = true;
+    qDocument.qVNodeData ||= new WeakMap();
+    enqueueProcessVNodeDataJob(qDocument, processRootVNodeData(document));
+}
 function processOutOfOrderSegmentVNodeData(document, segmentId, contentNode) {
     if (!__EXPERIMENTAL__.suspense || !contentNode) {
         return;
     }
     const qContainerElement = contentNode.closest('[q\\:container]');
-    const script = qContainerElement?.querySelector(`script[type="qwik/vnode"][q\\:r="${segmentId}"]:not([q\\:patch])`);
-    processVNodeDataImpl(document, segmentId, qContainerElement, contentNode, script?.textContent || undefined);
-    const patches = qContainerElement?.querySelectorAll(`script[type="qwik/vnode"][q\\:r="${segmentId}"][q\\:patch]`);
-    for (let i = 0; patches && i < patches.length; i++) {
-        document.qProcessVNodeDataPatch?.(patches[i]);
+    if (!qContainerElement) {
+        return;
+    }
+    const script = qContainerElement.querySelector(`script[type="qwik/vnode"][q\\:r="${segmentId}"]:not([q\\:patch])`);
+    const patches = qContainerElement.querySelectorAll(`script[type="qwik/vnode"][q\\:r="${segmentId}"][q\\:patch]`);
+    enqueueProcessVNodeDataJob(document, processOutOfOrderSegmentVNodeDataIterator(document, segmentId, qContainerElement, contentNode, script?.textContent || undefined, patches));
+}
+const onVNodeDataReady = (document, callback) => {
+    const qDocument = document;
+    if (qDocument.qVNodeDataReady) {
+        callback();
+    }
+    else {
+        (qDocument.qVNodeDataCallbacks ||= []).push(callback);
+    }
+};
+function enqueueProcessVNodeDataJob(qDocument, iterator) {
+    const state = (qDocument.qVNodeDataState ||= {
+        $queue$: [],
+        $active$: null,
+    });
+    qDocument.qProcessVNodeDataPatch ||= (script) => enqueueProcessVNodeDataJob(qDocument, processVNodeDataPatch(qDocument, script));
+    qDocument.qVNodeDataReady = false;
+    state.$queue$.push(iterator);
+    scheduleProcessVNodeData(qDocument, state);
+}
+function scheduleProcessVNodeData(qDocument, state) {
+    if (state.$active$) {
+        return;
+    }
+    const iterator = state.$queue$.shift();
+    if (!iterator) {
+        markVNodeDataReady(qDocument);
+        return;
+    }
+    state.$active$ = createYieldingIteratorState(runProcessVNodeData(qDocument, state, iterator), () => {
+        if (qDocument.qVNodeDataState === state) {
+            state.$active$ = null;
+            scheduleProcessVNodeData(qDocument, state);
+        }
+    }, (error) => {
+        state.$active$ = null;
+        logError(error);
+        markVNodeDataReady(qDocument);
+    });
+    scheduleYieldingIterator(state.$active$);
+}
+function* runProcessVNodeData(qDocument, state, iterator) {
+    while (qDocument.qVNodeDataState === state) {
+        if (iterator.next().done) {
+            return;
+        }
+        yield;
     }
 }
-function processVNodeData(document) {
-    processVNodeDataImpl(document);
-    document.qVNodeDataProcessed = true;
+function markVNodeDataReady(document) {
+    if (document.qVNodeDataReady) {
+        return;
+    }
+    document.qVNodeDataReady = true;
+    document.qVNodeDataState = undefined;
+    const callbacks = document.qVNodeDataCallbacks;
+    document.qVNodeDataCallbacks = undefined;
+    if (callbacks) {
+        for (let i = 0; i < callbacks.length; i++) {
+            callbacks[i]();
+        }
+    }
+}
+function* processRootVNodeData(document) {
+    yield* processVNodeDataImpl(document);
+    const qDocument = document;
+    qDocument.qVNodeDataProcessed = true;
+    // Re-open the gate so a container added after this drain re-runs a walk.
+    qDocument.qVNodeDataStarted = false;
+}
+function* processOutOfOrderSegmentVNodeDataIterator(document, segmentId, segmentContainer, segmentContent, segmentVNodeData, patches) {
+    yield* processVNodeDataImpl(document, segmentId, segmentContainer, segmentContent, segmentVNodeData);
+    for (let i = 0; i < patches.length; i++) {
+        yield* processVNodeDataPatch(document, patches[i]);
+    }
+}
+function* processVNodeDataPatch(document, script) {
+    const qContainerElement = script?.closest('[q\\:container]');
+    const patchSegment = script?.getAttribute(Q_SUSPENSE_RESOLVED);
+    const contentNode = qContainerElement &&
+        (patchSegment
+            ? qContainerElement.querySelector(`[q\\:rp="${patchSegment}"]`)
+            : qContainerElement);
+    if (qContainerElement && contentNode) {
+        yield* processVNodeDataImpl(document, patchSegment || undefined, qContainerElement, contentNode, script.textContent);
+    }
 }
-function processVNodeDataImpl(document, segmentId, segmentContainer, segmentContent, segmentVNodeData) {
+function* processVNodeDataImpl(document, segmentId, segmentContainer, segmentContent, segmentVNodeData) {
     const Q_CONTAINER = 'q:container';
     const Q_CONTAINER_END = '/' + Q_CONTAINER;
     const Q_PROPS_SEPARATOR = ':';
@@ -13691,9 +14225,7 @@ function processVNodeDataImpl(document, segmentId, segmentContainer, segmentCont
     const Q_IGNORE_END = '/' + Q_IGNORE;
     const Q_CONTAINER_ISLAND = 'q:container-island';
     const Q_CONTAINER_ISLAND_END = '/' + Q_CONTAINER_ISLAND;
-    const Q_SUSPENSE_RESOLVED = 'q:r';
     const Q_SUSPENSE_RESULT_PARENT = 'q:rp';
-    const Q_PATCH = 'q:patch';
     const qDocument = document;
     const vNodeDataMap = (qDocument.qVNodeData ||= new WeakMap());
     const prototype = document.body;
@@ -13711,7 +14243,7 @@ function processVNodeDataImpl(document, segmentId, segmentContainer, segmentCont
     const hasAttribute = prototype.hasAttribute;
     const getNodeType = getter(prototype, 'nodeType');
     // Process all of the `qwik/vnode` script tags by attaching them to the corresponding containers.
-    const attachVnodeDataAndRefs = (element) => {
+    const attachVnodeDataAndRefs = function* (element) {
         const scripts = element.querySelectorAll('script[type="qwik/vnode"]');
         for (let i = 0; i < scripts.length; i++) {
             const script = scripts[i];
@@ -13719,6 +14251,7 @@ function processVNodeDataImpl(document, segmentId, segmentContainer, segmentCont
             qContainer.qVNodeRefs ||= new Map();
             if (script.hasAttribute(Q_PATCH)) {
                 qDocument.qProcessVNodeDataPatch?.(script);
+                yield;
                 continue;
             }
             const scriptContent = script.textContent;
@@ -13729,14 +14262,21 @@ function processVNodeDataImpl(document, segmentId, segmentContainer, segmentCont
             else {
                 qContainer.qVnodeData = scriptContent;
             }
+            yield;
         }
         const shadowRoots = element.querySelectorAll('[q\\:shadowroot]');
         for (let i = 0; i < shadowRoots.length; i++) {
             const parent = shadowRoots[i];
             const shadowRoot = parent.shadowRoot;
-            shadowRoot && attachVnodeDataAndRefs(shadowRoot);
+            if (shadowRoot) {
+                yield* attachVnodeDataAndRefs(shadowRoot);
+            }
+            yield;
         }
     };
+    ///////////////////////////////
+    // Functions to consume the tree.
+    ///////////////////////////////
     /**
      * Looks up which type of node this is in a monomorphic way which should be faster.
      *
@@ -13792,7 +14332,7 @@ function processVNodeDataImpl(document, segmentId, segmentContainer, segmentCont
      * @param exitNode The node which represents the last node and we should exit.
      * @param qVNodeRefs Place to store the VNodeRefs
      */
-    const walkContainer = (walker, containerNode, node, exitNode, vData, qVNodeRefs, qContainerElement, segmentId) => {
+    const walkContainer = function* (walker, containerNode, node, exitNode, vData, qVNodeRefs, qContainerElement, segmentId) {
         const isSegment = __EXPERIMENTAL__.suspense && segmentId !== undefined;
         const vData_length = vData.length;
         /// Stores the current element index as the TreeWalker traverses the DOM.
@@ -13818,6 +14358,9 @@ function processVNodeDataImpl(document, segmentId, segmentContainer, segmentCont
             }
             return elementsToSkip;
         };
+        if (!node) {
+            return;
+        }
         do {
             if (node === exitNode) {
                 return;
@@ -13831,7 +14374,7 @@ function processVNodeDataImpl(document, segmentId, segmentContainer, segmentCont
                 while (cursor && !(nextNode = nextSibling(cursor))) {
                     cursor = cursor.parentNode;
                 }
-                walkContainer(walker, container, node, nextNode, container.qVnodeData || '', container.qVNodeRefs, container);
+                yield* walkContainer(walker, container, node, nextNode, container.qVnodeData || '', container.qVNodeRefs, container);
             }
             else if (nodeType === 16 /* NodeType.COMMENT_IGNORE_START */) {
                 let islandNode = node;
@@ -13866,7 +14409,7 @@ function processVNodeDataImpl(document, segmentId, segmentContainer, segmentCont
                         throw new Error(`<!--${node?.nodeValue}--> not closed!`);
                     }
                 } while (getFastNodeType(nextNode) !== 8 /* NodeType.COMMENT_SKIP_END */);
-                walkContainer(walker, node, node, nextNode, '', null, qContainerElement);
+                yield* walkContainer(walker, node, node, nextNode, '', null, qContainerElement);
             }
             else if (nodeType === 6 /* NodeType.ELEMENT_SHADOW_ROOT_WRAPPER */) {
                 // If we are in a shadow root, we need to get the shadow root element.
@@ -13874,7 +14417,7 @@ function processVNodeDataImpl(document, segmentId, segmentContainer, segmentCont
                 const shadowRootContainer = node;
                 const shadowRoot = shadowRootContainer?.shadowRoot;
                 if (shadowRoot) {
-                    walkContainer(
+                    yield* walkContainer(
                     // we need to create a new walker for the shadow root
                     document.createTreeWalker(shadowRoot, 0x1 /* NodeFilter.SHOW_ELEMENT  */ | 0x80 /*  NodeFilter.SHOW_COMMENT */), null, shadowRoot, null, '', null, null);
                 }
@@ -13937,51 +14480,42 @@ function processVNodeDataImpl(document, segmentId, segmentContainer, segmentCont
                 }
                 elementIdx++;
                 if (__EXPERIMENTAL__.suspense && contentBoundaryId !== null) {
-                    processSuspenseContentSegment(qContainerElement, node, contentBoundaryId);
+                    yield* processSuspenseContentSegment(qContainerElement, node, contentBoundaryId);
                     nextNode = nextSibling(node);
                     if (nextNode) {
                         walker.currentNode = nextNode;
                     }
                 }
             }
+            yield;
         } while ((node = nextNode || walker.nextNode()));
     };
-    const processVNodeDataScope = (qContainerElement, contentNode, vData, scopeSegmentId) => {
+    const processVNodeDataScope = function* (qContainerElement, contentNode, vData, scopeSegmentId) {
         qContainerElement.qVNodeRefs ||= new Map();
         const scopeWalker = document.createTreeWalker(document, 0x1 /* NodeFilter.SHOW_ELEMENT  */ | 0x80 /*  NodeFilter.SHOW_COMMENT */);
         scopeWalker.currentNode = contentNode;
-        walkContainer(scopeWalker, contentNode, contentNode, nextSibling(contentNode), vData, qContainerElement.qVNodeRefs, qContainerElement, scopeSegmentId);
+        yield* walkContainer(scopeWalker, contentNode, contentNode, nextSibling(contentNode), vData, qContainerElement.qVNodeRefs, qContainerElement, scopeSegmentId);
     };
-    const processSuspenseContentSegment = __EXPERIMENTAL__.suspense
-        ? (qContainerElement, contentNode, boundaryId, vData) => {
-            vData ||= qContainerElement?.qSegmentVnodeData?.get(boundaryId);
-            if (qContainerElement && vData) {
-                processVNodeDataScope(qContainerElement, contentNode, vData, boundaryId);
-            }
-        }
-        : null;
-    qDocument.qProcessVNodeDataPatch = (script) => {
-        const qContainerElement = script?.closest('[q\\:container]');
-        const patchSegment = script?.getAttribute(Q_SUSPENSE_RESOLVED);
-        const contentNode = qContainerElement &&
-            (patchSegment
-                ? qContainerElement.querySelector(`[q\\:rp="${patchSegment}"]`)
-                : qContainerElement);
-        if (qContainerElement && contentNode) {
-            processVNodeDataScope(qContainerElement, contentNode, script.textContent, patchSegment || undefined);
+    const processSuspenseContentSegment = function* (qContainerElement, contentNode, boundaryId, vData) {
+        vData ||= qContainerElement?.qSegmentVnodeData?.get(boundaryId);
+        if (qContainerElement && vData) {
+            yield* processVNodeDataScope(qContainerElement, contentNode, vData, boundaryId);
         }
     };
-    if (__EXPERIMENTAL__.suspense && segmentId !== undefined) {
-        if (segmentContainer && segmentContent && segmentVNodeData) {
-            segmentContainer.qVNodeRefs ||= new Map();
-            processSuspenseContentSegment(segmentContainer, segmentContent, segmentId, segmentVNodeData);
+    if (segmentContainer && segmentContent && segmentVNodeData !== undefined) {
+        segmentContainer.qVNodeRefs ||= new Map();
+        if (__EXPERIMENTAL__.suspense && segmentId !== undefined) {
+            yield* processSuspenseContentSegment(segmentContainer, segmentContent, segmentId, segmentVNodeData);
+        }
+        else {
+            yield* processVNodeDataScope(segmentContainer, segmentContent, segmentVNodeData);
         }
         return;
     }
-    attachVnodeDataAndRefs(document);
+    yield* attachVnodeDataAndRefs(document);
     // Walk the tree and process each `q:container` element.
     const walker = document.createTreeWalker(document, 0x1 /* NodeFilter.SHOW_ELEMENT  */ | 0x80 /*  NodeFilter.SHOW_COMMENT */);
-    walkContainer(walker, null, walker.firstChild(), null, '', null, null);
+    yield* walkContainer(walker, null, walker.firstChild(), null, '', null, null);
 }
 const isSeparator = (ch) => 
 /* `!` */ VNodeDataSeparator.ADVANCE_1 <= ch && ch <= VNodeDataSeparator.ADVANCE_8192; /* `.` */
@@ -14016,6 +14550,87 @@ const findVDataSectionEnd = (vData, start, end) => {
     return start;
 };
 
+function isContainerReady(container) {
+    return container.$containerDataProcessState$ === 3 /* ContainerDataProcessState.ProcessingStateDone */;
+}
+function processContainerStateData(container, iterator) {
+    const state = (container.$containerStateDataState$ ||= {
+        $queue$: [],
+        $active$: null,
+    });
+    container.$containerDataProcessState$ = 2 /* ContainerDataProcessState.ProcessingState */;
+    state.$queue$.push(iterator);
+    scheduleProcessContainerStateData(container, state);
+}
+const onContainerDataReady = (container, callback) => {
+    const domContainer = container;
+    const checkReady = () => {
+        if (!isContainerReady(domContainer)) {
+            (domContainer.$containerStateReadyCallbacks$ ||= []).push(checkReady);
+            return;
+        }
+        onVNodeDataReady(domContainer.document, () => {
+            if (isContainerReady(domContainer)) {
+                callback();
+            }
+            else {
+                checkReady();
+            }
+        });
+    };
+    checkReady();
+};
+const whenContainerDataReady = (container, callback) => {
+    const domContainer = container;
+    if (isContainerReady(domContainer) && domContainer.document.qVNodeDataReady) {
+        return callback();
+    }
+    return new Promise((resolve, reject) => {
+        onContainerDataReady(domContainer, () => {
+            try {
+                resolve(callback());
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+};
+function scheduleProcessContainerStateData(container, state) {
+    if (state.$active$) {
+        return;
+    }
+    const iterator = state.$queue$.shift();
+    if (!iterator) {
+        markContainerDataReady(container);
+        return;
+    }
+    state.$active$ = createYieldingIteratorState(iterator, () => {
+        state.$active$ = null;
+        scheduleProcessContainerStateData(container, state);
+    }, (error) => {
+        state.$active$ = null;
+        logError(error);
+        markContainerDataReady(container);
+    });
+    scheduleYieldingIterator(state.$active$);
+}
+function markContainerDataReady(container) {
+    const state = container.$containerDataProcessState$;
+    if (state !== 2 /* ContainerDataProcessState.ProcessingState */) {
+        return;
+    }
+    container.$containerDataProcessState$ = 3 /* ContainerDataProcessState.ProcessingStateDone */;
+    container.$containerStateDataState$ = undefined;
+    const callbacks = container.$containerStateReadyCallbacks$;
+    container.$containerStateReadyCallbacks$ = undefined;
+    if (callbacks) {
+        for (let i = 0; i < callbacks.length; i++) {
+            callbacks[i]();
+        }
+    }
+}
+
 /** @file Public APIs for the SSR */
 /** @public */
 function getDomContainer(element) {
@@ -14038,8 +14653,12 @@ function getOutOfOrderStreamingScript(boundaryId, content) {
     const qContainerElement = content?.closest(QContainerSelector);
     const qContainer = qContainerElement?.qContainer;
     if (qContainer) {
-        processOutOfOrderSegmentVNodeData(qContainer.element.ownerDocument, segmentId, content);
-        processSegmentStateScripts(qContainer, segmentId);
+        const document = qContainer.element.ownerDocument;
+        processOutOfOrderSegmentVNodeData(document, segmentId, content);
+        onVNodeDataReady(document, () => {
+            qContainer.element.qContainer === qContainer &&
+                processContainerStateData(qContainer, processSegmentStateScriptsIterator(qContainer, segmentId));
+        });
     }
 }
 /** @internal */
@@ -14054,6 +14673,9 @@ class DomContainer extends _SharedContainer {
     $instanceHash$;
     $forwardRefs$ = null;
     vNodeLocate = (id) => vnode_locate(this.rootVNode, id);
+    $containerDataProcessState$ = 0 /* ContainerDataProcessState.NotStarted */;
+    $containerStateReadyCallbacks$ = undefined;
+    $containerStateDataState$ = undefined;
     $rawStateData$;
     $stateData$;
     $rootForwardRefs$ = null;
@@ -14064,7 +14686,8 @@ class DomContainer extends _SharedContainer {
         if (!this.qContainer) {
             throw qError(25 /* QError.elementWithoutContainer */);
         }
-        this.document = element.ownerDocument;
+        const document = element.ownerDocument;
+        this.document = document;
         this.element = element;
         this.$buildBase$ = element.getAttribute(QBaseAttr);
         this.$instanceHash$ = element.getAttribute(QInstanceAttr);
@@ -14072,23 +14695,46 @@ class DomContainer extends _SharedContainer {
         this.rootVNode = vnode_newUnMaterializedElement(this.element);
         this.$rawStateData$ = [];
         this.$stateData$ = [];
-        const document = this.element.ownerDocument;
-        if (!document.qVNodeDataProcessed) {
-            processVNodeData(document);
-        }
         if (__EXPERIMENTAL__.suspense && document.querySelector('template[q\\:r]')) {
             document.qProcessOOOS ||= getOutOfOrderStreamingScript;
         }
         this.$qFuncs$ = getQFuncs(document, this.$instanceHash$) || EMPTY_ARRAY;
         this.$setServerData$();
-        element.setAttribute(QContainerAttr, "resumed" /* QContainerValue.RESUMED */);
         element.qContainer = this;
         element.qDestroy = () => this.$destroy$();
-        this.$processRootStateScript$();
+        this.$containerDataProcessState$ = 1 /* ContainerDataProcessState.ProcessingVNode */;
+        processVNodeData(document, element);
+        onVNodeDataReady(document, () => {
+            if (this.$containerDataProcessState$ === 1 /* ContainerDataProcessState.ProcessingVNode */) {
+                processContainerStateData(this, this.$processContainerData$());
+            }
+        });
+    }
+    *$processContainerData$() {
+        const element = this.element;
+        if (element.qContainer !== this) {
+            return;
+        }
+        const rootState = element.querySelector(`script[type="qwik/state"][q\\:instance="${this.$instanceHash$}"]:not(${QStatePatchAttrSelector})`) ||
+            element.querySelector(`script[type="qwik/state"]:not([q\\:instance]):not(${QStatePatchAttrSelector})`);
+        if (rootState) {
+            this.$rawStateData$ = JSON.parse(rootState.textContent);
+            yield* preprocessStateIterator(this.$rawStateData$, this);
+            this.$rootForwardRefs$ = this.$forwardRefs$;
+            const rootCount = this.$rawStateData$.length / 2;
+            const statePrewarm = element.getAttribute(QStatePrewarmAttr);
+            if (statePrewarm !== null && rootCount > 0 && rootCount >= Number(statePrewarm)) {
+                this.$stateData$ = yield* eagerDeserializeStateIterator(this, this.$rawStateData$);
+            }
+            else {
+                this.$stateData$ = wrapDeserializerProxy(this, this.$rawStateData$);
+            }
+        }
         if (__EXPERIMENTAL__.suspense) {
-            processSegmentStateScripts(this);
+            yield* processSegmentStateScriptsIterator(this);
         }
         this.$hoistStyles$();
+        element.setAttribute(QContainerAttr, "resumed" /* QContainerValue.RESUMED */);
         if (!qTest && element.isConnected) {
             element.dispatchEvent(new CustomEvent('qresume', { bubbles: true }));
         }
@@ -14108,9 +14754,15 @@ class DomContainer extends _SharedContainer {
         }
         el.removeAttribute(QContainerAttr);
         const document = el.ownerDocument;
+        this.$containerStateDataState$ = undefined;
+        this.$containerDataProcessState$ = 0 /* ContainerDataProcessState.NotStarted */;
         const hasContainers = document.querySelector(QContainerSelector) !== null;
         if (!hasContainers) {
             document.qVNodeData = undefined;
+            document.qVNodeDataStarted = undefined;
+            document.qVNodeDataReady = undefined;
+            document.qVNodeDataState = undefined;
+            document.qVNodeDataCallbacks = undefined;
             document.qVNodeDataProcessed = undefined;
             document.qProcessVNodeDataPatch = undefined;
         }
@@ -14120,18 +14772,6 @@ class DomContainer extends _SharedContainer {
             }
         }
     }
-    $processRootStateScript$() {
-        const rootState = this.element.querySelector(`${this.$stateScriptSelector$()}:not(${QStatePatchAttrSelector})`);
-        if (rootState) {
-            this.$rawStateData$ = JSON.parse(rootState.textContent);
-            preprocessState(this.$rawStateData$, this);
-            this.$rootForwardRefs$ = this.$forwardRefs$;
-            this.$stateData$ = wrapDeserializerProxy(this, this.$rawStateData$);
-        }
-    }
-    $stateScriptSelector$() {
-        return `script[type="qwik/state"][q\\:instance="${this.$instanceHash$}"]`;
-    }
     /**
      * The first time we render we need to hoist the styles. (Meaning we need to move all styles from
      * component inline to <head>)
@@ -14229,7 +14869,6 @@ class DomContainer extends _SharedContainer {
             case OnRenderProp:
             case QCtxAttr:
             case QBackRefs:
-            case QCursorBoundary:
                 getObjectById = this.$getObjectById$;
                 break;
             case ELEMENT_SEQ_IDX:
@@ -14420,8 +15059,7 @@ function invokeApply(context, fn, args) {
         _context = previousContext;
     }
 }
-const newInvokeContextFromDOM = (event, element) => {
-    const domContainer = getDomContainer(element);
+const newInvokeContextFromDOM = (event, element, domContainer = getDomContainer(element)) => {
     const hostElement = vnode_locate(domContainer.rootVNode, element);
     const locale = domContainer.$locale$;
     locale && setLocale(locale);
@@ -14563,7 +15201,7 @@ const initLazyRefDev = (lazy) => {
 };
 /** Validate captured scope and register WeakRef tracking on a QRLClass instance. */
 const initQrlClassDev = (lazy, captures, qrl) => {
-    if (captures && typeof captures === 'object') {
+    if (Array.isArray(captures)) {
         for (let i = 0; i < captures.length; i++) {
             const item = captures[i];
             verifySerializable(item, 'Captured variable in the closure can not be serialized');
@@ -14656,6 +15294,7 @@ const setupHmr = (LazyRefClass, setGetLazyRef) => {
 };
 
 // keep these imports above the rest to prevent circular dep issues
+let reportedChunkFailures;
 let getLazyRef = (chunk, symbol, symbolFn, ref, container) => {
     return new LazyRef(chunk, symbol, symbolFn, ref, container);
 };
@@ -14696,7 +15335,25 @@ class LazyRef {
         this.$ref$ = ref;
         if (isPromise(ref)) {
             ref.then((r) => (this.$ref$ = r), (err) => {
-                console.error(`qrl ${this.$symbol$} failed to load`, err);
+                const errorMessage = `qrl ${this.$symbol$} failed to load`;
+                if (qTest ? isServerPlatform() : isServer) {
+                    console.error(errorMessage, err);
+                }
+                else if (qTest ? !isServerPlatform() : isBrowser$1) {
+                    const failureKey = this.$chunk$ === null ? `symbol:${this.$symbol$}` : `chunk:${this.$chunk$}`;
+                    const container = this.$container$;
+                    let containerFailures = container && reportedChunkFailures?.get(container);
+                    if (!containerFailures?.has(failureKey)) {
+                        if (container) {
+                            if (!containerFailures) {
+                                containerFailures = new Set();
+                                (reportedChunkFailures ||= new WeakMap()).set(container, containerFailures);
+                            }
+                            containerFailures.add(failureKey);
+                        }
+                        console.error(errorMessage, err);
+                    }
+                }
                 // We shouldn't cache rejections, we can try again later
                 this.$ref$ = null;
             });
@@ -14765,7 +15422,9 @@ class QRLClass {
         }
         // If it is plain value with deserialized or missing captures, resolve it immediately
         // Otherwise we keep using the async path so we can wait for qrls to load
-        if ($lazy$.$ref$ != null && typeof this.$captures$ !== 'string' && !isPromise($lazy$.$ref$)) {
+        if ($lazy$.$ref$ != null &&
+            (!this.$captures$ || typeof this.$captures$ !== 'string') &&
+            !isPromise($lazy$.$ref$)) {
             this.resolved = bindCaptures(this, $lazy$.$ref$);
         }
     }
@@ -14787,6 +15446,10 @@ const qrlWithCaptures = function (captures) {
     const newQrl = new QRLClass(qrl.$lazy$, captures, qrl.$captures$ ? qrl.$container$ : undefined);
     return makeQrlFn(newQrl);
 };
+const qrlWithMovedCaptures = function () {
+    this[QRL_STATE].$lazy$.$hasMovedCaptures$ = true;
+    return this;
+};
 const qrlSetRef = function (ref) {
     const qrl = getInstance(this);
     qrl.$lazy$.$setRef$(ref);
@@ -14842,6 +15505,11 @@ const QRL_FUNCTION_PROTO = Object.create(Function.prototype, {
             this[QRL_STATE].$captures$ = value;
         },
     },
+    $hasMovedCaptures$: {
+        get() {
+            return this[QRL_STATE].$lazy$.$hasMovedCaptures$;
+        },
+    },
     $container$: {
         get() {
             return this[QRL_STATE].$container$;
@@ -14890,6 +15558,9 @@ const QRL_FUNCTION_PROTO = Object.create(Function.prototype, {
     w: {
         value: qrlWithCaptures,
     },
+    m: {
+        value: qrlWithMovedCaptures,
+    },
     s: {
         value: qrlSetRef,
     },
@@ -14920,31 +15591,50 @@ let _captures = null;
 const setCaptures = (captures) => {
     _captures = captures;
 };
-const deserializeCaptures = (container, captures) => {
+const deserializeCaptureDeltas = (container, deltaString, startIndex = 0, previousRootId) => {
     const refs = [];
-    const captureIds = captures.split(' ');
-    for (let i = 0; i < captureIds.length; i++) {
-        const id = captureIds[i];
-        refs.push(container.$getObjectById$(id));
+    let previous = previousRootId;
+    let start = startIndex;
+    for (let i = startIndex; i <= deltaString.length; i++) {
+        if (i === deltaString.length || deltaString.charCodeAt(i) === 32) {
+            if (i > start) {
+                const delta = Number(deltaString.slice(start, i));
+                previous = previous === undefined ? delta : previous + delta;
+                refs.push(container.$getObjectById$(previous));
+            }
+            start = i + 1;
+        }
     }
     return refs;
 };
+const deserializeQrlCaptureDeltas = (container, qrlString) => {
+    const firstHash = qrlString.indexOf('#');
+    if (firstHash === -1) {
+        return deserializeCaptureDeltas(container, qrlString);
+    }
+    const secondHash = qrlString.indexOf('#', firstHash + 1);
+    const previousRootId = Number(qrlString.slice(0, firstHash)) + Number(qrlString.slice(firstHash + 1, secondHash));
+    return deserializeCaptureDeltas(container, qrlString, secondHash + 1, previousRootId);
+};
 /** Puts the qrl captures into `_captures`, and returns a Promise that should be awaited if possible */
 const ensureQrlCaptures = (qrl) => {
     // We read the captures once, synchronously, so no need to keep previous
-    _captures = qrl.$captures$;
+    const serializedCaptures = qrl.$captures$;
     const container = qrl.$container$;
-    if (typeof _captures === 'string') {
+    if (typeof serializedCaptures === 'string') {
         if (!container) {
             throw qError(13 /* QError.qrlMissingContainer */);
         }
         const prevLoading = loading;
-        _captures = qrl.$captures$ = deserializeCaptures(container, _captures);
+        _captures = qrl.$captures$ = deserializeQrlCaptureDeltas(container, serializedCaptures);
         if (loading !== prevLoading) {
             // return the loading promise so callers can await it
             return loading;
         }
     }
+    else {
+        _captures = serializedCaptures || null;
+    }
 };
 // Wrap functions to provide their lexical scope
 const bindCaptures = (qrl, ref) => {
@@ -15911,7 +16601,13 @@ const useComputedQrl = (qrl, options) => {
  * recalculated, and if the result changed, all tasks which are tracking the signal will be re-run
  * and all components that read the signal will be re-rendered.
  *
- * The function must be synchronous and must not have any side effects.
+ * Every synchronous signal or store read is tracked automatically. Reads after an `await` are not:
+ * the tracking context is lost, so track them explicitly with the `track()` provided on the context
+ * argument. When the function is async, the returned signal exposes the async API: reading an
+ * unresolved `.value` throws the computation promise, and `.pending` and `.error` expose the
+ * computation state.
+ *
+ * The function must not have any side effects.
  *
  * @public
  */
@@ -16009,7 +16705,7 @@ const useVisibleTaskQrl = (qrl, opts) => {
         // In SSR we defer execution until triggered in DOM
         flags = 1 /* TaskFlags.VISIBLE_TASK */;
     }
-    const task = new Task(flags, i, iCtx.$hostElement$, qrl, undefined, null);
+    const task = new Task(flags, i, iCtx.$hostElement$, qrl, null);
     set(task);
     useRegisterTaskEvents(task, eagerness);
 };
@@ -16047,11 +16743,11 @@ 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`.
  *
- * @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.
+ * @deprecated Use `useComputed$` instead, which is more powerful and flexible. `useResource$` is
+ *   still available for backward compatibility but it is recommended to migrate to `useComputed$`
+ *   for new code and when updating existing code.
  * @public
- * @see useAsync$
+ * @see useComputed$
  * @see Resource
  * @see ResourceReturn
  */
@@ -16156,7 +16852,10 @@ const creator = (qrl, options) => {
     qrl.resolve();
     return createAsyncSignal(qrl, options);
 };
-/** @internal */
+/**
+ * @deprecated Use `useComputed$` instead, it has async support now.
+ * @internal
+ */
 const useAsyncQrl = (qrl, options) => {
     return useConstant((creator), qrl, options);
 };
@@ -16179,6 +16878,8 @@ const useAsyncQrl = (qrl, options) => {
  * will subscribe to it and return the last resolved value until the new value is ready. As soon as
  * the new value is ready, the subscribers will be updated.
  *
+ * @deprecated Use `useComputed$` instead, it has async support now. It auto-tracks synchronous
+ *   reads; after the first `await`, use the provided `track()` like before.
  * @public
  */
 const useAsync$ = implicit$FirstArg(useAsyncQrl);
@@ -16197,10 +16898,10 @@ const eachCmpTask = async ({ track }) => {
     const context = tryGetInvokeContext();
     const host = context.$hostElement$;
     const container = context.$container$;
-    markVNodeDirty(container, host, 256 /* ChoreBits.RECONCILE */);
+    const renderPromise = markVNodeDirty(container, host, 256 /* ChoreBits.RECONCILE */);
     const isSsr = qTest ? isServerPlatform() : isServer;
     if (isSsr) {
-        await container.$renderPromise$;
+        await renderPromise;
     }
 };
 /** @internal */
@@ -16215,6 +16916,46 @@ const eachCmp = (props) => {
 const Each = /*#__PURE__*/ componentQrl(
 /*#__PURE__*/ inlinedQrl(eachCmp, '_eaC'));
 
+const invokeShowFn = (fn, context, arg) => {
+    return isQrl(fn) ? fn.getFn(context)(arg) : fn(arg);
+};
+/** @internal */
+const showCmpTask = ({ track }) => {
+    const props = _captures[0];
+    const context = tryGetInvokeContext();
+    const host = context.$hostElement$;
+    const container = context.$container$;
+    const isSsr = qTest ? isServerPlatform() : isServer;
+    return maybeThen(track(() => invokeShowFn(props.when$, tryGetInvokeContext(), undefined)), (condition) => {
+        const branch = condition ? props.then$ : props.else$;
+        return maybeThen(branch ? invokeShowFn(branch, context, condition) : null, (output) => {
+            const jsx = branch ? [output] : [];
+            if (isSsr) {
+                const ssr = container;
+                return ssr.renderJSX(jsx, {
+                    currentStyleScoped: null,
+                    parentComponentFrame: ssr.getComponentFrame(0),
+                });
+            }
+            else {
+                setNodeDiffPayload(host, jsx);
+                markVNodeDirty(container, host, 2 /* ChoreBits.NODE_DIFF */);
+            }
+        });
+    });
+};
+/** @internal */
+const showCmp = (props) => {
+    if (!__EXPERIMENTAL__.show) {
+        throw new Error('Show is experimental and must be enabled with `experimental: ["show"]` in the `qwikVite` plugin.');
+    }
+    useTaskQrl(/*#__PURE__*/ inlinedQrl(showCmpTask, '_shT', [props]));
+    return SkipRender;
+};
+/** @public @experimental */
+const Show = /*#__PURE__*/ componentQrl(
+/*#__PURE__*/ inlinedQrl(showCmp, '_shC'));
+
 const RevealContext = /*#__PURE__*/ createContextId('qk-reveal');
 const createRevealContext = (props) => {
     return {
@@ -16319,19 +17060,19 @@ const _hf0 = (p0, p1, p2, p3) => ({
     display: p1.value === 'fallback' &&
         p0.fallback != null &&
         p0.fallback !== false &&
-        (p2 === null || p2.value || !p3.reveal.collapsed)
+        (p2.value || !p3.reveal.collapsed)
         ? 'contents'
         : 'none',
 });
-const _hf0_str = '{display:p1.value==="fallback"&&p0.fallback!=null&&p0.fallback!==false&&(p2===null||p2.value||!p3.reveal.collapsed)?"contents":"none"}';
-const _hf1 = (p0, p1, p2) => ({
-    display: (p1.value === 'content' || p0.showStale) && (p2 === null || p2.value) ? 'contents' : 'none',
+const _hf0_str = '{display:p1.value==="fallback"&&p0.fallback!=null&&p0.fallback!==false&&(p2.value||!p3.reveal.collapsed)?"contents":"none"}';
+const _hf1 = (p0, p1) => ({
+    display: p0.value === 'content' && p1.value ? 'contents' : 'none',
 });
-const _hf1_str = '{display:(p1.value==="content"||p0.showStale)&&(p2===null||p2.value)?"contents":"none"}';
+const _hf1_str = '{display:p0.value==="content"&&p1.value?"contents":"none"}';
 /** @internal */
 const suspenseTask = ({ track, cleanup }) => {
     const cursorBoundary = _captures[0], props = _captures[1], state = _captures[2], revealRegistration = _captures[3];
-    const pendingCount = track(cursorBoundary.pending);
+    const pendingCount = track(cursorBoundary);
     const isBrowserEnv = qTest ? !isServerPlatform() : isBrowser$1;
     if (revealRegistration !== null && isBrowserEnv) {
         revealRegistration.reveal.version.value++;
@@ -16341,7 +17082,7 @@ const suspenseTask = ({ track, cleanup }) => {
         return;
     }
     const delayTimer = setTimeout(() => {
-        if (cursorBoundary.pending.value > 0) {
+        if (cursorBoundary.value > 0) {
             state.value = 'fallback';
         }
     }, props.delay ?? 0);
@@ -16370,19 +17111,17 @@ const suspenseCmp = (props) => {
     const outOfOrderRevealBoundary = isServerOutOfOrder
         ? (revealRegistration?.reveal.ooos?.register(revealRegistration) ?? null)
         : null;
-    const showOutOfOrderFallback = isServerOutOfOrder && shouldRenderFallback(props.fallback, outOfOrderRevealBoundary);
+    const showOutOfOrderFallback = isServerOutOfOrder &&
+        untrack(() => props.fallback != null && props.fallback !== false) &&
+        (outOfOrderRevealBoundary === null || outOfOrderRevealBoundary.showFallback);
     const outOfOrderBoundaryState = showOutOfOrderFallback && isPositiveDelay(props.delay)
-        ? { contentResolved: false, delayTimer: null }
+        ? { contentResolved: false, delay: props.delay, delayTimer: null }
         : null;
-    const outOfOrderFallbackStyle = isServerOutOfOrder
-        ? /*#__PURE__*/ _fnSignal(_hf0, [props, state, canReveal, revealRegistration], _hf0_str)
-        : null;
-    const contentStyle = /*#__PURE__*/ _fnSignal(_hf1, [props, state, canReveal], _hf1_str);
+    const contentStyle = /*#__PURE__*/ _fnSignal(_hf1, [state, canReveal], _hf1_str);
     const fallbackHost = (isServerOutOfOrder
         ? /*#__PURE__*/ _jsxSorted(SSRFallback, {
             boundary: outOfOrderBoundaryState,
-            delay: props.delay,
-            fallbackStyle: outOfOrderFallbackStyle,
+            fallbackStyle: _fnSignal(_hf0, [props, state, canReveal, revealRegistration], _hf0_str),
             showFallback: showOutOfOrderFallback,
             state,
         }, null, _wrapProp(props, 'fallback'), 1, null)
@@ -16418,15 +17157,16 @@ const Suspense = /*#__PURE__*/ componentQrl(
 const SSRFallback = __EXPERIMENTAL__.suspense
     ? /*#__PURE__*/ createInternalServerComponent((ssr, jsx, _options, enqueue) => {
         const boundaryState = jsx.varProps.boundary;
-        const delay = jsx.varProps.delay;
         const fallbackStyle = jsx.varProps.fallbackStyle;
         const showFallback = jsx.varProps.showFallback === true;
         const state = jsx.varProps.state;
-        if (showFallback && !isPositiveDelay(delay)) {
-            state.value = 'fallback';
-        }
-        else if (boundaryState && showFallback && isPositiveDelay(delay)) {
-            enqueue(() => scheduleOutOfOrderFallbackDelay(ssr, boundaryState, state, delay));
+        if (showFallback) {
+            if (boundaryState) {
+                enqueue(() => scheduleOutOfOrderFallbackDelay(ssr, boundaryState, state));
+            }
+            else {
+                state.value = 'fallback';
+            }
         }
         enqueue(
         /*#__PURE__*/ _jsxSorted('div', {
@@ -16436,13 +17176,13 @@ const SSRFallback = __EXPERIMENTAL__.suspense
     : null;
 const SSRDeferredSlot = __EXPERIMENTAL__.suspense
     ? /*#__PURE__*/ createInternalServerComponent(async (ssr, jsx, options) => {
-        const boundaryId = jsx.varProps.boundaryId ?? ssr.nextOutOfOrderId();
+        const boundaryId = jsx.varProps.boundaryId;
         const contentSegment = `${boundaryId}`;
         const boundaryState = jsx.varProps.boundary;
         const contentStyle = jsx.varProps.contentStyle;
         const revealBoundary = jsx.varProps.reveal;
         const content = ssr.segment(contentSegment, createClaimedDeferredSlot(ssr, jsx, options), options);
-        writeOutOfOrderPlaceholder(ssr, boundaryId);
+        ssr.write(`<template ${QSuspenseResolved}="${boundaryId}"></template>`);
         ssr.emitOutOfOrderExecutorIfNeeded();
         ssr.queueOutOfOrderSegment(content.then((rendered) => emitRenderedOutOfOrderSegment(ssr, boundaryId, contentSegment, rendered, contentStyle, revealBoundary, boundaryState)));
     })
@@ -16461,29 +17201,27 @@ function createClaimedDeferredSlot(ssr, jsx, options) {
     return /*#__PURE__*/ _jsxSorted(Slot, jsx.varProps, jsx.constProps, slotChildren, jsx.flags, jsx.key);
 }
 async function emitRenderedOutOfOrderSegment(ssr, boundaryId, segmentId, rendered, contentStyle, revealBoundary, boundaryState) {
-    markOutOfOrderContentResolved(boundaryState);
+    if (boundaryState) {
+        boundaryState.contentResolved = true;
+        if (boundaryState.delayTimer) {
+            clearTimeout(boundaryState.delayTimer);
+            boundaryState.delayTimer = null;
+        }
+    }
     revealBoundary?.resolve();
     await ssr.$runQueuedRender$(async () => {
         ssr.addRoot(contentStyle);
         const result = await rendered.container.$finalizeOutOfOrderSegment$(segmentId, rendered);
-        writeOutOfOrderResolvedTemplate(ssr, boundaryId, result.html, revealBoundary);
+        ssr.write(`<template ${QSuspenseResolved}="${boundaryId}"${revealBoundary?.attrs ?? ''}>`);
+        ssr.write(result.html);
+        ssr.write('</template>');
         ssr.emitOutOfOrderSegmentScripts(result.scripts);
         ssr.emitInlineScript(`qO(${boundaryId})`);
         // qO() is the browser-visible handoff for this segment, so flush it immediately.
         await ssr.streamHandler.flush();
     });
 }
-function markOutOfOrderContentResolved(boundaryState) {
-    if (!boundaryState) {
-        return;
-    }
-    boundaryState.contentResolved = true;
-    if (boundaryState.delayTimer) {
-        clearTimeout(boundaryState.delayTimer);
-        boundaryState.delayTimer = null;
-    }
-}
-function scheduleOutOfOrderFallbackDelay(ssr, boundaryState, state, delay) {
+function scheduleOutOfOrderFallbackDelay(ssr, boundaryState, state) {
     boundaryState.delayTimer = setTimeout(() => {
         boundaryState.delayTimer = null;
         void ssr.$runQueuedRender$(async () => {
@@ -16494,24 +17232,11 @@ function scheduleOutOfOrderFallbackDelay(ssr, boundaryState, state, delay) {
             ssr.emitBackpatchDataAndExecutorIfNeeded();
             await ssr.streamHandler.flush();
         });
-    }, delay);
+    }, boundaryState.delay);
 }
 function isPositiveDelay(delay) {
     return typeof delay === 'number' && Number.isFinite(delay) && delay > 0;
 }
-function shouldRenderFallback(fallback, revealBoundary) {
-    return (fallback != null &&
-        fallback !== false &&
-        (revealBoundary === null || revealBoundary.showFallback));
-}
-function writeOutOfOrderPlaceholder(ssr, boundaryId) {
-    ssr.write(`<template ${QSuspenseResolved}="${boundaryId}"></template>`);
-}
-function writeOutOfOrderResolvedTemplate(ssr, boundaryId, html, revealBoundary) {
-    ssr.write(`<template ${QSuspenseResolved}="${boundaryId}"${revealBoundary?.attrs ?? ''}>`);
-    ssr.write(html);
-    ssr.write('</template>');
-}
 
 // keep this import from core/build so the cjs build works
 /**
@@ -16608,5 +17333,5 @@ if (import.meta.hot) {
     });
 }
 
-export { $, Each, Fragment, NoSerializeSymbol, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, Reveal, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SerializerSymbol, SkipRender, Slot, Suspense, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, ELEMENT_SEQ as _ELEMENT_SEQ, EMPTY_ARRAY as _EMPTY_ARRAY, EMPTY_OBJ as _EMPTY_OBJ, _IMMUTABLE, _SharedContainer, SubscriptionData as _SubscriptionData, SubscriptionPatch as _SubscriptionPatch, Task as _Task, _UNINITIALIZED, _VAR_PROPS, _addProjection, _captures, _chk, _createDeserializeContainer, createQRL as _createQRL, createStore as _createStore, delay as _delay, _deserialize, _dumpState, eachCmp as _eaC, eachCmpTask as _eaT, _executeSsrChores, _fnSignal, getAsyncLocalStorage as _getAsyncLocalStorage, _getConstProps, _getContextContainer, _getContextEvent, _getContextHostElement, getDomContainer as _getDomContainer, _getQContainerElement, getSubscriber as _getSubscriber, _getVarProps, _hasStoreEffects, _hmr, _injectAsyncSignalValue, invoke as _invoke, 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, newInvokeContext as _newInvokeContext, _noopQrl, _noopQrlDEV, preprocessState as _preprocessState, _qrlSync, qrlToString as _qrlToString, _qrlWithChunk, _qrlWithChunkDEV, revealCmp as _reC, revealCanReveal as _reR, revealCleanupTask as _reT, _regSymbol, _removeProjection, _res, _resolveContextWithoutSequentialScope, _restProps, retryOnPromise as _retryOnPromise, _rsc, _run, _serialize, setEvent as _setEvent, _setProjectionTarget, suspenseCmp as _suC, suspenseTask as _suT, scheduleTask as _task, _updateProjectionProps, _useHmr, _val, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getElementName as _vnode_getElementName, vnode_getFirstChild as _vnode_getFirstChild, vnode_getProp as _vnode_getProp, vnode_getVNodeForChildNode as _vnode_getVNodeForChildNode, vnode_insertBefore as _vnode_insertBefore, vnode_isElementVNode as _vnode_isElementVNode, vnode_isMaterialized as _vnode_isMaterialized, vnode_isTextVNode as _vnode_isTextVNode, vnode_isVirtualVNode as _vnode_isVirtualVNode, vnode_newVirtual as _vnode_newVirtual, vnode_remove as _vnode_remove, vnode_setProp as _vnode_setProp, 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, getClientManifest, 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 { $, Each, Fragment, NoSerializeSymbol, PrefetchGraph, PrefetchServiceWorker, RenderOnce, Resource, Reveal, SSRComment, SSRRaw, SSRStream, SSRStreamBlock, SerializerSymbol, Show, SkipRender, Slot, Suspense, _CONST_PROPS, DomContainer as _DomContainer, _EFFECT_BACK_REF, ELEMENT_SEQ as _ELEMENT_SEQ, EMPTY_ARRAY as _EMPTY_ARRAY, EMPTY_OBJ as _EMPTY_OBJ, _IMMUTABLE, _SharedContainer, SubscriptionData as _SubscriptionData, SubscriptionPatch as _SubscriptionPatch, Task as _Task, _UNINITIALIZED, _VAR_PROPS, _addProjection, _captures, _chk, _createDeserializeContainer, createQRL as _createQRL, createStore as _createStore, delay as _delay, _deserialize, _dumpState, eachCmp as _eaC, eachCmpTask as _eaT, _executeSsrChores, _fnSignal, getAsyncLocalStorage as _getAsyncLocalStorage, _getConstProps, _getContextContainer, _getContextEvent, _getContextHostElement, getDomContainer as _getDomContainer, _getQContainerElement, getSubscriber as _getSubscriber, _getVarProps, _hasStoreEffects, _hmr, _injectAsyncSignalValue, invoke as _invoke, 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, _markSignalAsExternallyOwned, newInvokeContext as _newInvokeContext, _noopQrl, _noopQrlDEV, preprocessState as _preprocessState, _qrlSync, qrlToString as _qrlToString, _qrlWithChunk, _qrlWithChunkDEV, revealCmp as _reC, revealCanReveal as _reR, revealCleanupTask as _reT, _regSymbol, _removeProjection, _res, _resolveContextWithoutSequentialScope, _restProps, retryOnPromise as _retryOnPromise, _rsc, _run, _serialize, setEvent as _setEvent, _setProjectionTarget, showCmp as _shC, showCmpTask as _shT, suspenseCmp as _suC, suspenseTask as _suT, scheduleTask as _task, _updateProjectionProps, _useHmr, _val, verifySerializable as _verifySerializable, vnode_ensureElementInflated as _vnode_ensureElementInflated, vnode_getAttrKeys as _vnode_getAttrKeys, vnode_getElementName as _vnode_getElementName, vnode_getFirstChild as _vnode_getFirstChild, vnode_getProp as _vnode_getProp, vnode_getVNodeForChildNode as _vnode_getVNodeForChildNode, vnode_insertBefore as _vnode_insertBefore, vnode_isElementVNode as _vnode_isElementVNode, vnode_isMaterialized as _vnode_isMaterialized, vnode_isTextVNode as _vnode_isTextVNode, vnode_isVirtualVNode as _vnode_isVirtualVNode, vnode_newVirtual as _vnode_newVirtual, vnode_remove as _vnode_remove, vnode_setProp as _vnode_setProp, 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, getClientManifest, 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