Backtestsvuerun-20261009-161443#9239

Issue #9239 Merged fix PR #11682 Run 9 Oct 2026 · run-20261009-161443 vuejs/core

the div which has the ref attribute inside the v-for, when I v-if toggle them, the ref value.length increase more and more

Worse

The merged fix was judged better than our patch.

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

The bug happens when a keyed element is a direct child of a stable v-for. `:key` forces the element into a block, so `buildProps` skips adding NEED_PATCH. `transformFor` then demotes the block to a plain vnode with no patch flag. The vnode is therefore missing from the fragment's dynamicChildren, and the unmount path never resets its ref, directives or vnode hooks.

Patch B removes `!shouldUseBlock` from the NEED_PATCH condition. Every block with ref/hook/directive and flag 0 now gets 512. This is minimal and fixes the reported static-ref case. It is mostly harmless for real blocks, which explains the snapshot churn. However, it leaves two gaps:
- `hasRef` is still only set after the early return for const/setup bindings. A keyed v-for child with `:ref="setupConstFn"` still gets no NEED_PATCH and is still dropped from tracking. That is the same bug class, and the issue explicitly compares against function refs.
- Elements that needed a block for ordering (`@vue:before-update` or runtime directives with children) are still silently demoted. They are now tracked, but beforeUpdate can fire after the children update.

Patch A addresses the root cause more completely:
- It moves the `hasRef` detection before the const-binding early return, so setup-const function refs are covered.
- It records `needsPatch` on the VNodeCall and applies NEED_PATCH only when vFor actually demotes the node. Real blocks are left untouched, so there are no snapshot changes.
- It adds `isBlockRequired`, so before-update hooks (now matched camelized as well) and directives with children stay blocks inside stable fragments, preserving hook ordering.

A's tests cover compiler flags for static ref, directives, vnode hooks and the const function ref, plus block preservation. They also include runtime tests for ref-array clearing, function-ref null calls, unmounted hooks and beforeUpdate ordering. B's tests are solid but cover only the static-ref, directive and hook cases.

A is more complex, but the added logic is targeted and well tested. It holds up across more of the scenarios this bug class implies, so A is the better 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

12m 37s

Wall-clock time in the container

Full test suite

No new failures

1,862 passed · 1 skipped · 1,863 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

139vs 338 merged

Changed lines, ours vs merged

Vue version

3.2.47

Link to minimal reproduction

https://play.vuejs.org/#eNqtVUtv00AQ/iuDOSSV0qSot9QttNADSDxEERfMwbUnzjab3dU+3ESR/zuz68R2nNIglR6a3Z1v5pu3N9G1UuPSYTSNYpNppiwYtE4BT0VxmUTWJNFVIthSSW1hAxpnI/qXZpaVOAIpPksnLOYjyORSuXB6TG02hwpmWi5hQMYHjYH3BLrZCsaTcPPsBEhEJoWxwMxPZtg9R7j0ZEOrHZ4kYuYEUUoBVhYFxy1meAKbRECrNC5T7rzqq95TIqqWg+x+YOUdE2RpSyMc50TTyL1rTwH2TVxrvRX/+t3X7sniSZ1eSmZscal4apHOAHHOSjB2zZHSfS91jnoKb9QKjOQsh9eIeAEqzXPyhgRnahUqAvTnVa+6wUxhE0rURldV8cSj9hXa6HYanXh7KnMNk0M+im7MURR23uFsH5/hPdTcfz3G3zYIabeXtzBYoxnAFAZCDvpG7p211DzvMs6yhW/rbhdRPvfu8aSGk3LLC+Upm5Fmw5hETdXmyIq59cWh6lzAYRGV0yrw1PYATEj17hbsUyLIVLd4HTxh6tFpUG3BCBbXo9TA92Lv1eFlgTCx6LiVap2u96IoT2dSk6VhWZ6NgIkcV2cn9AvnRDNd4Nozh1e6d0OmBjgab435t2B3p3jSmbY4BAomkwrz3YrjaPySowH1QkJFI1p7NMszVowfjBS0G8OWSSK/4xhH/VX5XURa1MI1cRKlnMvHT+HN76zR7j2bY7Z44v3B0CBP6fBNo0FdUh0amU11gbYW3959wRWdG+FS5s5X7Rnhd6RyOe9jDbtxIie3O7jg7cewlKmJfpjblUVhdkF5Rz2yCvgkohXtc/630Ft3z8fnQY/WLWWx2e//7+vS+6wkosEM6WNweQWb6uiyzXhqDLE/6lT52UdjX9It1R+VZ24c

Steps to reproduce

if I click toggleVisible many times,

  1. the refDivSingle toggle between null and div
  2. the refCompSingle toggle between null and {}
  3. the refDivArr.length increase more and more <-- error here
  4. the refCompArr.length toggle between 3 and 0

if I use ref function, it don't get null
<img width="532" alt="image" src="https://github.com/vuejs/core/assets/417448/b1a09a97-2c9f-4310-9430-27aa04b79863">

What is expected?

the refDivArr.length should toggle between 3 and 0, same as the refCompArr.length

What is actually happening?

the refDivArr.length increase more and more

System Info

_No response_

Any additional comments?

_No response_

The two patches

Our patch+135 −4
packages/compiler-core/__tests__/transforms/__snapshots__/cacheStatic.spec.ts.snapindex 7d5e47719..ea966a937 100644@@ -217,7 +217,7 @@ return function render(_ctx, _cache) {     return (_openBlock(), _createElementBlock("div", null, [       _withDirectives((_openBlock(), _createElementBlock("svg", null, [...(_cache[0] || (_cache[0] = [         _createElementVNode("path", { d: "M2,3H5.5L12" }, null, -1 /* CACHED */)-      ]))])), [+      ]))], 512 /* NEED_PATCH */)), [         [_directive_foo]       ])     ]))packages/compiler-core/__tests__/transforms/__snapshots__/transformText.spec.ts.snapindex 7fb49ea78..55a7d7143 100644@@ -73,7 +73,7 @@ return function render(_ctx, _cache) {      return _withDirectives((_openBlock(), _createElementBlock("p", null, [       _createTextVNode(_toDisplayString(foo), 1 /* TEXT */)-    ])), [+    ], 512 /* NEED_PATCH */)), [       [_directive_foo]     ])   }packages/compiler-core/__tests__/transforms/vFor.spec.tsindex 839d9d358..85448184a 100644@@ -15,9 +15,15 @@ import {   NodeTypes,   type RootNode,   type SimpleExpressionNode,+  type VNodeCall, } from '../../src/ast' import { ErrorCodes } from '../../src/errors'-import { type CompilerOptions, generate } from '../../src'+import {+  BindingTypes,+  type CompilerOptions,+  baseCompile,+  generate,+} from '../../src' import { FRAGMENT, RENDER_LIST, RENDER_SLOT } from '../../src/runtimeHelpers' import { PatchFlags } from '@vue/shared' import { createObjectMatcher } from '../testUtils'@@ -1144,4 +1150,58 @@ describe('compiler: v-for', () => {       })     })   })++  describe('stable fragment child forced into a block', () => {+    function getChildCodegen(template: string, options: CompilerOptions = {}) {+      const { ast } = baseCompile(template, {+        prefixIdentifiers: true,+        cacheHandlers: true,+        ...options,+      })+      const forNode = ast.children[0] as ForNode & {+        codegenNode: ForCodegenNode+      }+      expect(forNode.codegenNode.patchFlag).toBe(PatchFlags.STABLE_FRAGMENT)+      const child = (forNode.codegenNode.children.arguments[1] as any)+        .returns as VNodeCall+      expect(child.isBlock).toBe(false)+      return child+    }++    // the child is demoted from a block to a plain vnode, so it needs a patch+    // flag to be tracked in the fragment's dynamicChildren+    test('keyed element with ref', () => {+      const child = getChildCodegen(+        `<div v-for="i in 3" :key="i" ref="foo">static</div>`,+      )+      expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+    })++    test('keyed element with ref (inline mode)', () => {+      const child = getChildCodegen(+        `<div v-for="i in 3" :key="i" ref="foo">static</div>`,+        { inline: true, bindingMetadata: { foo: BindingTypes.SETUP_REF } },+      )+      expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+    })++    test('keyed element with vnode hook', () => {+      const child = getChildCodegen(+        `<div v-for="i in 3" :key="i" @vue:unmounted="foo">static</div>`,+      )+      expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+    })++    test('element with custom directive and children', () => {+      const child = getChildCodegen(`<div v-for="i in 3" v-foo>static</div>`)+      expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+    })++    test('element with inline before-update hook and children', () => {+      const child = getChildCodegen(+        `<div v-for="i in 3" @vue:before-update="foo">static</div>`,+      )+      expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+    })+  }) })packages/compiler-core/src/transforms/transformElement.tsindex 40f08d45b..41e343cdd 100644@@ -736,8 +736,11 @@ export function buildProps(       patchFlag |= PatchFlags.NEED_HYDRATION     }   }+  // NEED_PATCH is also needed when the element is forced into a block, since+  // the block may later be demoted to a plain vnode (e.g. the direct child of+  // a stable v-for fragment) and must still be tracked in the parent's+  // dynamicChildren so that its ref / vnode hooks / directives are processed.   if (-    !shouldUseBlock &&     (patchFlag === 0 || patchFlag === PatchFlags.NEED_HYDRATION) &&     (hasRef || hasVnodeHook || runtimeDirectives.length > 0)   ) {packages/vue/__tests__/index.spec.tsindex 79e48b775..5b21a0b39 100644@@ -347,4 +347,72 @@ describe('compiler + runtime integration', () => {     app.mount(root)     expect(root.innerHTML).toBe('<div>60000000100000111</div>')   })++  // keyed elements are forced into blocks, but are demoted back to plain+  // vnodes as children of a stable (constant source) v-for fragment.+  // prefixIdentifiers + cacheHandlers mirror build-time (SFC) compilation;+  // prefixIdentifiers is required for the v-for source to be analyzed as+  // constant.+  describe('keyed element in stable v-for toggled by v-if', () => {+    const compilerOptions = { prefixIdentifiers: true, cacheHandlers: true }++    test('array template ref', async () => {+      const root = document.createElement('div')+      const visible = ref(true)+      const refDivArr = ref<HTMLElement[]>([])+      createApp({+        template: `<template v-if="visible"><div v-for="i in 3" :key="i" ref="refDivArr">div</div></template>`,+        compilerOptions,+        setup: () => ({ visible, refDivArr }),+      }).mount(root)+      await nextTick()+      expect(refDivArr.value.length).toBe(3)++      for (let i = 0; i < 3; i++) {+        visible.value = false+        await nextTick()+        expect(refDivArr.value.length).toBe(0)++        visible.value = true+        await nextTick()+        expect(refDivArr.value.length).toBe(3)+        expect(refDivArr.value).toEqual(+          Array.from(root.querySelectorAll('div')),+        )+      }+    })++    test('custom directive unmounted hook', async () => {+      const root = document.createElement('div')+      const visible = ref(true)+      const unmounted = vi.fn()+      createApp({+        template: `<template v-if="visible"><div v-for="i in 3" :key="i" v-foo>div</div></template>`,+        directives: { foo: { unmounted } },+        compilerOptions,+        setup: () => ({ visible }),+      }).mount(root)+      await nextTick()++      visible.value = false+      await nextTick()+      expect(unmounted).toHaveBeenCalledTimes(3)+    })++    test('vnode unmounted hook', async () => {+      const root = document.createElement('div')+      const visible = ref(true)+      const onUnmounted = vi.fn()+      createApp({+        template: `<template v-if="visible"><div v-for="i in 3" :key="i" @vue:unmounted="onUnmounted">div</div></template>`,+        compilerOptions,+        setup: () => ({ visible, onUnmounted }),+      }).mount(root)+      await nextTick()++      visible.value = false+      await nextTick()+      expect(onUnmounted).toHaveBeenCalledTimes(3)+    })+  }) }) 
Merged fix · PR #11682+321 −17
packages/compiler-core/__tests__/transforms/transformElement.spec.tsindex bf3510a05..8215ceedb 100644@@ -74,6 +74,12 @@ function parseWithBind(template: string, options?: CompilerOptions) {   }) } +function getVForChild(+  node: ReturnType<typeof parseWithForTransform>['node'],+): VNodeCall {+  return node.codegenNode.children.arguments[1].returns as VNodeCall+}+ describe('compiler: element transform', () => {   test('import + resolve component', () => {     const { root } = parseWithElementTransform(`<Foo/>`)@@ -1028,6 +1034,105 @@ describe('compiler: element transform', () => {       expect(node.patchFlag).toBe(PatchFlags.NEED_PATCH)     }) +    test('NEED_PATCH (stable v-for + static ref)', () => {+      const { node } = parseWithForTransform(+        `<div v-for="i in 3" :key="i" ref="foo" />`,+        { prefixIdentifiers: true },+      )+      const child = getVForChild(node)+      expect(child.isBlock).toBe(false)+      expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+    })++    test('NEED_PATCH (stable v-for + custom directives)', () => {+      const { node } = parseWithForTransform(+        `<div v-for="i in 3" :key="i" v-dir />`,+        { prefixIdentifiers: true },+      )+      const child = getVForChild(node)+      expect(child.isBlock).toBe(false)+      expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+    })++    test('NEED_PATCH (stable v-for + vnode hooks)', () => {+      const { node } = parseWithForTransform(+        `<div v-for="i in 3" :key="i" @vue:unmounted="foo" />`,+        {+          prefixIdentifiers: true,+          cacheHandlers: true,+          directiveTransforms: {+            bind: transformBind,+            on: transformOn,+          },+        },+      )+      const child = getVForChild(node)+      expect(child.isBlock).toBe(false)+      expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+    })++    test('NEED_PATCH (stable v-for + setup-const function ref)', () => {+      const { node } = parseWithForTransform(+        `<div v-for="i in 3" :key="i" :ref="setRefFn" />`,+        {+          prefixIdentifiers: true,+          bindingMetadata: {+            setRefFn: BindingTypes.SETUP_CONST,+          },+        },+      )+      const child = getVForChild(node)+      expect(child.isBlock).toBe(false)+      expect(child.patchFlag).toBe(PatchFlags.NEED_PATCH)+    })++    test('preserve block for stable v-for + custom directive with children', () => {+      const { node } = parseWithForTransform(+        `<div v-for="i in 3" v-dir>{{ i }}</div>`,+        { prefixIdentifiers: true },+      )+      const child = getVForChild(node)+      expect(child.isBlock).toBe(true)+      expect(child.patchFlag).toBe(PatchFlags.TEXT)+    })++    test.each(['before-update', 'beforeUpdate'])(+      'preserve block for stable v-for + @vue:%s vnode hook',+      hook => {+        const { node } = parseWithForTransform(+          `<div v-for="i in 3" @vue:${hook}="foo"><span /></div>`,+          {+            prefixIdentifiers: true,+            cacheHandlers: true,+            directiveTransforms: {+              bind: transformBind,+              on: transformOn,+            },+          },+        )+        const child = getVForChild(node)+        expect(child.isBlock).toBe(true)+        expect(child.patchFlag).toBeUndefined()+      },+    )++    test('does not add NEED_PATCH when another patch flag tracks the vnode', () => {+      const { node } = parseWithForTransform(+        `<div v-for="i in 3" :key="i" @vue:unmounted="foo">{{ i }}</div>`,+        {+          prefixIdentifiers: true,+          cacheHandlers: true,+          directiveTransforms: {+            bind: transformBind,+            on: transformOn,+          },+        },+      )+      const child = getVForChild(node)+      expect(child.isBlock).toBe(false)+      expect(child.patchFlag).toBe(PatchFlags.TEXT)+    })+     test('script setup inline mode template ref (binding exists)', () => {       const { node } = parseWithElementTransform(`<input ref="input"/>`, {         inline: true,packages/compiler-core/src/ast.tsindex e6da01edb..f67231539 100644@@ -330,6 +330,10 @@ export interface VNodeCall extends Node {   patchFlag: PatchFlags | undefined   dynamicProps: string | SimpleExpressionNode | undefined   directives: DirectiveArguments | undefined+  /** Whether this vnode must be patched if a later transform makes it non-block. */+  needsPatch?: boolean+  /** Whether a later transform must preserve this vnode as a block. */+  isBlockRequired?: boolean   isBlock: boolean   disableTracking: boolean   isComponent: booleanpackages/compiler-core/src/transforms/transformElement.tsindex 40f08d45b..b2024b329 100644@@ -102,6 +102,8 @@ export const transformElement: NodeTransform = (node, context) => {     let vnodeDynamicProps: VNodeCall['dynamicProps']     let dynamicPropNames: string[] | undefined     let vnodeDirectives: VNodeCall['directives']+    let needsPatch = false+    let isBlockRequired = false      let shouldUseBlock =       // dynamic component may resolve to plain elements@@ -127,6 +129,8 @@ export const transformElement: NodeTransform = (node, context) => {       vnodeProps = propsBuildResult.props       patchFlag = propsBuildResult.patchFlag       dynamicPropNames = propsBuildResult.dynamicPropNames+      needsPatch = propsBuildResult.needsPatch+      isBlockRequired = propsBuildResult.isBlockRequired       const directives = propsBuildResult.directives       vnodeDirectives =         directives && directives.length@@ -206,7 +210,7 @@ export const transformElement: NodeTransform = (node, context) => {       vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames)     } -    node.codegenNode = createVNodeCall(+    const vnodeCall = (node.codegenNode = createVNodeCall(       context,       vnodeTag,       vnodeProps,@@ -218,7 +222,15 @@ export const transformElement: NodeTransform = (node, context) => {       false /* disableTracking */,       isComponent,       node.loc,-    )+    ))+    needsPatch =+      needsPatch && (patchFlag === 0 || patchFlag === PatchFlags.NEED_HYDRATION)+    if (needsPatch) {+      vnodeCall.needsPatch = true+    }+    if (isBlockRequired) {+      vnodeCall.isBlockRequired = true+    }   } } @@ -382,6 +394,8 @@ export function buildProps(   patchFlag: number   dynamicPropNames: string[]   shouldUseBlock: boolean+  needsPatch: boolean+  isBlockRequired: boolean } {   const { tag, loc: elementLoc, children } = node   let properties: ObjectExpression['properties'] = []@@ -389,6 +403,7 @@ export function buildProps(   const runtimeDirectives: DirectiveNode[] = []   const hasChildren = children.length > 0   let shouldUseBlock = false+  let isBlockRequired = false    // patchFlag analysis   let patchFlag = 0@@ -444,6 +459,10 @@ export function buildProps(         hasVnodeHook = true       } +      if (name === 'ref') {+        hasRef = true+      }+       if (isEventHandler && value.type === NodeTypes.JS_CALL_EXPRESSION) {         // handler wrapped with internal helper e.g. withModifiers(fn)         // extract the actual expression@@ -460,13 +479,15 @@ export function buildProps(         return       } -      if (name === 'ref') {-        hasRef = true-      } else if (name === 'class') {+      if (name === 'class') {         hasClassBinding = true       } else if (name === 'style') {         hasStyleBinding = true-      } else if (name !== 'key' && !dynamicPropNames.includes(name)) {+      } else if (+        name !== 'ref' &&+        name !== 'key' &&+        !dynamicPropNames.includes(name)+      ) {         dynamicPropNames.push(name)       } @@ -573,14 +594,21 @@ export function buildProps(         continue       } +      // #938: elements with dynamic keys should be forced into blocks+      if (isVBind && isStaticArgOf(arg, 'key')) {+        shouldUseBlock = true+      }+      // inline before-update hooks need to remain blocks so that they are+      // invoked before children       if (-        // #938: elements with dynamic keys should be forced into blocks-        (isVBind && isStaticArgOf(arg, 'key')) ||-        // inline before-update hooks need to force block so that it is invoked-        // before children-        (isVOn && hasChildren && isStaticArgOf(arg, 'vue:before-update'))+        isVOn &&+        hasChildren &&+        arg &&+        isStaticExp(arg) &&+        camelize(arg.content) === 'vue:beforeUpdate'       ) {         shouldUseBlock = true+        isBlockRequired = true       }        if (isVBind && isStaticArgOf(arg, 'ref')) {@@ -691,6 +719,7 @@ export function buildProps(         // to ensure before-update gets called before children update         if (hasChildren) {           shouldUseBlock = true+          isBlockRequired = true         }       }     }@@ -736,11 +765,10 @@ export function buildProps(       patchFlag |= PatchFlags.NEED_HYDRATION     }   }-  if (-    !shouldUseBlock &&+  const needsPatch =     (patchFlag === 0 || patchFlag === PatchFlags.NEED_HYDRATION) &&     (hasRef || hasVnodeHook || runtimeDirectives.length > 0)-  ) {+  if (!shouldUseBlock && needsPatch) {     patchFlag |= PatchFlags.NEED_PATCH   } @@ -825,6 +853,8 @@ export function buildProps(     patchFlag,     dynamicPropNames,     shouldUseBlock,+    needsPatch,+    isBlockRequired,   } } packages/compiler-core/src/transforms/vFor.tsindex dcc31a9a9..ebf67d3d7 100644@@ -186,7 +186,9 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform(           if (isTemplate && keyProperty) {             injectProp(childBlock, keyProperty, context)           }-          if (childBlock.isBlock !== !isStableFragment) {+          const shouldUseBlock =+            !isStableFragment || childBlock.isBlockRequired === true+          if (childBlock.isBlock !== shouldUseBlock) {             if (childBlock.isBlock) {               // switch from block to vnode               removeHelper(OPEN_BLOCK)@@ -200,12 +202,16 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform(               )             }           }-          childBlock.isBlock = !isStableFragment+          childBlock.isBlock = shouldUseBlock           if (childBlock.isBlock) {             helper(OPEN_BLOCK)             helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent))           } else {             helper(getVNodeHelper(context.inSSR, childBlock.isComponent))+            if (childBlock.needsPatch) {+              childBlock.patchFlag = ((childBlock.patchFlag ?? 0) |+                PatchFlags.NEED_PATCH) as PatchFlags+            }           }         } packages/vue/__tests__/index.spec.tsindex 79e48b775..98f00cf28 100644@@ -1,5 +1,19 @@+import { BindingTypes, type CompilerOptions } from '@vue/compiler-core'+import { compile } from '@vue/compiler-dom' import { EMPTY_ARR } from '@vue/shared'-import { createApp, nextTick, reactive, ref } from '../src'+import { type VNode, createApp, nextTick, reactive, ref } from '../src'+import * as Vue from '../src'+import type { InternalRenderFunction } from '../../runtime-core/src/component'++function compileToFunction(template: string, options?: CompilerOptions) {+  const { code } = compile(template, {+    hoistStatic: true,+    ...options,+  })+  const render = new Function('Vue', code)(Vue) as InternalRenderFunction+  render._rc = true+  return render+}  describe('compiler + runtime integration', () => {   it('should support runtime template compilation', () => {@@ -347,4 +361,149 @@ describe('compiler + runtime integration', () => {     app.mount(root)     expect(root.innerHTML).toBe('<div>60000000100000111</div>')   })++  describe('stable v-for lifecycle', () => {+    test('clears static ref arrays on branch removal', async () => {+      const show = ref(true)+      const items = ref<HTMLElement[]>([])+      const app = createApp({+        setup: () => ({ items, show }),+        render: compileToFunction(+          `<template v-if="show"><div v-for="i in 3" :key="i" ref="items" /></template>`,+          { prefixIdentifiers: true },+        ),+      })+      const container = document.createElement('div')++      app.mount(container)+      expect(items.value).toHaveLength(3)++      show.value = false+      await nextTick()+      expect(items.value).toHaveLength(0)++      app.unmount()+    })++    test('calls setup-const function refs with null on branch removal', async () => {+      const show = ref(true)+      const values: (Element | null)[] = []+      const setRef = (value: Element | null) => values.push(value)+      const app = createApp({+        setup: () => ({ setRef, show }),+        render: compileToFunction(+          `<template v-if="show"><div v-for="i in 1" :ref="setRef" /></template>`,+          {+            prefixIdentifiers: true,+            bindingMetadata: {+              setRef: BindingTypes.SETUP_CONST,+            },+          },+        ),+      })+      const container = document.createElement('div')++      app.mount(container)+      expect(values).toHaveLength(1)+      expect(values[0]).toBeInstanceOf(HTMLDivElement)++      show.value = false+      await nextTick()+      expect(values).toHaveLength(2)+      expect(values[1]).toBeNull()++      app.unmount()+    })++    test('calls directive unmounted hooks on branch removal', async () => {+      const show = ref(true)+      const unmounted = vi.fn()+      const app = createApp({+        directives: { dir: { unmounted } },+        setup: () => ({ show }),+        render: compileToFunction(+          `<template v-if="show"><div v-for="i in 1" v-dir /></template>`,+          { prefixIdentifiers: true },+        ),+      })+      const container = document.createElement('div')++      app.mount(container)+      show.value = false+      await nextTick()+      expect(unmounted).toHaveBeenCalledOnce()++      app.unmount()+    })++    test('calls vnode unmounted hooks on branch removal', async () => {+      const show = ref(true)+      const onVnodeUnmounted = vi.fn()+      const app = createApp({+        setup: () => ({ onVnodeUnmounted, show }),+        render: compileToFunction(+          `<template v-if="show"><div v-for="i in 1" @vue:unmounted="onVnodeUnmounted" /></template>`,+          { prefixIdentifiers: true },+        ),+      })+      const container = document.createElement('div')++      app.mount(container)+      show.value = false+      await nextTick()+      expect(onVnodeUnmounted).toHaveBeenCalledOnce()++      app.unmount()+    })++    test('runs directive beforeUpdate before child updates', async () => {+      const value = ref('old')+      const observed: string[] = []+      const app = createApp({+        directives: {+          dir: {+            beforeUpdate(el: HTMLElement) {+              observed.push(el.textContent!)+            },+          },+        },+        setup: () => ({ value }),+        render: compileToFunction(+          `<div v-for="i in 1" v-dir>{{ value }}</div>`,+          { prefixIdentifiers: true },+        ),+      })+      const container = document.createElement('div')++      app.mount(container)+      value.value = 'new'+      await nextTick()+      expect(observed).toEqual(['old'])++      app.unmount()+    })++    test('runs vnode beforeUpdate before nested child updates', async () => {+      const value = ref('old')+      const observed: string[] = []+      const onVnodeBeforeUpdate = (vnode: VNode) => {+        observed.push((vnode.el as HTMLElement).textContent!)+      }+      const app = createApp({+        setup: () => ({ onVnodeBeforeUpdate, value }),+        render: compileToFunction(+          `<div v-for="i in 1" @vue:beforeUpdate="onVnodeBeforeUpdate"><span>{{ value }}</span></div>`,+          { prefixIdentifiers: true },+        ),+      })+      const container = document.createElement('div')++      app.mount(container)+      value.value = 'new'+      await nextTick()+      expect(observed).toEqual(['old'])++      app.unmount()+    })+  }) })