Backtestsvuerun-20261009-161443#15332

Issue #15332 Merged fix PR #15333 Run 9 Oct 2026 · run-20261009-161443 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.

Both patches make the same core fix in `patchSuspense`. They skip `patch(activeBranch, newFallback)` and `setActiveBranch` while `suspense.isFallbackMountPending` is true, in both the `isInFallback` paths. They also change the deferred `mountFallback` to mount the latest `suspense.vnode.ssFallback`, so a fallback update skipped during the window is not lost. This targets the root cause described in the issue: `activeBranch` is no longer hijacked by the fallback, and `resolve()` hooks onto the leaving content's real afterLeave.

The only code difference is small. A uses the latest `ssFallback` only when `delayEnter` is true and otherwise keeps the passed `fallbackVNode`. B always uses `ssFallback`. In the immediate path these should be the same vnode, because `suspense.vnode` is already updated before `fallback(newFallback)` is called. So B's version is probably equivalent, but A's is the more conservative change and leaves the non-deferred behavior exactly as before.

Tests are where they differ most. A adds deterministic unit tests in Suspense.spec using `BaseTransition` with manually held `onLeave` done callbacks, as the issue's event-ordered repro does. They cover three orderings:
- Resolve before leave completes: the exact bug.
- Leave completes before resolve, which also checks the latest fallback is mounted and stays reactive.
- Switching to a second async branch while the mount is pending.

A's tests also assert that the fallback is not mounted early after the parent update. B adds e2e tests that rely on wall-clock timeouts, a 10ms Suspense timeout plus buffer, and `transitionFinish` durations. They are more timing-sensitive and cover fewer orderings, though they do reproduce the real-world scenario and check the latest-fallback behavior.

B's comments explain the failure mode a bit more thoroughly, but the craft is otherwise comparable. With the fixes essentially equal, A wins on more precise, deterministic and broader test coverage and a slightly more conservative change.

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

7m 40s

Wall-clock time in the container

Full test suite

No new failures

1,797 passed · 1 skipped · 1,798 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

145vs 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+141 −4
packages/runtime-core/__tests__/components/Suspense.spec.tsindex 6b6373fab..b18285e10 100644@@ -3,6 +3,7 @@  */  import {+  BaseTransition,   type ComponentOptions,   Fragment,   KeepAlive,@@ -2805,6 +2806,132 @@ describe('Suspense', () => {     render(h(App), root)   }) +  // #15332+  describe('out-in transition + fallback mount deferred to afterLeave', () => {+    function setup() {+      const leaveDones: (() => void)[] = []+      const transitionProps = {+        mode: 'out-in' as const,+        onLeave: (_el: any, done: () => void) => {+          leaveDones.push(done)+        },+      }+      const resolvers: (() => void)[] = []+      const createAsync = (text: string) => ({+        setup() {+          return new Promise(r => {+            resolvers.push(() => r(() => h('div', text)))+          })+        },+      })+      const One = { render: () => h('div', 'one') }+      const Async = createAsync('async')+      const Async2 = createAsync('async2')+      const view = shallowRef<any>(One)+      const count = ref(0)+      const root = nodeOps.createElement('div')+      const App = {+        setup() {+          return () =>+            h(BaseTransition, transitionProps, () =>+              h(+                Suspense,+                { timeout: 0 },+                {+                  default: () => h(view.value),+                  fallback: () => h('div', `fallback ${count.value}`),+                },+              ),+            )+        },+      }+      render(h(App), root)+      return { root, view, count, leaveDones, resolvers, Async, Async2 }+    }++    const flush = async () => {+      await new Promise(r => setTimeout(r))+      await nextTick()+    }++    test('parent update during fallback swap, then resolve, then leave finishes', async () => {+      const { root, view, count, leaveDones, resolvers, Async } = setup()+      expect(serializeInner(root)).toBe(`<div>one</div>`)++      // switch to async branch -> timeout 0 -> fallback swap starts,+      // content leave held open+      view.value = Async+      await nextTick()+      expect(leaveDones.length).toBe(1)+      expect(serializeInner(root)).toBe(`<div>one</div>`)++      // parent re-render while the leave is in progress+      count.value+++      await nextTick()+      // the fallback must not be mounted before the leave finishes+      expect(serializeInner(root)).toBe(`<div>one</div>`)++      // async resolves before the leave finishes+      resolvers[0]()+      await flush()++      // leave finishes -> resolved branch is inserted+      leaveDones[0]()+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>async</div>`)+    })++    test('parent update during fallback swap, then leave finishes, then resolve', async () => {+      const { root, view, count, leaveDones, resolvers, Async } = setup()++      view.value = Async+      await nextTick()+      expect(leaveDones.length).toBe(1)++      count.value+++      await nextTick()+      expect(serializeInner(root)).toBe(`<div>one</div>`)++      // leave finishes -> latest fallback is mounted+      leaveDones[0]()+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>fallback 1</div>`)++      // fallback stays reactive after it is mounted+      count.value+++      await nextTick()+      expect(serializeInner(root)).toBe(`<div>fallback 2</div>`)++      resolvers[0]()+      await flush()+      // fallback leaves (out-in)+      expect(leaveDones.length).toBe(2)+      leaveDones[1]()+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>async</div>`)+    })++    test('switch to another async branch during fallback swap', async () => {+      const { root, view, leaveDones, resolvers, Async, Async2 } = setup()++      view.value = Async+      await nextTick()+      expect(leaveDones.length).toBe(1)++      // toggled to a 3rd branch while the fallback mount is pending+      view.value = Async2+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>one</div>`)++      // the second async branch resolves, then the leave finishes+      resolvers[1]()+      await flush()+      leaveDones[0]()+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>async2</div>`)+    })+  })+   // #13453   test('add new async deps during patching', async () => {     const getComponent = (type: string) => {packages/runtime-core/src/components/Suspense.tsindex 37e5067ff..cf5d45c4c 100644@@ -266,7 +266,11 @@ 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) {+        // #15332 if the fallback mount is still waiting for the leaving+        // content's afterLeave (out-in transition), activeBranch is still the+        // leaving content and the fallback is not mounted yet. the latest+        // fallback (suspense.vnode.ssFallback) will be mounted in afterLeave.+        if (!isHydrating && !suspense.isFallbackMountPending) {           patch(             activeBranch,             newFallback,@@ -316,7 +320,8 @@ function patchSuspense(         )         if (suspense.deps <= 0) {           suspense.resolve()-        } else {+        } else if (!suspense.isFallbackMountPending) {+          // #15332 skip while the fallback mount is deferred to afterLeave           patch(             activeBranch,             newFallback,@@ -666,10 +671,15 @@ function createSuspenseBoundary(         if (!suspense.isInFallback) {           return         }+        // #15332 the suspense vnode may have been patched while the fallback+        // mount was deferred, mount the latest fallback tree in that case+        const latestFallback = delayEnter+          ? suspense.vnode.ssFallback!+          : fallbackVNode         // mount the fallback tree         patch(           null,-          fallbackVNode,+          latestFallback,           container,           anchor,           parentComponent,@@ -678,7 +688,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',