Backtestsvuerun-20261003-231210#12569

Issue #12569 Merged fix PR # Run 3 Oct 2026 · run-20261003-231210 vuejs/core

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

Better

Our patch was judged better than the merged fix.

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

Both patches fix the root cause the same way. When transformFor downgrades a block child of a stable fragment to a plain vnode, the child lacked NEED_PATCH because transformElement only adds that flag when it is not forcing a block. Without the flag the vnode is left out of dynamicChildren, so directive, vnode-hook and ref teardown are skipped on unmount.

Patch A applies the fix locally in vFor.ts. A small helper mirrors transformElement's NEED_PATCH condition: no other patch flag, plus runtime directives or reserved props such as ref or onVnode*. If the helper matches, the downgraded child gets NEED_PATCH. The change is small, easy to review, and leaves non-v-for compilation untouched. Its compiler tests cover the flag combinations: a directive with children, a dynamic key with a directive, a ref, another existing flag, and nothing to patch. Its integration tests reproduce the issue's scenario (directive unmounted on a v-for under a v-if toggle) plus vnode hooks and ref cleanup, and would fail before the fix.

Patch B fixes the same bug by threading needsPatch and isBlockRequired metadata from buildProps through the VNodeCall AST into vFor. It also bundles several behavior changes beyond the issue:
- It moves hasRef detection before the constant-expression early return, which changes NEED_PATCH emission for setup-const :ref on all elements, not just in v-for.
- It broadens the before-update check to camelized variants.
- It keeps beforeUpdate-hook elements as blocks inside stable fragments.

These may be defensible improvements, but they widen the change surface across transformElement, buildProps and the AST interface, which adds regression risk and obscures the core fix. Its test helper also reaches into the AST by raw indices, and its integration-test setup is heavier.

On the reported issue, both are correct and well tested. A is the focused, lower-risk fix, while B's extra redesign earns no credit and adds risk.

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

13m 4s

Wall-clock time in the container

Full test suite

No new failures

3,656 passed · 6 skipped · 3,662 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

193vs 338 merged

Changed lines, ours vs merged

The two patches

Our patch+192 −1
packages/compiler-core/__tests__/transforms/vFor.spec.tsindex 839d9d358..5afeae55a 100644@@ -874,6 +874,57 @@ describe('compiler: v-for', () => {       expect(generate(root).code).toMatchSnapshot()     }) +    // #12569+    test('v-for with constant expression on element forced into block', () => {+      const getInnerVNodeCall = (template: string) => {+        const {+          node: { codegenNode },+        } = parseWithForTransform(template, { prefixIdentifiers: true })+        return assertSharedCodegen(+          codegenNode,+          false /* keyed */,+          false /* customReturn */,+          false /* disableTracking */,+        ).innerVNodeCall+      }++      // custom directive w/ children forces a block+      expect(+        getInnerVNodeCall(`<p v-for="item in 10" v-foo>hi</p>`),+      ).toMatchObject({+        isBlock: false,+        patchFlag: PatchFlags.NEED_PATCH,+        directives: {},+      })+      // dynamic key forces a block+      expect(+        getInnerVNodeCall(`<p v-for="item in 10" :key="item" v-foo />`),+      ).toMatchObject({+        isBlock: false,+        patchFlag: PatchFlags.NEED_PATCH,+      })+      expect(+        getInnerVNodeCall(`<p v-for="item in 10" :key="item" ref="foo" />`),+      ).toMatchObject({+        isBlock: false,+        patchFlag: PatchFlags.NEED_PATCH,+      })+      // other dynamic bindings already make it tracked+      expect(+        getInnerVNodeCall(`<p v-for="i in 10" :key="i" :id="i" v-foo />`),+      ).toMatchObject({+        isBlock: false,+        patchFlag: PatchFlags.PROPS,+      })+      // nothing to patch at runtime+      expect(+        getInnerVNodeCall(`<p v-for="item in 10" :key="item" />`),+      ).toMatchObject({+        isBlock: false,+        patchFlag: undefined,+      })+    })+     test('template v-for', () => {       const {         root,packages/compiler-core/src/transforms/vFor.tsindex dcc31a9a9..36ffa45a0 100644@@ -47,7 +47,7 @@ import { } from '../runtimeHelpers' import { processExpression } from './transformExpression' import { validateBrowserExpression } from '../validateExpression'-import { PatchFlags } from '@vue/shared'+import { PatchFlags, isReservedProp } from '@vue/shared'  export const transformFor: NodeTransform = createStructuralDirectiveTransform(   'for',@@ -200,6 +200,19 @@ export const transformFor: NodeTransform = createStructuralDirectiveTransform(               )             }           }+          if (+            childBlock.isBlock &&+            isStableFragment &&+            needsPatchAsPlainVNode(childBlock)+          ) {+            // the element was forced into a block (e.g. by `key` or a custom+            // directive), so transformElement did not add NEED_PATCH. Now that+            // it is downgraded to a plain vnode it must be marked so it is+            // tracked by the stable fragment's block; otherwise its directive+            // / vnode hooks and ref are skipped on update and unmount.+            childBlock.patchFlag =+              (childBlock.patchFlag || 0) | PatchFlags.NEED_PATCH+          }           childBlock.isBlock = !isStableFragment           if (childBlock.isBlock) {             helper(OPEN_BLOCK)@@ -391,3 +404,29 @@ function createParamsList(     .slice(0, i + 1)     .map((arg, i) => arg || createSimpleExpression(`_`.repeat(i + 1), false)) }++/**+ * Whether an element vnode call needs NEED_PATCH to be collected as a dynamic+ * child when it is not a block. Mirrors the NEED_PATCH condition in+ * transformElement: no other patch flag, and has ref / vnode hooks / runtime+ * directives.+ */+function needsPatchAsPlainVNode(node: VNodeCall): boolean {+  const { patchFlag, props, directives } = node+  if (patchFlag && patchFlag !== PatchFlags.NEED_HYDRATION) {+    return false+  }+  if (directives) {+    return true+  }+  return (+    !!props &&+    props.type === NodeTypes.JS_OBJECT_EXPRESSION &&+    props.properties.some(({ key }) => {+      if (key.type !== NodeTypes.SIMPLE_EXPRESSION || !key.isStatic) {+        return false+      }+      return key.content !== 'key' && isReservedProp(key.content)+    })+  )+}packages/vue/__tests__/index.spec.tsindex 79e48b775..6b7e666fa 100644@@ -329,6 +329,107 @@ describe('compiler + runtime integration', () => {     expect(container.innerHTML).toBe(`<div>foo</div>`)   }) +  // #12569+  describe('v-for with constant source', () => {+    const template = (attrs: string, content = 'static') =>+      `<template v-if="visible">` ++      `<h1 v-for="i in 2" :key="i" ${attrs}>${content}</h1>` ++      `</template>`++    test('custom directive hooks on update and unmount', async () => {+      const calls: string[] = []+      const visible = ref(true)+      const msg = ref('a')+      const container = document.createElement('div')+      createApp({+        // needed for the v-for source to be analyzed as constant+        compilerOptions: { prefixIdentifiers: true },+        template: template('v-foo', '{{ msg }}'),+        directives: {+          foo: {+            mounted: (el: Element) => calls.push(`mounted ${el.textContent}`),+            updated: (el: Element) => calls.push(`updated ${el.textContent}`),+            unmounted: (el: Element) =>+              calls.push(`unmounted ${el.textContent}`),+          },+        },+        setup() {+          return { visible, msg }+        },+      }).mount(container)+      expect(calls).toEqual(['mounted a', 'mounted a'])++      msg.value = 'b'+      await nextTick()+      expect(calls.slice(2)).toEqual(['updated b', 'updated b'])++      visible.value = false+      await nextTick()+      expect(container.innerHTML).toBe(`<!--v-if-->`)+      expect(calls.slice(4)).toEqual(['unmounted b', 'unmounted b'])+    })++    test('custom directive unmounted hook w/ static content', async () => {+      const unmounted = vi.fn()+      const visible = ref(true)+      const container = document.createElement('div')+      createApp({+        // needed for the v-for source to be analyzed as constant+        compilerOptions: { prefixIdentifiers: true },+        template: template('v-foo'),+        directives: { foo: { unmounted } },+        setup() {+          return { visible }+        },+      }).mount(container)++      visible.value = false+      await nextTick()+      expect(container.innerHTML).toBe(`<!--v-if-->`)+      expect(unmounted).toHaveBeenCalledTimes(2)+    })++    test('vnode hooks on unmount', async () => {+      const unmounted = vi.fn()+      const visible = ref(true)+      const container = document.createElement('div')+      createApp({+        // needed for the v-for source to be analyzed as constant+        // cached handler so the element has no other patch flag+        compilerOptions: { prefixIdentifiers: true, cacheHandlers: true },+        template: template('@vue:unmounted="onUnmounted"'),+        setup() {+          return { visible, onUnmounted: unmounted }+        },+      }).mount(container)++      visible.value = false+      await nextTick()+      expect(container.innerHTML).toBe(`<!--v-if-->`)+      expect(unmounted).toHaveBeenCalledTimes(2)+    })++    test('ref is unset on unmount', async () => {+      const visible = ref(true)+      const items = ref<Element[]>([])+      const container = document.createElement('div')+      createApp({+        // needed for the v-for source to be analyzed as constant+        compilerOptions: { prefixIdentifiers: true },+        template: template('ref="items"'),+        setup() {+          return { visible, items }+        },+      }).mount(container)+      expect(items.value.length).toBe(2)++      visible.value = false+      await nextTick()+      expect(container.innerHTML).toBe(`<!--v-if-->`)+      expect(items.value.length).toBe(0)+    })+  })+   // #2413   it('EMPTY_ARR should not change', () => {     const App = { 
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()+    })+  }) })