SPIKE: RFC 957 scheduler interface + adaptive render flushing, on clean main

[NullVoxPopuli-ai-agent]

A testable build of the "ideal path" for RFC #957: the @ember/scheduler interface from #21493 plus the renderer flushing through an adaptive tri-mode scheduler — as the only changes on top of current main. No VM changes, no subtree-skipping (#21512), no legacy-read removal (#21513): this isolates what scheduling alone is worth, as evidence for the RFC discussion.

Numbers (rere-benchmark, 8x CPU throttle, same-batch vs identically-built main)

bench	main	this branch
DB Monitor	17.3 fps	28.7 fps	1.66x
1 item, 100k updates (async)	1587ms	182ms	8.7x
1k items, 1 update each (seq, async)	1326ms	204ms	6.5x
1k items, 25% random (async)	560ms	86ms	6.5x
1k items, 5% random (async)	188ms	51ms	3.7x
1 item, 1k updates (async)	59ms	23ms	2.6x
sync one-shot benches (3)	—	~par	+8–36ms latency hop
Incrementing Render Effect (100k-step dependent chain)	3.8s	5.5s	1.45x worse

Times are anchored on the last DOM mutation (a MutationObserver), not the benchmark's :done mark — :done rides a bare requestIdleCallback whose grant latency adds hundreds of ms of noise for any framework that defers rendering.

How the scheduler works

scheduleRevalidate classifies dirt by arrival latency:

• Chain dirt (<1ms since the last flush — render → microtask → set loops): flushes via queueMicrotask, same task turn, so dependent chains don't pay a task hop per step. This cannot defeat coalescing of awaited update loops: those drain their entire microtask chain before their first flush runs.
• Stream dirt (fresh tasks — worker messages, events): flushes on a race between an unclamped macrotask (MessageChannel; setTimeout's 4ms nesting clamp would crawl) and requestAnimationFrame. Under sustained per-frame bursts the macrotask leg stands down and flushes ride the frame.
• In-flush dirt (rendering itself dirtying state) is drained by a flush-until-stable loop inside the same flush.

Hard-won details, each worth a test in the real implementation:

• The macrotask stand-down only applies while rAF is actually being serviced. Backgrounded/occluded pages stop firing rAF entirely, and since the per-frame counter is only reset by a frame firing, standing down there strands all rendering until the tab is foregrounded again.
• The scheduled-flag must clear after the flush: clearing before meant dirt produced mid-flush re-armed a vacuous second flush (1.47 flushes per chain step, measured), which was most of an earlier 4x chain regression.
• Chain flushes must not count toward the stand-down: they're same-task and invisible to frames, and counting them starved misclassified stream dirt of its macrotask leg for up to a full frame.
• Scheduling allocates nothing per dirt event — all callbacks are persistent fields (chains re-enter once per step; closure churn there is measurable GC pressure).

How to test

git fetch <this remote> scheduler-flush-only && git checkout scheduler-flush-only
pnpm install && pnpm build
pnpm pack   # then point your app's ember-source at the tarball

The @ember/scheduler phase API (render()/layout()/composite()/next()/idle() + registerStrategy) is included and its tests pass; the renderer's flushing is hardwired in base-renderer.ts rather than routed through a registered strategy yet — that seam (plus an optional feature flag defaulting to today's backburner behavior, settled()/test-waiter integration, and a sync-flush escape hatch) is the landable follow-up.

Expected breakage

This is a spike: the full test suite is not expected green — classic runloop-timing tests assume renders flush synchronously at runloop end. The landable shape puts this behind an optional feature per the RFC's migration story.

The remaining chain-bench gap (5.5s vs 3.8s) is per-step performance.now() + queueMicrotask + flush-body overhead vs backburner's tuned autorun; the structural fix is running render-effects inside the flush's own drain loop (the RFC's phase model is exactly that seam — Angular's afterEveryRender shape as a public API).

Related: #21493 (interface, mergeable), #21512 (subtree-skip, independent), #21513 (full spike incl. legacy-read removal — that lever turns out unnecessary for the async story).

🤖 Generated with Claude Code