Backtestsvuerun-20261003-231210#15332

Issue #15332 Merged fix PR #15333 Run 3 Oct 2026 · run-20261003-231210 vuejs/core

Suspense timeout + Transition out-in: parent update during the fallback swap permanently drops the resolved branch

Better

Our patch was judged better than the merged fix.

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

The two source changes are essentially the same. Both skip the `patch(activeBranch, newFallback)` and `setActiveBranch` calls in both `isInFallback` paths of `patchSuspense` while `isFallbackMountPending` is set. Both also make the deferred `mountFallback` mount the latest fallback vnode (`suspense.vnode.ssFallback`) instead of the stale closure-captured one. This matches the root cause in the issue: the leaving content stays as `activeBranch`, so `resolve()` hooks onto the correct `afterLeave`. It also covers the follow-on problem that skipping the patch would otherwise mount a stale fallback.

The one code difference is small. A writes `suspense.vnode.ssFallback || fallbackVNode`, which falls back to the old value safely. B uses a non-null assertion. Both work in practice, but A is slightly more defensive.

Tests are where they meaningfully differ. A adds deterministic unit tests in Suspense.spec using `BaseTransition` with a manually held `onLeave` `done` callback, so the exact event ordering from the issue is reproduced without timing dependence. A covers three scenarios:
- resolve before the leave finishes (the reported bug);
- the leave finishing before resolve, checking that the latest fallback ('fallback 1') is mounted;
- the pending branch being toggled during the leave, which exercises the second guarded path in the toggle branch.

B adds two e2e tests driven by real timeouts and `transitionFinish` waits. These are more timing-sensitive and slower. They do not exercise the pending-branch-toggle path, and their assertions are looser (`toContain('two')`). A's tests are more targeted, more robust, and cover more of the changed code paths.

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 6s

Wall-clock time in the container

Full test suite

No new failures

3,700 passed · 6 skipped · 3,707 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

143vs 170 merged

Changed lines, ours vs merged

Version

3.5.41

Reproduction link

play.vuejs.org/

Steps to reproduce

Open the playground with Vue 3.5.41 selected (the banner in the preview shows the actually running version). The repro is fully event-ordered (JS transition hooks hold the leave open), so it fails on the first run, every run:

  1. A keyed component inside <Suspense :timeout="100"> inside <Transition mode="out-in"> navigates to a cold async component (defineAsyncComponent, chunk not loaded yet).
  2. timeout elapses → Suspense starts the fallback swap; the old content's leave transition begins.
  3. While the leave is in progress, the parent re-renders (in a real app: a ResizeObserver callback, a store update — anything).
  4. The async component resolves; the leave finishes.

What is expected?

The resolved page is mounted (with the fallback shown in between).

What is actually happening?

@resolve fires and the module is loaded, but the page is never inserted — the fallback stays on screen forever. No error, no warning. A later unrelated parent re-render "un-sticks" it, which is why this is so hard to catch in the wild.

Removing any one of the three ingredients — the timeout, mode="out-in", or the mid-swap parent re-render — makes it pass (all three controls verified).

The bug is deterministic: 3.5.30 passes, 3.5.31+ fails (bisected).


Root cause (bisected + traced)

Regression introduced by 908c6ad05 (#9392, first released in 3.5.31), which added isFallbackMountPending:

  • fallback() sets isFallbackMountPending = true and defers mountFallback to the leaving branch's afterLeave.
  • A parent re-render hits patchSuspense's isInFallback path, which patches activeBranch → newFallback and calls setActiveBranch(suspense, newFallback) — mounting the fallback early without clearing isFallbackMountPending.
  • resolve() then skips unmount(activeBranch) because the flag is still true, yet hooks the content move onto activeBranch.transition.afterLeave — where activeBranch is now the fallback, which is never unmounted. The afterLeave never fires; the resolved branch is lost.

Before #9392, resolve() unconditionally unmounted the active branch, so the fallback left and its afterLeave inserted the content.

A guard in patchSuspense fixes it — while isFallbackMountPending is true, activeBranch is still the leaving content, so the patch(activeBranch, newFallback) + setActiveBranch(suspense, newFallback) calls in the isInFallback paths must be skipped. Happy to submit a PR with the fix and an e2e regression test (prepared and passing locally, including the #9392 test for #7966).

Real-world impact: in our production SPA (layout = RouterView → Transition out-in → Suspense timeout, per the documented pattern) roughly 1 in 10 cold first navigations ended on an infinite spinner — console clean, all network requests succeed.

<!-- generated by vue-issues. DO NOT REMOVE -->

The two patches

Our patch+137 −6
packages/runtime-core/__tests__/components/Suspense.spec.tsindex 6b6373fab..0a9443834 100644@@ -3,6 +3,7 @@  */  import {+  BaseTransition,   type ComponentOptions,   Fragment,   KeepAlive,@@ -26,6 +27,7 @@ import {   renderList,   renderSlot,   resolveDynamicComponent,+  serialize,   serializeInner,   shallowRef,   watch,@@ -1461,6 +1463,129 @@ describe('Suspense', () => {     expect(calls).toEqual([`one mounted`, `one unmounted`, `two mounted`])   }) +  describe('timeout + out-in transition: parent update during fallback swap', () => {+    function setup() {+      const doneLeave: Record<string, () => void> = {}+      const makeComp = (name: string, delay = 0) =>+        defineAsyncComponent(+          {+            setup() {+              return () => h('div', [name])+            },+          },+          delay,+        )+      const One = makeComp('one')+      const Two = makeComp('two', 30)+      const Three = makeComp('three', 30)++      const view = shallowRef<any>(One)+      const count = ref(0)++      const Comp = {+        setup() {+          return () =>+            h(+              BaseTransition,+              {+                mode: 'out-in',+                onLeave: (el: any, done: () => void) => {+                  doneLeave[serialize(el)] = done+                },+              },+              () =>+                h(+                  Suspense,+                  { timeout: 10 },+                  {+                    default: h(view.value),+                    fallback: h('div', `fallback ${count.value}`),+                  },+                ),+            )+        },+      }++      const root = nodeOps.createElement('div')+      render(h(Comp), root)+      return { root, view, count, doneLeave, Two, Three }+    }++    async function enterFallbackSwap(ctx: ReturnType<typeof setup>) {+      const { root, view, doneLeave, Two } = ctx+      expect(serializeInner(root)).toBe(`<div>fallback 0</div>`)+      await deps[0]+      await nextTick()+      // initial fallback leaves (out-in), then the content enters+      doneLeave[`<div>fallback 0</div>`]()+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>one</div>`)++      // navigate to a cold async component+      view.value = Two+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>one</div>`)++      // timeout elapses -> fallback swap starts, "one" is leaving+      await new Promise(r => setTimeout(r, 10))+      await nextTick()+      expect(doneLeave[`<div>one</div>`]).toBeTypeOf('function')+    }++    test('parent re-render while pending branch is unchanged', async () => {+      const ctx = setup()+      const { root, count, doneLeave } = ctx+      await enterFallbackSwap(ctx)++      // parent re-renders while the leave is still in progress+      count.value+++      await nextTick()++      // async component resolves, then the leave finishes+      await deps[1]+      await nextTick()+      doneLeave[`<div>one</div>`]()+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>two</div>`)+    })++    test('parent re-render while leave is pending, then leave finishes before resolve', async () => {+      const ctx = setup()+      const { root, count, doneLeave } = ctx+      await enterFallbackSwap(ctx)++      count.value+++      await nextTick()++      // leave finishes first: the latest fallback should be mounted+      doneLeave[`<div>one</div>`]()+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>fallback 1</div>`)++      await deps[1]+      await nextTick()+      doneLeave[`<div>fallback 1</div>`]()+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>two</div>`)+    })++    test('pending branch toggled while leave is in progress', async () => {+      const ctx = setup()+      const { root, view, doneLeave, Three } = ctx+      await enterFallbackSwap(ctx)++      // switch to another cold async component during the leave+      view.value = Three+      await nextTick()++      await deps[2]+      await nextTick()+      doneLeave[`<div>one</div>`]()+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>three</div>`)+    })+  })+   test('mount the fallback content is in the correct position', async () => {     const makeComp = (name: string, delay = 0) =>       defineAsyncComponent(packages/runtime-core/src/components/Suspense.tsindex 37e5067ff..7f1a8b1e9 100644@@ -265,8 +265,12 @@ function patchSuspense(         // setup in children of suspense boundary, that would be problemtic         // because we aren't actually showing a fallback content when         // patchSuspense is called. In such case, patch of fallback content-        // should be no op-        if (!isHydrating) {+        // should be no op.+        // If the fallback is still waiting for the leaving content's+        // afterLeave (out-in transition), activeBranch is the leaving content,+        // not the fallback, so it must not be patched into the fallback here.+        // The deferred mount will pick up the latest fallback vnode.+        if (!isHydrating && !suspense.isFallbackMountPending) {           patch(             activeBranch,             newFallback,@@ -316,7 +320,7 @@ function patchSuspense(         )         if (suspense.deps <= 0) {           suspense.resolve()-        } else {+        } else if (!suspense.isFallbackMountPending) {           patch(             activeBranch,             newFallback,@@ -666,10 +670,12 @@ function createSuspenseBoundary(         if (!suspense.isInFallback) {           return         }-        // mount the fallback tree+        // mount the latest fallback tree, the parent may have re-rendered+        // while the mount was deferred+        const latestFallback = suspense.vnode.ssFallback || fallbackVNode         patch(           null,-          fallbackVNode,+          latestFallback,           container,           anchor,           parentComponent,@@ -678,7 +684,7 @@ function createSuspenseBoundary(           slotScopeIds,           optimized,         )-        setActiveBranch(suspense, fallbackVNode)+        setActiveBranch(suspense, latestFallback)       }        const delayEnter = 
Merged fix · PR #15333+166 −4
packages/runtime-core/src/components/Suspense.tsindex 37e5067ff..6b6f58ba0 100644@@ -266,7 +266,13 @@ function patchSuspense(         // because we aren't actually showing a fallback content when         // patchSuspense is called. In such case, patch of fallback content         // should be no op-        if (!isHydrating) {+        // The same applies while the fallback mount is deferred to the leaving+        // branch's afterLeave (out-in transition): activeBranch is still the+        // leaving content, not the fallback. Patching it with the fallback here+        // would hijack activeBranch, and resolve() would then attach the+        // content move to an afterLeave that never fires, permanently dropping+        // the resolved branch.+        if (!isHydrating && !suspense.isFallbackMountPending) {           patch(             activeBranch,             newFallback,@@ -316,7 +322,9 @@ function patchSuspense(         )         if (suspense.deps <= 0) {           suspense.resolve()-        } else {+        } else if (!suspense.isFallbackMountPending) {+          // while the fallback mount is deferred to the leaving branch's+          // afterLeave, activeBranch is still the leaving content — see above           patch(             activeBranch,             newFallback,@@ -666,10 +674,14 @@ function createSuspenseBoundary(         if (!suspense.isInFallback) {           return         }+        // a parent update may have produced a newer fallback vnode while the+        // mount was deferred (its patch is skipped during that window), so+        // mount the latest one+        const latestFallback = suspense.vnode.ssFallback!         // mount the fallback tree         patch(           null,-          fallbackVNode,+          latestFallback,           container,           anchor,           parentComponent,@@ -678,7 +690,7 @@ function createSuspenseBoundary(           slotScopeIds,           optimized,         )-        setActiveBranch(suspense, fallbackVNode)+        setActiveBranch(suspense, latestFallback)       }        const delayEnter =packages/vue/__tests__/e2e/Transition.spec.tsindex 025cc7c00..0a0739ca0 100644@@ -2169,6 +2169,156 @@ describe('e2e: Transition', () => {       E2E_TIMEOUT,     ) +    // a parent update arriving while the timed-out fallback swap is waiting+    // for the leaving branch's afterLeave must not drop the resolved branch+    test(+      'parent update during timed-out fallback swap with out-in transition',+      async () => {+        await page().evaluate(() => {+          const { createApp, shallowRef, ref, h, defineAsyncComponent } = (+            window as any+          ).Vue+          const One = {+            setup() {+              return () => h('div', { class: 'test' }, 'one')+            },+          }+          const Two = {+            async setup() {+              return () => h('div', { class: 'test' }, 'two')+            },+          }+          const AsyncTwo = defineAsyncComponent(+            () =>+              new Promise(res => {+                ;(window as any).resolveTwo = () => res(Two as any)+              }),+          )+          createApp({+            template: `+              <div id="container">+                <transition mode="out-in" :duration="300">+                  <Suspense :timeout="10">+                    <component :is="view" :key="name" :data-tick="tick"/>+                    <template #fallback><div class="fallback">loading</div></template>+                  </Suspense>+                </transition>+              </div>+              <button id="toggleBtn" @click="click">button</button>+              <button id="tickBtn" @click="tick++">tick</button>+            `,+            setup: () => {+              const view = shallowRef(One)+              const name = ref('one')+              const tick = ref(0)+              const click = () => {+                view.value = AsyncTwo+                name.value = 'two'+              }+              return { view, name, tick, click }+            },+          }).mount('#app')+        })+        await transitionFinish()+        expect(await html('#container')).toBe(+          '<div class="test" data-tick="0">one</div>',+        )++        // navigate to the cold async branch; timeout=10 starts the fallback+        // swap and the old branch's leave transition+        await click('#toggleBtn')+        await timeout(10 + buffer)+        // unrelated parent re-render while the fallback mount is deferred to+        // the leaving branch's afterLeave+        await click('#tickBtn')+        // the async branch resolves while the leave is still in progress+        await page().evaluate(() => (window as any).resolveTwo())+        await transitionFinish(300)+        await transitionFinish(300)+        await nextTick()+        expect(await html('#container')).toContain('two')+        expect(await html('#container')).not.toContain('loading')+      },+      E2E_TIMEOUT,+    )++    // a parent update that changes the fallback content while its mount is+    // deferred must mount the latest fallback, not the stale one+    test(+      'fallback updated by parent while its mount is deferred',+      async () => {+        await page().evaluate(() => {+          const { createApp, shallowRef, ref, h, defineAsyncComponent } = (+            window as any+          ).Vue+          const One = {+            setup() {+              return () => h('div', { class: 'test' }, 'one')+            },+          }+          const Two = {+            async setup() {+              return () => h('div', { class: 'test' }, 'two')+            },+          }+          const AsyncTwo = defineAsyncComponent(+            () =>+              new Promise(res => {+                ;(window as any).resolveTwo = () => res(Two as any)+              }),+          )+          createApp({+            template: `+              <div id="container">+                <transition mode="out-in" :duration="300">+                  <Suspense :timeout="10">+                    <component :is="view" :key="name" :data-tick="tick"/>+                    <template #fallback><div class="fallback">loading {{ tick }}</div></template>+                  </Suspense>+                </transition>+              </div>+              <button id="toggleBtn" @click="click">button</button>+              <button id="tickBtn" @click="tick++">tick</button>+            `,+            setup: () => {+              const view = shallowRef(One)+              const name = ref('one')+              const tick = ref(0)+              const click = () => {+                view.value = AsyncTwo+                name.value = 'two'+              }+              return { view, name, tick, click }+            },+          }).mount('#app')+        })+        await transitionFinish()+        expect(await html('#container')).toBe(+          '<div class="test" data-tick="0">one</div>',+        )++        // navigate to the cold async branch; the fallback mount is deferred+        // to the old branch's afterLeave+        await click('#toggleBtn')+        await timeout(10 + buffer)+        // parent update changes the fallback content while its mount is+        // still deferred+        await click('#tickBtn')+        // let the leave finish so the (latest) fallback mounts+        await transitionFinish(300)+        await nextTick()+        expect(await html('#container')).toContain('loading 1')+        // the async branch resolves after the leave completed+        await page().evaluate(() => (window as any).resolveTwo())+        await transitionFinish(300)+        await transitionFinish(300)+        await nextTick()+        expect(await html('#container')).toContain('two')+        expect(await html('#container')).not.toContain('loading')+      },+      E2E_TIMEOUT,+    )+     // #14640     test(       'switch suspense branches after teleport updates before pending mount finishes',