Backtestsvuerun-20261009-161443#15070

Issue #15070 Merged fix PR #15071 Run 9 Oct 2026 · run-20261009-161443 vuejs/core

SSR memory leak after a render error in a dynamic component

Better

Our patch was judged better than the merged fix.

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

Both patches address the core mechanism. In SSR, a dynamic `<component :is>` is rendered in vnode mode. `renderSlot` calls `openBlock()`, the slot throws, and `currentBlock` is left pointing at a stale array that keeps collecting every vnode created afterwards.

Patch B fixes this precisely where blocks are opened. It unwinds to the previous stack depth in `renderSlot` and `withCtx`, which also covers inline `v-if` blocks. That is a targeted, low-risk fix for the reported scenario. It does nothing for the other retention paths a render error leaves behind:
- the dev warning-context stack is never popped;
- `currentRenderingInstance` stays set after a rethrown render-function error;
- the setup `currentInstance` is not restored;
- SSR watcher handles are never stopped when rendering rejects.

B's test only checks apps created after the failure and uses `expect().rejects`, so it never verifies that the failed app itself is collected.

Patch A attacks the problem at the SSR boundary. It resets the block stack, now correctly clearing `currentBlock` too; the old `blockStack.length = 0` in `renderComponentRoot` left `currentBlock` stale. It also makes cleanup exception-safe: `popWarningContext` in `finally`, restoring the rendering instance when `handleError` rethrows, `resetTracking`/`reset` in `finally` around `setup`, and stopping watchers on failure in both `renderToString` and the stream path.

Resetting the whole stack on an `ssrRender` throw is safe, because the error aborts the synchronous render anyway. A's test matrix is much stronger:
- six failure shapes (slot of a dynamic component, `v-if` branch, plain template, render function, child setup, sync watcher on shared state);
- both `renderToString` and stream rendering;
- the failed app itself is included in the `WeakRef` set.

A is broader, but every addition targets the same class of bug (render-error leaks) and adds little risk. A wins on robustness and test coverage.

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

13m 58s

Wall-clock time in the container

Full test suite

No new failures

3,621 passed · 6 skipped · 3,627 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

442vs 152 merged

Changed lines, ours vs merged

Vue version

3.5.39

Link to minimal reproduction

https://stackblitz.com/edit/vitejs-vite-qfkzyzwp?file=leak.mjs

Steps to reproduce

  • download the reproduction from stackblitz (won't work there, needs to be run locally)
  • run pnpm i && pnpm leak
  • see the heap size & alive app instances grow with each request after the single failed render

The script renders 500 fresh SSR apps, which all get garbage-collected. Then renders one app whose slot content throws, then renders 500 more identical healthy apps, which will never be garbage collected afterwards.

A dynamic component <component :is> with a <slot /> is needed for this to reproduce.

Card

<script setup>
    defineProps({ tag: { type: String, default: 'div' } })
</script>

<template>
    <component :is="tag" class="card">
        <slot />
    </component>
</template>

app:

<script setup>
    defineProps(['payload'])  // one request renders with `payload: null` → throws
</script>

<template>
    <main>
        <Card>{{ payload.title }}</Card>
    </main>
</template>

What is expected?

A failed renderToString should not affect subsequent renders and all apps rendered after it should get garbage collected.

What is actually happening?

Every app created after the single failed render is kept in memory forever.

--- phase 1: 500 healthy renders ---
after 500: created=500 finalized=500 alive=0 heap=20.6MB

--- one crashing render (SSR render error) ---
render rejected as expected: Cannot read properties of null (reading 'title')

--- phase 2: 500 healthy renders (identical to phase 1) ---
after 500: created=1001 finalized=500 alive=501 heap=29.0MB

FINAL: created=1001 finalized=500 alive=501

System Info

Any additional comments?

_No response_

The two patches

Our patch+336 −106
packages/runtime-core/src/component.tsindex c46741bee..aede04199 100644@@ -870,18 +870,24 @@ function setupStatefulComponent(     const setupContext = (instance.setupContext =       setup.length > 1 ? createSetupContext(instance) : null)     const reset = setCurrentInstance(instance)-    const setupResult = callWithErrorHandling(-      setup,-      instance,-      ErrorCodes.SETUP_FUNCTION,-      [-        __DEV__ ? shallowReadonly(instance.props) : instance.props,-        setupContext,-      ],-    )+    let setupResult+    try {+      setupResult = callWithErrorHandling(+        setup,+        instance,+        ErrorCodes.SETUP_FUNCTION,+        [+          __DEV__ ? shallowReadonly(instance.props) : instance.props,+          setupContext,+        ],+      )+    } finally {+      // restore even if setup() throws, so the failed instance isn't left as+      // the current instance / active effect scope+      resetTracking()+      reset()+    }     const isAsyncSetup = isPromise(setupResult)-    resetTracking()-    reset()      if ((isAsyncSetup || instance.sp) && !isAsyncWrapper(instance)) {       // async setup / serverPrefetch, mark as async boundary for useId()packages/runtime-core/src/componentRenderUtils.tsindex 0b46130c0..6d60357df 100644@@ -8,11 +8,11 @@ import {   Comment,   type VNode,   type VNodeArrayChildren,-  blockStack,   cloneVNode,   createVNode,   isVNode,   normalizeVNode,+  resetBlockStack, } from './vnode' import { ErrorCodes, handleError } from './errorHandling' import {@@ -141,8 +141,15 @@ export function renderComponentRoot(         : getFunctionalFallthrough(attrs)     }   } catch (err) {-    blockStack.length = 0-    handleError(err, instance, ErrorCodes.RENDER_FUNCTION)+    resetBlockStack()+    try {+      handleError(err, instance, ErrorCodes.RENDER_FUNCTION)+    } catch (e) {+      // the error is rethrown (e.g. unhandled in dev / SSR): don't leave the+      // failed instance as the current rendering instance+      setCurrentRenderingInstance(prev)+      throw e+    }     result = createVNode(Comment)   } packages/runtime-core/src/index.tsindex 792a28b25..fbc252555 100644@@ -401,7 +401,7 @@ import { } from './component' import { renderComponentRoot } from './componentRenderUtils' import { setCurrentRenderingInstance } from './componentRenderContext'-import { isVNode, normalizeVNode } from './vnode'+import { isVNode, normalizeVNode, resetBlockStack } from './vnode' import { ensureValidVNode } from './helpers/renderSlot' import { popWarningContext, pushWarningContext } from './warning' @@ -416,6 +416,7 @@ const _ssrUtils: {   ensureValidVNode: typeof ensureValidVNode   pushWarningContext: typeof pushWarningContext   popWarningContext: typeof popWarningContext+  resetBlockStack: typeof resetBlockStack } = {   createComponentInstance,   setupComponent,@@ -427,6 +428,7 @@ const _ssrUtils: {   ensureValidVNode,   pushWarningContext,   popWarningContext,+  resetBlockStack, }  /**packages/runtime-core/src/vnode.tsindex b4fe6f237..89e534053 100644@@ -290,6 +290,17 @@ export function closeBlock(): void {   currentBlock = blockStack[blockStack.length - 1] || null } +/**+ * Discard blocks left open by a render that threw before reaching+ * `createBlock`. Otherwise the stale `currentBlock` keeps collecting (and+ * retaining) every vnode created afterwards.+ * @internal+ */+export function resetBlockStack(): void {+  blockStack.length = 0+  currentBlock = null+}+ // Whether we should be tracking dynamic child nodes inside a block. // Only tracks when this value is > 0 // We are not using a simple boolean because this value may need to bepackages/server-renderer/__tests__/ssrRenderErrorGc.spec.tsnew file mode 100644index 000000000..1a07144fc@@ -0,0 +1,164 @@+import {+  type App,+  createSSRApp,+  defineComponent,+  h,+  reactive,+  watch,+} from 'vue'+import { Writable } from 'node:stream'+import { renderToString } from '../src/renderToString'+import { pipeToNodeWritable } from '../src/renderToStream'++const gc = () =>+  new Promise<void>(resolve => {+    setTimeout(() => {+      global.gc!()+      resolve()+    })+  })++const renderToStream = (app: App) =>+  new Promise<string>((resolve, reject) => {+    let result = ''+    pipeToNodeWritable(+      app,+      {},+      new Writable({+        write(chunk, _encoding, callback) {+          result += chunk+          callback()+        },+        final(callback) {+          resolve(result)+          callback()+        },+        destroy(err, callback) {+          if (err) reject(err)+          callback(null)+        },+      }),+    )+  })++const Card = defineComponent({+  props: { tag: { type: String, default: 'div' } },+  template: `<component :is="tag" class="card"><slot /></component>`,+})++// module-level state shared by all requests+const store = reactive({ count: 0 })++const cases: [string, Record<string, any>][] = [+  [+    'slot content of a dynamic component',+    {+      props: ['payload'],+      components: { Card },+      template: `<main><Card>{{ payload.title }}</Card></main>`,+    },+  ],+  [+    'v-if branch in slot of a dynamic component',+    {+      props: ['payload'],+      template: `<main><component :is="'section'"><div v-if="true">{{ payload.title }}</div></component></main>`,+    },+  ],+  [+    'plain template',+    {+      props: ['payload'],+      template: `<main><div>{{ payload.title }}</div></main>`,+    },+  ],+  [+    'render function',+    {+      props: ['payload'],+      render(this: any) {+        return h('main', [h('div', [h('span', this.payload.title)])])+      },+    },+  ],+  [+    'setup of a child component',+    {+      props: ['payload'],+      components: {+        Child: defineComponent({+          props: ['payload'],+          setup(props) {+            const title = props.payload.title+            return () => h('span', title)+          },+        }),+      },+      template: `<main><Child :payload="payload" /></main>`,+    },+  ],+  [+    'component with a sync watcher on shared state',+    {+      props: ['payload'],+      setup() {+        watch(() => store.count, () => {}, { flush: 'sync' })+      },+      template: `<main><div>{{ payload.title }}</div></main>`,+    },+  ],+]++describe.skipIf(!global.gc)('ssr: render error gc', () => {+  describe.each([+    ['renderToString', renderToString],+    ['renderToStream', renderToStream],+  ] as const)('%s', (_, render) => {+    test.each(cases)(+      'should not retain apps after a render error in %s',+      async (_, App) => {+        const weakRefs: { deref(): unknown | undefined }[] = []++        const renderOnce = async (payload: { title: string } | null) => {+          const app = createSSRApp(App, { payload })+          // @ts-expect-error ES2021 API+          weakRefs.push(new WeakRef(app))+          return render(app)+        }++        for (let i = 0; i < 5; i++) {+          expect(await renderOnce({ title: 'ok' })).toContain('ok')+        }++        // not using `expect().rejects` as it keeps the rejected render alive+        let msg = ''+        try {+          await renderOnce(null)+        } catch (e: any) {+          msg = e.message+        }+        expect(msg).toBe(`Cannot read properties of null (reading 'title')`)+        if (!App.template) {+          expect(+            'Unhandled error during execution of render function',+          ).toHaveBeenWarned()+        }+        if (App.components && App.components.Child) {+          expect(+            'Unhandled error during execution of setup function',+          ).toHaveBeenWarned()+        }++        for (let i = 0; i < 5; i++) {+          expect(await renderOnce({ title: 'ok' })).toContain('ok')+        }++        for (let i = 0; i < 5; i++) {+          await gc()+        }++        expect(weakRefs.filter(ref => ref.deref()).length).toBe(0)+      },+    )+  })+})packages/server-renderer/src/render.tsindex 8fc9b0128..4167f7ec7 100644@@ -38,6 +38,7 @@ const {   normalizeVNode,   pushWarningContext,   popWarningContext,+  resetBlockStack, } = ssrUtils  export type SSRBuffer = SSRBufferItem[] & { hasAsync?: boolean }@@ -100,8 +101,12 @@ export function renderComponentVNode(     null,   ))   if (__DEV__) pushWarningContext(vnode)-  const res = setupComponent(instance, true /* isSSR */)-  if (__DEV__) popWarningContext()+  let res+  try {+    res = setupComponent(instance, true /* isSSR */)+  } finally {+    if (__DEV__) popWarningContext()+  }   const hasAsyncSetup = isPromise(res)   let prefetches = instance.sp /* LifecycleHooks.SERVER_PREFETCH */   if (hasAsyncSetup || prefetches) {@@ -130,94 +135,106 @@ function renderComponentSubTree(   if (__DEV__) pushWarningContext(instance.vnode)   const comp = instance.type as Component   const { getBuffer, push } = createBuffer()-  if (isFunction(comp)) {-    let root = renderComponentRoot(instance)-    // #5817 scope ID attrs not falling through if functional component doesn't-    // have props-    if (!(comp as FunctionalComponent).props) {-      for (const key in instance.attrs) {-        if (key.startsWith(`data-v-`)) {-          ;(root.props || (root.props = {}))[key] = ``+  try {+    if (isFunction(comp)) {+      let root = renderComponentRoot(instance)+      // #5817 scope ID attrs not falling through if functional component doesn't+      // have props+      if (!(comp as FunctionalComponent).props) {+        for (const key in instance.attrs) {+          if (key.startsWith(`data-v-`)) {+            ;(root.props || (root.props = {}))[key] = ``+          }         }       }-    }-    renderVNode(push, (instance.subTree = root), instance, slotScopeId)-  } else {-    if (-      (!instance.render || instance.render === NOOP) &&-      !instance.ssrRender &&-      !comp.ssrRender &&-      isString(comp.template)-    ) {-      comp.ssrRender = ssrCompile(comp.template, instance)-    }+      renderVNode(push, (instance.subTree = root), instance, slotScopeId)+    } else {+      if (+        (!instance.render || instance.render === NOOP) &&+        !instance.ssrRender &&+        !comp.ssrRender &&+        isString(comp.template)+      ) {+        comp.ssrRender = ssrCompile(comp.template, instance)+      } -    const ssrRender = instance.ssrRender || comp.ssrRender-    if (ssrRender) {-      // optimized-      // resolve fallthrough attrs-      let attrs = instance.inheritAttrs !== false ? instance.attrs : undefined-      let hasCloned = false+      const ssrRender = instance.ssrRender || comp.ssrRender+      if (ssrRender) {+        // optimized+        // resolve fallthrough attrs+        let attrs = instance.inheritAttrs !== false ? instance.attrs : undefined+        let hasCloned = false -      let cur = instance-      while (true) {-        const scopeId = cur.vnode.scopeId-        if (scopeId) {-          if (!hasCloned) {-            attrs = { ...attrs }-            hasCloned = true+        let cur = instance+        while (true) {+          const scopeId = cur.vnode.scopeId+          if (scopeId) {+            if (!hasCloned) {+              attrs = { ...attrs }+              hasCloned = true+            }+            attrs![scopeId] = ''+          }+          const parent = cur.parent+          if (parent && parent.subTree && parent.subTree === cur.vnode) {+            // parent is a non-SSR compiled component and is rendering this+            // component as root. inherit its scopeId if present.+            cur = parent+          } else {+            break           }-          attrs![scopeId] = ''-        }-        const parent = cur.parent-        if (parent && parent.subTree && parent.subTree === cur.vnode) {-          // parent is a non-SSR compiled component and is rendering this-          // component as root. inherit its scopeId if present.-          cur = parent-        } else {-          break         }-      } -      if (slotScopeId) {-        if (!hasCloned) attrs = { ...attrs }-        const slotScopeIdList = slotScopeId.trim().split(' ')-        for (let i = 0; i < slotScopeIdList.length; i++) {-          attrs![slotScopeIdList[i]] = ''+        if (slotScopeId) {+          if (!hasCloned) attrs = { ...attrs }+          const slotScopeIdList = slotScopeId.trim().split(' ')+          for (let i = 0; i < slotScopeIdList.length; i++) {+            attrs![slotScopeIdList[i]] = ''+          }         }-      } -      // set current rendering instance for asset resolution-      const prev = setCurrentRenderingInstance(instance)-      try {-        ssrRender(-          instance.proxy,+        // set current rendering instance for asset resolution+        const prev = setCurrentRenderingInstance(instance)+        try {+          ssrRender(+            instance.proxy,+            push,+            instance,+            attrs,+            // compiler-optimized bindings+            instance.props,+            instance.setupState,+            instance.data,+            instance.ctx,+          )+        } catch (err) {+          // a vnode-mode slot / branch may have thrown after `openBlock()`;+          // close it so later renders don't leak into the stale block+          resetBlockStack()+          throw err+        } finally {+          setCurrentRenderingInstance(prev)+        }+      } else if (instance.render && instance.render !== NOOP) {+        renderVNode(           push,+          (instance.subTree = renderComponentRoot(instance)),           instance,-          attrs,-          // compiler-optimized bindings-          instance.props,-          instance.setupState,-          instance.data,-          instance.ctx,+          slotScopeId,+        )+      } else {+        const componentName = comp.name || comp.__file || `<Anonymous>`+        warn(+          `Component ${componentName} is missing template or render function.`,         )-      } finally {-        setCurrentRenderingInstance(prev)+        push(`<!---->`)       }-    } else if (instance.render && instance.render !== NOOP) {-      renderVNode(-        push,-        (instance.subTree = renderComponentRoot(instance)),-        instance,-        slotScopeId,-      )-    } else {-      const componentName = comp.name || comp.__file || `<Anonymous>`-      warn(`Component ${componentName} is missing template or render function.`)-      push(`<!---->`)     }+  } finally {+    // always pop, so a render error doesn't leave this vnode (and its whole+    // app) referenced from the warning context stack+    if (__DEV__) popWarningContext()   }-  if (__DEV__) popWarningContext()   return getBuffer() } packages/server-renderer/src/renderToStream.tsindex cb5ef75e0..392c63cac 100644@@ -9,7 +9,7 @@ import { import { isPromise, isString } from '@vue/shared' import { type SSRBuffer, type SSRContext, renderComponentVNode } from './render' import type { Readable, Writable } from 'node:stream'-import { resolveTeleports } from './renderToString'+import { resolveTeleports, stopWatchers } from './renderToString'  const { isVNode } = ssrUtils @@ -73,17 +73,29 @@ export function renderToSimpleStream<T extends SimpleReadable>(   // provide the ssr context to the tree   input.provide(ssrContextKey, context) -  Promise.resolve(renderComponentVNode(vnode))+  let res: ReturnType<typeof renderComponentVNode>+  try {+    res = renderComponentVNode(vnode)+  } catch (error) {+    // also stop on failure, otherwise watched sources keep the app alive+    stopWatchers(context)+    throw error+  }++  Promise.resolve(res)     .then(buffer => unrollBuffer(buffer, stream))     .then(() => resolveTeleports(context))-    .then(() => {-      if (context.__watcherHandles) {-        for (const unwatch of context.__watcherHandles) {-          unwatch()-        }-      }-    })-    .then(() => stream.push(null))+    .then(+      () => {+        stopWatchers(context)+        stream.push(null)+      },+      error => {+        // also stop on failure, otherwise watched sources keep the app alive+        stopWatchers(context)+        throw error+      },+    )     .catch(error => {       stream.destroy(error)     })packages/server-renderer/src/renderToString.tsindex 83d659bd9..c2eec5a59 100644@@ -81,19 +81,26 @@ export async function renderToString(   vnode.appContext = input._context   // provide the ssr context to the tree   input.provide(ssrContextKey, context)-  const buffer = await renderComponentVNode(vnode)+  try {+    const buffer = await renderComponentVNode(vnode) -  const result = await unrollBuffer(buffer as SSRBuffer)+    const result = await unrollBuffer(buffer as SSRBuffer) -  await resolveTeleports(context)+    await resolveTeleports(context) +    return result+  } finally {+    // also stop on failure, otherwise watched sources keep the app alive+    stopWatchers(context)+  }+}++export function stopWatchers(context: SSRContext): void {   if (context.__watcherHandles) {     for (const unwatch of context.__watcherHandles) {       unwatch()     }   }--  return result }  export async function resolveTeleports(context: SSRContext): Promise<void> {vitest.config.tsindex 2fbc92f92..9b9c8a5a0 100644@@ -58,6 +58,7 @@ export default defineConfig({             '**/e2e/**',             '**/{vue,vue-compat,runtime-dom}/**',             'packages/server-renderer/__tests__/ssrWatch.spec.ts',+            'packages/server-renderer/__tests__/ssrRenderErrorGc.spec.ts',           ],         },       },@@ -66,7 +67,10 @@ export default defineConfig({         test: {           name: 'unit-gc',           pool: 'forks',-          include: ['packages/server-renderer/__tests__/ssrWatch.spec.ts'],+          include: [+            'packages/server-renderer/__tests__/ssrWatch.spec.ts',+            'packages/server-renderer/__tests__/ssrRenderErrorGc.spec.ts',+          ],           execArgv: ['--expose-gc'],         },       }, 
Merged fix · PR #15071+128 −24
packages/runtime-core/src/componentRenderContext.tsindex b1fc70c03..d10eba648 100644@@ -1,6 +1,6 @@ import type { ComponentInternalInstance } from './component' import { devtoolsComponentUpdated } from './devtools'-import { setBlockTracking } from './vnode'+import { blockStack, closeBlock, setBlockTracking } from './vnode'  /**  * mark the current rendering instance for asset resolution (e.g.@@ -89,10 +89,14 @@ export function withCtx(       setBlockTracking(-1)     }     const prevInstance = setCurrentRenderingInstance(ctx)+    const prevStackSize = blockStack.length     let res     try {       res = fn(...args)     } finally {+      // close blocks left dangling when the slot throws mid-block+      // inline blocks (for example `v-if`) have no helper to unwind themselves (#15070)+      for (let i = blockStack.length; i > prevStackSize; i--) closeBlock()       setCurrentRenderingInstance(prevInstance)       if (renderFnWithContext._d) {         setBlockTracking(1)packages/runtime-core/src/helpers/renderSlot.tsindex 2f1296bb1..8f65f8af4 100644@@ -9,6 +9,8 @@ import {   Fragment,   type VNode,   type VNodeArrayChildren,+  blockStack,+  closeBlock,   createBlock,   createVNode,   isVNode,@@ -71,32 +73,42 @@ export function renderSlot(   if (slot && (slot as ContextualRenderFn)._c) {     ;(slot as ContextualRenderFn)._d = false   }+  const prevStackSize = blockStack.length   openBlock()-  const validSlotContent = slot && ensureValidVNode(slot(props))-  const slotKey =-    props.key ||-    // slot content array of a dynamic conditional slot may have a branch-    // key attached in the `createSlots` helper, respect that-    (validSlotContent && (validSlotContent as any).key)-  const rendered = createBlock(-    Fragment,-    {-      key:-        (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) +-        // #7256 force differentiate fallback content from actual content-        (!validSlotContent && fallback ? '_fb' : ''),-    },-    validSlotContent || (fallback ? fallback() : []),-    validSlotContent && (slots as RawSlots)._ === SlotFlags.STABLE-      ? PatchFlags.STABLE_FRAGMENT-      : PatchFlags.BAIL,-  )+  let rendered: VNode+  try {+    const validSlotContent = slot && ensureValidVNode(slot(props))+    const slotKey =+      props.key ||+      // slot content array of a dynamic conditional slot may have a branch+      // key attached in the `createSlots` helper, respect that+      (validSlotContent && (validSlotContent as any).key)+    rendered = createBlock(+      Fragment,+      {+        key:+          (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) ++          // #7256 force differentiate fallback content from actual content+          (!validSlotContent && fallback ? '_fb' : ''),+      },+      validSlotContent || (fallback ? fallback() : []),+      validSlotContent && (slots as RawSlots)._ === SlotFlags.STABLE+        ? PatchFlags.STABLE_FRAGMENT+        : PatchFlags.BAIL,+    )+  } catch (err) {+    // close blocks left dangling when the slot throws mid-block+    // they would otherwise retain every vnode created afterwards (#15070)+    for (let i = blockStack.length; i > prevStackSize; i--) closeBlock()+    throw err+  } finally {+    if (slot && (slot as ContextualRenderFn)._c) {+      ;(slot as ContextualRenderFn)._d = true+    }+  }   if (!noSlotted && rendered.scopeId) {     rendered.slotScopeIds = [rendered.scopeId + '-s']   }-  if (slot && (slot as ContextualRenderFn)._c) {-    ;(slot as ContextualRenderFn)._d = true-  }   return rendered } packages/server-renderer/__tests__/ssrRender.spec.tsnew file mode 100644index 000000000..2d23452a3@@ -0,0 +1,84 @@+import { createSSRApp } from 'vue'+import { renderToString } from '../src/renderToString'++const gc = () =>+  new Promise<void>(resolve => {+    setTimeout(() => {+      global.gc!()+      resolve()+    })+  })++const Card = {+  props: { tag: { type: String, default: 'div' } },+  template: `<component :is="tag" class="card"><slot /></component>`,+}++const Page = {+  components: { Card },+  props: ['payload'],+  template: `<main><Card>{{ payload.title }}</Card></main>`,+}++describe.skipIf(!global.gc)('ssr: render error leak', () => {+  // #15070+  test('should GC apps created after a render error in a forwarded slot', async () => {+    const createApp = (payload: any) => createSSRApp(Page, { payload })++    expect(await renderToString(createApp({ title: 'ok' }))).toContain('ok')++    await expect(renderToString(createApp(null))).rejects.toThrow(+      `Cannot read properties of null`,+    )++    const weakRefs: { deref(): unknown | undefined }[] = []+    const renderOnce = async () => {+      const app = createApp({ title: 'ok' })+      // @ts-expect-error ES2021 API+      weakRefs.push(new WeakRef(app))+      expect(await renderToString(app)).toContain('ok')+    }+    for (let i = 0; i < 20; i++) {+      await renderOnce()+    }++    for (let i = 0; i < 5; i++) {+      await gc()+    }++    expect(weakRefs.filter(ref => ref.deref()).length).toBe(0)+  })++  test('should GC apps created after a render error in an inline block (`v-if`)', async () => {+    const PageIf = {+      props: ['payload'],+      template: `<component :is="'div'"><div v-if="payload.list">{{ payload.list.missing.x }}</div></component>`,+    }+    const createApp = (payload: any) => createSSRApp(PageIf, { payload })++    expect(+      await renderToString(createApp({ list: { missing: { x: 'ok' } } })),+    ).toContain('ok')++    await expect(renderToString(createApp({ list: {} }))).rejects.toThrow(+      `Cannot read properties of undefined`,+    )++    const weakRefs: { deref(): unknown | undefined }[] = []+    const renderOnce = async () => {+      const app = createApp({ list: { missing: { x: 'ok' } } })+      // @ts-expect-error ES2021 API+      weakRefs.push(new WeakRef(app))+      expect(await renderToString(app)).toContain('ok')+    }+    for (let i = 0; i < 20; i++) {+      await renderOnce()+    }++    for (let i = 0; i < 5; i++) {+      await gc()+    }++    expect(weakRefs.filter(ref => ref.deref()).length).toBe(0)+  })+})vitest.config.tsindex 2fbc92f92..8e1f5bec8 100644@@ -58,6 +58,7 @@ export default defineConfig({             '**/e2e/**',             '**/{vue,vue-compat,runtime-dom}/**',             'packages/server-renderer/__tests__/ssrWatch.spec.ts',+            'packages/server-renderer/__tests__/ssrRender.spec.ts',           ],         },       },@@ -66,7 +67,10 @@ export default defineConfig({         test: {           name: 'unit-gc',           pool: 'forks',-          include: ['packages/server-renderer/__tests__/ssrWatch.spec.ts'],+          include: [+            'packages/server-renderer/__tests__/ssrWatch.spec.ts',+            'packages/server-renderer/__tests__/ssrRender.spec.ts',+          ],           execArgv: ['--expose-gc'],         },       },