createOptimisticStore overlay is not reverted after a failed action while attribution is enabled (rc.10 regression) #3687

import { captureArtifact } from '@solidjs/diagnostics'
import { action, createOptimistic, createOptimisticStore, createRoot, createEffect, flush } from 'solid-js'
import { expect, it } from 'vitest'

const tick = () => new Promise((r) => setTimeout(r, 0))
async function settle() { for (let i = 0; i < 4; i++) { await tick(); flush() } }

type Row = { id: string; done: boolean }
function liveSource(initial: Row[]): AsyncIterable<Row[]> {
  return { async *[Symbol.asyncIterator]() { yield initial; await new Promise(() => {}) } }
}

for (const source of ['promise', 'async-iterable'] as const)
  for (const observed of [false, true]) {
    it(`failed action reverts: source=${source} captureArtifact=${observed}`, async () => {
      const body = async () => {
        const seen: string[] = []
        let run!: () => Promise<unknown>
        const dispose = createRoot((d) => {
          const init = [{ id: 'a', done: false }]
          const [list, setList] = createOptimisticStore<Row[]>(() => source === 'promise' ? Promise.resolve(init) : liveSource(init), [], { key: 'id' })
          createEffect(() => list.map((r) => `${r.id}:${r.done}`).join(' '), (v) => { seen.push(v) })
          const act = action(function* () {
            setList((l) => { if (l[0]) l[0].done = true })
            try { yield Promise.reject(new Error('x')) } catch {}
          })
          run = () => act()
          return d
        })
        await settle(); await run(); await settle()
        dispose()
        return seen.at(-1)
      }
      let last: string | undefined
      if (observed) await captureArtifact(async () => { last = await body() }, { scenario: 'probe' })
      else last = await body()
      expect(last).toBe('a:false')
    })
  }

for (const observed of [false, true])
  it(`createOptimistic(false) reverts after caught failure: captureArtifact=${observed}`, async () => {
    const body = async () => {
      let read!: () => boolean, run!: () => Promise<unknown>
      const dispose = createRoot((d) => {
        const [busy, setBusy] = createOptimistic(false)
        read = busy
        createEffect(() => busy(), () => {})
        const act = action(function* () { setBusy(true); try { yield Promise.reject(new Error('x')) } catch {} })
        run = () => act()
        return d
      })
      await settle(); await run(); await settle()
      const v = read(); dispose(); return v
    }
    let last: boolean | undefined
    if (observed) await captureArtifact(async () => { last = await body() }, { scenario: 'probe2' })
    else last = await body()
    expect(last).toBe(false)
  })