Backtestsvuerun-20261003-231210#10505

Issue #10505 Merged fix PR #15298 Run 3 Oct 2026 · run-20261003-231210 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 fix the root cause the same way. The `_assigning` flag in the select's `updated` hook unconditionally skipped `setSelected` until nextTick, even when a `@change` handler changed the model again in the same tick. Each patch replaces that blanket skip with a comparison: the DOM resync is skipped only if the incoming model value still matches what was just assigned from the DOM. Each snapshots the Array value so a handler mutating it in place is still detected, and each resyncs for the issue's single-select-cleared-to-null scenario.

Patch A compares with `hasChanged` on `toRaw(value)` and clears the snapshot in nextTick. Its tests cover the issue directly: single select reset to null, multiple-select reassignment, and in-place mutation of an Array or Set.

Patch B compares with `looseEqual`, which matches how `setSelected` itself compares option values. It also handles more edge cases:
- It records whether the select was `multiple` at assign time and resyncs if that toggles.
- It clears the pending value in `updated`, guarded by identity so a stale nextTick cannot clobber a newer one.
- It uses try/finally around the assigner.

Patch B's tests are notably stronger. Beyond the issue's reset-in-change-handler case, they check:
- Set override.
- Duplicate option values keep the chosen index.
- Mutation of the emitted Array or Set.
- The multiple/single toggle.
- No `option.selected` writes when the model simply echoes the DOM, for primitive arrays and for Arrays and Sets of objects.

The no-write tests guard the performance optimization that introduced the regression. That optimization is the main risk of any fix here, and Patch A has no test for it.

Both are correct and in scope. Patch A is somewhat simpler. Patch B's more robust edge handling and much more thorough regression coverage give it the edge.

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

7m 5s

Wall-clock time in the container

Full test suite

No new failures

3,683 passed · 6 skipped · 3,689 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

213vs 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+211 −2
packages/runtime-dom/__tests__/directives/vModel.spec.tsindex 590c0d7df..818a3ebad 100644@@ -1009,6 +1009,179 @@ describe('vModel', () => {     expect(bar.selected).toEqual(true)   }) +  it('should update DOM when value is changed in change handler (single select)', async () => {+    const value = ref<any>(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]')+    const bar = root.querySelector('option[value=bar]')+    expect(input.selectedIndex).toBe(-1)++    foo.selected = true+    triggerEvent('change', input)+    await nextTick()+    expect(value.value).toBe(null)+    expect(input.selectedIndex).toBe(-1)+    expect(foo.selected).toBe(false)++    bar.selected = true+    triggerEvent('change', input)+    await nextTick()+    expect(value.value).toBe(null)+    expect(input.selectedIndex).toBe(-1)+    expect(bar.selected).toBe(false)+  })++  it('should update DOM when value is changed in change handler (multiple select)', async () => {+    const value = ref<any>([])+    const component = defineComponent({+      render() {+        return [+          withVModel(+            h(+              'select',+              {+                multiple: true,+                'onUpdate:modelValue': (val: any) => (value.value = val),+                onChange: () => {+                  value.value = ['bar']+                },+              },+              [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]')+    const bar = root.querySelector('option[value=bar]')++    foo.selected = true+    triggerEvent('change', input)+    await nextTick()+    expect(value.value).toMatchObject(['bar'])+    expect(foo.selected).toBe(false)+    expect(bar.selected).toBe(true)+  })++  it('should update DOM when Set value is changed in change handler (multiple select)', async () => {+    const value = ref<any>(new Set())+    const component = defineComponent({+      render() {+        return [+          withVModel(+            h(+              'select',+              {+                multiple: true,+                'onUpdate:modelValue': (val: any) => (value.value = val),+                onChange: () => {+                  value.value = new Set()+                },+              },+              [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]')+    const bar = root.querySelector('option[value=bar]')++    foo.selected = true+    bar.selected = true+    triggerEvent('change', input)+    await nextTick()+    expect(value.value.size).toBe(0)+    expect(foo.selected).toBe(false)+    expect(bar.selected).toBe(false)+  })++  it('should update DOM when Array/Set value is mutated in change handler (multiple select)', async () => {+    const arr = ref<any>([])+    const set = ref<any>(new Set())+    const component = defineComponent({+      render() {+        return [+          withVModel(+            h(+              'select',+              {+                class: 'arr',+                multiple: true,+                'onUpdate:modelValue': (val: any) => (arr.value = val),+                onChange: () => {+                  arr.value.splice(0)+                },+              },+              [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+            ),+            arr.value,+          ),+          withVModel(+            h(+              'select',+              {+                class: 'set',+                multiple: true,+                'onUpdate:modelValue': (val: any) => (set.value = val),+                onChange: () => {+                  set.value.clear()+                },+              },+              [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+            ),+            set.value,+          ),+        ]+      },+    })+    render(h(component), root)++    for (const cls of ['arr', 'set']) {+      const input = root.querySelector(`select.${cls}`)+      const foo = input.querySelector('option[value=foo]')+      const bar = input.querySelector('option[value=bar]')++      foo.selected = true+      bar.selected = true+      triggerEvent('change', input)+      await nextTick()+      expect(foo.selected).toBe(false)+      expect(bar.selected).toBe(false)+    }+    expect(arr.value.length).toBe(0)+    expect(set.value.size).toBe(0)+  })+   it('multiple select (model is Array)', async () => {     const component = defineComponent({       data() {packages/runtime-dom/src/directives/vModel.tsindex eeb248f28..7c470dc32 100644@@ -4,10 +4,12 @@ import {   type ObjectDirective,   type VNode,   nextTick,+  toRaw,   warn, } from '@vue/runtime-core' import { addEventListener } from '../modules/events' import {+  hasChanged,   invokeArrayFns,   isArray,   isSet,@@ -39,11 +41,13 @@ function onCompositionEnd(e: Event) {  const assignKey: unique symbol = Symbol('_assign') const initialValueKey: unique symbol = Symbol('_initialValue')+const assignedValueKey: unique symbol = Symbol('_assignedValue')  type ModelDirective<T, Modifiers extends string = string> = ObjectDirective<   T & {     [assignKey]: AssignerFn     [initialValueKey]?: string+    [assignedValueKey]?: any[]     _assigning?: boolean   },   any,@@ -244,12 +248,16 @@ export const vModelSelect: ModelDirective<HTMLSelectElement, 'number'> = {         el.multiple           ? isSet((el as any)._modelValue)             ? new Set(selectedVal)-            : selectedVal+            : selectedVal.slice()           : selectedVal[0],       )+      // snapshot of what the DOM currently reflects, so that `updated` can+      // detect if the model was changed again in the same tick+      el[assignedValueKey] = selectedVal       el._assigning = true       nextTick(() => {         el._assigning = false+        el[assignedValueKey] = undefined       })     })     el[assignKey] = getModelAssigner(vnode)@@ -264,12 +272,40 @@ export const vModelSelect: ModelDirective<HTMLSelectElement, 'number'> = {     el[assignKey] = getModelAssigner(vnode)   },   updated(el, { value }) {-    if (!el._assigning) {+    // the DOM already reflects the value just assigned from the change event,+    // but the model may have been changed to something else in the same tick+    // (e.g. reset or mutated in a @change handler), in which case the DOM must+    // be synced.+    if (!el._assigning || !isAssignedValue(el, value)) {       setSelected(el, value)     }   }, } +function isAssignedValue(+  el: HTMLSelectElement & { [assignedValueKey]?: any[] },+  value: any,+): boolean {+  const assigned = el[assignedValueKey]+  if (!assigned) return false+  value = toRaw(value)+  if (!el.multiple) {+    return !hasChanged(value, assigned[0])+  }+  if (isArray(value)) {+    return (+      value.length === assigned.length &&+      value.every((v, i) => !hasChanged(v, assigned[i]))+    )+  }+  if (isSet(value)) {+    return (+      value.size === assigned.length && assigned.every(v => value.has(v))+    )+  }+  return false+}+ function setSelected(el: HTMLSelectElement, value: any) {   const isMultiple = el.multiple   const isArrayValue = isArray(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)