Backtestsvuerun-20261007-145226#15288
KeepAlive caches a never-mounted vnode when a switch lands while an ancestor Suspense is pending
Our patch was judged better than the merged fix.
In this judgment, Patch A = our agent, Patch B = the merged fix.
Both patches add the guard the issue suggests: do not cache an inner child whose `component` is null. That fixes the poisoned cache entry and the null `suspenseId` / `unmountComponent(null)` crashes. Patch B stops there, which leaves KeepAlive's bookkeeping inconsistent. `render()` has already run `keys.add(pendingCacheKey)` and set `current` to the never-mounted vnode. Under B, that key stays in `keys` with no matching `cache` entry. With `max`, this causes a real bug. A later switch can prune that stale key first. `pruneCacheEntry` finds no cached vnode and falls into the `else if (current) resetShapeFlag(current)` branch. That strips COMPONENT_SHOULD_KEEP_ALIVE from the currently active, mounted page, so the page is truly unmounted instead of deactivated. A kept-alive page is silently lost. Patch A handles this. When the inner child was never patched, it deletes the stale key and re-points `current`/`cache`/`keys` at the Suspense's actual `activeBranch`. It derives the key the same way KeepAlive does (key or type), so state stays consistent. Tests: A covers the issue scenario and adds targeted tests that are likely to expose B's bookkeeping gap: - unmounting the whole tree unmounts exactly the cached pages - `max` pruning does not unmount the wrong page, and the LRU order is respected B's single test covers only the basic reported flow, using async pages and a manually resolved root dep. A's extra logic adds some complexity, but it is directly tied to the defect and makes the fix complete rather than partial. A is the more correct fix.
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 48s
Wall-clock time in the container
Full test suite
No new failures
3,681 passed · 6 skipped · 3,687 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
173vs 76 merged
Changed lines, ours vs merged
The issue
View on GitHubVue version
3.5.41 (also reproduces on 3.5.40 and 3.6.0-rc.3)
Link to minimal reproduction
Steps to reproduce
The reproduction drives itself from onMounted — just open it and read the log. The tree is the one Nuxt renders for a page with <NuxtPage keepalive>:
<Suspense> <!-- root boundary, still pending -->
<RootDep /> <!-- async setup, resolves after 300ms -->
<KeepAlive>
<Suspense> <!-- per-page boundary -->
<component :is="page" :key="key" />
</Suspense>
</KeepAlive>
</Suspense>
- While
RootDepis still pending (soparentSuspense.deps > 0), switch the inner page fromPageAtoPageB. - Let the root boundary resolve.
- Switch back to
PageA, then toPageBagain.
What is expected?
The inner page follows the switches, and no errors are raised.
What is actually happening?
The rendered page is stuck on PageA forever — every later switch is a no-op — and the renderer throws:
Cannot read properties of null (reading 'suspenseId') // patchSuspense
Cannot read properties of null (reading 'm') // unmountComponent
In a production build the second one is the more familiarUncaught (in promise) TypeError: Cannot destructure property 'bum' of 'instance' as it is null.
Removing the <KeepAlive> and changing nothing else makes both errors go away and navigation work.
System Info
System:
OS: Linux 7.0 Ubuntu 26.04 LTS
CPU: (4) x64 Intel(R) Core(TM) i7-8700 CPU @ 3.20GHz
Memory: 5.86 GB / 11.67 GB
Binaries:
Node: 24.19.0
npm: 11.19.0
npmPackages:
vue: 3.5.41
Browsers:
Chromium (Playwright 1.5x, headless)
Any additional comments?
The chain, as far as I could trace it:
- The route change re-renders
KeepAlive, so the inner<Suspense>is patched withn1 != null. Because an ancestor boundary is still pending,SuspenseImpl.processtakes its early return:
if (parentSuspense && parentSuspense.deps > 0 && !n1.suspense.isInFallback) {
n2.suspense = n1.suspense
n2.suspense.vnode = n2
n2.el = n1.el
return
}
The incoming page vnode is therefore never patched: vnode.component === null, vnode.el === null.
KeepAlive'sonUpdated→cacheSubtreestill caches it, unconditionally:
if (isSuspense(instance.subTree.type)) {
queuePostRenderEffect(() => {
cache.set(pendingCacheKey, getInnerChild(instance.subTree))
}, instance.subTree.suspense)
}
- The next render for that key hits the poisoned entry:
KeepAlivecopiescachedVNode.component(null) onto the new vnode and setsCOMPONENT_KEPT_ALIVE, sopatchSuspensereadsnewBranch.component.suspenseIdonnull, and the teardown that follows callsunmountComponent(null).
Suggested fix — the same shape as the two guards already at that site, i.e. do not cache a vnode that never finished mounting:
const innerChild = getInnerChild(instance.subTree)
if (innerChild.component) {
cache.set(pendingCacheKey, innerChild)
}
With that guard the page is simply not cached that one time, and the reproduction runs clean.
This looks like a third path into the defect class fixed by #10912 (avoid caching vnode that not been mounted, for #10899) and #11479 (for #6028) — both guard KeepAlive's own subtree, while here it is an ancestor Suspense that is pending.
Real-world context: this is how it surfaced for us — a Nuxt 4 app rendering <NuxtPage :keepalive="{ max: 5 }" />, where a link clicked before hydration finished intermittently left the user on a blank page with Cannot destructure property 'bum' of 'e' as it is null in the console. The window widens with slower hydration, so it shows up under load / on slow clients.
<sub>Investigation and reproduction prepared with Claude Code, on behalf of drunomics.</sub>
The two patches
packages/runtime-core/__tests__/components/Suspense.spec.tsindex d40f85b86..ed13bf3e3 100644@@ -2111,6 +2111,155 @@ describe('Suspense', () => { expect(serializeInner(root)).toBe(`<div>async2</div>`) }) + test('KeepAlive + Suspense switch while ancestor is pending', async () => {+ const RootDep = defineAsyncComponent({+ render() {+ return h('div', 'root')+ },+ })+ const PageA = {+ render() {+ return h('div', 'pageA')+ },+ }+ const PageB = {+ render() {+ return h('div', 'pageB')+ },+ }+ const pages = [PageA, PageB]+ const viewRef = ref(0)+ const root = nodeOps.createElement('div')+ const App = {+ render() {+ return h(Suspense, null, {+ default: h(Fragment, null, [+ h(RootDep),+ h(KeepAlive, null, {+ default: () =>+ h(Suspense, null, {+ default: h(pages[viewRef.value], { key: viewRef.value }),+ }),+ }),+ ]),+ fallback: h('div', 'loading'),+ })+ },+ }+ render(h(App), root)+ expect(serializeInner(root)).toBe(`<div>loading</div>`)++ // switch to PageB while the ancestor Suspense is still pending+ viewRef.value = 1+ await nextTick()+ expect(serializeInner(root)).toBe(`<div>loading</div>`)++ await Promise.all(deps)+ await nextTick()+ expect(serializeInner(root)).toBe(`<div>root</div><div>pageA</div>`)++ viewRef.value = 0+ await nextTick()+ expect(serializeInner(root)).toBe(`<div>root</div><div>pageA</div>`)++ viewRef.value = 1+ await nextTick()+ expect(serializeInner(root)).toBe(`<div>root</div><div>pageB</div>`)++ viewRef.value = 0+ await nextTick()+ expect(serializeInner(root)).toBe(`<div>root</div><div>pageA</div>`)+ })++ describe('KeepAlive + Suspense switch while ancestor pending', () => {+ const setup = (max?: number) => {+ const RootDep = defineAsyncComponent({+ render() {+ return h('div', 'root')+ },+ })+ const unmounted: string[] = []+ const createPage = (name: string) => ({+ name,+ setup() {+ onUnmounted(() => unmounted.push(name))+ return () => h('div', name)+ },+ })+ const pages = [createPage('A'), createPage('B'), createPage('C')]+ const viewRef = ref(0)+ const root = nodeOps.createElement('div')+ const App = {+ render() {+ return h(Suspense, null, {+ default: h(Fragment, null, [+ h(RootDep),+ h(+ KeepAlive,+ { max },+ {+ default: () =>+ h(Suspense, null, {+ default: h(pages[viewRef.value], { key: viewRef.value }),+ }),+ },+ ),+ ]),+ fallback: h('div', 'loading'),+ })+ },+ }+ render(h(App), root)+ return { root, viewRef, unmounted }+ }++ test('mounted page is cached and unmounted', async () => {+ const { root, viewRef, unmounted } = setup()+ viewRef.value = 1+ await nextTick()+ await Promise.all(deps)+ await nextTick()+ expect(serializeInner(root)).toBe(`<div>root</div><div>A</div>`)++ viewRef.value = 2+ await nextTick()+ expect(serializeInner(root)).toBe(`<div>root</div><div>C</div>`)+ expect(unmounted).toEqual([])++ render(null, root)+ await nextTick()+ expect(unmounted.sort()).toEqual(['A', 'C'])+ })++ test('max pruning does not unmount pages twice', async () => {+ const { root, viewRef, unmounted } = setup(2)+ viewRef.value = 1+ await nextTick()+ await Promise.all(deps)+ await nextTick()++ viewRef.value = 0+ await nextTick()+ viewRef.value = 2+ await nextTick()+ expect(serializeInner(root)).toBe(`<div>root</div><div>C</div>`)+ expect(unmounted).toEqual([])++ viewRef.value = 0+ await nextTick()+ expect(serializeInner(root)).toBe(`<div>root</div><div>A</div>`)+ viewRef.value = 1+ await nextTick()+ expect(serializeInner(root)).toBe(`<div>root</div><div>B</div>`)+ // C is the least recently used entry+ expect(unmounted).toEqual(['C'])++ render(null, root)+ await nextTick()+ expect(unmounted.sort()).toEqual(['A', 'B', 'C'])+ })+ })+ test('KeepAlive + Suspense + comment slot', async () => { const toggle = ref(false) const Async = defineAsyncComponent({packages/runtime-core/src/components/KeepAlive.tsindex 55eaf8624..3dd0cd575 100644@@ -248,7 +248,29 @@ const KeepAliveImpl: ComponentOptions = { // avoid caching vnode that not been mounted if (isSuspense(instance.subTree.type)) { queuePostRenderEffect(() => {- cache.set(pendingCacheKey!, getInnerChild(instance.subTree))+ const innerChild = getInnerChild(instance.subTree)+ if (innerChild.component) {+ cache.set(pendingCacheKey!, innerChild)+ } else {+ // the inner child is never patched if an ancestor Suspense was+ // pending when this KeepAlive updated. Cache the branch that is+ // actually mounted instead.+ keys.delete(pendingCacheKey!)+ const activeBranch = instance.subTree.suspense!.activeBranch+ if (+ activeBranch &&+ activeBranch.component &&+ activeBranch.shapeFlag & ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE+ ) {+ const key =+ activeBranch.key == null+ ? (activeBranch.type as ConcreteComponent)+ : activeBranch.key+ cache.set(key, activeBranch)+ keys.add(key)+ current = activeBranch+ }+ } }, instance.subTree.suspense) } else { cache.set(pendingCacheKey, getInnerChild(instance.subTree))
packages/runtime-core/__tests__/components/Suspense.spec.tsindex d40f85b86..6b6373fab 100644@@ -2111,6 +2111,77 @@ describe('Suspense', () => { expect(serializeInner(root)).toBe(`<div>async2</div>`) }) + // #15288+ test('KeepAlive + Suspense switch while ancestor is pending', async () => {+ let resolveRootDep!: (comp: ComponentOptions) => void+ const rootDep = new Promise<ComponentOptions>(resolve => {+ resolveRootDep = resolve+ })+ const RootDep = defineAsyncComp(() => rootDep)+ const makePage = (name: string) =>+ defineAsyncComponent({+ render: () => h('div', `page ${name}`),+ })+ const PageA = makePage('A')+ const PageB = makePage('B')+ const page = shallowRef(PageA)+ const key = ref('a')+ const root = nodeOps.createElement('div')+ const App = {+ render() {+ return h(Suspense, null, {+ default: h('div', [+ h(RootDep),+ h(KeepAlive, null, {+ default: () =>+ h(Suspense, null, {+ default: h(page.value, { key: key.value }),+ }),+ }),+ ]),+ fallback: h('div', 'loading'),+ })+ },+ }++ render(h(App), root)+ expect(serializeInner(root)).toBe('<div>loading</div>')++ await Promise.all(deps)+ await nextTick()++ page.value = PageB+ key.value = 'b'+ await nextTick()+ expect(serializeInner(root)).toBe('<div>loading</div>')++ resolveRootDep({+ render: () => h('div', 'root'),+ })+ await rootDep+ await new Promise(r => setTimeout(r))+ await nextTick()+ expect(serializeInner(root)).toBe(+ '<div><div>root</div><div>page A</div></div>',+ )++ page.value = PageA+ key.value = 'a'+ await nextTick()+ expect(serializeInner(root)).toBe(+ '<div><div>root</div><div>page A</div></div>',+ )++ page.value = PageB+ key.value = 'b'+ await nextTick()+ await Promise.all(deps)+ await nextTick()+ expect(serializeInner(root)).toBe(+ '<div><div>root</div><div>page B</div></div>',+ )+ })+ test('KeepAlive + Suspense + comment slot', async () => { const toggle = ref(false) const Async = defineAsyncComponent({packages/runtime-core/src/components/KeepAlive.tsindex 55eaf8624..b09152f72 100644@@ -248,7 +248,10 @@ const KeepAliveImpl: ComponentOptions = { // avoid caching vnode that not been mounted if (isSuspense(instance.subTree.type)) { queuePostRenderEffect(() => {- cache.set(pendingCacheKey!, getInnerChild(instance.subTree))+ const vnode = getInnerChild(instance.subTree)+ if (vnode.component) {+ cache.set(pendingCacheKey!, vnode)+ } }, instance.subTree.suspense) } else { cache.set(pendingCacheKey, getInnerChild(instance.subTree))