scope-capture VS lumo

Awesome tools.

Personally I can't imagine coding in clojure without scope capture

https://github.com/vvvvalvalval/scope-capture

I haven't tried it myself. I generally just use truss for runtime constraint checking. I use a modified version that integrates scope-capture. And malli validation for more complex cases, but I try to limit that. For me it is better to validate individual attributes as needed, vs validating an entire "type"/collection of attributes. So each function only cares about the attributes that it needs, and validates only as needed.

Use scope-capture to observe the actual data flowing through the system

Scope capture library https://github.com/vvvvalvalval/scope-capture automates this approach.

Is anyone aware of any prior art along the lines of this? I've seen scope-capture but it's more about instrumenting existing programs than writing new ones interactively.

I am not advocating against the use of a compiler. I am going to illustrate how to reproduce the scope of a program and replay it in the REPL as it is done for instance in Clojure with scope-capture. In some use cases, I find this approach is simpler than using a debugger. This approach is possible only because the data is immutable.

Is this similar to Lumo (https://github.com/anmonteiro/lumo)? I would assume Lumo has a faster start time since it boots from a V8 snapshot, but otherwise I'd assume the two projects are similar (except that, of course, lumo is EOL)

Lumo: a standalone ClojureScript environment, runs on Node.js. Doesn't seem to have its own reader conditional, uses :cljs.

Lumo and Planck (standalone Clojurescript environments, based on Node and on JavaScriptCore with some additional functionality to make it suitable for scripting, respectively), and Clojerl (Clojure implemented on BEAM). Startup times are comparable to e.g. Racket.