Closes #172.

What this adds

A bench/ directory, separate from the test suite, plus luajit in the dev shell and a CI step. Layout and usage are documented in bench/README.md.

./bench/run produces local wall-clock numbers: hand-written micro pairs (curried application, dictionary-driven comparison, constructor allocation + tag match, module-field access), each in its current generated shape next to the idiomatic Lua it stands for, and three macrobenchmarks driving real linked modules (Bench.Fib, Bench.ArrayFoldl, Bench.BindChain, sources under test/ps/src/Bench/). Everything runs under PUC Lua, LuaJIT, and luajit -joff. Timings stay out of CI: shared runners are too noisy for them.

./bench/ci is the CI check. It relinks the Bench.* artifacts with the current compiler, regenerates two kinds of LuaJIT counter reports, proves each is byte-stable (every report is generated twice and compared), and diffs them against the committed oracles in bench/goldens/. After a deliberate codegen change, ./bench/ci --accept rewrites the oracles and the diff gets reviewed like any golden. The CI step runs after the test suite on purpose: the suite's spago build leaves the full CoreFn output on disk, which is what bench/link links from.

Both meters read jit.util directly instead of parsing -bl/-jv text, whose format is not a contract and has already changed shape across LuaJIT versions:

• fnew_census walks a linked artifact's prototypes statically (no execution) and counts FNEW bytecodes, split into main-chunk occurrences, which run once at load, and function-body occurrences, which allocate a closure per call and abort trace recording (NYI: bytecode FNEW). The census is a pure function of the artifact.
• trace_report drives a macro spec hot and reports the set of distinct trace-abort sites plus the end state of loop and function-entry opcodes: LuaJIT rewrites them to J* forms when it installs a trace and to I* forms when it blacklists a spot. Blacklisting is never logged by -jv/-jdump, and raw abort counts jitter with the entropy-seeded retry-penalty PRNG (mainline LuaJIT has no jit.prngstate to pin it), so the post-hoc opcode read and the deduplicated site set are the stable signals. Aborts whose reason is merely "blacklisted" are filtered out: whether recording ever runs into an already-blacklisted spot depends on the retry count, and the I* opcode already carries that fact deterministically.

Measured baselines (this machine, LuaJIT 2.1.1741730670, PUC Lua 5.1.5)

The issue's verification bullets all reproduce. The curried hot loop runs the same with the JIT on and off, because every partial application emits an FNEW; the census shows those FNEWs in function bodies (12 in the Bench.ArrayFoldl artifact, one per curried level). The FFI fold loop ends up IFORL-blacklisted even though it is a plain for, while the hand-written fold compiles to a JFORL trace. In bind_chain the blacklist lands on the driver loop, whose callee cannot be inlined: the caller pays. All six counter reports came out identical over repeated runs (the trace reports were additionally checked over 6 consecutive runs), so CI can gate on them byte for byte.

Two comparator notes. The issue's one-off measurement quoted ~54x for the curried loop and ~85x for foldl; the ratios here differ in the expected directions. The curried gap grew to 120x because the uncurried loop compiles tighter under the current LuaJIT snapshot. The foldl gap shrank to 24-38x because the harness's ideal does the same total work as the linked artifact, array construction included; against a fold-only comparator like the issue's, the same runs give ~88x at 1e7 elements.

Notes

• The macro modules are new Bench.* sources rather than the linked golden artifacts themselves: a module export can be driven and timed in-process without going through stdout, and the Bench. prefix keeps them out of the golden suite (the harness only collects Golden.*). Bench.Fib is source-identical to the golden's fib.