Backtestsvuerun-20261021-133314#9239

Issue #9239 Merged fix PR #11682 Run 21 Oct 2026 · run-20261021-133314 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

Tie

The judges split evenly between our patch and the merged fix.

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

Root cause (both identify it correctly): buildProps skips NEED_PATCH when the element is forced into a block by a dynamic :key, and transformFor then demotes that block to a plain vnode for a stable (constant-source) fragment, leaving a ref/directive/vnode-hook-carrying vnode with no patch flag. The parent block never tracks it, so unmount never calls setRef(null) and the ref array grows. Both patches make the demoted vnode carry NEED_PATCH, and all four independent tests pass on both.

Patch B simply drops the `!shouldUseBlock` guard. That is minimal and runtime-safe (NEED_PATCH on an already-tracked block is redundant and changes no patching path), but it is also incomplete relative to the issue text. The issue explicitly says a function ref 'don't get null'. In the reporter's script-setup environment a `:ref="fn"` binding is SETUP_CONST, so analyzePatchFlag returns early (constant value) before `hasRef = true` is ever set. B leaves that path untouched, so a setup-const function ref in the v-for still gets no NEED_PATCH and is never nulled; the independent function-ref test only passed on B because it was compiled without const binding metadata. B also leaves the before-update ordering broken: a demoted vnode with NEED_PATCH gets tracked after its own dynamic children in the parent block, so a `@vue:before-update` / directive beforeUpdate element with children inside a stable v-for fires after its children update, which is exactly what the forced-block rule exists to prevent. B's snapshot churn (NEED_PATCH added to every forced block with a directive/ref) is harmless but is noise rather than a fix.

Patch A addresses the demotion precisely: buildProps reports `needsPatch` and `isBlockRequired`, transformElement re-validates `needsPatch` against the final patchFlag (so TEXT-flagged nodes don't get a spurious NEED_PATCH, covered by a test), and transformFor ORs in NEED_PATCH only when it actually demotes a block, while keeping the block when a before-update hook with children requires it. It also moves `hasRef = true` ahead of the constant-value early return, so setup-const function refs are tracked, directly covering the issue's function-ref complaint with a dedicated integration test. The camelized `vue:beforeUpdate` match is an adjacent change but small, tested, and consistent with how transformOn normalizes the name.

Tests: both add compiler and compiler+runtime tests that fail on base. A's suite is broader and covers the const function ref, directive unmounted, vnode unmounted, and both beforeUpdate ordering cases; B covers static ref and directive unmount including repeated toggles.

Scope and craft: A is more invasive (two new optional VNodeCall fields) but the extra work is all the same mechanism and resolves parts of the issue B leaves broken. B is cleaner to read but emits a redundant flag on all forced blocks. A wins on correctness against the issue as stated.

Four judges ruled on this ticket in parallel, and the verdict comes from counting their votes. Each saw the issue and the two patches, labelled A and B in random order (two of them saw ours as A), with issue links and version numbers removed. Where tests could check the fix, they also saw the results of tests a separate agent wrote for the issue, run on both patches. None was told which patch was ours. The reasoning above is one judge's, shown verbatim.

Solve

11m 26s

Wall-clock time in the container

Full test suite

No new failures

1,855 passed · 1 skipped · 1,856 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

126vs 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+123 −3
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..428b77562 100644@@ -874,6 +874,55 @@ describe('compiler: v-for', () => {       expect(generate(root).code).toMatchSnapshot()     }) +    test('keyed v-for with constant expression and ref', () => {+      const {+        node: { codegenNode },+      } = parseWithForTransform(+        '<p v-for="i in 3" :key="i" ref="foo"><span/></p>',+        { prefixIdentifiers: true },+      )+      // the child is first created as a block due to the dynamic key, then+      // demoted to a plain vnode for the stable fragment. It must still carry+      // NEED_PATCH so it's tracked by the parent block for ref handling.+      expect(+        assertSharedCodegen(+          codegenNode,+          false /* keyed */,+          false /* customReturn */,+          false /* disableTracking */,+        ),+      ).toMatchObject({+        innerVNodeCall: {+          tag: `"p"`,+          isBlock: false,+          patchFlag: PatchFlags.NEED_PATCH,+        },+      })+    })++    test('keyed v-for with constant expression and custom directive', () => {+      const {+        node: { codegenNode },+      } = parseWithForTransform(+        '<p v-for="i in 3" :key="i" v-foo><span/></p>',+        { prefixIdentifiers: true },+      )+      expect(+        assertSharedCodegen(+          codegenNode,+          false /* keyed */,+          false /* customReturn */,+          false /* disableTracking */,+        ),+      ).toMatchObject({+        innerVNodeCall: {+          tag: `"p"`,+          isBlock: false,+          patchFlag: PatchFlags.NEED_PATCH,+        },+      })+    })+     test('template v-for', () => {       const {         root,packages/compiler-core/src/transforms/transformElement.tsindex 40f08d45b..d723e387f 100644@@ -736,8 +736,11 @@ export function buildProps(       patchFlag |= PatchFlags.NEED_HYDRATION     }   }+  // NEED_PATCH is also needed when the node is forced into a block, since it+  // may later be demoted to a plain vnode (e.g. a keyed v-for child with a+  // constant source) and must still be tracked so that its ref / vnode hooks /+  // directives are handled on patch and unmount.   if (-    !shouldUseBlock &&     (patchFlag === 0 || patchFlag === PatchFlags.NEED_HYDRATION) &&     (hasRef || hasVnodeHook || runtimeDirectives.length > 0)   ) {packages/vue/__tests__/index.spec.tsindex 79e48b775..5173a6bee 100644@@ -347,4 +347,72 @@ describe('compiler + runtime integration', () => {     app.mount(root)     expect(root.innerHTML).toBe('<div>60000000100000111</div>')   })++  // a keyed v-for over a constant source compiles to a stable fragment whose+  // children are plain vnodes, they must still be tracked for ref cleanup+  test('ref in keyed v-for with constant source should be cleaned up on unmount', async () => {+    const container = document.createElement('div')+    const Comp = { template: `<div>test</div>` }+    const isVisible = ref(true)+    const refDivArr = ref<Element[]>([])+    const refCompArr = ref<any[]>([])+    const App = {+      components: { Comp },+      compilerOptions: { prefixIdentifiers: true },+      setup() {+        return { isVisible, refDivArr, refCompArr }+      },+      template: `+        <div v-if="isVisible">+          <div v-for="(v, i) in 3" :key="i" ref="refDivArr">+            <Comp ref="refCompArr" />+          </div>+        </div>`,+    }+    createApp(App).mount(container)+    await nextTick()+    expect(refDivArr.value.length).toBe(3)+    expect(refCompArr.value.length).toBe(3)++    for (let i = 0; i < 3; i++) {+      isVisible.value = false+      await nextTick()+      expect(refDivArr.value.length).toBe(0)+      expect(refCompArr.value.length).toBe(0)++      isVisible.value = true+      await nextTick()+      expect(refDivArr.value.length).toBe(3)+      expect(refCompArr.value.length).toBe(3)+    }+  })++  test('custom directive in keyed v-for with constant source should be unmounted', async () => {+    const container = document.createElement('div')+    const isVisible = ref(true)+    let mounted = 0+    let unmounted = 0+    const App = {+      compilerOptions: { prefixIdentifiers: true },+      directives: {+        foo: {+          mounted: () => mounted++,+          unmounted: () => unmounted++,+        },+      },+      setup() {+        return { isVisible }+      },+      template: `+        <div v-if="isVisible">+          <div v-for="i in 3" :key="i" v-foo><span>{{ i }}</span></div>+        </div>`,+    }+    createApp(App).mount(container)+    expect(mounted).toBe(3)++    isVisible.value = false+    await nextTick()+    expect(unmounted).toBe(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()+    })+  }) })