Backtestsvuerun-20261007-145226#12569

Issue #12569 Merged fix PR # Run 7 Oct 2026 · run-20261007-145226 vuejs/core

Custom directive's unmounted event is not triggered on v-for element

Worse

The merged fix was judged better than our patch.

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

The bug: buildProps forces an element with a custom directive and children (or a dynamic key) into a block, which skips NEED_PATCH. A stable v-for then turns that block back into a plain vnode with no patch flag. The vnode is no longer tracked in the parent's dynamicChildren, so its directive unmounted and updated hooks, its ref and its vnode hooks are all skipped. Both patches fix the reported unmounted symptom.

Patch B adds NEED_PATCH in vFor whenever the converted vnode needs it. It detects this with `needsPatchAsVNode`, a helper that re-scans the element's props to duplicate buildProps' logic. That duplication is fragile. B also always demotes these elements to plain vnodes, which loses the reason they were forced into blocks: a directive's or vnode hook's beforeUpdate must run before the children update. As a plain vnode in the fragment, the element's children are created and tracked before the parent, so they update before its beforeUpdate. B's own test 'custom directive with children' locks in that non-block behavior.

Patch A carries information from buildProps on the VNodeCall instead:
- `needsPatch` adds NEED_PATCH when vFor demotes a key-forced block.
- `isBlockRequired` keeps the element a block when it has a custom directive or a vnode before-update hook with children.

This fixes the issue's case (directive plus children), because the element stays a tracked block and unmount and update hooks run. It also preserves beforeUpdate ordering, which A verifies with runtime tests. A also fixes a minor issue: the camelized `@vue:beforeUpdate` spelling was not recognized. Its compiler and runtime tests cover refs, function refs, directives, vnode hooks and ordering.

A touches more code (the AST interface and buildProps), but the changes are coherent and avoid B's duplicated prop-scanning. Overall A is the more correct root-cause 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 35s

Wall-clock time in the container

Full test suite

No new failures

3,666 passed · 6 skipped · 3,672 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

228vs 338 merged

Changed lines, ours vs merged

The two patches

Our patch+227 −1
packages/compiler-core/__tests__/transforms/vFor.spec.tsindex 839d9d358..b47f2a2ff 100644@@ -874,6 +874,80 @@ describe('compiler: v-for', () => {       expect(generate(root).code).toMatchSnapshot()     }) +    // #12569+    describe('constant v-for on element forced into a block', () => {+      function getInnerVNodeCall(template: string) {+        const {+          node: { codegenNode },+        } = parseWithForTransform(template, { prefixIdentifiers: true })+        return assertSharedCodegen(+          codegenNode,+          false /* keyed */,+          false /* customReturn */,+          false /* disableTracking */,+        ).innerVNodeCall+      }++      test('custom directive + dynamic key', () => {+        expect(+          getInnerVNodeCall(`<p v-for="i in 3" :key="i" v-foo>hi</p>`),+        ).toMatchObject({+          tag: `"p"`,+          isBlock: false,+          directives: { type: NodeTypes.JS_ARRAY_EXPRESSION },+          patchFlag: PatchFlags.NEED_PATCH,+        })+      })++      test('custom directive with children', () => {+        expect(+          getInnerVNodeCall(`<p v-for="i in 3" v-foo>hi</p>`),+        ).toMatchObject({+          isBlock: false,+          patchFlag: PatchFlags.NEED_PATCH,+        })+      })++      test('ref + dynamic key', () => {+        expect(+          getInnerVNodeCall(`<p v-for="i in 3" :key="i" ref="el">hi</p>`),+        ).toMatchObject({+          isBlock: false,+          patchFlag: PatchFlags.NEED_PATCH,+        })+      })++      test('template v-for with single element child', () => {+        expect(+          getInnerVNodeCall(+            `<template v-for="i in 3" :key="i"><p v-foo>hi</p></template>`,+          ),+        ).toMatchObject({+          tag: `"p"`,+          isBlock: false,+          patchFlag: PatchFlags.NEED_PATCH,+        })+      })++      test('keeps existing patch flag', () => {+        expect(+          getInnerVNodeCall(`<p v-for="i in 3" :key="i" v-foo>{{ i }}</p>`),+        ).toMatchObject({+          isBlock: false,+          patchFlag: PatchFlags.TEXT,+        })+      })++      test('does not add NEED_PATCH when not needed', () => {+        expect(+          getInnerVNodeCall(`<p v-for="i in 3" :key="i">hi</p>`),+        ).toMatchObject({+          isBlock: false,+          patchFlag: undefined,+        })+      })+    })+     test('template v-for', () => {       const {         root,packages/compiler-core/src/transforms/vFor.tsindex dcc31a9a9..6065f0fce 100644@@ -47,7 +47,7 @@ import { } from '../runtimeHelpers' import { processExpression } from './transformExpression' import { validateBrowserExpression } from '../validateExpression'-import { PatchFlags } from '@vue/shared'+import { PatchFlags, isOn, isReservedProp } from '@vue/shared'  export const transformFor: NodeTransform = createStructuralDirectiveTransform(   'for',@@ -201,6 +201,18 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform(             }           }           childBlock.isBlock = !isStableFragment+          if (+            !childBlock.isBlock &&+            needsPatchAsVNode(children[0] as PlainElementNode, childBlock)+          ) {+            // the element may have been forced into a block (e.g. by a dynamic+            // key or custom directives), which skipped the NEED_PATCH flag.+            // As a plain vnode inside a stable fragment it must still be+            // tracked as a dynamic child, otherwise its directives, ref and+            // vnode hooks are skipped on update / unmount.+            childBlock.patchFlag =+              (childBlock.patchFlag || 0) | PatchFlags.NEED_PATCH+          }           if (childBlock.isBlock) {             helper(OPEN_BLOCK)             helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent))@@ -391,3 +403,30 @@ function createParamsList(     .slice(0, i + 1)     .map((arg, i) => arg || createSimpleExpression(`_`.repeat(i + 1), false)) }++// mirrors the NEED_PATCH condition in buildProps (transformElement): a vnode+// with no patch flag (or only NEED_HYDRATION, which is not tracked by blocks)+// that has a ref, vnode hooks or runtime directives needs NEED_PATCH.+function needsPatchAsVNode(node: PlainElementNode, vnodeCall: VNodeCall) {+  const { patchFlag } = vnodeCall+  if (patchFlag && patchFlag !== PatchFlags.NEED_HYDRATION) {+    return false+  }+  if (vnodeCall.directives) {+    return true+  }+  return node.props.some(p => {+    if (p.type === NodeTypes.ATTRIBUTE) {+      return p.name === 'ref' || (isOn(p.name) && isReservedProp(p.name))+    }+    const arg =+      p.arg && p.arg.type === NodeTypes.SIMPLE_EXPRESSION && p.arg.isStatic+        ? p.arg.content+        : null+    if (arg == null) return false+    if (p.name === 'bind') {+      return arg === 'ref' || (isOn(arg) && isReservedProp(arg))+    }+    return p.name === 'on' && arg.startsWith('vue:')+  })+}packages/vue/__tests__/index.spec.tsindex 79e48b775..f914eece7 100644@@ -347,4 +347,117 @@ describe('compiler + runtime integration', () => {     app.mount(root)     expect(root.innerHTML).toBe('<div>60000000100000111</div>')   })++  // #12569+  describe('constant v-for children forced into blocks', () => {+    // constant v-for sources are only detected with prefixIdentifiers, which+    // is what pre-compiled (SFC / build tool) templates use.+    const compilerOptions = { prefixIdentifiers: true }++    it('should call custom directive unmounted hook', async () => {+      const container = document.createElement('div')+      const visible = ref(true)+      const mounted = vi.fn()+      const unmounted = vi.fn()+      createApp({+        compilerOptions,+        template: `+          <template v-if="visible">+            <h1 v-for="i in 3" :key="i" v-focus>hello</h1>+          </template>+          <template v-if="visible">+            <template v-for="i in 2" :key="i"><p v-focus>static</p></template>+          </template>+          <div v-focus v-if="visible">my tag</div>+        `,+        directives: {+          focus: {+            mounted: (el: Element) => mounted(el.tagName),+            unmounted: (el: Element) => unmounted(el.tagName),+          },+        },+        setup: () => ({ visible }),+      }).mount(container)+      expect(mounted).toHaveBeenCalledTimes(6)++      visible.value = false+      await nextTick()+      expect(container.querySelectorAll('h1,p,div').length).toBe(0)+      expect(unmounted.mock.calls.map(c => c[0])).toEqual([+        'H1',+        'H1',+        'H1',+        'P',+        'P',+        'DIV',+      ])+    })++    it('should call custom directive updated hook', async () => {+      const container = document.createElement('div')+      const count = ref(0)+      const updated = vi.fn()+      createApp({+        compilerOptions,+        template: `+          <span>{{ count }}</span>+          <h1 v-for="i in 2" :key="i" v-foo="count">static</h1>+        `,+        directives: {+          foo: {+            updated: (_el: Element, binding: any) => updated(binding.value),+          },+        },+        setup: () => ({ count }),+      }).mount(container)++      count.value+++      await nextTick()+      expect(updated.mock.calls).toEqual([[1], [1]])+    })++    it('should unset template ref on unmount', async () => {+      const container = document.createElement('div')+      const visible = ref(true)+      let instance: any+      createApp({+        compilerOptions,+        template: `+          <template v-if="visible">+            <h1 v-for="i in 2" :key="i" ref="items">static</h1>+          </template>+        `,+        setup: () => ({ visible }),+        mounted() {+          instance = this+        },+      }).mount(container)+      expect(instance.$refs.items.length).toBe(2)++      visible.value = false+      await nextTick()+      expect(instance.$refs.items).toEqual([])+    })++    it('should call vnode unmounted hook', async () => {+      const container = document.createElement('div')+      const visible = ref(true)+      const onUnmounted = vi.fn()+      createApp({+        // cached handlers make the hook prop constant+        compilerOptions: { ...compilerOptions, cacheHandlers: true },+        template: `+          <template v-if="visible">+            <h1 v-for="i in 2" :key="i" @vue:unmounted="onUnmounted()">static</h1>+          </template>+        `,+        setup: () => ({ visible, onUnmounted }),+      }).mount(container)++      visible.value = false+      await nextTick()+      expect(container.querySelectorAll('h1').length).toBe(0)+      expect(onUnmounted).toHaveBeenCalledTimes(2)+    })+  }) }) 
Merged fix · PR #+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()+    })+  }) })