Backtestsvuerun-20261009-161443#15142
Suspense: flushing buffered effects overflows the call stack when many effects accumulate while pending (RangeError: Maximum call stack size exceeded)
Our patch was judged better than the merged fix.
In this judgment, Patch B = our agent, Patch A = the merged fix.
Both patches fix the three spread-push sites the issue names: `queuePostFlushCb`, the nested `flushPostFlushCbs` merge into `activePostFlushCbs`, and the Suspense merge into a pending parent. Each replaces the spread with an indexed loop, so on those sites they are equivalent and correct. Patch B also fixes a fourth site on the same buffering path that the issue does not list: `queueEffectWithSuspense` does `suspense.effects.push(...fn)` when `fn` is an array of lifecycle hooks. A large enough hook array would still overflow there under a pending suspense. This is low-risk hardening of the code that fills `suspense.effects`, and B tests it directly with a component registering 500k `onMounted` hooks. On tests, A adds two scheduler unit tests with 1M-entry arrays. They cover `queuePostFlushCb` and the nested active-flush merge, and would fail before the fix. B adds equivalent scheduler tests. It also adds Suspense integration tests that reproduce the issue end to end: an async dependency plus a tree buffering 500k post effects, then flushing on resolve. One of these covers nested suspense, where the inner boundary resolves first and merges into the pending outer one. That exercises the `parent.effects` merge path, which A's tests never touch, so A's Suspense change is untested. B's tests are heavier to run but much closer to the reported scenario. Craft is comparable: both use clear comments and simple loops consistent with the surrounding code. B wins on broader coverage of the overflow sites and more faithful regression 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
5m 40s
Wall-clock time in the container
Full test suite
No new failures
1,747 passed · 1 skipped · 1,748 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
218vs 55 merged
Changed lines, ours vs merged
The issue
View on GitHubVue version
3.5.39 (also reproduces on 3.5.40 / @b5f8518 in the playground)
Link to minimal reproduction
Steps to reproduce
- Open the playground and show the Preview pane.
- The app renders a
<Suspense>whose default slot contains an async component (resolves after ~4s) plus a large tree (2000 rows, each with a fewflush: 'post'watchers). - While the suspense is pending, a timer keeps mutating a ref, so the still-mounted tree re-renders repeatedly. Each re-render buffers its post effects into
suspense.effects(viaqueueEffectWithSuspense). - When the async component resolves, the suspense flushes the buffered effects.
What is expected?
The buffered effects flush and the app keeps working.
What is actually happening?
Uncaught (in promise): RangeError: Maximum call stack size exceeded — thrown from queuePostFlushCb called by suspense.resolve():
RangeError: Maximum call stack size exceeded
at queuePostFlushCb (runtime-core.esm-bundler.js:331)
at Object.resolve (runtime-core.esm-bundler.js:7426)
The scheduler dies mid-flush, leaving the app permanently wedged (blank page).
Root cause
suspense.effects is unbounded — every post effect of every component under a pending suspense boundary is buffered into it. On resolve, the whole array is flushed with a spread call:
scheduler.ts:pendingPostFlushCbs.push(...cb)scheduler.ts(flushPostFlushCbsnested case):activePostFlushCbs.push(...deduped)Suspense.ts(merge into pending parent):parent.effects.push(...effects)
Spreading an array into a function call is limited by the engine's call stack (~100k–200k args in V8), so once enough effects accumulate the flush itself throws.
Real-world impact
We hit this in production in a Nuxt app: a kanban board page with ~1000 mounted cards that re-renders once per second (elapsed-time ticker). Navigating to another page keeps the board mounted under <NuxtPage>'s pending Suspense; its buffered effects exceed the spread limit and every SPA navigation away from the board crashes with a permanent white screen (hard reload of the target URL works fine, since there is no pending suspense in that case).
Suggested fix
Replace the unbounded spread pushes with plain loops. I have a PR ready with the fix and a regression test (queuePostFlushCb with a 1M-entry array).
The two patches
packages/runtime-core/__tests__/components/Suspense.spec.tsindex d40f85b86..e4d0f2aca 100644@@ -683,6 +683,164 @@ describe('Suspense', () => { expect(calls).toEqual([`outer mounted`, `inner mounted`]) }) + describe('flushing a large number of buffered effects', () => {+ const componentCount = 1000+ const hooksPerComponent = 500+ const count = componentCount * hooksPerComponent++ // a sync tree that buffers a large number of post effects into the+ // pending suspense boundary+ const createManyHooks = (counter: { calls: number }) => {+ const Child = {+ setup() {+ for (let i = 0; i < hooksPerComponent; i++) {+ onMounted(() => {+ counter.calls+++ })+ }+ return () => null+ },+ }+ return {+ setup() {+ return () =>+ h('div', Array.from({ length: componentCount }, () => h(Child)))+ },+ }+ }++ test('should not overflow the call stack on resolve', async () => {+ const counter = { calls: 0 }+ const ManyHooks = createManyHooks(counter)+ const Async = defineAsyncComponent({+ render() {+ return h('div', 'async')+ },+ })++ const Comp = {+ setup() {+ return () =>+ h(Suspense, null, {+ default: h('div', [h(Async), h(ManyHooks)]),+ fallback: h('div', 'fallback'),+ })+ },+ }++ const root = nodeOps.createElement('div')+ render(h(Comp), root)+ expect(serializeInner(root)).toBe(`<div>fallback</div>`)+ expect(counter.calls).toBe(0)++ await Promise.all(deps)+ await nextTick()+ expect(serializeInner(root)).toBe(+ `<div><div>async</div><div>${'<!---->'.repeat(componentCount)}</div></div>`,+ )+ expect(counter.calls).toBe(count)+ })++ test('should not overflow the call stack when buffering a large hook array', async () => {+ let calls = 0+ const Child = {+ setup() {+ for (let i = 0; i < count; i++) {+ onMounted(() => {+ calls+++ })+ }+ return () => h('div', 'child')+ },+ }+ const Async = defineAsyncComponent({+ render() {+ return h('div', 'async')+ },+ })++ const Comp = {+ setup() {+ return () =>+ h(Suspense, null, {+ default: h('div', [h(Async), h(Child)]),+ fallback: h('div', 'fallback'),+ })+ },+ }++ const root = nodeOps.createElement('div')+ render(h(Comp), root)+ expect(serializeInner(root)).toBe(`<div>fallback</div>`)+ expect(calls).toBe(0)++ await Promise.all(deps)+ await nextTick()+ expect(serializeInner(root)).toBe(+ `<div><div>async</div><div>child</div></div>`,+ )+ expect(calls).toBe(count)+ })++ test('should not overflow the call stack when merging into pending parent suspense', async () => {+ const counter = { calls: 0 }+ const ManyHooks = createManyHooks(counter)+ const AsyncOuter = defineAsyncComponent(+ {+ render() {+ return h('div', 'async outer')+ },+ },+ 10,+ )+ const AsyncInner = defineAsyncComponent(+ {+ render() {+ return h('div', 'async inner')+ },+ },+ 1,+ )++ const Inner = {+ setup() {+ return () =>+ h(Suspense, null, {+ default: h('div', [h(AsyncInner), h(ManyHooks)]),+ fallback: h('div', 'fallback inner'),+ })+ },+ }++ const Comp = {+ setup() {+ return () =>+ h(Suspense, null, {+ default: h('div', [h(AsyncOuter), h(Inner)]),+ fallback: h('div', 'fallback outer'),+ })+ },+ }++ const root = nodeOps.createElement('div')+ render(h(Comp), root)+ expect(serializeInner(root)).toBe(`<div>fallback outer</div>`)++ // inner resolves first, its effects are merged into the pending outer+ await deps[1]+ await nextTick()+ expect(serializeInner(root)).toBe(`<div>fallback outer</div>`)+ expect(counter.calls).toBe(0)++ await Promise.all(deps)+ await nextTick()+ expect(serializeInner(root)).toBe(+ `<div><div>async outer</div><div><div>async inner</div><div>${'<!---->'.repeat(componentCount)}</div></div></div>`,+ )+ expect(counter.calls).toBe(count)+ })+ })+ test('nested suspense (child resolves first)', async () => { const calls: string[] = [] packages/runtime-core/__tests__/scheduler.spec.tsindex 3e454aec0..f61daeb4d 100644@@ -341,6 +341,21 @@ describe('scheduler', () => { await nextTick() expect(calls).toEqual(['cb1', 'cb2']) })++ it('should not overflow the call stack with a large array of cbs', async () => {+ const count = 1_000_000+ let calls = 0+ const cbs: (() => void)[] = []+ for (let i = 0; i < count; i++) {+ cbs.push(() => {+ calls+++ })+ }++ expect(() => queuePostFlushCb(cbs)).not.toThrow()+ await nextTick()+ expect(calls).toBe(count)+ }) }) describe('queueJob w/ queuePostFlushCb', () => {@@ -747,6 +762,29 @@ describe('scheduler', () => { expect(count).toBe(1) }) + test('nested flushPostFlushCbs with a large number of cbs', async () => {+ const count = 1_000_000+ let calls = 0+ const cbs: (() => void)[] = []+ for (let i = 0; i < count; i++) {+ cbs.push(() => {+ calls+++ })+ }++ queuePostFlushCb(() => {+ // nested flush while the post flush queue is active: the pending cbs+ // are merged into the active queue+ for (let i = 0; i < count; i++) {+ queuePostFlushCb(cbs[i])+ }+ flushPostFlushCbs()+ })++ await nextTick()+ expect(calls).toBe(count)+ })+ // #910 test('should not run stopped reactive effects', async () => { const spy = vi.fn()packages/runtime-core/src/components/Suspense.tsindex ba5e194ae..a247528f9 100644@@ -617,7 +617,12 @@ function createSuspenseBoundary( if (parent.pendingBranch) { // found a pending parent suspense, merge buffered post jobs // into that parent- parent.effects.push(...effects)+ // avoid spread push: effects can be large enough to overflow the+ // call stack+ const parentEffects = parent.effects+ for (let i = 0; i < effects.length; i++) {+ parentEffects.push(effects[i])+ } hasUnresolvedAncestor = true break }@@ -906,7 +911,10 @@ export function queueEffectWithSuspense( ): void { if (suspense && suspense.pendingBranch) { if (isArray(fn)) {- suspense.effects.push(...fn)+ const effects = suspense.effects+ for (let i = 0; i < fn.length; i++) {+ effects.push(fn[i])+ } } else { suspense.effects.push(fn) }packages/runtime-core/src/scheduler.tsindex af6752078..93e41ed32 100644@@ -134,7 +134,11 @@ export function queuePostFlushCb(cb: SchedulerJobs): void { // if cb is an array, it is a component lifecycle hook which can only be // triggered by a job, which is already deduped in the main queue, so // we can skip duplicate check here to improve perf- pendingPostFlushCbs.push(...cb)+ // avoid spread push: large arrays (e.g. buffered suspense effects) can+ // exceed the engine's max call arguments and overflow the stack+ for (let i = 0; i < cb.length; i++) {+ pendingPostFlushCbs.push(cb[i])+ } } queueFlush() }@@ -179,7 +183,9 @@ export function flushPostFlushCbs(seen?: CountMap): void { // #1947 already has active queue, nested flushPostFlushCbs call if (activePostFlushCbs) {- activePostFlushCbs.push(...deduped)+ for (let i = 0; i < deduped.length; i++) {+ activePostFlushCbs.push(deduped[i])+ } return }
packages/runtime-core/__tests__/scheduler.spec.tsindex 3e454aec0..000a0d578 100644@@ -303,6 +303,44 @@ describe('scheduler', () => { expect(calls).toEqual(['cb1', 'cb2', 'cb3']) }) + it('should not overflow the call stack with a very large cb array', async () => {+ // a suspense boundary can buffer an unbounded number of post effects+ // while pending (e.g. a large tree re-rendering under it) and flush them+ // all at once on resolve - spreading such an array into push() throws+ // RangeError: Maximum call stack size exceeded+ let called = 0+ const cbs: SchedulerJob[] = []+ for (let i = 0; i < 1000000; i++) {+ cbs.push(() => {+ called+++ })+ }++ queuePostFlushCb(cbs)+ await nextTick()+ expect(called).toBe(1000000)+ })++ it('should not overflow the call stack when merging a very large cb array into an active flush', async () => {+ // same as above, but the large array is queued while a post flush is+ // already in progress, exercising the merge into activePostFlushCbs+ // inside a nested flushPostFlushCbs call+ let called = 0+ const cbs: SchedulerJob[] = []+ for (let i = 0; i < 1000000; i++) {+ cbs.push(() => {+ called+++ })+ }++ queuePostFlushCb(() => {+ queuePostFlushCb(cbs)+ flushPostFlushCbs()+ })+ await nextTick()+ expect(called).toBe(1000000)+ })+ it('should dedupe queued postFlushCb', async () => { const calls: string[] = [] const cb1 = () => {packages/runtime-core/src/components/Suspense.tsindex ba5e194ae..37e5067ff 100644@@ -617,7 +617,9 @@ function createSuspenseBoundary( if (parent.pendingBranch) { // found a pending parent suspense, merge buffered post jobs // into that parent- parent.effects.push(...effects)+ for (let i = 0; i < effects.length; i++) {+ parent.effects.push(effects[i])+ } hasUnresolvedAncestor = true break }packages/runtime-core/src/scheduler.tsindex af6752078..4355018a0 100644@@ -133,8 +133,13 @@ export function queuePostFlushCb(cb: SchedulerJobs): void { } else { // if cb is an array, it is a component lifecycle hook which can only be // triggered by a job, which is already deduped in the main queue, so- // we can skip duplicate check here to improve perf- pendingPostFlushCbs.push(...cb)+ // we can skip duplicate check here to improve perf.+ // use a loop instead of `push(...cb)`: the array can be arbitrarily large+ // (e.g. effects buffered by a suspense boundary) and spreading it would+ // overflow the call stack (#15142)+ for (let i = 0; i < cb.length; i++) {+ pendingPostFlushCbs.push(cb[i])+ } } queueFlush() }@@ -179,7 +184,9 @@ export function flushPostFlushCbs(seen?: CountMap): void { // #1947 already has active queue, nested flushPostFlushCbs call if (activePostFlushCbs) {- activePostFlushCbs.push(...deduped)+ for (let i = 0; i < deduped.length; i++) {+ activePostFlushCbs.push(deduped[i])+ } return }