Backtestsvuerun-20261005-124535#12575

Issue #12575 Merged fix PR #12601 Run 5 Oct 2026 · run-20261005-124535 vuejs/core

Vue is not catching errors on server side in SSR when using async child setup

Better

Our patch was judged better than the merged fix.

In this judgment, Patch B = our agent, Patch A = the merged fix.

The issue asks that a component whose async setup rejects in SSR should not render its template, and that the error should reach the parent's onErrorCaptured.

Patch B fixes this at the root. In SSR mode, setupStatefulComponent now re-throws after calling handleError, so the server renderer can tell that setup failed. renderComponentVNode then skips serverPrefetch hooks and the component's subtree, and emits an empty `<!---->` placeholder instead. That matches client-side behavior: the error is captured once and the template never runs against missing state. Its tests are meaningful and would fail before the change:
- top-level await via withAsyncContext followed by a throw, with a sibling still rendering;
- a render-function parent with two failing children;
- serverPrefetch confirmed not called.
It also updates existing expectations ('missing template' is no longer warned, and the async child is no longer rendered). Those updates are consistent with the new, correct semantics.

Patch A only treats the symptom. The component with failed setup is still rendered. Patch A wraps ssrRender in a try/catch with handleError, so the second, derived TypeError ('Cannot read properties of undefined') also reaches onErrorCaptured. Its own test asserts two captured errors, including the render crash and the 'Property foo was accessed during render' warning. The template still executes against nonexistent data, which the issue explicitly calls wrong. Catching render errors mid-ssrRender can also leave partially pushed buffer content. Converting sync throws into Promise.reject changes error-propagation behavior beyond the issue's scope.

B is correct, well-scoped and well-tested; A papers over the problem.

The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.

Solve

14m 36s

Wall-clock time in the container

Full test suite

No new failures

3,617 passed · 6 skipped · 3,623 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

120vs 58 merged

Changed lines, ours vs merged

Vue version

3.5.13

Link to minimal reproduction

Vue SFC Playground

Steps to reproduce

Just open a link and you will see errors when SSR is ON.
When SSR is OFF everything works as expected.

Also, commeting the line with top-level await (making Comp.vue a sync component) will also work fine both with and without SSR.

What is expected?

In SSR mode the page is expected to be blank white for 1 second and then display error message from App.vue.
This works as expected with SSR turned off.

Basically onErrorCaptured should be triggered, child setup and <template> render immediately stopped and error message from parent component shown.

What is actually happening?

In SSR mode the page is blank for 1 second but then it tries to render the <template> of Comp.vue using the data that might not even exist (because it appears in setup after throwing error).

And even if it manages to render <template> correctly, it still does not trigger onErrorCaptured in App.vue and do not switch to show error message.

Any additional comments?

I am building a custom rendering package built on top of Vue and it heavily uses structures like these:

 // Wrappers are supposed to catch ALL errors and throws in child <Block /> and show nice error message

<BlockWrapper>
    <Block ... />
</BlockWrapper>

<BlockWrapper>
    <Block ... />
</BlockWrapper>

<BlockWrapper>
    <Block ... />
</BlockWrapper>

...

Because of this bug OR my misunderstanding of how to handle async errors in Vue 3, even when thrown it still tries to render child block's <template> even with missing data (because setup is stopped executing), throws on reading properties of non-existing objects and the whole Nuxt page breaks.

Please, don't tell me this is a no-fix. It would be a disaster... 😭

The two patches

Our patch+104 −16
packages/runtime-core/src/component.tsindex c46741bee..7f8fdd636 100644@@ -891,13 +891,17 @@ function setupStatefulComponent(     if (isAsyncSetup) {       setupResult.then(unsetCurrentInstance, unsetCurrentInstance)       if (isSSR) {-        // return the promise so server-renderer can wait on it+        // return the promise so server-renderer can wait on it.+        // the error is re-thrown after being handled so that the+        // server-renderer knows setup failed and skips rendering the+        // component's subtree (#12575)         return setupResult           .then((resolvedResult: unknown) => {             handleSetupResult(instance, resolvedResult, isSSR)           })           .catch(e => {             handleError(e, instance, ErrorCodes.SETUP_FUNCTION)+            throw e           })       } else if (__FEATURE_SUSPENSE__) {         // async setup returned Promise.packages/server-renderer/__tests__/render.spec.tsindex 268c7dc1e..4f830724e 100644@@ -20,6 +20,7 @@ import {   resolveComponent,   resolveDynamicComponent,   watchEffect,+  withAsyncContext,   withCtx, } from 'vue' import { escapeHtml } from '@vue/shared'@@ -935,7 +936,8 @@ function testRender(type: string, render: typeof renderToString) {       }        const html = await renderToString(app)-      expect(html).toBe(`<div class="app"><div>asyncChildren</div></div>`)+      // #12575 a component whose async setup rejected must not be rendered+      expect(html).toBe(`<div class="app"><!----></div>`)        expect(fn).toHaveBeenCalledTimes(1)       expect(fn).toBeCalledWith('async child error')@@ -944,6 +946,67 @@ function testRender(type: string, render: typeof renderToString) {       expect(fn2).toBeCalledWith('async child error')     }) +    // #12575+    test('should not render component whose async setup throws after await', async () => {+      const captured: unknown[] = []+      const serverPrefetch = vi.fn()+      const Comp = defineComponent({+        async setup() {+          // equivalent of compiled `<script setup>` top-level await+          const [awaitable, restore] = withAsyncContext(+            () => new Promise(r => setTimeout(r, 10)),+          )+          await awaitable+          restore()+          onServerPrefetch(serverPrefetch)+          throw new Error('async setup error')+        },+        // would throw if rendered, since setup never returned `data`+        template: `<div>{{ data.msg }}</div>`,+      })+      const app = createApp({+        components: { Comp },+        setup() {+          onErrorCaptured(e => {+            captured.push(e)+            return false+          })+        },+        template: `<div class="wrapper"><Comp /><span>sibling</span></div>`,+      })++      const html = await render(app)+      expect(html).toBe(+        `<div class="wrapper"><!----><span>sibling</span></div>`,+      )+      expect(captured.length).toBe(1)+      expect((captured[0] as Error).message).toBe('async setup error')+      expect(serverPrefetch).not.toHaveBeenCalled()+    })++    // #12575+    test('should not render component whose async setup throws (render function parent)', async () => {+      const errorHandler = vi.fn()+      const Comp = defineComponent({+        async setup() {+          await new Promise(r => setTimeout(r, 10))+          throw new Error('async setup error')+        },+        render(this: any) {+          return h('div', this.data.msg)+        },+      })+      const app = createApp({+        render: () => h('div', [h(Comp), h(Comp)]),+      })+      app.config.errorHandler = errorHandler++      const html = await render(app)+      expect(html).toBe(`<div><!----><!----></div>`)+      expect(errorHandler).toHaveBeenCalledTimes(2)+      expect(errorHandler.mock.calls[0][0].message).toBe('async setup error')+    })+     // https://github.com/vuejs/core/issues/3322     test('effect onInvalidate does not error', async () => {       const noop = () => {}packages/server-renderer/__tests__/ssrSuspense.spec.tsindex 5f8cecaf9..973c80690 100644@@ -43,7 +43,7 @@ describe('SSR Suspense', () => {     expect(await renderToString(createApp(Comp))).toBe(`<!---->`)      expect(Comp.errorCaptured).toHaveBeenCalledTimes(1)-    expect('missing template').toHaveBeenWarned()+    expect('missing template').not.toHaveBeenWarned()   })    test('2 components', async () => {@@ -77,7 +77,7 @@ describe('SSR Suspense', () => {     )      expect(Comp.errorCaptured).toHaveBeenCalledTimes(1)-    expect('missing template or render function').toHaveBeenWarned()+    expect('missing template or render function').not.toHaveBeenWarned()   })    test('failing suspense in passing suspense', async () => {@@ -102,7 +102,7 @@ describe('SSR Suspense', () => {     )      expect(Comp.errorCaptured).toHaveBeenCalledTimes(1)-    expect('missing template').toHaveBeenWarned()+    expect('missing template').not.toHaveBeenWarned()   })    // nuxt/nuxt#28162@@ -148,6 +148,6 @@ describe('SSR Suspense', () => {       `<div><!----><div><div>async</div></div></div>`,     )     expect(Comp.errorCaptured).toHaveBeenCalledTimes(1)-    expect('missing template').toHaveBeenWarned()+    expect('missing template').not.toHaveBeenWarned()   }) })packages/server-renderer/src/render.tsindex 8fc9b0128..6701dcf3c 100644@@ -105,24 +105,45 @@ export function renderComponentVNode(   const hasAsyncSetup = isPromise(res)   let prefetches = instance.sp /* LifecycleHooks.SERVER_PREFETCH */   if (hasAsyncSetup || prefetches) {+    let setupFailed = false     const p: Promise<unknown> = Promise.resolve(res as Promise<void>)-      .then(() => {-        // instance.sp may be null until an async setup resolves, so evaluate it here-        if (hasAsyncSetup) prefetches = instance.sp-        if (prefetches) {-          return Promise.all(-            prefetches.map(prefetch => prefetch.call(instance.proxy)),-          )-        }-      })+      .then(+        () => {+          // instance.sp may be null until an async setup resolves, so evaluate it here+          if (hasAsyncSetup) prefetches = instance.sp+          if (prefetches) {+            return Promise.all(+              prefetches.map(prefetch => prefetch.call(instance.proxy)),+            )+          }+        },+        () => {+          // async setup rejected. The error has already been passed to+          // errorCaptured hooks / app.config.errorHandler by setupComponent,+          // the component's state is incomplete so it must not be rendered+          // (#12575)+          setupFailed = true+        },+      )       // Note: error display is already done by the wrapped lifecycle hook function.       .catch(NOOP)-    return p.then(() => renderComponentSubTree(instance, slotScopeId))+    return p.then(() =>+      setupFailed+        ? renderFailedComponent()+        : renderComponentSubTree(instance, slotScopeId),+    )   } else {     return renderComponentSubTree(instance, slotScopeId)   } } +function renderFailedComponent(): SSRBuffer {+  // render an empty placeholder, same as a component rendering nothing+  const { getBuffer, push } = createBuffer()+  push(`<!---->`)+  return getBuffer()+}+ function renderComponentSubTree(   instance: ComponentInternalInstance,   slotScopeId?: string, 
Merged fix · PR #12601+55 −3
packages/server-renderer/__tests__/render.spec.tsindex 268c7dc1e..f537a6219 100644@@ -12,6 +12,7 @@ import {   defineComponent,   getCurrentInstance,   h,+  nextTick,   onErrorCaptured,   onServerPrefetch,   reactive,@@ -822,6 +823,9 @@ function testRender(type: string, render: typeof renderToString) {           )         } catch {}         expect(getCurrentInstance()).toBe(prev)+        expect(+          '[Vue warn]: Unhandled error during execution of render function',+        ).toHaveBeenWarned()       })        // #7733@@ -1191,6 +1195,40 @@ function testRender(type: string, render: typeof renderToString) {       expect((capturedError as unknown as Error).message).toBe('An error')     }) +    test('async setup throwing error', async () => {+      const capturedError: string[] = []++      const Child = {+        async setup() {+          await nextTick()+          throw new Error('An error')+          return { foo: { bar: 1 } }+        },+        template: `<span>{{ foo.bar }}</span>`,+      }++      const app = createApp({+        components: { Child },+        setup() {+          onErrorCaptured(e => {+            capturedError.push(e.message)+            return false+          })+        },+        template: `<Suspense><Child /></Suspense>`,+      })++      expect(await render(app)).toBe('')+      expect(capturedError.length).toBe(2)+      expect(capturedError).toStrictEqual([+        'An error',+        "Cannot read properties of undefined (reading 'bar')",+      ])+      expect(+        '[Vue warn]: Property "foo" was accessed during render but is not defined on instance',+      ).toHaveBeenWarned()+    })+     test('computed reactivity during SSR with onServerPrefetch', async () => {       const store = {         // initial state could be hydratedpackages/server-renderer/__tests__/ssrSuspense.spec.tsindex 5f8cecaf9..2cc3da1cd 100644@@ -107,9 +107,10 @@ describe('SSR Suspense', () => {    // nuxt/nuxt#28162   test('propagates sync errors from compiled ssrRenderSuspense default slot', async () => {+    const error = new TypeError('bang')     const Throwing = defineComponent({       ssrRender(_ctx: any, _push: any) {-        throw new TypeError('bang')+        throw error       },     }) @@ -124,7 +125,10 @@ describe('SSR Suspense', () => {       },     }) -    await expect(renderToString(createApp(Root))).rejects.toThrow('bang')+    await expect(renderToString(createApp(Root))).rejects.toBe(error)+    expect(+      '[Vue warn]: Unhandled error during execution of render function',+    ).toHaveBeenWarnedTimes(1)   })    test('passing suspense in failing suspense', async () => {packages/server-renderer/src/render.tsindex 8fc9b0128..c2bde4d1e 100644@@ -3,6 +3,7 @@ import {   type Component,   type ComponentInternalInstance,   type DirectiveBinding,+  ErrorCodes,   Fragment,   type FunctionalComponent,   Static,@@ -10,6 +11,7 @@ import {   type VNode,   type VNodeArrayChildren,   type VNodeProps,+  handleError,   mergeProps,   ssrUtils,   warn,@@ -119,7 +121,13 @@ export function renderComponentVNode(       .catch(NOOP)     return p.then(() => renderComponentSubTree(instance, slotScopeId))   } else {-    return renderComponentSubTree(instance, slotScopeId)+    try {+      return renderComponentSubTree(instance, slotScopeId)+    } catch (err) {+      // let the SSR buffer propagate the error so parent render functions+      // don't handle the same error again+      return Promise.reject(err)+    }   } } @@ -201,6 +209,8 @@ function renderComponentSubTree(           instance.data,           instance.ctx,         )+      } catch (err) {+        handleError(err, instance, ErrorCodes.RENDER_FUNCTION)       } finally {         setCurrentRenderingInstance(prev)       }