@qwik.dev/core 2.0.0-beta.40 → 2.0.0-beta.42

package/dist/core.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.40-dev+a459d55
+ * @qwik.dev/core 2.0.0-beta.42-dev+3473a49
  * 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
@@ -29,6 +29,9 @@ const STYLE = qDev
 const logError = (message, ...optionalParams) => {
     return createAndLogError(false, message, ...optionalParams);
 };
+const logErrorAndThrowAsync = (message, ...optionalParams) => {
+    return createAndLogError(true, message, ...optionalParams);
+};
 const throwErrorAndStop = (message, ...optionalParams) => {
     const error = createAndLogError(false, message, ...optionalParams);
     // eslint-disable-next-line no-debugger
@@ -418,6 +421,8 @@ const QSlotS = 'q:s';
 const QStatePatchAttrSelector = '[q\\:patch]';
 const QSuspenseResolved = 'q:r';
 const QSuspenseResultParent = 'q:rp';
+const QErrorContentHost = 'q:ebc';
+const QErrorFallbackHost = 'q:ebf';
 const QStyle = 'q:style';
 const QStyleSelector = 'style[q\\:style]';
 const QStyleSSelector = 'style[q\\:sstyle]';
@@ -489,8 +494,13 @@ const debugStyleScopeIdPrefixAttr = '__scopedStyleIdPrefix__';
 
 const MAX_RETRY_ON_PROMISE_COUNT = 100;
 const isPromise = (value) => {
-    // not using "value instanceof Promise" to have zone.js support
-    return !!value && typeof value == 'object' && typeof value.then === 'function';
+    try {
+        // not using "value instanceof Promise" to have zone.js support
+        return !!value && typeof value == 'object' && typeof value.then === 'function';
+    }
+    catch {
+        return false;
+    }
 };
 const safeCall = (call, thenFn, rejectFn) => {
     try {
@@ -518,8 +528,13 @@ const delay = (timeout) => {
     });
 };
 const checkError = (e) => {
-    if (isServer && e instanceof ReferenceError && e.message.includes('window')) {
-        e.message = 'It seems like you forgot to add "if (isBrowser) {...}" here:' + e.message;
+    try {
+        if (isServer && e instanceof ReferenceError && e.message.includes('window')) {
+            e.message = 'It seems like you forgot to add "if (isBrowser) {...}" here:' + e.message;
+        }
+    }
+    catch {
+        // ignore
     }
 };
 const justThrow = (e) => {
@@ -1266,7 +1281,7 @@ const COMMA = ',';
  *
  * @public
  */
-const version = "2.0.0-beta.40-dev+a459d55";
+const version = "2.0.0-beta.42-dev+3473a49";
 
 const isNode = (value) => {
     return value && typeof value.nodeType === 'number';
@@ -2656,9 +2671,9 @@ class ComputedSignalImpl extends SignalImpl {
         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.
+     * Invoke the compute fn with the ComputeCtx argument. CTX_ARG signals (createAsyncQrl,
+     * 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;
@@ -3043,14 +3058,6 @@ const createSignal = createSignal$1;
  * @public
  */
 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);
 /**
  * Create a signal that holds a custom serializable value. See {@link useSerializer$} for more
  * details.
@@ -3784,11 +3791,48 @@ function getFileLocationFromJsx(jsxDev) {
 }
 
 const _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+const _propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
 function isSlotProp(prop) {
     return !prop.startsWith('q:') && !prop.startsWith(NON_SERIALIZABLE_MARKER_PREFIX);
 }
+function hasSlotProps(props) {
+    if (props) {
+        for (const prop in props) {
+            if (isSlotProp(prop)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 /** @internal */
 const _restProps = (props, omit = [], target = {}) => {
+    // The optimizer can apply this transform to plain, non-component objects and
+    // even primitives (e.g. destructuring a string). Guard `isPropsProxy`, whose
+    // `in` check throws on primitives, then fall back to native object-rest
+    // copying so the transform cannot silently lose data.
+    if (!isObject(props) || !isPropsProxy(props)) {
+        // Match native rest-destructuring: `({ ...rest }) => …` throws on nullish.
+        if (props == null) {
+            throw new TypeError(`Cannot destructure '${props}' as it is ${props}.`);
+        }
+        // Box primitives so they get native ToObject rest semantics (e.g. 'ab' -> {0:'a',1:'b'}).
+        const source = Object(props);
+        const keys = Reflect.ownKeys(source);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (_propertyIsEnumerable.call(source, key) &&
+                (typeof key === 'symbol' || !omit.includes(key))) {
+                Object.defineProperty(target, key, {
+                    value: source[key],
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                });
+            }
+        }
+        return target;
+    }
     let constPropsTarget = null;
     const constProps = props[_CONST_PROPS];
     if (constProps) {
@@ -4003,7 +4047,12 @@ function addCursorBoundary(cursorData, vNode) {
     if (!__EXPERIMENTAL__.suspense) {
         return;
     }
-    const boundary = getNearestCursorBoundary(vNode);
+    let boundary = null;
+    let current = vNode;
+    while (current && !boundary) {
+        boundary = getNearestCursorBoundary(current);
+        current = current.slotParent || current.parent;
+    }
     if (!boundary) {
         return;
     }
@@ -4150,7 +4199,7 @@ function runEventHandlerQRL(handler, event, element, ctx) {
         if (!(hostElement.flags & 32 /* VNodeFlags.Deleted */)) {
             return invokeApply(ctx, realHandler, [event, element]);
         }
-    }, (err) => container.handleError(err, hostElement));
+    }, (err) => container.handleError(err, hostElement, "event" /* ErrorBoundaryPhase.Event */));
 }
 /**
  * This is called by qwik-loader to run a QRL. It has to be synchronous when possible.
@@ -9316,7 +9365,10 @@ const runTask = (task, container, host) => {
         return pendingTask;
     }
     task.$flags$ &= -5 /* TaskFlags.DIRTY */;
-    const handleError = (reason) => container.handleError(reason, host);
+    const handleError = (reason) => {
+        tagErrorPhase(reason, "hook" /* ErrorBoundaryPhase.Hook */);
+        container.handleError(reason, host, "hook" /* ErrorBoundaryPhase.Hook */);
+    };
     let taskPromise = null;
     const result = maybeThen(cleanupAsyncDestroyable(task, handleError), () => {
         const iCtx = newInvokeContext(container.$locale$, host, TaskEvent);
@@ -9386,6 +9438,10 @@ function scheduleTask(_event, element) {
             setCaptures(deserializeCaptureDeltas(container, this));
         }
         const task = _captures[0];
+        if (!task.$el$) {
+            // An ErrorBoundary tore the host down; the task has nothing left to run against.
+            return;
+        }
         task.$flags$ |= 4 /* TaskFlags.DIRTY */;
         markVNodeDirty(container, task.$el$, 1 /* ChoreBits.TASKS */);
     });
@@ -9650,7 +9706,12 @@ const getStoreHandler = (value) => {
     return value[STORE_HANDLER];
 };
 const getStoreTarget = (value) => {
-    return value?.[STORE_TARGET] || null;
+    try {
+        return value?.[STORE_TARGET] || null;
+    }
+    catch {
+        return null;
+    }
 };
 /**
  * Force a store to recompute and schedule effects.
@@ -9751,11 +9812,17 @@ class StoreHandler {
             return this.toString;
         }
         const flags = this.$flags$;
-        if (flags & 1 /* StoreFlags.RECURSIVE */ &&
-            isObject(value) &&
-            !Object.isFrozen(value) &&
-            !isStore(value) &&
-            !Object.isFrozen(target)) {
+        let shouldWrapRecursively = false;
+        if (flags & 1 /* StoreFlags.RECURSIVE */ && isObject(value)) {
+            try {
+                shouldWrapRecursively =
+                    !Object.isFrozen(value) && !isStore(value) && !Object.isFrozen(target);
+            }
+            catch {
+                // ignore
+            }
+        }
+        if (shouldWrapRecursively) {
             return getOrCreateStore(value, this.$flags$, this.$container$);
         }
         return value;
@@ -10708,8 +10775,9 @@ class Serializer {
                 }
                 const out = [value.$computeQrl$, value.$effects$];
                 if (isAsync) {
+                    const untrackedError = value.$untrackedError$;
                     // After SSR, the signal is never loading, so no need to send it
-                    out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedError$);
+                    out.push(value.$loadingEffects$, value.$errorEffects$, untrackedError === undefined || isDev ? untrackedError : redactToGeneric(untrackedError));
                     out.push(asyncFlags || undefined);
                 }
                 if (v !== NEEDS_COMPUTATION || concurrency !== undefined || timeout !== undefined) {
@@ -10746,8 +10814,9 @@ class Serializer {
         }
         else if (value instanceof Error) {
             const out = [value.message];
-            // flatten gives us the right output
-            out.push(...Object.entries(value).flat());
+            for (const entry of Object.entries(value)) {
+                out.push(entry[0], entry[1]);
+            }
             /// In production we don't want to leak the stack trace.
             if (isDev) {
                 out.push('stack', value.stack);
@@ -10755,15 +10824,20 @@ class Serializer {
             this.output(23 /* TypeIds.Error */, out);
         }
         else if (this.$serializationContext$.$isSsrNode$(value)) {
+            // Paired with ssr-container's vnode-data INERT skip: drop the state root AND the path together.
+            if (value.vnodeData &&
+                value.vnodeData[0] & 32 /* VNodeDataFlag.INERT */ &&
+                /[A-Za-z]/.test(value.id)) {
+                this.output(3 /* TypeIds.Constant */, 0 /* Constants.Undefined */);
+                return;
+            }
             const rootIndex = this.$serializationContext$.$addRoot$(value);
             this.$serializationContext$.$setProp$(value, ELEMENT_ID, rootIndex);
             // we need to output before the vnode overwrites its values
             this.output(10 /* TypeIds.VNode */, value.id);
             const vNodeData = value.vnodeData;
             if (vNodeData) {
-                discoverValuesForVNodeData(vNodeData, (vNodeDataValue) => {
-                    this.$serializationContext$.$addRoot$(vNodeDataValue);
-                });
+                discoverValuesForVNodeData(vNodeData, this.$serializationContext$);
                 this.$serializationContext$.$markSsrNodeForSerialization$(value, 16 /* VNodeDataFlag.SERIALIZE */);
             }
             if (value.children) {
@@ -11047,9 +11121,9 @@ function getCustomSerializerPromise(signal, value) {
         return data;
     });
 }
-const discoverValuesForVNodeData = (vnodeData, callback) => {
+const discoverValuesForVNodeData = (vnodeData, serializationContext) => {
     const length = vnodeData.length;
-    for (let i = 0; i < length; i++) {
+    for (let i = 1; i < length; i++) {
         const value = vnodeData[i];
         if (isSsrAttrs(value)) {
             for (const key in value) {
@@ -11062,7 +11136,7 @@ const discoverValuesForVNodeData = (vnodeData, callback) => {
                             shouldSkipComponentProps(value, attrValue)))) {
                     continue;
                 }
-                callback(attrValue);
+                serializationContext.$addRoot$(attrValue);
             }
         }
     }
@@ -12048,15 +12122,23 @@ 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.
-        }
-    });
+// we need to differentiate between JSX functions and ssr container functions for error boundary
+// JSX functions need to be skipped after error boundary catch an error
+class InvokeJSXFunction {
+}
+const openBoundaryContentScope = (ssr, contentHost) => {
+    const enclosing = ssr.$errorContentHost$;
+    ssr.$errorContentHost$ = contentHost;
+    return () => {
+        ssr.$errorContentHost$ = enclosing;
+    };
+};
+const isInsideFailedBoundaryContent = (ssr) => {
+    const contentHost = ssr.$errorContentHost$;
+    return !!contentHost && (contentHost.vnodeData[0] & 32 /* VNodeDataFlag.INERT */) !== 0;
+};
+const markPromiseHandled = (promise) => {
+    promise.catch(() => { });
 };
 function setParentOptions(mutable, styleScoped, parentComponentFrame) {
     return () => {
@@ -12069,23 +12151,43 @@ async function _walkJSX(ssr, value, options) {
     const stack = [value];
     const enqueue = (value) => stack.push(value);
     const enqueuePromise = (promise) => {
-        markPromiseHandled(ssr, promise);
+        markPromiseHandled(promise);
         stack.push(promise);
         stack.push(Promise);
     };
     const drain = async () => {
         while (stack.length) {
+            let phase = "render" /* ErrorBoundaryPhase.Render */;
             try {
                 const value = stack.pop();
                 // Reference equality first (no prototype walk), then typeof
                 if (value === MaybeAsyncSignal) {
                     const trackFn = stack.pop();
+                    if (__EXPERIMENTAL__.errorBoundary && isInsideFailedBoundaryContent(ssr)) {
+                        continue;
+                    }
+                    phase = "hook" /* ErrorBoundaryPhase.Hook */;
                     await retryOnPromise(() => stack.push(trackFn()));
                     continue;
                 }
+                if (__EXPERIMENTAL__.errorBoundary && value === InvokeJSXFunction) {
+                    const fnChild = stack.pop();
+                    if (isInsideFailedBoundaryContent(ssr)) {
+                        continue;
+                    }
+                    const result = fnChild.apply(ssr);
+                    if (isPromise(result)) {
+                        await result;
+                    }
+                    continue;
+                }
                 if (typeof value === 'function') {
                     if (value === Promise) {
-                        stack.push(await stack.pop());
+                        const pending = stack.pop();
+                        if (__EXPERIMENTAL__.errorBoundary && isInsideFailedBoundaryContent(ssr)) {
+                            continue;
+                        }
+                        stack.push(await pending);
                     }
                     else {
                         const result = value.apply(ssr);
@@ -12095,8 +12197,17 @@ async function _walkJSX(ssr, value, options) {
                     }
                     continue;
                 }
+                if (__EXPERIMENTAL__.errorBoundary && isInsideFailedBoundaryContent(ssr)) {
+                    if (isPromise(value)) {
+                        value.catch(() => { });
+                    }
+                    continue;
+                }
                 processJSXNode(ssr, enqueue, enqueuePromise, value, options);
             }
+            catch (err) {
+                ssr.handleError(err, ssr.getOrCreateLastNode(), phase);
+            }
             finally {
                 const pendingFlush = ssr.streamHandler.waitForPendingFlush();
                 if (isPromise(pendingFlush)) {
@@ -12107,6 +12218,12 @@ async function _walkJSX(ssr, value, options) {
     };
     await drain();
 }
+function enqueueJSX(enqueue, value) {
+    enqueue(value);
+    if (__EXPERIMENTAL__.errorBoundary && typeof value === 'function') {
+        enqueue(InvokeJSXFunction);
+    }
+}
 function processJSXNode(ssr, enqueue, enqueuePromise, value, options) {
     // console.log('processJSXNode', value);
     if (value == null) {
@@ -12124,7 +12241,7 @@ function processJSXNode(ssr, enqueue, enqueuePromise, value, options) {
     else if (typeof value === 'object') {
         if (Array.isArray(value)) {
             for (let i = value.length - 1; i >= 0; i--) {
-                enqueue(value[i]);
+                enqueueJSX(enqueue, value[i]);
             }
         }
         else if (isSignal(value)) {
@@ -12143,19 +12260,28 @@ function processJSXNode(ssr, enqueue, enqueuePromise, value, options) {
         }
         else if (isAsyncGenerator(value)) {
             enqueue(async () => {
-                for await (const chunk of value) {
-                    await _walkJSX(ssr, chunk, {
-                        currentStyleScoped: options.currentStyleScoped,
-                        parentComponentFrame: options.parentComponentFrame,
-                    });
-                    await ssr.streamHandler.flush();
+                if (__EXPERIMENTAL__.errorBoundary && isInsideFailedBoundaryContent(ssr)) {
+                    return;
+                }
+                const freshWalkOptions = () => ({
+                    currentStyleScoped: options.currentStyleScoped,
+                    parentComponentFrame: options.parentComponentFrame,
+                });
+                try {
+                    for await (const chunk of value) {
+                        await _walkJSX(ssr, chunk, freshWalkOptions());
+                        await ssr.streamHandler.flush();
+                    }
+                }
+                catch (err) {
+                    ssr.handleError(err, ssr.getOrCreateLastNode(), "render" /* ErrorBoundaryPhase.Render */);
+                    await _walkJSX(ssr, null, freshWalkOptions());
                 }
             });
         }
         else {
             const jsx = value;
             const type = jsx.type;
-            // Below, JSXChildren allows functions and regexes, but we assume the dev only uses those as appropriate.
             if (typeof type === 'string') {
                 appendClassIfScopedStyleExists(jsx, options.currentStyleScoped);
                 let qwikInspectorAttrValue = null;
@@ -12169,6 +12295,9 @@ function processJSXNode(ssr, enqueue, enqueuePromise, value, options) {
                 if (innerHTML) {
                     ssr.htmlNode(innerHTML);
                 }
+                if (__EXPERIMENTAL__.errorBoundary && directGetPropsProxyProp(jsx, QErrorContentHost)) {
+                    enqueue(openBoundaryContentScope(ssr, ssr.getOrCreateLastNode()));
+                }
                 enqueue(ssr.closeElement);
                 if (type === 'head') {
                     ssr.emitQwikLoaderAtTopIfNeeded();
@@ -12187,10 +12316,11 @@ function processJSXNode(ssr, enqueue, enqueuePromise, value, options) {
                     }
                 }
                 const children = jsx.children;
-                children != null && enqueue(children);
+                children != null && enqueueJSX(enqueue, children);
             }
             else if (isFunction(type)) {
-                if (__EXPERIMENTAL__.suspense && isInternalServerComponent(type)) {
+                if ((__EXPERIMENTAL__.suspense || __EXPERIMENTAL__.errorBoundary) &&
+                    isInternalServerComponent(type)) {
                     enqueue(() => getInternalServerComponentHandler(type)(ssr, jsx, options, enqueue));
                     return;
                 }
@@ -12201,9 +12331,8 @@ function processJSXNode(ssr, enqueue, enqueuePromise, value, options) {
                     }
                     ssr.openFragment(attrs);
                     enqueue(ssr.closeFragment);
-                    // In theory we could get functions or regexes, but we assume all is well
                     const children = jsx.children;
-                    children != null && enqueue(children);
+                    children != null && enqueueJSX(enqueue, children);
                 }
                 else if (type === Slot) {
                     const componentFrame = options.parentComponentFrame;
@@ -12225,7 +12354,7 @@ function processJSXNode(ssr, enqueue, enqueuePromise, value, options) {
                         if (slotDefaultChildren && slotChildren !== slotDefaultChildren) {
                             ssr.addUnclaimedProjection(componentFrame, QDefaultSlot, slotDefaultChildren);
                         }
-                        enqueue(slotChildren);
+                        enqueueJSX(enqueue, slotChildren);
                         enqueue(setParentOptions(options, componentFrame.projectionScopedStyle, componentFrame.projectionComponentFrame));
                     }
                     else {
@@ -12272,7 +12401,7 @@ function processJSXNode(ssr, enqueue, enqueuePromise, value, options) {
                 else if (type === SSRStreamBlock) {
                     ssr.streamHandler.streamBlockStart();
                     enqueue(() => ssr.streamHandler.streamBlockEnd());
-                    enqueue(jsx.children);
+                    enqueueJSX(enqueue, jsx.children);
                 }
                 else if (isQwikComponent(type)) {
                     // prod: use new instance of an object for props, we always modify props for a component
@@ -12282,13 +12411,13 @@ function processJSXNode(ssr, enqueue, enqueuePromise, value, options) {
                     }
                     ssr.openComponent(componentAttrs);
                     const host = ssr.getOrCreateLastNode();
+                    enqueue(setParentOptions(options, options.currentStyleScoped, options.parentComponentFrame));
+                    enqueue(() => ssr.closeComponent());
                     const componentFrame = ssr.getParentComponentFrame();
                     componentFrame.distributeChildrenIntoSlots(jsx.children, options.currentStyleScoped, options.parentComponentFrame);
                     const jsxOutput = applyQwikComponentBody(ssr, jsx, type);
-                    enqueue(setParentOptions(options, options.currentStyleScoped, options.parentComponentFrame));
-                    enqueue(() => ssr.closeComponent());
                     if (isPromise(jsxOutput)) {
-                        markPromiseHandled(ssr, jsxOutput, host);
+                        markPromiseHandled(jsxOutput);
                         // Defer reading QScopedStyle until after the promise resolves
                         enqueue(async () => {
                             await ssr.streamHandler.flush();
@@ -12340,6 +12469,99 @@ function appendClassIfScopedStyleExists(jsx, styleScoped) {
     }
 }
 
+/** @internal */
+function handleSSRError(container, err, host, phase) {
+    if (!__EXPERIMENTAL__.errorBoundary || (qDev && !isRecoverable(err))) {
+        throw err;
+    }
+    for (let boundaryNode = host; boundaryNode; boundaryNode = boundaryNode.parentComponent) {
+        const errorStore = getOwnSSRErrorBoundaryStore(boundaryNode);
+        if (!errorStore || !errorStore.$fallback$) {
+            continue;
+        }
+        if (container.$isOutOfOrderSegment$ && errorStore.$emitFallback$) {
+            throw err;
+        }
+        markBoundaryErrored(errorStore, err, phase);
+        getRootContainer(container).$hasBoundaryError$ = true;
+        if (container.$isOutOfOrderSegment$) {
+            markErrorFromDeferredSegment(errorStore);
+        }
+        markErrorBoundaryContentInert(container, boundaryNode, errorStore);
+        return;
+    }
+    throw err;
+}
+function markErrorBoundaryContentInert(container, boundaryNode, errorStore) {
+    const ancestorOwners = new Map();
+    let boundaryContentOwner = null;
+    let depth = 0;
+    for (let node = boundaryNode; node; node = node.parentComponent) {
+        if (node.id) {
+            ancestorOwners.set(node.id, { node, depth: depth++ });
+        }
+        if (node !== boundaryNode && !boundaryContentOwner) {
+            const store = getOwnSSRErrorBoundaryStore(node);
+            if (store?.error !== undefined || !hasSlotProps(node.getProp(ELEMENT_PROPS))) {
+                boundaryContentOwner = node;
+            }
+        }
+    }
+    const topmostSevered = { node: null, depth: -1 };
+    const children = boundaryNode.children;
+    if (children) {
+        for (let i = 0; i < children.length; i++) {
+            markErrorSubtreeInert(container, children[i], ancestorOwners, topmostSevered);
+        }
+    }
+    if (topmostSevered.node) {
+        const immediateContentOwner = topmostSevered.node.parentComponent;
+        if (topmostSevered.node === boundaryNode) {
+            container.$retainForResume$(boundaryContentOwner);
+        }
+        else if (immediateContentOwner?.id) {
+            container.$retainForResume$(immediateContentOwner);
+            errorStore.projectedContentOwner = immediateContentOwner;
+        }
+    }
+}
+function getOwnSSRErrorBoundaryStore(node) {
+    const ctx = node.getProp(QCtxAttr);
+    return ctx ? mapArray_get(ctx, ERROR_CONTEXT.id, 0) : null;
+}
+function markErrorSubtreeInert(container, node, ancestorOwners, topmostSevered) {
+    node.vnodeData[0] |= 32 /* VNodeDataFlag.INERT */;
+    const ownerId = node.getProp(QSlotParent);
+    if (ownerId) {
+        const owner = ancestorOwners.get(ownerId);
+        if (owner) {
+            owner.node.removeProp(node.getProp(QSlot) ?? QDefaultSlot);
+            if (owner.depth > topmostSevered.depth) {
+                topmostSevered.node = owner.node;
+                topmostSevered.depth = owner.depth;
+            }
+        }
+    }
+    // Element consumers keep materializing when inert, so their bindings would keep patching hidden
+    // DOM; virtual ones can't materialize and would leave producers pointing at a dead node.
+    clearAllEffects(container, node);
+    const seq = node.getProp(ELEMENT_SEQ);
+    if (seq) {
+        for (let i = 0; i < seq.length; i++) {
+            const item = seq[i];
+            if (isTask(item)) {
+                clearAllEffects(container, item);
+            }
+        }
+    }
+    const children = node.children;
+    if (children) {
+        for (let i = 0; i < children.length; i++) {
+            markErrorSubtreeInert(container, children[i], ancestorOwners, topmostSevered);
+        }
+    }
+}
+
 // <docs markdown="../readme.md#useLexicalScope">
 // !!DO NOT EDIT THIS COMMENT DIRECTLY!!!
 // (edit ../readme.md#useLexicalScope instead and run `pnpm docs.sync`)
@@ -12420,7 +12642,7 @@ const useResourceQrl = (qrl, opts) => {
  * const Cmp = component$(() => {
  *   const city = useSignal('');
  *
- *   const weather = useAsync$(async ({ track, cleanup, abortSignal }) => {
+ *   const weather = useComputed$(async ({ track, cleanup, abortSignal }) => {
  *     const cityName = track(city);
  *     const res = await fetch(`http://weatherdata.com?city=${cityName}`, {
  *       signal: abortSignal,
@@ -12434,7 +12656,7 @@ const useResourceQrl = (qrl, opts) => {
  *       <input name="city" bind:value={city} />
  *       <div>
  *         Temperature:{' '}
- *         {weather.loading
+ *         {weather.pending
  *           ? 'Loading...'
  *           : weather.error
  *             ? `Error: ${weather.error.message}`
@@ -12445,8 +12667,8 @@ const useResourceQrl = (qrl, opts) => {
  * });
  * ```
  *
- * @deprecated Use `useAsync$` instead, which is more efficient, and has a more flexible API. Just
- *   read the `loading` and `error` properties from the returned signal to determine the status.
+ * @deprecated Use `useComputed$` instead. Read the `pending` and `error` properties from the
+ *   returned signal to determine the status.
  * @public
  */
 const Resource = ({ value, onResolved, onPending, onRejected, }) => {
@@ -13817,14 +14039,179 @@ const _resolveContextWithoutSequentialScope = (context) => {
 };
 
 const ERROR_CONTEXT = /*#__PURE__*/ createContextId('qk-error');
-const isRecoverable = (err) => {
-    if (err && err instanceof Error) {
-        if ('plugin' in err) {
-            return false;
+const ERROR_BOUNDARY_QRL_SYMBOL = '_ebC';
+const safeRead = (read, fallback) => {
+    try {
+        return read();
+    }
+    catch {
+        return fallback;
+    }
+};
+const isRecoverable = (err) => safeRead(() => !(err instanceof Error && 'plugin' in err), true);
+const GENERIC_BOUNDARY_ERROR_MESSAGE = 'An error occurred';
+const errorBoundaryDigest = (err) => hashCode(safeRead(() => err instanceof Error ? `${err.name}: ${err.message}\n${err.stack ?? ''}` : String(err), 'unknown'));
+const REDACTED = /*#__PURE__*/ Symbol();
+const redactToGeneric = (err) => {
+    const redacted = new Error(GENERIC_BOUNDARY_ERROR_MESSAGE);
+    redacted.digest = errorBoundaryDigest(err);
+    Object.defineProperty(redacted, REDACTED, { value: true });
+    return redacted;
+};
+const toBoundaryError = (raw) => {
+    if (raw instanceof Error) {
+        return raw;
+    }
+    let message;
+    try {
+        message = String(raw);
+    }
+    catch {
+        try {
+            message = Object.prototype.toString.call(raw);
         }
+        catch {
+            message = GENERIC_BOUNDARY_ERROR_MESSAGE;
+        }
+    }
+    const wrapped = new Error(message);
+    wrapped.cause = raw;
+    return wrapped;
+};
+const isReadableProjection = (projected) => safeRead(() => {
+    void projected.message;
+    void projected.name;
+    for (const key in projected) {
+        void projected[key];
     }
     return true;
+}, false);
+const redactBoundaryErrorForDisplay = (error, showRaw, transformError) => {
+    try {
+        if (transformError) {
+            const projected = transformError(error);
+            if (projected instanceof Error) {
+                return isReadableProjection(projected) ? projected : redactToGeneric(error);
+            }
+            if (projected != null) {
+                if (showRaw && isPromise(projected)) {
+                    logWarn('transformError must return synchronously; an async one redacts every error.');
+                }
+                return redactToGeneric(error);
+            }
+        }
+        if (safeRead(() => error instanceof Error && REDACTED in error, false)) {
+            return error;
+        }
+        if (!showRaw) {
+            return redactToGeneric(error);
+        }
+        if (error instanceof Error) {
+            return error;
+        }
+        const rawMessage = error?.message;
+        if (typeof rawMessage === 'string') {
+            const wrapped = new Error(rawMessage);
+            wrapped.cause = error;
+            return wrapped;
+        }
+        return toBoundaryError(error);
+    }
+    catch {
+        return redactToGeneric(error);
+    }
+};
+const fireOnError = (onError, error, phase, boundaryId) => {
+    if (!onError) {
+        return;
+    }
+    try {
+        const digest = errorBoundaryDigest(error);
+        void Promise.resolve(onError(toBoundaryError(error), { phase, boundaryId, digest })).catch(logError);
+    }
+    catch (e) {
+        logError(e);
+    }
+};
+const boundariesWithDeferredError = /*#__PURE__*/ new WeakSet();
+const markErrorFromDeferredSegment = (store) => {
+    boundariesWithDeferredError.add(store);
 };
+const isErrorFromDeferredSegment = (store) => boundariesWithDeferredError.has(store);
+const ERROR_PHASE = /*#__PURE__*/ Symbol('qErrorPhase');
+const tagErrorPhase = (err, phase) => {
+    try {
+        Object.defineProperty(err, ERROR_PHASE, { value: phase, configurable: true });
+    }
+    catch {
+        // ignore
+    }
+};
+const getTaggedErrorPhase = (err) => safeRead(() => err?.[ERROR_PHASE], undefined);
+const markBoundaryErrored = (store, error, phase = "render" /* ErrorBoundaryPhase.Render */) => {
+    // `null` would collide with the capture-only sentinel, so wrap every nullish throw.
+    store.error = error == null ? toBoundaryError(error) : error;
+    const onError = store.$onError$;
+    if (onError) {
+        fireOnError(onError, error, getTaggedErrorPhase(error) ?? phase, store.boundaryId ?? '');
+    }
+};
+const handleQError = (e) => {
+    const detail = e
+        .detail;
+    if (detail?.importError) {
+        return;
+    }
+    const source = detail.element;
+    // The listener is document-wide, so only this document's elements may route through it.
+    if (!source || source.ownerDocument !== e.currentTarget) {
+        return;
+    }
+    // A destroyed container clears this back-pointer, so a stale target resolves to nothing.
+    const container = source.closest(QContainerSelector)?.qContainer;
+    const host = container?.vNodeLocate(source);
+    if (!container || !host) {
+        return;
+    }
+    try {
+        container.handleError(detail.error, host, "event" /* ErrorBoundaryPhase.Event */);
+    }
+    catch (handlerError) {
+        logError(handlerError);
+    }
+};
+/**
+ * One listener per document, routed by target, so no container is retained by the document. The
+ * marker lives on the document so a second bundle on the page reuses it instead of
+ * double-handling.
+ */
+function installQErrorListener(doc) {
+    if (!doc.qErrorHandler) {
+        doc.qErrorHandler = handleQError;
+        doc.addEventListener?.('qerror', handleQError);
+    }
+}
+function handleDevError(container, err, host) {
+    if (typeof document !== 'undefined') {
+        setErrorPayload(host, err);
+        markVNodeDirty(container, host, 512 /* ChoreBits.ERROR_WRAP */);
+    }
+    try {
+        if (err instanceof Error && !('hostElement' in err)) {
+            err['hostElement'] = String(host);
+        }
+    }
+    catch {
+        // ignore
+    }
+    if (!isRecoverable(err)) {
+        throw err;
+    }
+}
+function getOwnErrorBoundaryStore(container, host) {
+    const ctx = container.getHostProp(host, QCtxAttr);
+    return ctx ? mapArray_get(ctx, ERROR_CONTEXT.id, 0) : null;
+}
 
 /** @internal */
 const canRevealRegistration = (registration, isPending = (item) => item.boundary.untrackedValue > 0) => {
@@ -14702,6 +15089,9 @@ class DomContainer extends _SharedContainer {
         this.$setServerData$();
         element.qContainer = this;
         element.qDestroy = () => this.$destroy$();
+        if (__EXPERIMENTAL__.errorBoundary) {
+            installQErrorListener(this.document);
+        }
         this.$containerDataProcessState$ = 1 /* ContainerDataProcessState.ProcessingVNode */;
         processVNodeData(document, element);
         onVNodeDataReady(document, () => {
@@ -14797,29 +15187,48 @@ class DomContainer extends _SharedContainer {
         this.$stateData$[id] = vParent;
     }
     parseQRL(qrlStr) {
-        const qrl = parseQRL(qrlStr, this);
-        return qrl;
+        return parseQRL(qrlStr, this);
     }
-    handleError(err, host) {
+    handleError(err, host, phase = "render" /* ErrorBoundaryPhase.Render */) {
         if (qDev && host) {
-            if (typeof document !== 'undefined') {
-                setErrorPayload(host, err);
-                markVNodeDirty(this, host, 512 /* ChoreBits.ERROR_WRAP */);
-            }
-            if (err && err instanceof Error) {
-                if (!('hostElement' in err)) {
-                    err['hostElement'] = String(host);
-                }
-            }
-            if (!isRecoverable(err)) {
+            handleDevError(this, err, host);
+        }
+        if (!__EXPERIMENTAL__.errorBoundary) {
+            const errorStore = host && this.resolveContext(host, ERROR_CONTEXT);
+            if (!errorStore) {
                 throw err;
             }
+            errorStore.error = err;
+            return;
         }
-        const errorStore = host && this.resolveContext(host, ERROR_CONTEXT);
-        if (!errorStore) {
-            throw err;
+        // `null` would collide with the capture-only sentinel, so wrap every nullish throw.
+        const storedError = err == null ? toBoundaryError(err) : err;
+        let current = host;
+        while (current) {
+            const boundaryHost = this.resolveContextHost(current, ERROR_CONTEXT);
+            if (!boundaryHost) {
+                break;
+            }
+            const store = getOwnErrorBoundaryStore(this, boundaryHost);
+            if (store && store.error === undefined) {
+                store.error = storedError;
+                const boundaryProps = this.getHostProp(boundaryHost, ELEMENT_PROPS);
+                fireOnError(boundaryProps?.onError$, err, phase, store.boundaryId ?? '');
+                markVNodeDirty(this, boundaryHost, 4 /* ChoreBits.COMPONENT */);
+                return;
+            }
+            // Capture-only sentinel for the ErrorProvider test spy; folds away in prod builds.
+            if (qTest && store && store.error === null) {
+                store.error = storedError;
+                return;
+            }
+            if (boundaryHost.dirty & 4 /* ChoreBits.COMPONENT */) {
+                logError(err);
+                return;
+            }
+            current = this.getParentHost(boundaryHost);
         }
-        errorStore.error = err;
+        logErrorAndThrowAsync(err);
     }
     setContext(host, context, value) {
         let ctx = this.getHostProp(host, QCtxAttr);
@@ -14829,14 +15238,20 @@ class DomContainer extends _SharedContainer {
         mapArray_set(ctx, context.id, value, 0, true);
     }
     resolveContext(host, contextId) {
+        const found = this.resolveContextHost(host, contextId);
+        return found
+            ? mapArray_get(this.getHostProp(found, QCtxAttr), contextId.id, 0)
+            : undefined;
+    }
+    resolveContextHost(host, contextId) {
         while (host) {
             const ctx = this.getHostProp(host, QCtxAttr);
             if (ctx != null && mapArray_has(ctx, contextId.id, 0)) {
-                return mapArray_get(ctx, contextId.id, 0);
+                return host;
             }
             host = this.getParentHost(host);
         }
-        return undefined;
+        return null;
     }
     getParentHost(host) {
         let vNode = host.parent;
@@ -16587,13 +17002,13 @@ const _useStyles = (styleQrl, transform, scoped) => {
     return styleId;
 };
 
-const creator$2 = (qrl, options) => {
+const creator$1 = (qrl, options) => {
     qrl.resolve();
     return createComputedSignal(qrl, options);
 };
 /** @internal */
 const useComputedQrl = (qrl, options) => {
-    return useConstant((creator$2), qrl, options);
+    return useConstant((creator$1), qrl, options);
 };
 /**
  * Creates a computed signal which is calculated from the given function. A computed signal is a
@@ -16613,12 +17028,12 @@ const useComputedQrl = (qrl, options) => {
  */
 const useComputed$ = implicit$FirstArg(useComputedQrl);
 
-const creator$1 = (qrl) => {
+const creator = (qrl) => {
     qrl.resolve();
     return createSerializerSignal(qrl);
 };
 /** @internal */
-const useSerializerQrl = (qrl) => useConstant((creator$1), qrl);
+const useSerializerQrl = (qrl) => useConstant((creator), qrl);
 /**
  * Creates a signal which holds a custom serializable value. It requires that the value implements
  * the `CustomSerializable` type, which means having a function under the `[SerializeSymbol]`
@@ -16848,49 +17263,217 @@ const useTask$ = /*#__PURE__*/ implicit$FirstArg(useTaskQrl);
 // We need to cast to help out the api extractor
 const useVisibleTask$ = /*#__PURE__*/ implicit$FirstArg(useVisibleTaskQrl);
 
-const creator = (qrl, options) => {
-    qrl.resolve();
-    return createAsyncSignal(qrl, options);
-};
-/**
- * @deprecated Use `useComputed$` instead, it has async support now.
- * @internal
- */
-const useAsyncQrl = (qrl, options) => {
-    return useConstant((creator), qrl, options);
-};
-/**
- * Creates an AsyncSignal which holds the result of the given async function. If the function uses
- * `track()` to track reactive state, and that state changes, the AsyncSignal is recalculated, and
- * if the result changed, all tasks which are tracking the AsyncSignal will be re-run and all
- * subscribers (components, tasks etc) that read the AsyncSignal will be updated.
- *
- * If the async function throws an error, the AsyncSignal will capture the error and set the `error`
- * property. The error can be cleared by re-running the async function successfully.
- *
- * While the async function is running, the `loading` property will be set to `true`. Once the
- * function completes, `loading` will be set to `false`.
- *
- * If the value has not yet been resolved, reading the AsyncSignal will throw a Promise, which will
- * retry the component or task once the value resolves.
- *
- * If the value has been resolved, but the async function is re-running, reading the AsyncSignal
- * 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);
-
-/** @public */
-const useErrorBoundary = () => {
-    const error = useStore({ error: undefined });
+const createErrorBoundaryStore = () => Object.defineProperty({ error: undefined }, 'error', { enumerable: false });
+/** @internal */
+const useErrorBoundaryStore = () => {
+    const error = useStore(createErrorBoundaryStore);
     useContextProvider(ERROR_CONTEXT, error);
     return error;
 };
 
+/** Finalizes a deferred segment and emits its swap scripts; shared by Suspense and ErrorBoundary. */
+async function finalizeAndSwapOutOfOrderSegment(ssr, boundaryId, rendered, revealBoundary) {
+    const segmentId = String(boundaryId);
+    const result = await rendered.container.$finalizeOutOfOrderSegment$(segmentId, rendered);
+    ssr.write(`<template ${QSuspenseResolved}="${boundaryId}"${revealBoundary?.attrs ?? ''}>`);
+    ssr.write(result.html);
+    ssr.write('</template>');
+    ssr.emitOutOfOrderSegmentScripts(result.scripts);
+    ssr.emitOutOfOrderExecutorIfNeeded();
+    ssr.emitInlineScript(`qO(${boundaryId})`);
+    const errorSwapIds = rendered.container.$errorSwapIds$;
+    if (__EXPERIMENTAL__.errorBoundary && errorSwapIds?.length) {
+        ssr.emitErrorSwapExecutorIfNeeded();
+        for (let i = 0; i < errorSwapIds.length; i++) {
+            ssr.emitInlineScript(`qErr(${errorSwapIds[i]})`);
+        }
+    }
+    // qO() is the browser-visible handoff for this segment, so flush it immediately.
+    await ssr.streamHandler.flush();
+}
+
+/** @internal */
+const errorBoundaryReset = () => {
+    const [host] = _captures;
+    // this is executed only on client
+    const container = tryGetInvokeContext()?.$container$;
+    const isBrowserEnv = qTest ? !isServerPlatform() : isBrowser$1;
+    if (isBrowserEnv && host && container) {
+        resetErrorBoundary(container, host);
+    }
+};
+const RESET_KEY_SUFFIX = '\0';
+/** @internal */
+function resetErrorBoundary(container, host) {
+    const boundaryHost = container.resolveContextHost(host, ERROR_CONTEXT);
+    if (!boundaryHost) {
+        return;
+    }
+    const store = getOwnErrorBoundaryStore(container, boundaryHost);
+    if (!store) {
+        return;
+    }
+    scheduleBoundaryContentReset(container, boundaryHost, store.projectedContentOwner ?? null);
+    store.error = undefined;
+}
+function scheduleBoundaryContentReset(container, boundaryHost, recordedContentOwner) {
+    let resetHost = boundaryHost;
+    let contentOwner = null;
+    let vNode = vnode_getProjectionParentOrParent(boundaryHost);
+    let crossedProjection = false;
+    while (vNode) {
+        if (vnode_isVirtualVNode(vNode)) {
+            if (vnode_getProp(vNode, QSlot, null) !== null) {
+                crossedProjection = true;
+            }
+            else if (vnode_getProp(vNode, OnRenderProp, null) !== null) {
+                if (!crossedProjection) {
+                    const ownerBoundary = getOwnErrorBoundaryStore(container, vNode);
+                    if (!ownerBoundary || ownerBoundary.error !== undefined) {
+                        if (contentOwner) {
+                            resetHost = contentOwner;
+                        }
+                        contentOwner = vNode;
+                        if (ownerBoundary?.error !== undefined || !hasSlotProps(vNode.props)) {
+                            break;
+                        }
+                    }
+                }
+                crossedProjection = false;
+            }
+        }
+        vNode = vnode_getProjectionParentOrParent(vNode);
+    }
+    if (recordedContentOwner && recordedContentOwner !== contentOwner) {
+        resetHost = contentOwner ?? resetHost;
+        contentOwner = recordedContentOwner;
+    }
+    if (contentOwner) {
+        // Force keyed diff to recreate emptied projected content.
+        resetHost.key = `${resetHost.key ?? ''}${RESET_KEY_SUFFIX}`;
+        markVNodeDirty(container, contentOwner, 4 /* ChoreBits.COMPONENT */);
+    }
+    else {
+        markVNodeDirty(container, boundaryHost, 4 /* ChoreBits.COMPONENT */);
+    }
+}
+const renderFallbackOrLastResort = (fallbackQrl, error, reset) => {
+    return fallbackQrl(error, reset).catch((err) => {
+        if (fallbackQrl.resolved !== undefined) {
+            throw err;
+        }
+        return /*#__PURE__*/ _jsxSorted('div', { role: 'alert' }, null, 'Something went wrong.', 0, null);
+    });
+};
+const buildSSRErrorBoundaryHosts = (store, container) => {
+    const boundaryId = container?.nextOutOfOrderId(false) ?? 0;
+    return [
+        /*#__PURE__*/ _jsxSorted('div', {
+            [QErrorContentHost]: String(boundaryId),
+            style: 'display:contents',
+        }, null, 
+        /*#__PURE__*/ _jsxSorted(Slot, null, null, null, 0, null), 1, null),
+        /*#__PURE__*/ _jsxSorted(SSRErrorFallbackHost, {
+            boundaryId,
+            store,
+        }, null, null, 1, null),
+    ];
+};
+/** @internal */
+const errorBoundaryCmp = (props) => {
+    if (!__EXPERIMENTAL__.errorBoundary) {
+        throw new Error('<ErrorBoundary> requires the `errorBoundary` experimental feature. Enable it in your Qwik Vite config: qwikVite({ experimental: ["errorBoundary"] }).');
+    }
+    const store = useErrorBoundaryStore();
+    const invokeCtx = tryGetInvokeContext();
+    const container = invokeCtx?.$container$;
+    if (container && (getStoreTarget(store) ?? store).boundaryId === undefined) {
+        store.boundaryId = getNextUniqueIndex(container);
+    }
+    const isServerEnv = qTest ? isServerPlatform() : !isBrowser$1;
+    if (!isServerEnv && store.error === undefined) {
+        return /*#__PURE__*/ _jsxSorted(Slot, null, null, null, 0, null);
+    }
+    const reset = /*#__PURE__*/ inlinedQrl(errorBoundaryReset, '_ebR', [invokeCtx?.$hostElement$]);
+    if (isServerEnv) {
+        const fallbackQrl = props.fallback$;
+        store.$fallback$ = noSerialize((error) => fallbackQrl(error, reset));
+        const onErrorQrl = props.onError$;
+        if (onErrorQrl) {
+            store.$onError$ = noSerialize((error, info) => onErrorQrl(error, info));
+        }
+        return buildSSRErrorBoundaryHosts(store, container);
+    }
+    const displayError = redactBoundaryErrorForDisplay(store.error, true);
+    return /*#__PURE__*/ _jsxSorted(Fragment, null, null, renderFallbackOrLastResort(props.fallback$, displayError, reset), 0, null);
+};
+/** Renders `fallback$` instead of its children when a descendant throws. @public @experimental */
+const ErrorBoundary = 
+/*#__PURE__*/ componentQrl(
+/*#__PURE__*/ inlinedQrl(errorBoundaryCmp, ERROR_BOUNDARY_QRL_SYMBOL));
+const consumeSSRErrorFallback = (ssr, store) => {
+    const fallback = store.$fallback$;
+    delete store.$fallback$;
+    const projected = redactBoundaryErrorForDisplay(store.error, isDev, ssr.$transformError$);
+    return fallback(projected);
+};
+const SSRErrorFallbackRenderer = __EXPERIMENTAL__.errorBoundary
+    ? /*#__PURE__*/ createInternalServerComponent((ssr, jsx, options, enqueue) => {
+        const boundaryId = jsx.varProps.boundaryId;
+        const store = jsx.varProps.store;
+        if (jsx.varProps.deliverLate) {
+            const streamFallback = async (error) => {
+                if (!store.$fallback$) {
+                    return;
+                }
+                // The catch site already recorded it; marking again refires onError$.
+                if (store.error !== error) {
+                    markBoundaryErrored(store, error, "render" /* ErrorBoundaryPhase.Render */);
+                }
+                const segment = await ssr.segment(`${boundaryId}`, consumeSSRErrorFallback(ssr, store), options);
+                // qErr hides the errored content host and strips its broadcast handlers.
+                segment.container.$registerErrorSwap$(boundaryId);
+                await ssr.$runQueuedRender$(() => finalizeAndSwapOutOfOrderSegment(ssr, boundaryId, segment, null));
+            };
+            store.$emitFallback$ = noSerialize(streamFallback);
+            ssr.write(`<template ${QSuspenseResolved}="${boundaryId}"></template>`);
+            if (store.error !== undefined) {
+                return streamFallback(store.error);
+            }
+            return;
+        }
+        if (store.error === undefined || !store.$fallback$) {
+            return;
+        }
+        if (isOutOfOrderSegmentContainer(ssr)) {
+            ssr.$registerErrorSwap$(boundaryId);
+        }
+        else {
+            enqueue(() => {
+                ssr.emitErrorSwapExecutorIfNeeded();
+                ssr.emitInlineScript(`qErr(${boundaryId})`);
+            });
+        }
+        enqueue(consumeSSRErrorFallback(ssr, store));
+    })
+    : null;
+const SSRErrorFallbackHost = __EXPERIMENTAL__.errorBoundary
+    ? /*#__PURE__*/ createInternalServerComponent((ssr, jsx, _options, enqueue) => {
+        const boundaryId = jsx.varProps.boundaryId;
+        const store = jsx.varProps.store;
+        const deliverLate = __EXPERIMENTAL__.suspense &&
+            ssr.outOfOrderStreaming &&
+            !isOutOfOrderSegmentContainer(ssr) &&
+            (store.error === undefined || isErrorFromDeferredSegment(store));
+        enqueue(
+        /*#__PURE__*/ _jsxSorted('div', {
+            [deliverLate ? QSuspenseResultParent : QErrorFallbackHost]: String(boundaryId),
+            style: 'display:none',
+        }, null, 
+        /*#__PURE__*/ _jsxSorted(SSRErrorFallbackRenderer, { boundaryId, store, deliverLate }, null, null, 1, null), 1, null));
+    })
+    : null;
+
 /** @internal */
 const eachCmpTask = async ({ track }) => {
     const props = _captures[0];
@@ -17181,10 +17764,23 @@ const SSRDeferredSlot = __EXPERIMENTAL__.suspense
         const boundaryState = jsx.varProps.boundary;
         const contentStyle = jsx.varProps.contentStyle;
         const revealBoundary = jsx.varProps.reveal;
+        const errorBoundaryStore = __EXPERIMENTAL__.errorBoundary && options.parentComponentFrame
+            ? ssr.resolveContext(options.parentComponentFrame.componentNode, ERROR_CONTEXT)
+            : undefined;
         const content = ssr.segment(contentSegment, createClaimedDeferredSlot(ssr, jsx, options), options);
         ssr.write(`<template ${QSuspenseResolved}="${boundaryId}"></template>`);
         ssr.emitOutOfOrderExecutorIfNeeded();
-        ssr.queueOutOfOrderSegment(content.then((rendered) => emitRenderedOutOfOrderSegment(ssr, boundaryId, contentSegment, rendered, contentStyle, revealBoundary, boundaryState)));
+        ssr.queueOutOfOrderSegment(content
+            .then((rendered) => emitRenderedOutOfOrderSegment(ssr, boundaryId, rendered, contentStyle, revealBoundary, boundaryState))
+            .catch((error) => {
+            if (errorBoundaryStore?.$emitFallback$) {
+                return errorBoundaryStore.$emitFallback$(error);
+            }
+            if (errorBoundaryStore?.error !== undefined) {
+                return;
+            }
+            throw error;
+        }));
     })
     : null;
 function createClaimedDeferredSlot(ssr, jsx, options) {
@@ -17200,7 +17796,7 @@ 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) {
+async function emitRenderedOutOfOrderSegment(ssr, boundaryId, rendered, contentStyle, revealBoundary, boundaryState) {
     if (boundaryState) {
         boundaryState.contentResolved = true;
         if (boundaryState.delayTimer) {
@@ -17211,14 +17807,7 @@ async function emitRenderedOutOfOrderSegment(ssr, boundaryId, segmentId, rendere
     revealBoundary?.resolve();
     await ssr.$runQueuedRender$(async () => {
         ssr.addRoot(contentStyle);
-        const result = await rendered.container.$finalizeOutOfOrderSegment$(segmentId, rendered);
-        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();
+        await finalizeAndSwapOutOfOrderSegment(ssr, boundaryId, rendered, revealBoundary);
     });
 }
 function scheduleOutOfOrderFallbackDelay(ssr, boundaryState, state) {
@@ -17333,5 +17922,5 @@ if (import.meta.hot) {
     });
 }
 
-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 };
+export { $, Each, ErrorBoundary, 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, errorBoundaryCmp as _ebC, errorBoundaryReset as _ebR, _executeSsrChores, _fnSignal, getAsyncLocalStorage as _getAsyncLocalStorage, _getConstProps, _getContextContainer, _getContextEvent, _getContextHostElement, getDomContainer as _getDomContainer, _getQContainerElement, getSubscriber as _getSubscriber, _getVarProps, handleSSRError as _handleSSRError, _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, 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, useComputed$, useComputedQrl, useConstant, useContext, useContextProvider, 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