Backtestsvuerun-20261005-124535#15332

Issue #15332 Merged fix PR #15333 Run 5 Oct 2026 · run-20261005-124535 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 patches make the same core fix. Both skip the `patch(activeBranch, newFallback)` and `setActiveBranch` calls in both `isInFallback` paths of `patchSuspense` while `isFallbackMountPending` is true. This addresses the root cause the issue identified: `activeBranch` gets hijacked, so `resolve()` hooks onto an `afterLeave` that never fires. Both also make the deferred `mountFallback` use the latest `suspense.vnode.ssFallback`, so a fallback updated mid-leave is not lost. A does this only when `delayEnter` is set; B does it unconditionally with a non-null assertion. When the mount is not delayed, `ssFallback` is already the vnode captured by `fallback()`, so the two behave the same in practice. On correctness they are effectively equal.

The tests decide it. Patch A adds runtime-core unit tests that use `BaseTransition` with leave `done()` callbacks held manually. They are fully event-ordered and deterministic, like the issue's repro. They cover three scenarios: resolve before the leave finishes (the reported bug), leave finishes before resolve (checks that the latest fallback, 'fallback 1', mounts and that the fallback then leaves properly), and switching to a third pending branch mid-leave. Each would fail without the fix.

Patch B adds two Puppeteer e2e tests that depend on wall-clock timing (`timeout(10+buffer)`, 300ms durations, `transitionFinish`). They cover the main bug and the stale-fallback case, but they are slower, more prone to flakiness, and cover fewer scenarios.

Patch B's comments explain the mechanism slightly better, but that does not outweigh A's more thorough and deterministic 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

8m 14s

Wall-clock time in the container

Full test suite

No new failures

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

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

155vs 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+153 −2
packages/runtime-core/__tests__/components/Suspense.spec.tsindex 6b6373fab..5f363ce0c 100644@@ -3,6 +3,7 @@  */  import {+  BaseTransition,   type ComponentOptions,   Fragment,   KeepAlive,@@ -1461,6 +1462,146 @@ describe('Suspense', () => {     expect(calls).toEqual([`one mounted`, `one unmounted`, `two mounted`])   }) +  // #15332+  describe('timeout + out-in transition + parent update during leave', () => {+    const setup = () => {+      const makeComp = (name: string, delay = 0) =>+        defineAsyncComponent(+          {+            setup() {+              return () => h('div', [name])+            },+          },+          delay,+        )+      const One = makeComp('one')+      const Two = makeComp('two', 20)+      const Three = makeComp('three', 20)++      const view = shallowRef<any>(One)+      const count = ref(0)+      const leaveDone: (() => void)[] = []+      let holdLeave = false++      const Comp = {+        setup() {+          return () =>+            h(+              BaseTransition,+              {+                mode: 'out-in',+                onLeave(_el: any, done: () => void) {+                  if (holdLeave) {+                    leaveDone.push(done)+                  } else {+                    done()+                  }+                },+              },+              {+                default: () =>+                  h(+                    Suspense,+                    { timeout: 10 },+                    {+                      default: h(view.value),+                      fallback: h('div', `fallback ${count.value}`),+                    },+                  ),+              },+            )+        },+      }++      const root = nodeOps.createElement('div')+      return {+        root,+        Comp,+        view,+        count,+        leaveDone,+        Two,+        Three,+        holdLeaves: () => (holdLeave = true),+      }+    }++    const mountAndSwitch = async (ctx: ReturnType<typeof setup>) => {+      const { root, Comp, view, leaveDone, Two, holdLeaves } = ctx+      render(h(Comp), root)+      await deps[0]+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>one</div>`)+      // from now on, leave transitions are held open until done() is called+      holdLeaves()++      view.value = Two+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>one</div>`)++      // timeout elapses: fallback swap starts, old content leave is held open+      await new Promise(r => setTimeout(r, 10))+      await nextTick()+      expect(leaveDone.length).toBe(1)+    }++    test('resolve before the leave finishes', async () => {+      const ctx = setup()+      const { root, count, leaveDone } = ctx+      await mountAndSwitch(ctx)++      // parent re-render while the leave is in progress+      count.value+++      await nextTick()++      // async component resolves, then the leave finishes+      await deps[1]+      await nextTick()+      leaveDone[0]()+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>two</div>`)+    })++    test('leave finishes before resolve', async () => {+      const ctx = setup()+      const { root, count, leaveDone } = ctx+      await mountAndSwitch(ctx)++      count.value+++      await nextTick()++      // leave finishes: the latest fallback is mounted+      leaveDone[0]()+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>fallback 1</div>`)++      await deps[1]+      await nextTick()+      // fallback leaves, then the resolved content is inserted+      expect(leaveDone.length).toBe(2)+      leaveDone[1]()+      await nextTick()+      expect(serializeInner(root)).toBe(`<div>two</div>`)+    })++    test('switch to a 3rd branch during the leave', async () => {+      const ctx = setup()+      const { root, view, count, leaveDone, Three } = ctx+      await mountAndSwitch(ctx)++      // parent re-render switching to another pending branch+      view.value = Three+      count.value+++      await nextTick()++      await deps[2]+      await nextTick()+      leaveDone[0]()+      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..c6582e520 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 - skip the patch.+        // the latest fallback will be mounted once the leave finishes.+        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 if the fallback mount is deferred to afterLeave           patch(             activeBranch,             newFallback,@@ -666,6 +671,11 @@ function createSuspenseBoundary(         if (!suspense.isInFallback) {           return         }+        // #15332 the parent may have re-rendered while the fallback mount was+        // deferred to afterLeave, mount the latest fallback in that case+        if (delayEnter && suspense.vnode.ssFallback) {+          fallbackVNode = suspense.vnode.ssFallback+        }         // mount the fallback tree         patch(           null, 
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',