Backtestsvuerun-20261001-022054#10505

Issue #10505 Merged fix PR #15298 Run 30 Sep 2026 · run-20261001-022054 vuejs/core

Clearing select's value in change handler behaviour changed since 3.4.15 via webdriver

Worse

The merged fix was judged better than our patch.

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

Both patches find the same root cause. The `_assigning` flag added for select performance makes `updated` skip `setSelected` for the whole tick. So when a @change handler changes the model again after v-model's assignment (e.g. sets it to null), the DOM is never resynced. Both patches fix the issue by remembering what was assigned and resyncing only when the model no longer matches.

Patch A compares by identity: `toRaw(value) !== el._assignedValue`. This fixes the reported single-select case, where 'foo' is assigned and then the handler sets null. Its test reproduces the bug and would fail before the change. But identity comparison misses in-place changes. If the handler mutates the emitted Array (pop/push) or Set (delete), the reference is unchanged, so A still skips the resync and the DOM stays stale. That is the same class of bug the issue describes. A also never clears `_assignedValue` in `updated`, so it relies only on the nextTick reset.

Patch B snapshots the assigned value, copying Arrays so later mutation can't hide a change. It compares with `looseEqual` or a Set-membership check, also resyncs if `multiple` changed, and clears the pending marker in `updated`. A nextTick guard in `finally` means a throwing assigner can't leave stale state. These extra cases all follow from the same root cause (the model diverging from the DOM within the pending tick), so they are not unrelated churn.

B's tests cover the reported scenario plus mutation, Set override, duplicate values, a multiple-to-single toggle, and assigner errors. Several tests also check that the optimization is kept, using zero option write counts. The added complexity is moderate and well contained.

Overall, B is more robustly correct on the root cause and much better tested, while A is simpler but leaves closely related stale-DOM cases unfixed.

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

2m 31s12 turns

Wall-clock time in the container

Full test suite

No new failures

3,680 passed · 6 skipped · 3,686 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

52vs 345 merged

Changed lines, ours vs merged

Vue version

3.4.21

Link to minimal reproduction

https://play.vuejs.org/#eNp9Uk1P4zAQ/SuzvtBKkO5q91SllXYRh+VAEXACc4iSSWtwbMsfoVLIf2ds00IRkEMSz3sz8+Z5BvbXmKIPyOas9NgZWXlccgVQOpRYe+hPOt2gXHCWA0IrziJh9/QnWs3rTaXWSCT6NhJX6jQFOEu1qJo2MRP6SoZI+0nILVpdzjLwBe0X0VYKD1jlLAvJB0P9W22jPBAKMoQN5Q0DOBjHcmaIWc7eDUdHV1thPEgSSanecUapPkSq6Iy2Hgaw2MIIrdUdHJFDRzGx1sr51y5R6CKySuetUGt4BhWkXE7ie3rIxeaAene/nNzdE4erNqhc6tA5mEzn0GvRwBDnFC1M9l2LZA/8WCxSw2mmwL5VxgsT3OZjErUEGOPrY7VciysCyeFkz5IdkzU0RivWxYPTipYkteKs1p0REu0q3QvZN9+J4KySUj+dp5i3AY938XqD9eMn8Qe3jTHOLi06tD1tzR7zlV2jz/DZ9QVu6X8P0mIGSexvwCt0Woa8tJH2L0ST7TteUvs/3TldzI0723pUbjdUFJosS3zOaA9Ovxn9Te7v4s+r1SMbXwCvMCS3

Steps to reproduce

👋 sorry I can only reproduce this myself when acting on chrome with webdriver, but I have narrowed it down a lot

the basic premise is we have a strange select that clears its value on change, exampled in the repo link

The bug occurs when _webdriver_ clicks the select and clicks one of the options within the value does not get cleared afterwards. If I click in the page myself it clears properly.

What is expected?

The value of the select afterwards should be null

What is actually happening?

it is whatever was selected last, ie 0 or 1

System Info

System:
    OS: Linux 5.15 Ubuntu 20.04.6 LTS (Focal Fossa)
    CPU: (32) x64 AMD Ryzen 9 5950X 16-Core Processor
    Memory: 55.80 GB / 88.39 GB
    Container: Yes
    Shell: 5.0.17 - /bin/bash
  Binaries:
    Node: 18.16.1 - ~/.nvm/versions/node/v18.16.1/bin/node
    npm: 9.5.1 - ~/.nvm/versions/node/v18.16.1/bin/npm
  Browsers:
    Chrome: 122.0.6261.94

Any additional comments?

I have bisected the releases and found that this first happens from 3.4.15. I suspect the change is related to the select performance improvement https://github.com/vuejs/core/commit/2ffb956efe692da059f4895669084c5278871351

further i notice the commit introduces and _assigning field which changes the behaviour until the next tick. and wrapping the clearing call in nextTick works as a workaround in my instance.

  nextTick(() => { selection.value = null })

I suspect the issue relates to the fact that webdriver submits selection events in a slightly unusual manner. However I think that shouldn't mean this broke but it has

The two patches

Our patch+44 −8
packages/runtime-dom/__tests__/directives/vModel.spec.tsindex 590c0d7df..037d1b731 100644@@ -1009,6 +1009,36 @@ describe('vModel', () => {     expect(bar.selected).toEqual(true)   }) +  it('should reset single select value when cleared in change handler', async () => {+    const value = ref<string | null>(null)+    const component = defineComponent({+      render() {+        return withVModel(+          h(+            'select',+            {+              'onUpdate:modelValue': (val: any) => (value.value = val),+              onChange: () => (value.value = null),+            },+            [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+          ),+          value.value,+        )+      },+    })+    render(h(component), root)++    const input = root.querySelector('select')+    const foo = root.querySelector('option[value=foo]')++    foo.selected = true+    triggerEvent('change', input)+    await nextTick()+    expect(value.value).toBe(null)+    expect(input.selectedIndex).toBe(-1)+    expect(foo.selected).toBe(false)+  })+   it('multiple select (model is Array)', async () => {     const component = defineComponent({       data() {packages/runtime-dom/src/directives/vModel.tsindex eeb248f28..bcda2ebf3 100644@@ -4,6 +4,7 @@ import {   type ObjectDirective,   type VNode,   nextTick,+  toRaw,   warn, } from '@vue/runtime-core' import { addEventListener } from '../modules/events'@@ -45,6 +46,7 @@ type ModelDirective<T, Modifiers extends string = string> = ObjectDirective<     [assignKey]: AssignerFn     [initialValueKey]?: string     _assigning?: boolean+    _assignedValue?: any   },   any,   Modifiers@@ -240,16 +242,17 @@ export const vModelSelect: ModelDirective<HTMLSelectElement, 'number'> = {         .map((o: HTMLOptionElement) =>           number ? looseToNumber(getValue(o)) : getValue(o),         )-      el[assignKey](-        el.multiple-          ? isSet((el as any)._modelValue)-            ? new Set(selectedVal)-            : selectedVal-          : selectedVal[0],-      )+      const assignedValue = el.multiple+        ? isSet((el as any)._modelValue)+          ? new Set(selectedVal)+          : selectedVal+        : selectedVal[0]+      el[assignKey](assignedValue)       el._assigning = true+      el._assignedValue = assignedValue       nextTick(() => {         el._assigning = false+        el._assignedValue = undefined       })     })     el[assignKey] = getModelAssigner(vnode)@@ -264,7 +267,10 @@ export const vModelSelect: ModelDirective<HTMLSelectElement, 'number'> = {     el[assignKey] = getModelAssigner(vnode)   },   updated(el, { value }) {-    if (!el._assigning) {+    // skip re-syncing only if the model still holds the value just assigned+    // from the DOM; it may have been changed again in the same tick (e.g. by a+    // @change handler)+    if (!el._assigning || toRaw(value) !== el._assignedValue) {       setSelected(el, value)     }   }, 
Merged fix · PR #15298+333 −12
packages/runtime-dom/__tests__/directives/vModel.spec.tsindex 590c0d7df..429163126 100644@@ -1317,6 +1317,290 @@ describe('vModel', () => {     expect(bar.selected).toEqual(true)   }) +  function mountSelectModel(+    initialValue: any,+    update: (value: any) => any,+    multiple = false,+    optionValues: any[] = ['foo', 'bar'],+  ) {+    const component = defineComponent({+      data: () => ({ value: initialValue }),+      render() {+        return withVModel(+          h(+            'select',+            {+              multiple,+              'onUpdate:modelValue': (value: any) => {+                this.value = update(value)+              },+            },+            optionValues.map(value => h('option', { value })),+          ),+          this.value,+        )+      },+    })+    render(h(component), root)+    const input = root.querySelector('select') as HTMLSelectElement+    return { input, options: input.options, data: root._vnode.component.data }+  }++  function trackSelectedWrites(input: HTMLSelectElement) {+    const selected = Object.getOwnPropertyDescriptor(+      HTMLOptionElement.prototype,+      'selected',+    )!+    let writes = 0+    for (const option of input.options) {+      Object.defineProperty(option, 'selected', {+        configurable: true,+        get: selected.get,+        set(value) {+          writes+++          selected.set!.call(this, value)+        },+      })+    }+    return () => writes+  }++  it('should sync a multiple select when the Set model is overridden', async () => {+    const { input, options, data } = mountSelectModel(+      new Set<string>(),+      () => new Set(['foo']),+      true,+    )+    const foo = options[0]+    const bar = options[1]++    bar.selected = true+    triggerEvent('change', input)+    await nextTick()++    expect(Array.from(data.value)).toEqual(['foo'])+    expect(foo.selected).toBe(true)+    expect(bar.selected).toBe(false)+  })++  it('should clear a single select when a native change handler clears the model', async () => {+    const component = defineComponent({+      data() {+        return { value: null as string | null }+      },+      render() {+        return withVModel(+          h(+            'select',+            {+              'onUpdate:modelValue': setValue.bind(this),+              onChange: () => {+                this.value = null+              },+            },+            [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+          ),+          this.value,+        )+      },+    })+    render(h(component), root)+    const input = root.querySelector('select') as HTMLSelectElement+    const data = root._vnode.component.data++    input.options[1].selected = true+    triggerEvent('change', input)+    await nextTick()++    expect(data.value).toBe(null)+    expect(input.selectedIndex).toBe(-1)+  })++  it('should preserve the selected option when duplicate values exist', async () => {+    const { input, options, data } = mountSelectModel(+      null,+      value => value,+      false,+      ['foo', 'foo'],+    )++    options[1].selected = true+    triggerEvent('change', input)+    await nextTick()++    expect(data.value).toBe('foo')+    expect(input.selectedIndex).toBe(1)+  })++  it('should resync when a multiple select becomes single during the pending update', async () => {+    const component = defineComponent({+      data() {+        return { value: [] as string[], multiple: true }+      },+      render() {+        return withVModel(+          h(+            'select',+            {+              multiple: this.multiple,+              'onUpdate:modelValue': (value: string[]) => {+                this.value = value+                this.multiple = false+              },+            },+            [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+          ),+          this.value,+        )+      },+    })+    render(h(component), root)+    const input = root.querySelector('select') as HTMLSelectElement+    const data = root._vnode.component.data++    input.options[1].selected = true+    triggerEvent('change', input)+    await nextTick()++    expect(data.value).toEqual(['bar'])+    expect(input.multiple).toBe(false)+    expect(input.selectedIndex).toBe(-1)+  })++  it('should snapshot an emitted Array before the change handler mutates it', async () => {+    const { input, options, data } = mountSelectModel(+      ['foo'],+      (value: string[]) => {+        value.pop()+        return value+      },+      true,+    )+    const foo = options[0]+    const bar = options[1]++    foo.selected = true+    bar.selected = true+    triggerEvent('change', input)+    await nextTick()++    expect(data.value).toEqual(['foo'])+    expect(foo.selected).toBe(true)+    expect(bar.selected).toBe(false)+  })++  it('should resync after the emitted Set is mutated in the change handler', async () => {+    const { input, options, data } = mountSelectModel(+      new Set(['foo']),+      (value: Set<string>) => {+        value.delete('bar')+        return value+      },+      true,+    )+    const foo = options[0]+    const bar = options[1]++    foo.selected = true+    bar.selected = true+    triggerEvent('change', input)+    await nextTick()++    expect(Array.from(data.value)).toEqual(['foo'])+    expect(foo.selected).toBe(true)+    expect(bar.selected).toBe(false)+  })++  it('should not rewrite options after assigning a Set of objects', async () => {+    const fooValue = { id: 'foo' }+    const barValue = { id: 'bar' }+    const { input, options } = mountSelectModel(+      new Set([fooValue]),+      value => value,+      true,+      [fooValue, barValue],+    )++    options[0].selected = false+    options[1].selected = true+    const getWrites = trackSelectedWrites(input)+    triggerEvent('change', input)+    await nextTick()++    expect(getWrites()).toBe(0)+  })++  it('should not rewrite options after assigning an Array of objects', async () => {+    const fooValue = { id: 'foo' }+    const barValue = { id: 'bar' }+    const { input, options } = mountSelectModel([], value => value, true, [+      fooValue,+      barValue,+    ])++    options[1].selected = true+    const getWrites = trackSelectedWrites(input)+    triggerEvent('change', input)+    await nextTick()++    expect(getWrites()).toBe(0)+  })++  it('should not rewrite options for a primitive Array model', async () => {+    const optionValues = Array.from({ length: 10 }, (_, i) => i)+    const { input, options, data } = mountSelectModel(+      [],+      value => value,+      true,+      optionValues,+    )++    for (let i = 0; i < 5; i++) options[i].selected = true+    const getWrites = trackSelectedWrites(input)+    triggerEvent('change', input)+    await nextTick()++    expect(data.value).toHaveLength(5)+    expect(getWrites()).toBe(0)+  })++  it('should clear the pending assignment when the assigner throws', async () => {+    const error = new Error('assign failed')+    const component = defineComponent({+      data: () => ({ value: [] }),+      render() {+        return withVModel(+          h(+            'select',+            {+              multiple: true,+              'onUpdate:modelValue': () => {+                throw error+              },+            },+            [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+          ),+          this.value,+        )+      },+    })+    render(h(component), root)+    const input = root.querySelector('select') as HTMLSelectElement+    const onError = vi.fn((event: ErrorEvent) => event.preventDefault())+    window.addEventListener('error', onError)++    try {+      input.options[1].selected = true+      triggerEvent('change', input)+      await nextTick()++      expect(onError).toHaveBeenCalled()+      expect((input as any)._pendingValue).toBeUndefined()+    } finally {+      window.removeEventListener('error', onError)+    }+  })+   it('multiple select uses current Array/Set model type', async () => {     const component = defineComponent({       data() {packages/runtime-dom/src/directives/vModel.tsindex eeb248f28..041f17c5a 100644@@ -44,7 +44,7 @@ type ModelDirective<T, Modifiers extends string = string> = ObjectDirective<   T & {     [assignKey]: AssignerFn     [initialValueKey]?: string-    _assigning?: boolean+    _pendingValue?: [multiple: boolean, value: any]   },   any,   Modifiers@@ -240,17 +240,31 @@ export const vModelSelect: ModelDirective<HTMLSelectElement, 'number'> = {         .map((o: HTMLOptionElement) =>           number ? looseToNumber(getValue(o)) : getValue(o),         )-      el[assignKey](-        el.multiple-          ? isSet((el as any)._modelValue)-            ? new Set(selectedVal)+      const multiple = el.multiple+      const assignedValue = multiple+        ? isSet((el as any)._modelValue)+          ? new Set(selectedVal)+          : selectedVal+        : selectedVal[0]+      // Array models receive selectedVal directly, so snapshot it before user+      // code can mutate it. Set models already receive a fresh Set.+      const pending = (el._pendingValue = [+        multiple,+        multiple+          ? isArray(assignedValue)+            ? selectedVal.slice()             : selectedVal-          : selectedVal[0],-      )-      el._assigning = true-      nextTick(() => {-        el._assigning = false-      })+          : assignedValue,+      ])+      try {+        el[assignKey](assignedValue)+      } finally {+        nextTick(() => {+          if (el._pendingValue === pending) {+            el._pendingValue = undefined+          }+        })+      }     })     el[assignKey] = getModelAssigner(vnode)   },@@ -264,12 +278,35 @@ export const vModelSelect: ModelDirective<HTMLSelectElement, 'number'> = {     el[assignKey] = getModelAssigner(vnode)   },   updated(el, { value }) {-    if (!el._assigning) {+    const pending = el._pendingValue+    el._pendingValue = undefined+    if (+      !pending ||+      pending[0] !== el.multiple ||+      !isSameSelectValue(value, pending[1], pending[0])+    ) {       setSelected(el, value)     }   }, } +function isSameSelectValue(+  value: any,+  assignedValue: any,+  multiple: boolean,+): boolean {+  if (!multiple) return looseEqual(value, assignedValue)+  if (isArray(value)) return looseEqual(value, assignedValue)+  if (isSet(value)) {+    if (value.size !== assignedValue.length) return false+    for (const item of assignedValue) {+      if (!value.has(item)) return false+    }+    return true+  }+  return false+}+ function setSelected(el: HTMLSelectElement, value: any) {   const isMultiple = el.multiple   const isArrayValue = isArray(value) 

What the agent reported

I fixed the bug: a <select v-model> whose @change handler clears the model now actually clears on screen. The new regression test failed before the fix and passes after it.

What was wrong: The 3.4.15 speed-up (commit 2ffb956) works like this. When the select fires change, vModelSelect writes the picked value to the model and sets el._assigning = true until the next tick. While that flag is set, the updated hook skips setSelected, on the assumption that the page already shows the model's value. That assumption breaks when your @change handler runs in the same tick (v-model's listener runs first) and sets selection.value = null. The component re-renders with null, but setSelected is skipped, so the page keeps showing the option you picked. The nextTick workaround from the report only works because it runs after the flag has been reset.

What I changed (packages/runtime-dom/src/directives/vModel.ts):

  • The change listener now also stores the value it wrote, in el._assignedValue. It is cleared in the same nextTick that resets _assigning.
  • updated now skips setSelected only if the model still holds exactly that value (toRaw(value) === el._assignedValue). If anything changed the model again in the same tick, the select is updated to match it.
  • In the normal case (the model just takes the picked value), the update is still skipped, so the 3.4.15 speed-up is kept. toRaw makes the identity check work for reactive arrays and Sets.

Test evidence:

  • New test should reset single select value when cleared in change handler in packages/runtime-dom/__tests__/directives/vModel.spec.ts. It picks an option, fires change, has onChange set the model to null, and checks that the model is null, selectedIndex is -1 and the option is no longer selected.
  • Before the fix: it failed with expected +0 to be -1 on selectedIndex.
  • After the fix: it passes.
  • ./bt-test packages/runtime-dom: 16 test files, 242 passed, 1 skipped (that skip was already there). The vModel.spec.ts file on its own: 30/30 passed.
  • tsc --noEmit and the Prettier check are clean. Only those two files changed, and nothing is committed.

Requirements:

Item from the reportOutcome
Expected: the select's value is null after a change handler clears itDone. The regression test checks both the model and what the select shows.
Actual: it shows the last picked option (0 or 1)Reproduced by the failing test before the fix, and fixed.
Suspected cause: the _assigning field from commit 2ffb956Confirmed. The skip is now limited to when the model still holds the value just written.
Webdriver-only timingNot reproduced in a browser. I didn't run Chrome or webdriver. The jsdom test produces the same wrong result without any webdriver timing, and the fix doesn't depend on how the events arrive.
nextTick workaroundShould no longer be needed. Nothing to change.

Known gap (from the review): with a multi-select, if the @change handler empties the existing array or Set in place (for example arr.splice(0) or set.clear()) instead of assigning a new one, it's still the same object, so the select still isn't updated. That case also broke in 3.4.15 and isn't the reported scenario, so I left it alone to keep the change minimal. The new test covers single select only; the multiple-select path of the fix has no test.