Backtestsvuerun-20261005-155915#12575

Issue #12575 Merged fix PR #12601 Run 5 Oct 2026 · run-20261005-155915 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.

Patch B fixes the root cause. In SSR the async setup rejection was already passed to handleError, but the server renderer then rendered the component's template anyway, with no valid setup state. Patch B changes the SSR promise returned by setupStatefulComponent so it still calls handleError and then rethrows. renderComponentVNode records the rejection as setupFailed and emits a `<!---->` placeholder instead of calling renderComponentSubTree. So the child's template or ssrRender never runs, and errorCaptured / app.config.errorHandler fires exactly once with the real error. This matches the issue's expectation that the child render should stop immediately. Its tests check that the render function is never called, cover both render and ssrRender paths, and check that app.config.errorHandler receives the error. It also updates existing expectations ('missing template' warnings, an `asyncChildren` output) to the new, correct behavior. Patch A does not stop the child's template from rendering. It wraps the SSR render call in handleError, so the downstream TypeError from reading undefined data is caught instead of crashing the page. The template still executes against missing state, and errorCaptured fires twice: once for the real error and once for the spurious 'Cannot read properties of undefined' error. Its own test asserts that double capture and a 'Property foo was accessed during render' warning, which is the symptom the issue complains about. Patch A also changes general render error handling and adds a Promise.reject wrapper, which widens its scope beyond the issue. Patch B is the more correct and better-tested fix.

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

10m 12s

Wall-clock time in the container

Full test suite

No new failures

3,620 passed · 6 skipped · 3,626 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

151vs 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+130 −21
packages/runtime-core/src/component.tsindex c46741bee..e66c881d2 100644@@ -891,14 +891,19 @@ function setupStatefulComponent(     if (isAsyncSetup) {       setupResult.then(unsetCurrentInstance, unsetCurrentInstance)       if (isSSR) {-        // return the promise so server-renderer can wait on it-        return setupResult-          .then((resolvedResult: unknown) => {+        // return the promise so server-renderer can wait on it.+        // the returned promise rejects if setup() rejected (after the error has+        // been handled) so that server-renderer can skip rendering the+        // component, which has no valid setup state.+        return setupResult.then(+          (resolvedResult: unknown) => {             handleSetupResult(instance, resolvedResult, isSSR)-          })-          .catch(e => {+          },+          (e: unknown) => {             handleError(e, instance, ErrorCodes.SETUP_FUNCTION)-          })+            throw e+          },+        )       } else if (__FEATURE_SUSPENSE__) {         // async setup returned Promise.         // bail here and wait for re-entry.packages/server-renderer/__tests__/render.spec.tsindex 268c7dc1e..4177348b7 100644@@ -935,7 +935,8 @@ function testRender(type: string, render: typeof renderToString) {       }        const html = await renderToString(app)-      expect(html).toBe(`<div class="app"><div>asyncChildren</div></div>`)+      // the child's template must not be rendered since its setup failed+      expect(html).toBe(`<div class="app"><!----></div>`)        expect(fn).toHaveBeenCalledTimes(1)       expect(fn).toBeCalledWith('async child error')@@ -944,6 +945,90 @@ function testRender(type: string, render: typeof renderToString) {       expect(fn2).toBeCalledWith('async child error')     }) +    // #12575+    test('should not render component template when async setup throws', async () => {+      const renderChild = vi.fn()+      const capturedErrors: unknown[] = []++      const Child = defineComponent({+        async setup() {+          const data = await new Promise<{ msg: string }>((_, reject) =>+            setTimeout(() => reject(new Error('async setup error'))),+          )+          return { data }+        },+        render(this: any) {+          renderChild()+          return h('span', this.data.msg)+        },+      })++      const app = createApp({+        setup() {+          onErrorCaptured(e => {+            capturedErrors.push(e)+            return false+          })+          return () => h('div', [h('p', 'before'), h(Child), h('p', 'after')])+        },+      })++      const html = await render(app)+      expect(html).toBe(`<div><p>before</p><!----><p>after</p></div>`)+      expect(renderChild).not.toHaveBeenCalled()+      expect(capturedErrors.length).toBe(1)+      expect((capturedErrors[0] as Error).message).toBe('async setup error')+    })++    // #12575+    test('should not run ssrRender of component when async setup throws', async () => {+      const capturedErrors: unknown[] = []++      const Child = defineComponent({+        async setup() {+          await Promise.resolve()+          throw new Error('async setup error')+        },+        ssrRender(ctx: any, push: any) {+          push(`<span>${ctx.data.msg}</span>`)+        },+      })++      const app = createApp({+        components: { Child },+        template: `<div><Child /><Child /></div>`,+        errorCaptured(e) {+          capturedErrors.push(e)+          return false+        },+      })++      const html = await render(app)+      expect(html).toBe(`<div><!----><!----></div>`)+      expect(capturedErrors.length).toBe(2)+    })++    // #12575+    test('async setup error handled by app.config.errorHandler', async () => {+      const handler = vi.fn()+      const Child = defineComponent({+        async setup() {+          throw new Error('async setup error')+        },+        template: `<span>{{ missing.value }}</span>`,+      })+      const app = createApp({+        components: { Child },+        template: `<div><Child /></div>`,+      })+      app.config.errorHandler = handler++      const html = await render(app)+      expect(html).toBe(`<div><!----></div>`)+      expect(handler).toHaveBeenCalledTimes(1)+      expect(handler.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..e58c88f82 100644@@ -43,7 +43,8 @@ describe('SSR Suspense', () => {     expect(await renderToString(createApp(Comp))).toBe(`<!---->`)      expect(Comp.errorCaptured).toHaveBeenCalledTimes(1)-    expect('missing template').toHaveBeenWarned()+    // setup rejected: the component is not rendered at all+    expect('missing template').not.toHaveBeenWarned()   })    test('2 components', async () => {@@ -77,7 +78,8 @@ describe('SSR Suspense', () => {     )      expect(Comp.errorCaptured).toHaveBeenCalledTimes(1)-    expect('missing template or render function').toHaveBeenWarned()+    // setup rejected: the component is not rendered at all+    expect('missing template or render function').not.toHaveBeenWarned()   })    test('failing suspense in passing suspense', async () => {@@ -102,7 +104,8 @@ describe('SSR Suspense', () => {     )      expect(Comp.errorCaptured).toHaveBeenCalledTimes(1)-    expect('missing template').toHaveBeenWarned()+    // setup rejected: the component is not rendered at all+    expect('missing template').not.toHaveBeenWarned()   })    // nuxt/nuxt#28162@@ -148,6 +151,7 @@ describe('SSR Suspense', () => {       `<div><!----><div><div>async</div></div></div>`,     )     expect(Comp.errorCaptured).toHaveBeenCalledTimes(1)-    expect('missing template').toHaveBeenWarned()+    // setup rejected: the component is not rendered at all+    expect('missing template').not.toHaveBeenWarned()   }) })packages/server-renderer/src/render.tsindex 8fc9b0128..68ba85b70 100644@@ -105,19 +105,34 @@ 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 handled+          // (errorCaptured / app.config.errorHandler) by setupComponent.+          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(() => {+      if (setupFailed) {+        // the component has no valid setup state, so its template must not be+        // rendered. Render a placeholder comment instead.+        return [`<!---->`]+      }+      return renderComponentSubTree(instance, slotScopeId)+    })   } else {     return renderComponentSubTree(instance, slotScopeId)   } 
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)       }