Backtestsvuerun-20261007-145226#12575

Issue #12575 Merged fix PR #12601 Run 7 Oct 2026 · run-20261007-145226 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: the child's subtree is rendered even though its async setup failed. In SSR mode the setup promise's `.catch` reports the error through `handleError` and then swallows it. Patch B re-throws there, in the SSR-only branch of `setupStatefulComponent`, and the server renderer records the rejection. It then skips `renderComponentSubTree`, emitting a `<!---->` placeholder, so the template never runs against missing setup state. `onErrorCaptured` fires exactly once with the real setup error, and serverPrefetch hooks are skipped. That matches what the issue asks for: stop rendering the child and let the parent's error handler see the error. Its tests target the issue scenario directly: a template that would crash on `data.msg`, a vnode render function asserted not to be called, and prefetch not run. They would fail before the change. The updates to the existing tests (no more 'missing template' warnings, `<!---->` output) follow consistently from the intended behavior change.

Patch A does not stop the broken render. It wraps the compiled `ssrRender` call in try/catch and routes the error through `handleError`, so the child template still runs on incomplete state. Its own test shows this: it expects two captured errors, the setup error plus "Cannot read properties of undefined (reading 'bar')". That masks the symptom rather than fixing the cause. It also has a broader side effect: every SSR render-function error now goes through `handleError`. In production that logs and continues instead of rejecting, which can silently produce partial HTML where `renderToString` used to reject. Frameworks like Nuxt rely on that rejection. The extra try/catch with `Promise.reject` adds more complexity to the render path. Patch B's change is more targeted, matches the expected semantics, and has stronger tests.

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

8m 20s

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

136vs 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+121 −15
packages/runtime-core/src/component.tsindex c46741bee..966886191 100644@@ -898,6 +898,10 @@ function setupStatefulComponent(           })           .catch(e => {             handleError(e, instance, ErrorCodes.SETUP_FUNCTION)+            // the error has been reported. Re-throw so the server-renderer+            // knows setup failed and skips rendering the component's subtree,+            // which would otherwise run against incomplete setup state.+            throw e           })       } else if (__FEATURE_SUSPENSE__) {         // async setup returned Promise.packages/server-renderer/__tests__/render.spec.tsindex 268c7dc1e..451281476 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>`)+      // #12575 the subtree of a component whose async setup failed is not rendered+      expect(html).toBe(`<div class="app"><!----></div>`)        expect(fn).toHaveBeenCalledTimes(1)       expect(fn).toBeCalledWith('async child error')@@ -944,6 +945,89 @@ function testRender(type: string, render: typeof renderToString) {       expect(fn2).toBeCalledWith('async child error')     }) +    // #12575+    test('should not render subtree of component whose async setup throws', async () => {+      const capturedErrors: unknown[] = []+      const fetchData = async (): Promise<{ msg: string }> => {+        await new Promise(r => setTimeout(r, 1))+        throw new Error('child setup error')+      }++      const Child = defineComponent({+        async setup() {+          const data = await fetchData()+          return { data }+        },+        // would throw if rendered after the failed setup+        template: `<div>{{ data.msg }}</div>`,+      })++      const app = createApp({+        components: { Child },+        setup() {+          onErrorCaptured(e => {+            capturedErrors.push(e)+            return false+          })+        },+        template: `<div class="parent"><Child /><span>sibling</span></div>`,+      })++      const html = await renderToString(app)+      expect(html).toBe(+        `<div class="parent"><!----><span>sibling</span></div>`,+      )+      expect(capturedErrors).toHaveLength(1)+      expect((capturedErrors[0] as Error).message).toBe('child setup error')+    })++    // #12575+    test('should not render subtree of vnode component whose async setup throws', async () => {+      const errorHandler = vi.fn()+      const childRender = vi.fn(() => h('div', 'child'))++      const Child = {+        async setup() {+          throw new Error('child setup error')+        },+        render: childRender,+      }++      const app = createApp({+        render: () => h('div', [h(Child), h('span', 'sibling')]),+      })+      app.config.errorHandler = errorHandler++      const html = await renderToString(app)+      expect(html).toBe(`<div><!----><span>sibling</span></div>`)+      expect(childRender).not.toHaveBeenCalled()+      expect(errorHandler).toHaveBeenCalledTimes(1)+      expect(errorHandler.mock.calls[0][0].message).toBe('child setup error')+    })++    // #12575+    test('should not run serverPrefetch of component whose async setup throws', async () => {+      const prefetch = vi.fn()++      const Child = {+        async setup() {+          onServerPrefetch(prefetch)+          await Promise.resolve()+          throw new Error('child setup error')+        },+        render: () => h('div', 'child'),+      }++      const app = createApp({+        errorCaptured: () => false,+        render: () => h('div', [h(Child)]),+      })++      const html = await renderToString(app)+      expect(html).toBe(`<div><!----></div>`)+      expect(prefetch).not.toHaveBeenCalled()+    })+     // https://github.com/vuejs/core/issues/3322     test('effect onInvalidate does not error', async () => {       const noop = () => {}packages/server-renderer/__tests__/ssrSuspense.spec.tsindex 5f8cecaf9..5985e4e6c 100644@@ -43,7 +43,8 @@ describe('SSR Suspense', () => {     expect(await renderToString(createApp(Comp))).toBe(`<!---->`)      expect(Comp.errorCaptured).toHaveBeenCalledTimes(1)-    expect('missing template').toHaveBeenWarned()+    // #12575 the subtree of a component whose async setup failed is skipped+    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()+    // #12575 the subtree of a component whose async setup failed is skipped+    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()+    // #12575 the subtree of a component whose async setup failed is skipped+    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()+    // #12575 the subtree of a component whose async setup failed is skipped+    expect('missing template').not.toHaveBeenWarned()   }) })packages/server-renderer/src/render.tsindex 8fc9b0128..77fa82cf7 100644@@ -105,19 +105,33 @@ export function renderComponentVNode(   const hasAsyncSetup = isPromise(res)   let prefetches = instance.sp /* LifecycleHooks.SERVER_PREFETCH */   if (hasAsyncSetup || prefetches) {+    let asyncSetupFailed = 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 through+          // errorCaptured / app.config.errorHandler by setupStatefulComponent.+          asyncSetupFailed = true+        },+      )       // Note: error display is already done by the wrapped lifecycle hook function.       .catch(NOOP)-    return p.then(() => renderComponentSubTree(instance, slotScopeId))+    return p.then(() =>+      // #12575 do not render the subtree of a component whose async setup+      // failed: its setup state is incomplete. Render an empty placeholder.+      asyncSetupFailed+        ? [`<!---->`]+        : 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)       }