2.0.0-rc.16: a projection's error never reaches <Errored> when a signal it reads is written just before its promise rejects (regression from fb6006eb, #4156) #4189

const [version, setVersion] = createSignal(0, { ownedWrite: true })
const entry = { loading: false, error: undefined, promise: undefined }
const load = () => {
  entry.loading = true
  entry.promise = Promise.resolve().then(() => {
    entry.loading = false
    entry.error = new Error("failed")
    setVersion((v) => v + 1) // the cache event, before the promise rejects
    throw entry.error
  })
  setVersion((v) => v + 1) // the fetch-start event, inside the derive
  return entry.promise
}
let chained
const stable = (base) => (chained?.base === base ? chained.value : (chained = { base, value: base.then((value) => ({ value })) }).value)
const store = createProjection(() => {
  version()
  if (entry.loading) return stable(entry.promise)
  if (entry.error) throw entry.error
  return stable(load())
}, {})

// <Errored fallback={(e) => `errored: ${e().message}`}>
//   <Loading fallback="loading"><span>{String(store.value)}</span></Loading>
// </Errored>

// @solidjs/signals 2.0.0-rc.16: a rejection inside a projection never reaches <Errored> when the projection's
// rejecting promise is preceded by a synchronous write to a signal the projection reads, and the read sits in a nested
// computation (an element child inserted by `insert`, which is what compiled JSX emits), under <Loading>.
// On @solidjs/signals 2.0.0-rc.15 every case below prints "errored: failed".
//
// Run: npm install && node --conditions=browser repro.mjs
// (compare: npm install @solidjs/[email protected] via the "overrides" field, then run again)
import { JSDOM } from "jsdom"

const dom = new JSDOM("<!doctype html><html><body><div id=root></div></body></html>")
for (const key of ["window", "document", "Node", "Element", "HTMLElement", "Text", "Comment", "DocumentFragment", "MutationObserver", "navigator"]) {
	if (!(key in globalThis)) Object.defineProperty(globalThis, key, { value: dom.window[key], configurable: true, writable: true })
}

const solid = await import("solid-js")
const web = await import("@solidjs/web")
const c = solid.createComponent

// A data source the way a query cache feeds one: a version signal written by the source's own events, and a
// projection that derives from it. The first compute starts the load, which writes the version inside the compute
// (an "added/fetch" event); while loading, the compute hands back one stable promise; once failed, it throws.
// `notify` is when the failure's own event writes the version: "sync" (before the promise rejects) or "later".
function source(notify) {
	const [version, setVersion] = solid.createSignal(0, { ownedWrite: true })
	const entry = { loading: false, error: undefined, promise: undefined }
	const load = () => {
		entry.loading = true
		entry.promise = Promise.resolve().then(() => {
			entry.loading = false
			entry.error = new Error("failed")
			if (notify === "sync") setVersion((v) => v + 1)
			else setTimeout(() => setVersion((v) => v + 1))
			throw entry.error
		})
		setVersion((v) => v + 1)
		return entry.promise
	}
	let chained
	const stable = (base) => {
		if (chained?.base !== base) chained = { base, value: base.then((value) => ({ value })) }
		return chained.value
	}
	const store = solid.createProjection(() => {
		version()
		if (entry.loading) return stable(entry.promise)
		if (entry.error) throw entry.error
		return stable(load())
	}, {})
	return () => store.value
}

// `read`: "direct" returns the read as the Loading's child; "insert" puts it in an element through `insert`.
async function run(read, notify) {
	const root = document.getElementById("root")
	root.textContent = ""
	const [show, setShow] = solid.createSignal(false)
	const Page = () => {
		const value = source(notify)
		return c(solid.Loading, {
			fallback: "loading",
			get children() {
				if (read === "direct") return String(value())
				const span = document.createElement("span")
				web.insert(span, () => String(value()))
				return span
			},
		})
	}
	const dispose = web.render(
		() =>
			c(web.Dynamic, {
				component: "main",
				get children() {
					return show()
						? c(solid.Errored, { fallback: (error) => `errored: ${error().message}`, get children() { return c(Page, {}) } })
						: "home"
				},
			}),
		root,
	)
	solid.flush()
	setShow(true)
	solid.flush()
	await new Promise((resolve) => setTimeout(resolve, 100))
	solid.flush()
	const shown = root.textContent
	dispose()
	return `${read} read, ${notify} notify: "${shown}"`
}

const { version } = (await import("@solidjs/signals/package.json", { with: { type: "json" } })).default
console.log(`@solidjs/signals ${version}`)
// One case per process (`node --conditions=browser repro.mjs <read> <notify>`), since a case may never return.
const [read = "insert", notify = "sync"] = process.argv.slice(2)
console.log(await run(read, notify))
process.exit(0)