Reactive roadmap

Phases 1–8 shipped (feature foundation).
This roadmap covers production-grade + signature-grade work.
Priority: Correctness → Scheduler → Granularity → Memory → DevTools → Compiler → Concurrency → Benchmarks → Spec polish.

Normative semantics: REACTIVE_SPEC.md

Track status

Milestone A — Correctness foundation

Done when:

• [x] REACTIVE_SPEC.md v0.1
• [x] Stale dependency cleanup (luke_rx_clear_deps)
• [x] Scheduler counters + Build introspection
• [x] reactive_conformance_*.luke + make test-build
• [ ] Nested/recursive reaction rules documented + tested
• [x] Error propagation policy (v0.6 — isolation + retry)

Milestone B — Scheduler 2.0

• [x] Priority lanes (UI effect before BACKGROUND)
• [x] Dirty dedup counter + queue size instrumentation
• [x] Deferred nested flush (one turn, multiple passes)
• [x] Scheduler timeline / step counters
• [x] WHEN REACTIVE / WHEN BACKGROUND REACTIVE side-effect effects
• [x] BIND BACKGROUND low-priority binds
• [ ] Starvation guard (wait_epochs boost) — runtime hook present, conformance pending
• [ ] Macrotask queue / scheduleReactive API

Milestone C — Granularity

• [x] Argus region paint (argus_paint_one, THE REGION PAINT COUNT)
• [x] Hanka partial relayout (hanka_layout_dirty, hanka_mark_region)
• [x] Component subtree invalidation on scope dispose
• [x] reactive_conformance_subtree.luke
• [ ] Field-level object tracking
• [ ] Paint/layout dirty rects (spatial index)

Milestone E — Memory management (shipped v0.4)

• [x] Dead node disposal + THE DISPOSED COUNT
• [x] Graph audit + leak edge repair (luke_rx_audit_graph, THE LEAK EDGE COUNT)
• [x] Alive/dead counters (THE ALIVE NODE COUNT, THE DEAD NODE COUNT)
• [x] Weak reads (THE WEAK VALUE OF, THE WEAK READ COUNT)
• [x] AUDIT REACTIVE statement
• [x] Conformance: reactive_conformance_{memory,weak}.luke
• [x] Weak effect refs (WHEN REACTIVE WEAK, luke_rx_effect_weak)
• [x] Auto scope GC (luke_rx_scope_gc, UNMOUNT COMPONENT, THE SCOPE GC COUNT)
• [x] Conformance: reactive_conformance_{scope_gc,weak_effect}.luke

Milestone F — DevTools (shipped v0.5)

• [x] Graph stats (THE GRAPH CELL COUNT, THE GRAPH EDGE COUNT)
• [x] Why-changed trace (THE WHY ROOT OF, THE WHY DEPTH OF, TRACE WHY)
• [x] Last write id + dep/sub counts per node
• [x] Timeline step export (THE TIMELINE STEP ID AT n)
• [x] DUMP REACTIVE GRAPH live snapshot (stderr)
• [x] Conformance: reactive_conformance_devtools.luke

Milestone G — Error system (shipped v0.6)

• [x] Effect/derived error isolation (luke_rx_isolate_error, errored flag)
• [x] Flush continues after isolated failure (sibling effects still run)
• [x] Async failure reporting (REPORT REACTIVE FAILURE FOR … WITH …)
• [x] Retry + clear (RETRY REACTIVE ERROR, CLEAR REACTIVE ERROR)
• [x] Error boundaries (BEGIN ERROR BOUNDARY, RESET ERROR BOUNDARY)
• [x] Introspection: error/boundary counters
• [x] Conformance: reactive_conformance_{error,boundary}.luke

• Benchmark suite vs full rerender baseline — 1K/10K shipped (BENCHMARKS.md); 100K pressure via make pressure
• One signature reference app — dashboard (examples/build/dashboard_*.luke)
• WASM/native conformance CI matrix
• 100K node workload — green (examples/build/reactive_pressure.luke)

Definition of done: “fundamental execution model”

Reactive is not a “feature” when all of:

1. Normative spec with guarantees
2. Conformance tests (native + WASM)
3. Correctness + disposal + async failure suite
4. Reference stress app with measurable granular updates
5. Benchmark baselines published
6. Signature idioms documented (“Lukelang way”)

Signature line

Lukelang understands change.

The runtime knows what depends on what — and only that work runs.