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

package/dist/core.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.38-dev+0339f17
+ * @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
@@ -321,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.
@@ -405,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 */
@@ -438,7 +440,6 @@ 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
@@ -479,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';
@@ -1264,7 +1266,7 @@ const COMMA = ',';
  *
  * @public
  */
-const version = "2.0.0-beta.38-dev+0339f17";
+const version = "2.0.0-beta.39-dev+6fb620f";
 
 const isNode = (value) => {
     return value && typeof value.nodeType === 'number';
@@ -2314,7 +2316,7 @@ class Job {
     /** Backward compatible cache method for resource */
     cache() {
         isDev &&
-            console.error('useResource cache() method does not do anything. Use `useComputed$` 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$;
@@ -2333,7 +2335,7 @@ class Job {
  *
  * 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`, polling — giving it the same API as an AsyncSignal.
+ * 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()`.
  */
@@ -2381,20 +2383,11 @@ class ComputedSignalImpl extends SignalImpl {
             // 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 */;
-        }
-        const expires = options.expires ?? (options.interval ? Math.abs(options.interval) : undefined);
-        if (expires) {
-            this.expires = expires;
-        }
-        if (options.poll === false || (options.interval !== undefined && options.interval < 0)) {
-            this.$flags$ |= 256 /* AsyncSignalFlags.NO_POLL */;
-        }
+    }
+    /** Clear the value so readers see the loading state, then recompute. */
+    clear() {
+        this.$untrackedValue$ = NEEDS_COMPUTATION;
+        this.invalidate();
     }
     invalidate(info) {
         if (arguments.length > 0) {
@@ -2402,7 +2395,7 @@ class ComputedSignalImpl extends SignalImpl {
             this.$infoVersion$ = this.$infoVersion$ === undefined ? 1 : this.$infoVersion$ + 1;
         }
         if (this.$flags$ & 512 /* AsyncSignalFlags.ASYNC_MODE */) {
-            this.$setInvalid$(true, this.$flags$ & 128 /* AsyncSignalFlags.CLEAR_ON_INVALIDATE */);
+            this.$setInvalid$(true);
             return;
         }
         this.$flags$ |= 1 /* ComputedSignalFlags.INVALID */;
@@ -2450,9 +2443,7 @@ class ComputedSignalImpl extends SignalImpl {
             else if (this.$current$) {
                 this.$current$.$canWrite$ = false;
             }
-            this.$clearNextPoll$();
             super.value = value;
-            this.$scheduleNextPoll$();
             return;
         }
         super.value = value;
@@ -2572,52 +2563,8 @@ class ComputedSignalImpl extends SignalImpl {
         }
         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);
-    }
-    $setInvalid$(allowRecalc, mustClear) {
+    $setInvalid$(allowRecalc) {
         this.$flags$ |= 1 /* ComputedSignalFlags.INVALID */;
-        this.$clearNextPoll$();
-        if (mustClear) {
-            this.$untrackedValue$ = NEEDS_COMPUTATION;
-        }
         if (allowRecalc &&
             (this.$effects$?.size || this.$loadingEffects$?.size || this.$errorEffects$?.size)) {
             // compute in next microtask
@@ -2742,7 +2689,6 @@ class ComputedSignalImpl extends SignalImpl {
             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 /* ComputedSignalFlags.INVALID */;
         const current = this.$current$;
@@ -2845,7 +2791,6 @@ class ComputedSignalImpl extends SignalImpl {
             }
             else {
                 this.untrackedPending = false;
-                this.$scheduleNextPoll$();
             }
         }
     }
@@ -2868,7 +2813,6 @@ class ComputedSignalImpl extends SignalImpl {
     }
     /** Called after SSR/unmount */
     async $destroy$() {
-        this.$clearNextPoll$();
         clearTimeout(this.$computationTimeoutId$);
         const current = this.$current$;
         if (current) {
@@ -2881,24 +2825,6 @@ class ComputedSignalImpl extends SignalImpl {
             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);
     }
@@ -3053,9 +2979,9 @@ class SerializerSignalImpl extends ComputedSignalImpl {
  *
  * # ================================
  *
- * The async engine (jobs, loading, error, polling) 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).
+ * 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
  */
@@ -4066,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) {
@@ -4104,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++;
+        boundary.value = Math.max(0, boundary.value - 1);
     }
 }
-function getOwnCursorBoundary(container, vNode) {
+function getOwnCursorBoundary(vNode) {
     if (!__EXPERIMENTAL__.suspense) {
         return null;
     }
-    return container.getHostProp(vNode, QCursorBoundary);
-}
-function getNearestCursorBoundaryProp(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;
     }
@@ -4148,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);
     }
 }
 
@@ -4698,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.
@@ -4712,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 */);
@@ -5404,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.
@@ -6029,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) {
@@ -6994,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);
@@ -7094,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)) {
@@ -7300,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) {
@@ -7345,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
@@ -7397,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
@@ -7407,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 */;
         }
@@ -7446,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);
         }
@@ -7454,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) {
@@ -9132,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) {
@@ -9181,7 +9097,7 @@ function materializeFromVNodeData(vParent, vData, element, child, segmentId) {
         else if (peek() === VNodeDataChar.SEPARATOR) {
             // Custom attribute: |key|value
             const keyValue = consumeValue();
-            const key = decodeVNodeDataString(keyValue);
+            const key = decodeURIComponent(decodeVNodeDataString(keyValue));
             const valueSeparatorIdx = dataIdx + keyValue.length + 1;
             const isEscapedValue = getChar(valueSeparatorIdx + 1) === VNodeDataChar.SEPARATOR;
             let value;
@@ -10776,7 +10692,6 @@ class Serializer {
                 // 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 expires = isAsync && value.$expires$ !== 0 ? value.$expires$ : undefined;
                 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
@@ -10797,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
@@ -10809,7 +10721,6 @@ class Serializer {
                     out.push(v === undefined ? explicitUndefined : v);
                 }
                 if (isAsync) {
-                    out.push(expires);
                     out.push(concurrency);
                     out.push(timeout);
                 }
@@ -12137,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;
@@ -12147,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 {
@@ -12169,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();
@@ -12181,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('');
@@ -12202,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;
@@ -12213,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)) {
@@ -12285,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;
@@ -12337,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'));
@@ -12362,6 +12288,7 @@ 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();
@@ -12386,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 ComputedSignalImpl) {
-        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;
@@ -12579,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('_') && (Array.isArray(qrl.$captures$) || hasMovedCaptures)) {
+        if (!qrl.$symbol$.startsWith('_') &&
+            (Array.isArray(qrl.$captures$) || (hasMovedCaptures && qrl.$hasMovedCaptures$))) {
             qrl = createQRL(null, '_run', _run, null, [qrl]);
         }
         return qrlToChunks(serializationCtx, qrl);
@@ -13123,17 +13041,11 @@ function* inflateIterator(container, target, typeId, data) {
             if (asyncSignal.$untrackedValue$ === NEEDS_COMPUTATION) {
                 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);
@@ -13915,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;
     }
@@ -13992,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) => {
@@ -14024,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) {
@@ -14972,7 +14869,6 @@ class DomContainer extends _SharedContainer {
             case OnRenderProp:
             case QCtxAttr:
             case QBackRefs:
-            case QCursorBoundary:
                 getObjectById = this.$getObjectById$;
                 break;
             case ELEMENT_SEQ_IDX:
@@ -15398,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);
 };
@@ -15438,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;
             });
@@ -15531,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);
@@ -15586,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$;
@@ -15634,6 +15558,9 @@ const QRL_FUNCTION_PROTO = Object.create(Function.prototype, {
     w: {
         value: qrlWithCaptures,
     },
+    m: {
+        value: qrlWithMovedCaptures,
+    },
     s: {
         value: qrlSetRef,
     },
@@ -16971,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 */
@@ -17133,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++;
@@ -17155,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);
@@ -17184,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)
@@ -17232,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', {
@@ -17250,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)));
     })
@@ -17275,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 () => {
@@ -17308,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
 /**