The whole machine, end to end

The same source runs three ways: a tree-walking interpreter (steppable, the one the debugger drives), emitted JavaScript (fast), and a real WebAssembly module (bare-metal). A cross-runtime gate re-checks that all three produce byte-identical results — same trades, same final equity, max delta zero — on every change. A strategy that behaves differently depending on how it was compiled is a bug we fail the build on, not a footnote.

The three-backend parity gate is not a marketing line — it is a test that runs on every change and holds max delta at exactly zero. Correctness is enforced mechanically, not asserted.

For search, a strategy also lowers to a neural-style AST where each node carries its own credit, memoises partial evaluations across bars, and can claim a JIT slot on the hot path. That is what lets the evolutionary engine grade thousands of variants a second without re-running each one from cold. The canonical form stays a plain, readable program; the fast form is a working copy the engine drives.

The pure numeric functions underneath a strategy — the indicator math — also emit to plain Python or numba-JIT, so the same kernels drop into an existing Python quant stack without a rewrite.

Classes, enums and pattern matching keep strategies legible; the fast neural/JIT form is a derived working copy. You never lose the version a human can read and audit.

Pine AST → MuseScript AST, node by node, against ~85 mapped built-ins. Unmapped constructs are flagged with a line-cited TODO — honest partial coverage beats coverage that's quietly wrong.

The converter also runs a repaint audit: lookahead and future-peeking patterns — the ones that make a backtest look better than the strategy ever traded — are surfaced as warnings on the exact line they occur. We tell you where your strategy lied to you. That is a feature a platform whose retention depends on pretty backtests has no reason to build.