Backtestsvuerun-20261005-124535#15113

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

SSR memory leak - options API watchers are created and never stopped with async setup()

Better

Our patch was judged better than the merged fix.

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

Both patches fix the root cause the same way. In the async-setup `.then` branch, they put the SSR setup state back to true around `handleSetupResult`, so `applyOptions` creates watchers under the same SSR rules as a sync setup: no live non-immediate watchers, and sync-flush handles registered for cleanup. Correctness is essentially equal. Patch A saves and restores the previous `isInSSRComponentSetup` value instead of hard-resetting to false. That is slightly more robust against nesting or interleaving, though Patch B's reset matches the existing sync-path convention and is very likely safe in practice. The main difference is the tests. Patch A covers several cases that would fail before the fix: the issue's `watch` option case (also asserting no `__watcherHandles`), `this.$watch` inside `created`, an `immediate: true` watcher that runs exactly once and is not kept alive, and a `flush: 'sync'` watcher that is registered in `__watcherHandles` and stopped after render. Together these check that async setup now matches sync-setup SSR semantics. Patch B adds the issue's reproduction plus a GC-based retention test. That test is directly relevant to the memory-leak symptom, but it only runs when `global.gc` is exposed, so it is often skipped. Scope is equally tight in both. Patch A wins on the broader, more behavior-specific test coverage and the slightly more defensive state restoration.

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

6m 54s

Wall-clock time in the container

Full test suite

No new failures

3,630 passed · 6 skipped · 3,636 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

125vs 76 merged

Changed lines, ours vs merged

Vue version

3.5.40

Steps to reproduce

originally reported in https://github.com/nuxt/nuxt/issues/30782

  1. create an options API component with an async setup(), a computed property that reads shared module-level state, and a watch on that
  2. render it on the server and then mutate the shared state after the render is done
  3. see that the watcher is still active on the server

Reproduction

test('options-api watchers should not be created for async setup components', async () => {
  const open = ref(true)
  const spy = vi.fn()

  const App = defineComponent({
    setup: () => Promise.resolve({}),
    computed: {
      isOpen() {
        return open.value
      },
    },
    watch: {
      isOpen: spy,
    },
    render() {
      return h('div', String(this.isOpen))
    },
  })

  const html = await renderToString(createSSRApp(App))
  expect(html).toBe('<div>true</div>')

  // mutating the state after the request is done should not trigger the watcher
  open.value = false
  await nextTick()
  expect(spy).not.toHaveBeenCalled()
})

What is expected?

the same behavior as with a synchronous setup: regular watchers declared via the watch option don't run during SSR and don't survive the render

mutating the shared state after renderToString resolves should not trigger anything

What is actually happening?

when setup() returns a Promise, the watch option creates a live watcher on the server that is never stopped

if this subscribes to state that outlives the request, it keeps the entire component instance (and app) reachable forever

System Info

Any additional comments?

_No response_

The two patches

Our patch+124 −1
packages/runtime-core/src/component.tsindex c46741bee..c89370172 100644@@ -894,7 +894,16 @@ function setupStatefulComponent(         // return the promise so server-renderer can wait on it         return setupResult           .then((resolvedResult: unknown) => {-            handleSetupResult(instance, resolvedResult, isSSR)+            // restore SSR setup state so that options API (watch, computed,+            // lifecycle hooks) applied after async setup behaves the same+            // as with a sync setup+            const prevSSRSetupState = isInSSRComponentSetup+            setInSSRSetupState(true)+            try {+              handleSetupResult(instance, resolvedResult, isSSR)+            } finally {+              setInSSRSetupState(prevSSRSetupState)+            }           })           .catch(e => {             handleError(e, instance, ErrorCodes.SETUP_FUNCTION)packages/server-renderer/__tests__/ssrWatch.spec.tsindex 2b1ad98d2..0b5508358 100644@@ -294,6 +294,120 @@ describe('ssr: watchEffect', () => {   }) }) +// nuxt/nuxt#30782+describe('ssr: options API watch w/ async setup', () => {+  test('should not create watchers declared via the watch option', async () => {+    const open = ref(true)+    const spy = vi.fn()++    const App = defineComponent({+      setup: () => Promise.resolve({}),+      computed: {+        isOpen(): boolean {+          return open.value+        },+      },+      watch: {+        isOpen: spy,+      },+      render() {+        return h('div', String(this.isOpen))+      },+    })++    const ctx: SSRContext = {}+    const html = await renderToString(createSSRApp(App), ctx)+    expect(html).toBe('<div>true</div>')+    expect(ctx.__watcherHandles).toBeUndefined()++    // mutating the state after the request is done should not trigger the watcher+    open.value = false+    await nextTick()+    expect(spy).not.toHaveBeenCalled()+  })++  test('should not create watchers via this.$watch in created', async () => {+    const open = ref(true)+    const spy = vi.fn()++    const App = defineComponent({+      async setup() {+        return {}+      },+      created() {+        this.$watch(() => open.value, spy)+      },+      render() {+        return h('div', String(open.value))+      },+    })++    const html = await renderToString(createSSRApp(App))+    expect(html).toBe('<div>true</div>')++    open.value = false+    await nextTick()+    expect(spy).not.toHaveBeenCalled()+  })++  test('should run immediate watch option once and not keep it alive', async () => {+    const open = ref(true)+    const spy = vi.fn()++    const App = defineComponent({+      setup: () => Promise.resolve({}),+      watch: {+        open: {+          handler: spy,+          immediate: true,+        },+      },+      data: () => ({ open }),+      render() {+        return h('div', String(this.open))+      },+    })++    const ctx: SSRContext = {}+    const html = await renderToString(createSSRApp(App), ctx)+    expect(html).toBe('<div>true</div>')+    expect(spy).toHaveBeenCalledTimes(1)+    expect(ctx.__watcherHandles).toBeUndefined()++    open.value = false+    await nextTick()+    expect(spy).toHaveBeenCalledTimes(1)+  })++  test('should register flush: sync watch option for cleanup', async () => {+    const open = ref(true)+    const spy = vi.fn()++    const App = defineComponent({+      setup: () => Promise.resolve({}),+      watch: {+        open: {+          handler: spy,+          flush: 'sync',+        },+      },+      data: () => ({ open }),+      render() {+        return h('div', String(this.open))+      },+    })++    const ctx: SSRContext = {}+    const html = await renderToString(createSSRApp(App), ctx)+    expect(html).toBe('<div>true</div>')+    expect(ctx.__watcherHandles!.length).toBe(1)++    // the handle is stopped after render+    open.value = false+    expect(spy).not.toHaveBeenCalled()+  })+})+ describe.skipIf(!global.gc)('ssr: watch gc', () => {   test('should not retain apps when a watcher stop handle is registered with onScopeDispose after async context restore', async () => {     const weakRefs: { deref(): unknown | undefined }[] = [] 
Merged fix · PR #15114+75 −1
packages/runtime-core/src/component.tsindex c46741bee..162a6ad44 100644@@ -894,7 +894,12 @@ function setupStatefulComponent(         // return the promise so server-renderer can wait on it         return setupResult           .then((resolvedResult: unknown) => {-            handleSetupResult(instance, resolvedResult, isSSR)+            setInSSRSetupState(true)+            try {+              handleSetupResult(instance, resolvedResult, isSSR)+            } finally {+              setInSSRSetupState(false)+            }           })           .catch(e => {             handleError(e, instance, ErrorCodes.SETUP_FUNCTION)packages/server-renderer/__tests__/ssrWatch.spec.tsindex 2b1ad98d2..2dad83cd2 100644@@ -130,6 +130,35 @@ describe('ssr: watch', () => {     expect(msg).toBe('start')   }) +  // #15113+  test('options-api watchers should not be created for async setup components', async () => {+    const open = ref(true)+    const spy = vi.fn()++    const App = defineComponent({+      setup: () => Promise.resolve({}),+      computed: {+        isOpen() {+          return open.value+        },+      },+      watch: {+        isOpen: spy,+      },+      render() {+        return h('div', String(this.isOpen))+      },+    })++    const html = await renderToString(createSSRApp(App))+    expect(html).toBe('<div>true</div>')++    // mutating the state after the request is done should not trigger the watcher+    open.value = false+    await nextTick()+    expect(spy).not.toHaveBeenCalled()+  })+   test('should not run non-immediate watchers registered after async context restore', async () => {     const text = ref('start')     let beforeAwaitTriggered = false@@ -351,4 +380,44 @@ describe.skipIf(!global.gc)('ssr: watch gc', () => {      expect(weakRefs.filter(ref => ref.deref()).length).toBe(0)   })++  // #15113+  test('options-api should not retain apps with async setup + watcher on global state', async () => {+    const weakRefs: { deref(): unknown | undefined }[] = []++    const open = ref(true)++    const App = defineComponent({+      setup: () => Promise.resolve({}),+      computed: {+        isOpen() {+          return open.value+        },+      },+      watch: {+        isOpen() {},+      },+      render() {+        return h('div', String(this.isOpen))+      },+    })++    async function renderOnce() {+      const app = createSSRApp(App)+      // @ts-expect-error ES2021 API+      weakRefs.push(new WeakRef(app))+      const html = await renderToString(app)+      expect(html).toBe('<div>true</div>')+    }++    for (let i = 0; i < 10; i++) {+      await renderOnce()+    }++    for (let i = 0; i < 5; i++) {+      await gc()+    }++    expect(weakRefs.filter(ref => ref.deref()).length).toBe(0)+  }) })