@@ -0,0 +1,189 @@
+import { setFlagsFromString } from 'node:v8'
+import {
+  isProxy,
+  isReactive,
+  isReadonly,
+  reactive,
+  readonly,
+} from '../src/reactive'
+
+// kept in its own file: the protector check below must run before anything
+// else in the file iterates a reactive array
+describe('reactivity/reactive/Array iterator', () => {
+  // #15643
+  test('iterating should not invalidate V8 array iteration fast paths', () => {
+    setFlagsFromString('--allow-natives-syntax')
+    const isProtectorIntact = new Function(
+      'return %ArrayIteratorProtector()',
+    ) as () => boolean
+    // the protector is isolate-wide and can only ever be invalidated, so it
+    // has to be intact on entry for the check below to mean anything; each
+    // test file runs in its own worker, so nothing else can have tripped it
+    expect(isProtectorIntact()).toBe(true)
+
+    const seen: unknown[] = []
+    const deep = reactive([{ val: 1 }])
+    for (const item of deep) seen.push(item)
+    for (const item of deep.values()) seen.push(item)
+    for (const [, item] of deep.entries()) seen.push(item)
+    for (const item of readonly([{ val: 1 }])) seen.push(item)
+    for (const item of readonly(deep)) seen.push(item)
+    for (const item of readonly(deep).values()) seen.push(item)
+    for (const [, item] of readonly(deep).entries()) seen.push(item)
+    expect(seen.length).toBe(7)
+    expect(seen.every(isProxy)).toBe(true)
+
+    class Items extends Array {
+      [Symbol.iterator]() {
+        return super[Symbol.iterator]()
+      }
+      values() {
+        return super.values()
+      }
+      entries() {
+        return super.entries()
+      }
+    }
+    const custom = reactive(new Items())
+    custom.push({ val: 1 })
+    const iter = custom[Symbol.iterator]()
+    const values = custom.values()
+    const entries = custom.entries()
+    expect(isProtectorIntact()).toBe(true)
+    expect(isReactive(iter.next().value)).toBe(true)
+    expect(isReactive(values.next().value)).toBe(true)
+    expect(isReactive(entries.next().value![1])).toBe(true)
+
+    expect(isProtectorIntact()).toBe(true)
+  })
+
+  test('should keep native array iterator behavior', () => {
+    const iter = reactive([{ val: 1 }, { val: 2 }])[Symbol.iterator]()
+    // inherits from the shared native array iterator prototype
+    expect(Object.prototype.toString.call(iter)).toBe('[object Array Iterator]')
+    expect(iter[Symbol.iterator]()).toBe(iter)
+
+    const first = iter.next()
+    expect(first.done).toBe(false)
+    expect(isReactive(first.value)).toBe(true)
+    iter.next()
+    expect(iter.next()).toEqual({ value: undefined, done: true })
+  })
+
+  test('should close custom iterators on early exit', () => {
+    let closed = false
+    class Items extends Array {
+      *[Symbol.iterator]() {
+        try {
+          yield {}
+        } finally {
+          closed = true
+        }
+        return undefined
+      }
+    }
+
+    for (const item of reactive(new Items())) {
+      expect(isReactive(item)).toBe(true)
+      break
+    }
+    expect(closed).toBe(true)
+  })
+
+  test('should close native iterators returned by custom methods on early exit', () => {
+    let reads = 0
+    let closed = false
+    class Items extends Array {
+      [Symbol.iterator]() {
+        const iter = super[Symbol.iterator]()
+        Object.defineProperty(iter, 'return', {
+          get() {
+            expect(this).toBe(iter)
+            reads++
+            return function (this: unknown) {
+              expect(this).toBe(iter)
+              closed = true
+              return { value: undefined, done: true }
+            }
+          },
+        })
+        return iter
+      }
+    }
+
+    const items = new Items()
+    items.push({})
+    const iter = reactive(items)[Symbol.iterator]()
+    expect(reads).toBe(0)
+    for (const item of iter) {
+      expect(isReactive(item)).toBe(true)
+      expect(reads).toBe(0)
+      break
+    }
+    expect(reads).toBe(1)
+    expect(closed).toBe(true)
+  })
+
+  test('should pass wrapped values to iterator helpers', () => {
+    const raw = [{ val: 1 }]
+    if (!('map' in raw.values())) return
+
+    class Items extends Array {
+      *values() {
+        yield* raw
+        return undefined
+      }
+    }
+    for (const array of [
+      reactive(raw),
+      readonly(reactive(raw)),
+      reactive(new Items()),
+      readonly(reactive(new Items())),
+    ]) {
+      const iter = array.values()
+      // @ts-expect-error iterator helpers are not in es2016
+      const mapped = iter.map((item: (typeof raw)[number]) => {
+        expect(isReactive(item)).toBe(true)
+        expect(isReadonly(item)).toBe(isReadonly(array))
+        return item.val
+      })
+      expect([...mapped]).toEqual([1])
+    }
+  })
+
+  test.each(['return', 'throw'] as const)(
+    'should read the current native iterator %s method lazily',
+    method => {
+      const original = [{}].values()
+      const initial = vi.fn()
+      let closingMethod: unknown = initial
+      const getMethod = vi.fn(() => closingMethod)
+      Object.defineProperty(original, method, { get: getMethod })
+      class Items extends Array {
+        values() {
+          return original
+        }
+      }
+
+      const iter: IterableIterator<unknown> = reactive(new Items()).values()
+      expect(getMethod).not.toHaveBeenCalled()
+
+      const value = {}
+      const result = { value, done: true }
+      const close = vi.fn(() => result)
+      closingMethod = close
+      expect(iter[method]!(value)).toBe(result)
+      expect(initial).not.toHaveBeenCalled()
+      expect(close).toHaveBeenCalledExactlyOnceWith(value)
+      expect(close.mock.contexts[0]).toBe(original)
+      expect(getMethod).toHaveBeenCalledOnce()
+      expect(getMethod.mock.contexts[0]).toBe(original)
+
+      for (const replacement of [undefined, null, 1]) {
+        closingMethod = replacement
+        expect(iter[method]).toBe(replacement)
+      }
+      expect(getMethod).toHaveBeenCalledTimes(4)
+    },
+  )
+})
@@ -254,22 +254,52 @@ function iterator(
   // given that JS iterator can only be read once, this doesn't seem like
   // a plausible use-case, so this tracking simplification seems ok.
   const arr = shallowReadArray(self)
-  const iter = (arr[method] as any)() as IterableIterator<unknown> & {
+  const methodFn = arr[method] as any
+  const iter = methodFn.call(arr) as IterableIterator<unknown> & {
     _next: IterableIterator<unknown>['next']
   }
   if (arr !== self && !isShallow(self)) {
-    iter._next = iter.next
-    iter.next = () => {
-      const result = iter._next()
-      if (!result.done) {
-        result.value = wrapValue(result.value)
+    // #15643 an own `next` on a native array iterator permanently disables
+    // V8's array iteration fast paths (spread, Array.from, etc.) for the whole
+    // isolate, so it is wrapped instead. Checked on the iterator itself as
+    // user-extended or cross-realm arrays can return native iterators too.
+    if ((iter as any)[Symbol.toStringTag] === 'Array Iterator') {
+      const wrapped = Object.create(Object.getPrototypeOf(iter))
+      wrapped.next = () => wrapResult(iter.next(), wrapValue)
+      if (methodFn !== arrayProto[method]) {
+        Object.defineProperties(wrapped, {
+          return: {
+            get() {
+              const fn = iter.return
+              return typeof fn === 'function' ? fn.bind(iter) : fn
+            },
+          },
+          throw: {
+            get() {
+              const fn = iter.throw
+              return typeof fn === 'function' ? fn.bind(iter) : fn
+            },
+          },
+        })
       }
-      return result
+      return wrapped
     }
+    iter._next = iter.next
+    iter.next = () => wrapResult(iter._next(), wrapValue)
   }
   return iter
 }
 
+function wrapResult(
+  result: IteratorResult<unknown>,
+  wrapValue: (value: any) => unknown,
+) {
+  if (!result.done) {
+    result.value = wrapValue(result.value)
+  }
+  return result
+}
+
 // in the codebase we enforce es2016, but user code may run in environments
 // higher than that
 type ArrayMethods = keyof Array<any> | 'findLast' | 'findLastIndex'