Backtestsvuerun-20261007-145226#15113
SSR memory leak - options API watchers are created and never stopped with async setup()
Our patch was judged better than the merged fix.
In this judgment, Patch A = our agent, Patch B = the merged fix.
Both patches make the same source change in component.ts. Inside the async setup `.then` callback, each sets `setInSSRSetupState(true)` around `handleSetupResult` and resets it in a `finally` block. This re-establishes SSR setup state while options API (`applyOptions`) runs after async setup, so `watch` option watchers and `$watch` calls in `created` follow the SSR no-op or stop path. That addresses the root cause, and correctness is the same for both. Patch A adds an explanatory comment, a minor craft advantage. On tests, both include the issue's reproduction and a GC retention test. Patch A also covers two more scenarios: a `flush: 'sync'` options watcher and `this.$watch` inside `created()` for an async-setup component. Both exercise the same code path and would fail before the fix, so A's tests check the fix more thoroughly. Scope is equivalent and minimal in both. A wins on test coverage and a small clarity edge.
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
4m 43s
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
126vs 76 merged
Changed lines, ours vs merged
The issue
View on GitHubVue version
3.5.40
Steps to reproduce
originally reported in https://github.com/nuxt/nuxt/issues/30782
- create an options API component with an
async setup(), acomputedproperty that reads shared module-level state, and awatchon that - render it on the server and then mutate the shared state after the render is done
- 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
packages/runtime-core/src/component.tsindex c46741bee..4156a9170 100644@@ -894,7 +894,14 @@ 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 behave as in SSR+ 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..d2082197e 100644@@ -169,6 +169,86 @@ describe('ssr: watch', () => { expect(afterAwaitTriggered).toBe(false) }) + 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('options-api sync watchers should be stopped after render for async setup components', async () => {+ const count = ref(0)+ const spy = vi.fn()++ const App = defineComponent({+ setup: () => Promise.resolve({}),+ watch: {+ count: {+ handler: spy,+ flush: 'sync',+ },+ },+ computed: {+ count() {+ return count.value+ },+ },+ render() {+ return h('div', String(this.count))+ },+ })++ const html = await renderToString(createSSRApp(App))+ expect(html).toBe('<div>0</div>')++ count.value+++ await nextTick()+ expect(spy).not.toHaveBeenCalled()+ })++ test('$watch in created hook should not be live after render for async setup components', async () => {+ const open = ref(true)+ const spy = vi.fn()++ const App = defineComponent({+ setup: () => Promise.resolve({}),+ 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 not run non-immediate watchers registered after async context restore on rejection', async () => { const text = ref('start') let beforeAwaitTriggered = false@@ -351,4 +431,41 @@ describe.skipIf(!global.gc)('ssr: watch gc', () => { expect(weakRefs.filter(ref => ref.deref()).length).toBe(0) })++ test('async setup component with options API watchers should be garbage collected', async () => {+ const open = ref(true)+ const weakRefs: { deref(): unknown | undefined }[] = []++ const Comp = defineComponent({+ setup: () => Promise.resolve({}),+ computed: {+ isOpen() {+ return open.value+ },+ },+ watch: {+ isOpen() {},+ },+ render() {+ return h('div', String(this.isOpen))+ },+ })++ async function renderOnce() {+ const app = createSSRApp(Comp)+ // @ts-expect-error ES2021 API+ weakRefs.push(new WeakRef(app))+ expect(await renderToString(app)).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)+ }) })
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)+ }) })