Backtestsvuerun-20261005-155915#15496

Issue #15496 Merged fix PR #15499 Run 5 Oct 2026 · run-20261005-155915 vuejs/core

looseEqual: comparing Map/Set values with circular references throws RangeError (regression in 3.5.42)

Better

Our patch was judged better than the merged fix.

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

Both patches stop the unbounded recursion for cyclic Maps, Sets, objects and arrays. Both clear their tracking state after each comparison, so a failed tentative match inside `looseCompareCollections` does not leak into later comparisons.

Correctness: Patch A tracks (a, b) pairs that are currently on the recursion stack and treats a re-encountered pair as equal. This is the approach the issue suggests. It removes each entry in a `finally` block, so the state stays consistent even if a comparison throws. Patch B uses a bijection check (seenA/seenB). It returns false when an object reappears paired with a different partner, so a self-loop compared with a structurally identical 2-cycle reports unequal. That is a defensible but stricter definition, and the issue does not ask for it. Patch B also has no try/finally around its delete calls.

API risk: Patch B adds an optional third `seen` parameter to the exported `looseEqual`. If `looseEqual` is ever passed directly as a callback, for example `arr.some(looseEqual)`, the index would be received as `seen` and break destructuring. Patch A keeps the public signature unchanged and routes recursion through a private `looseEqualImpl`.

Tests: Patch A covers every repro listed in the issue: mutually-referencing Sets, Maps with cyclic values, and self-containing Sets and Maps. It adds negative cases, plain object and array cycles, and a regression test for tentative-match leakage. It also adds component-level `<select v-model>` tests that mirror the reported mount crash. Patch B's unit tests cover the main cases and a symmetry case, but it has no runtime-dom test of the reported scenario.

Scope and craft: both restructure similarly by extracting `looseCompareObjects`. Patch A's restructure is clean and keeps existing behaviour for array-versus-object mismatches.

Overall, Patch A is safer, closer to what the issue asks for, and better tested.

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 23s

Wall-clock time in the container

Full test suite

No new failures

3,747 passed · 6 skipped · 3,753 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

238vs 138 merged

Changed lines, ours vs merged

Vue version

3.5.42 (also reproduced on current main, commit 5409708)

Link to minimal reproduction

https://play.vuejs.org/#eyJBcHAudnVlIjogIjxzY3JpcHQgc2V0dXA-XG5pbXBvcnQgeyByZWYgfSBmcm9tICd2dWUnXG5cbmNvbnN0IG1ha2VHcmFwaCA9ICgpID0-IHtcbiAgY29uc3QgbjEgPSB7IGlkOiAxIH1cbiAgY29uc3QgbjIgPSB7IGlkOiAyIH1cbiAgbjEucGVlciA9IG4yXG4gIG4yLnBlZXIgPSBuMSAgLy8gY2lyY3VsYXIgcmVmZXJlbmNlXG4gIHJldHVybiBuZXcgU2V0KFtuMSwgbjJdKVxufVxuXG5jb25zdCBvcHRBID0gbWFrZUdyYXBoKClcbmNvbnN0IG9wdEIgPSBtYWtlR3JhcGgoKVxuY29uc3Qgc2VsZWN0ZWQgPSByZWYob3B0Qilcbjwvc2NyaXB0PlxuXG48dGVtcGxhdGU-XG4gIDxzZWxlY3Qgdi1tb2RlbD1cInNlbGVjdGVkXCI-XG4gICAgPG9wdGlvbiA6dmFsdWU9XCJvcHRBXCI-QTwvb3B0aW9uPlxuICAgIDxvcHRpb24gOnZhbHVlPVwib3B0QlwiPkI8L29wdGlvbj5cbiAgPC9zZWxlY3Q-XG48L3RlbXBsYXRlPlxuIiwgImltcG9ydC1tYXAuanNvbiI6ICJ7XCJpbXBvcnRzXCI6IHtcInZ1ZVwiOiBcImh0dHBzOi8vdW5wa2cuY29tL0B2dWUvcnVudGltZS1kb21AMy41LjQyL2Rpc3QvcnVudGltZS1kb20uZXNtLWJyb3dzZXIuanNcIn19In0=

Steps to reproduce

Open the reproduction above: a <select v-model> whose option :values are Sets containing mutually-referencing objects. The component throws during mount, before any interaction.

<script setup>
import { ref } from 'vue'

const makeGraph = () => {
  const n1 = { id: 1 }
  const n2 = { id: 2 }
  n1.peer = n2
  n2.peer = n1  // circular reference
  return new Set([n1, n2])
}

const optA = makeGraph()
const optB = makeGraph()
const selected = ref(optB)
</script>

<template>
  <select v-model="selected">
    <option :value="optA">A</option>
    <option :value="optB">B</option>
  </select>
</template>

What is expected?

Mounting the select should not throw. looseEqual should safely terminate on cyclic structures (e.g. by tracking already-visited pairs) and return true for two structurally identical cyclic Sets/Maps.

What is actually happening?

Mounting throws RangeError: Maximum call stack size exceeded:

RangeError: Maximum call stack size exceeded
    at looseCompareCollections (packages/shared/src/looseEqual.ts:16)
    at looseEqual (packages/shared/src/looseEqual.ts:64)
    at looseCompareCollections (packages/shared/src/looseEqual.ts:22)
    at looseEqual (packages/shared/src/looseEqual.ts:64)
    ...
[Vue warn]: Unhandled error during execution of directive hook

System Info

Reproduced locally with vuejs/core@main (5409708) via vitest: both the unit-level looseEqual calls and the component-level render path (same shape as the test added in #15328) throw RangeError.

Any additional comments?

This is a regression introduced by #15328 ("fix(shared): correctly compare Map and Set values", released in v3.5.42), which added looseCompareCollections in packages/shared/src/looseEqual.ts:

function looseCompareCollections(
  a: Map<any, any> | Set<any>,
  b: Map<any, any> | Set<any>,
) {
  if (a.size !== b.size) return false
  const candidates = Array.from(b)
  const matched = new Uint8Array(candidates.length)
  for (const item of a) {
    let index = -1
    for (let i = 0; i < candidates.length; i++) {
      if (!matched[i] && looseEqual(item, candidates[i])) {
        index = i
        break
      }
    }
    if (index < 0) return false
    matched[index] = 1
  }
  return true
}

looseEqual(item, candidates[i]) recurses into each [key, value] pair (Map) or element (Set), so a Map/Set whose entries point back to the collection itself or to each other causes unbounded recursion. Before 3.5.42, Maps/Sets never recursed into their entries (they fell through to String() comparison), so this exact code path — a <select v-model> with Map/Set values, which is precisely the scenario #15320/#15328 added support for — did not throw on 3.5.41; it silently compared wrong, which #15328 fixed.

Note: #5318 covers the same root cause for cyclic plain objects (pre-existing, still open). The Map/Set case is new in 3.5.42: cyclic Maps/Sets did not throw before.

Suggested fix: make looseEqual cycle-safe by tracking visited (a, b) pairs (e.g. with a WeakMap<object, Set<object>> and returning true on re-encounter), which also fixes #5318.

Additional local repro cases that all throw RangeError on current main:

  • looseEqual(new Set([a1, a2]), new Set([b1, b2])) where a1.peer = a2; a2.peer = a1 and b1.peer = b2; b2.peer = b1
  • looseEqual(mapA, mapB) where both maps hold mutually-referencing values
  • looseEqual(s1, s2) where s1.add(s1) and s2.add(s2)

The two patches

Our patch+208 −30
packages/runtime-dom/__tests__/directives/vModel.spec.tsindex a94cb8e0d..d2d569238 100644@@ -1902,4 +1902,71 @@ describe('vModel', () => {      expect(root.querySelector('select').selectedIndex).toBe(1)   })++  it('does not throw when option values are sets with circular references', () => {+    const makeGraph = (id: number) => {+      const n1: any = { id }+      const n2: any = { id: id + 1 }+      n1.peer = n2+      n2.peer = n1+      return new Set([n1, n2])+    }+    const optA = makeGraph(1)+    const optB = makeGraph(10)+    // a distinct but structurally identical graph, so matching option B+    // requires walking through the circular references+    const value = ref(makeGraph(10))+    const component = defineComponent(+      () => () =>+        withVModel(+          h(+            'select',+            {+              'onUpdate:modelValue': (val: Set<any>) => (value.value = val),+            },+            [+              h('option', { value: optA }, 'A'),+              h('option', { value: optB }, 'B'),+            ],+          ),+          value.value,+        ),+    )++    expect(() => render(h(component), root)).not.toThrow()+    expect(root.querySelector('select').selectedIndex).toBe(1)+  })++  it('does not throw when option values are maps with circular references', () => {+    const makeMap = (id: number) => {+      const map = new Map<string, any>([['id', id]])+      map.set('self', map)+      return map+    }+    const mapA = makeMap(1)+    const mapB = makeMap(2)+    // a distinct but structurally identical map, so matching option B+    // requires walking through the circular reference+    const value = ref(makeMap(2))+    const component = defineComponent(+      () => () =>+        withVModel(+          h(+            'select',+            {+              'onUpdate:modelValue': (val: Map<string, any>) =>+                (value.value = val),+            },+            [+              h('option', { value: mapA }, 'A'),+              h('option', { value: mapB }, 'B'),+            ],+          ),+          value.value,+        ),+    )++    expect(() => render(h(component), root)).not.toThrow()+    expect(root.querySelector('select').selectedIndex).toBe(1)+  }) })packages/shared/__tests__/looseEqual.spec.tsindex 777f3cfad..3ad8b6334 100644@@ -288,4 +288,83 @@ describe('utils/looseEqual', () => {     expect(looseEqual(new Set<any>([1, '1']), new Set<any>([1, 2]))).toBe(false)     expect(looseEqual(new Set(), new Map())).toBe(false)   })++  test('terminates on Sets with circular references', () => {+    const makeGraph = (id = 1) => {+      const n1: any = { id }+      const n2: any = { id: 2 }+      n1.peer = n2+      n2.peer = n1+      return new Set([n1, n2])+    }+    expect(looseEqual(makeGraph(), makeGraph())).toBe(true)+    expect(looseEqual(makeGraph(), makeGraph(3))).toBe(false)++    const s1 = new Set<any>()+    s1.add(s1)+    const s2 = new Set<any>()+    s2.add(s2)+    expect(looseEqual(s1, s2)).toBe(true)+    s2.add('extra')+    expect(looseEqual(s1, s2)).toBe(false)+  })++  test('terminates on Maps with circular references', () => {+    const makeMap = (id = 1) => {+      const v1: any = { id }+      const v2: any = { id: 2 }+      v1.peer = v2+      v2.peer = v1+      const map = new Map<any, any>([+        ['a', v1],+        ['b', v2],+      ])+      v1.owner = map+      return map+    }+    expect(looseEqual(makeMap(), makeMap())).toBe(true)+    expect(looseEqual(makeMap(), makeMap(3))).toBe(false)++    const m1 = new Map<any, any>()+    m1.set('self', m1)+    const m2 = new Map<any, any>()+    m2.set('self', m2)+    expect(looseEqual(m1, m2)).toBe(true)+  })++  test('terminates on objects and arrays with circular references', () => {+    const a: any = { foo: 1 }+    a.self = a+    const b: any = { foo: 1 }+    b.self = b+    expect(looseEqual(a, b)).toBe(true)+    const c: any = { foo: 2 }+    c.self = c+    expect(looseEqual(a, c)).toBe(false)++    const arr1: any[] = [1]+    arr1.push(arr1)+    const arr2: any[] = [1]+    arr2.push(arr2)+    expect(looseEqual(arr1, arr2)).toBe(true)+    const arr3: any[] = [2]+    arr3.push(arr3)+    expect(looseEqual(arr1, arr3)).toBe(false)+  })++  test('a failed tentative match does not leak into later comparisons', () => {+    // x is first tried against w, which matches it until a cyclic step+    // (x vs w2) fails; x then matches r. y must still be compared fairly+    // against w, which requires (x, w2) to be reported unequal again.+    const x: any = { n: 1 }+    x.self = x+    const y: any = { n: 1, self: x }+    const w2: any = { n: 2 }+    w2.self = w2+    const w: any = { n: 1, self: w2 }+    const r: any = { n: 1 }+    r.self = r+    expect(looseEqual(new Set([x]), new Set([r]))).toBe(true)+    expect(looseEqual(new Set([x, y]), new Set([w, r]))).toBe(false)+  }) })packages/shared/src/looseEqual.tsindex d037b0a57..527c28cd7 100644@@ -1,10 +1,14 @@ import { isArray, isDate, isMap, isObject, isSet, isSymbol } from './general' -function looseCompareArrays(a: any[], b: any[]) {+// pairs of objects currently being compared further up the recursion stack,+// used to terminate on cyclic structures (a pair met again is assumed equal)+type VisitedPairs = WeakMap<object, Set<object>>++function looseCompareArrays(a: any[], b: any[], visited: VisitedPairs) {   if (a.length !== b.length) return false   let equal = true   for (let i = 0; equal && i < a.length; i++) {-    equal = looseEqual(a[i], b[i])+    equal = looseEqualImpl(a[i], b[i], visited)   }   return equal }@@ -12,6 +16,7 @@ function looseCompareArrays(a: any[], b: any[]) { function looseCompareCollections(   a: Map<any, any> | Set<any>,   b: Map<any, any> | Set<any>,+  visited: VisitedPairs, ) {   if (a.size !== b.size) return false   const candidates = Array.from(b)@@ -19,7 +24,7 @@ function looseCompareCollections(   for (const item of a) {     let index = -1     for (let i = 0; i < candidates.length; i++) {-      if (!matched[i] && looseEqual(item, candidates[i])) {+      if (!matched[i] && looseEqualImpl(item, candidates[i], visited)) {         index = i         break       }@@ -31,6 +36,10 @@ function looseCompareCollections( }  export function looseEqual(a: any, b: any): boolean {+  return looseEqualImpl(a, b)+}++function looseEqualImpl(a: any, b: any, visited?: VisitedPairs): boolean {   if (a === b) return true   let aValidType = isDate(a)   let bValidType = isDate(b)@@ -42,43 +51,66 @@ export function looseEqual(a: any, b: any): boolean {   if (aValidType || bValidType) {     return a === b   }-  aValidType = isArray(a)-  bValidType = isArray(b)-  if (aValidType || bValidType) {-    return aValidType && bValidType ? looseCompareArrays(a, b) : false-  }   aValidType = isObject(a)   bValidType = isObject(b)   if (aValidType || bValidType) {     if (!aValidType || !bValidType) {       return false     }-    aValidType = isMap(a)-    bValidType = isMap(b)-    if (aValidType || bValidType) {-      return aValidType && bValidType ? looseCompareCollections(a, b) : false+    // cycle detection: if this pair is already being compared up the stack,+    // assume equality here and let the outer comparison decide+    if (!visited) visited = new WeakMap()+    let seenB = visited.get(a)+    if (seenB) {+      if (seenB.has(b)) return true+    } else {+      visited.set(a, (seenB = new Set()))     }-    aValidType = isSet(a)-    bValidType = isSet(b)-    if (aValidType || bValidType) {-      return aValidType && bValidType ? looseCompareCollections(a, b) : false+    seenB.add(b)+    try {+      return looseCompareObjects(a, b, visited)+    } finally {+      seenB.delete(b)     }-    const aKeysCount = Object.keys(a).length-    const bKeysCount = Object.keys(b).length-    if (aKeysCount !== bKeysCount) {+  }+  return String(a) === String(b)+}++function looseCompareObjects(a: any, b: any, visited: VisitedPairs): boolean {+  let aValidType = isArray(a)+  let bValidType = isArray(b)+  if (aValidType || bValidType) {+    return aValidType && bValidType ? looseCompareArrays(a, b, visited) : false+  }+  aValidType = isMap(a)+  bValidType = isMap(b)+  if (aValidType || bValidType) {+    return aValidType && bValidType+      ? looseCompareCollections(a, b, visited)+      : false+  }+  aValidType = isSet(a)+  bValidType = isSet(b)+  if (aValidType || bValidType) {+    return aValidType && bValidType+      ? looseCompareCollections(a, b, visited)+      : false+  }+  const aKeysCount = Object.keys(a).length+  const bKeysCount = Object.keys(b).length+  if (aKeysCount !== bKeysCount) {+    return false+  }+  for (const key in a) {+    const aHasKey = a.hasOwnProperty(key)+    const bHasKey = b.hasOwnProperty(key)+    if (+      (aHasKey && !bHasKey) ||+      (!aHasKey && bHasKey) ||+      !looseEqualImpl(a[key], b[key], visited)+    ) {       return false     }-    for (const key in a) {-      const aHasKey = a.hasOwnProperty(key)-      const bHasKey = b.hasOwnProperty(key)-      if (-        (aHasKey && !bHasKey) ||-        (!aHasKey && bHasKey) ||-        !looseEqual(a[key], b[key])-      ) {-        return false-      }-    }   }   return String(a) === String(b) } 
Merged fix · PR #15499+107 −31
packages/shared/__tests__/looseEqual.spec.tsindex 777f3cfad..bc1bc3acd 100644@@ -288,4 +288,45 @@ describe('utils/looseEqual', () => {     expect(looseEqual(new Set<any>([1, '1']), new Set<any>([1, 2]))).toBe(false)     expect(looseEqual(new Set(), new Map())).toBe(false)   })++  test('compares circular references correctly', () => {+    const makeGraph = () => {+      const n1: any = { id: 1 }+      const n2: any = { id: 2 }+      n1.peer = n2+      n2.peer = n1+      return [n1, n2]+    }++    expect(looseEqual(new Set(makeGraph()), new Set(makeGraph()))).toBe(true)+    expect(+      looseEqual(new Map([['a', makeGraph()]]), new Map([['a', makeGraph()]])),+    ).toBe(true)+    expect(looseEqual(makeGraph(), makeGraph())).toBe(true)+    expect(looseEqual({ n: makeGraph() }, { n: makeGraph() })).toBe(true)++    const selfSet = new Set<any>()+    selfSet.add(selfSet)+    const otherSelfSet = new Set<any>()+    otherSelfSet.add(otherSelfSet)+    expect(looseEqual(selfSet, otherSelfSet)).toBe(true)+    expect(looseEqual(selfSet, new Set([new Set()]))).toBe(false)++    const shared = { id: 1 }+    expect(+      looseEqual({ a: shared, b: shared }, { a: { id: 1 }, b: { id: 1 } }),+    ).toBe(true)+  })++  test('compares circular references symmetrically', () => {+    const self: any = {}+    self.next = self+    const first: any = {}+    const second: any = {}+    first.next = second+    second.next = first++    expect(looseEqual(self, first)).toBe(false)+    expect(looseEqual(first, self)).toBe(false)+  }) })packages/shared/src/looseEqual.tsindex d037b0a57..7e3e7f44e 100644@@ -1,10 +1,12 @@ import { isArray, isDate, isMap, isObject, isSet, isSymbol } from './general' -function looseCompareArrays(a: any[], b: any[]) {+type ComparisonState = [Map<any, any>, Map<any, any>]++function looseCompareArrays(a: any[], b: any[], seen: ComparisonState) {   if (a.length !== b.length) return false   let equal = true   for (let i = 0; equal && i < a.length; i++) {-    equal = looseEqual(a[i], b[i])+    equal = looseEqual(a[i], b[i], seen)   }   return equal }@@ -12,6 +14,7 @@ function looseCompareArrays(a: any[], b: any[]) { function looseCompareCollections(   a: Map<any, any> | Set<any>,   b: Map<any, any> | Set<any>,+  seen: ComparisonState, ) {   if (a.size !== b.size) return false   const candidates = Array.from(b)@@ -19,7 +22,7 @@ function looseCompareCollections(   for (const item of a) {     let index = -1     for (let i = 0; i < candidates.length; i++) {-      if (!matched[i] && looseEqual(item, candidates[i])) {+      if (!matched[i] && looseEqual(item, candidates[i], seen)) {         index = i         break       }@@ -30,7 +33,62 @@ function looseCompareCollections(   return true } -export function looseEqual(a: any, b: any): boolean {+function looseCompareObjects(a: any, b: any, seen: ComparisonState) {+  let aValidType = isMap(a)+  let bValidType = isMap(b)+  if (aValidType || bValidType) {+    return aValidType && bValidType+      ? looseCompareCollections(a, b, seen)+      : false+  }+  aValidType = isSet(a)+  bValidType = isSet(b)+  if (aValidType || bValidType) {+    return aValidType && bValidType+      ? looseCompareCollections(a, b, seen)+      : false+  }+  const aKeysCount = Object.keys(a).length+  const bKeysCount = Object.keys(b).length+  if (aKeysCount !== bKeysCount) {+    return false+  }+  for (const key in a) {+    const aHasKey = a.hasOwnProperty(key)+    const bHasKey = b.hasOwnProperty(key)+    if (+      (aHasKey && !bHasKey) ||+      (!aHasKey && bHasKey) ||+      !looseEqual(a[key], b[key], seen)+    ) {+      return false+    }+  }+  return String(a) === String(b)+}++function looseCompareNested(+  a: any,+  b: any,+  seen: ComparisonState | undefined,+  compare: (a: any, b: any, seen: ComparisonState) => boolean,+) {+  if (!seen) {+    seen = [new Map(), new Map()]+  }+  const [seenA, seenB] = seen+  if (seenA.has(a) || seenB.has(b)) {+    return seenA.get(a) === b && seenB.get(b) === a+  }+  seenA.set(a, b)+  seenB.set(b, a)+  const equal = compare(a, b, seen)+  seenA.delete(a)+  seenB.delete(b)+  return equal+}++export function looseEqual(a: any, b: any, seen?: ComparisonState): boolean {   if (a === b) return true   let aValidType = isDate(a)   let bValidType = isDate(b)@@ -45,7 +103,9 @@ export function looseEqual(a: any, b: any): boolean {   aValidType = isArray(a)   bValidType = isArray(b)   if (aValidType || bValidType) {-    return aValidType && bValidType ? looseCompareArrays(a, b) : false+    return aValidType && bValidType+      ? looseCompareNested(a, b, seen, looseCompareArrays)+      : false   }   aValidType = isObject(a)   bValidType = isObject(b)@@ -53,32 +113,7 @@ export function looseEqual(a: any, b: any): boolean {     if (!aValidType || !bValidType) {       return false     }-    aValidType = isMap(a)-    bValidType = isMap(b)-    if (aValidType || bValidType) {-      return aValidType && bValidType ? looseCompareCollections(a, b) : false-    }-    aValidType = isSet(a)-    bValidType = isSet(b)-    if (aValidType || bValidType) {-      return aValidType && bValidType ? looseCompareCollections(a, b) : false-    }-    const aKeysCount = Object.keys(a).length-    const bKeysCount = Object.keys(b).length-    if (aKeysCount !== bKeysCount) {-      return false-    }-    for (const key in a) {-      const aHasKey = a.hasOwnProperty(key)-      const bHasKey = b.hasOwnProperty(key)-      if (-        (aHasKey && !bHasKey) ||-        (!aHasKey && bHasKey) ||-        !looseEqual(a[key], b[key])-      ) {-        return false-      }-    }+    return looseCompareNested(a, b, seen, looseCompareObjects)   }   return String(a) === String(b) }