Fixes #104.

Problem

A straight-line do/>>= chain desugars to a right-nested tree of continuation closures, bind m1 (\x1 -> bind m2 (\x2 -> … last)). Past roughly 200 nesting levels Lua's parser refuses to load the chunk at all (chunk has too many syntax levels, LUAI_MAXCCALLS). On the JS/ES backends deep nesting is only a performance cost; on Lua it is a correctness failure, because the file never loads.

#46 fixed this for Effect/ST via magic-do: their computations are thunks, so a chain lowers to a flat statement sequence. That cannot work for an arbitrary monad, where bind m k is an opaque call whose control flow lives inside bind (Maybe short-circuits, lists call k zero or more times, State threads context). #104 is the general case.

The fix: flattenDeepBinds

A new IR pass, wired into optimizedUberModule right after magicDo (so by the time it runs, every Effect/ST chain is already a Let thunk and only other monads remain). It lambda-lifts a long bind chain: the chain is split into fixed-size segments, and each segment's continuation becomes a small named $kontN helper whose free continuation variables are passed as explicit parameters. The result is a flat let of helpers wrapping a shallow body, so nesting no longer grows with chain length.

This relocates closures and forwards their environment, but it never reorders, drops, or duplicates a bind/k call, so it is semantics-preserving for any monad, strict Lua included: the helper calls pass only variables, and binding a helper does not run its body. Recognition precision therefore only decides which expressions get restructured, not correctness.

Two properties make the De Bruijn bookkeeping disappear:

• The pass runs after renameShadowedNames, so every local is uniquely named. A helper reuses the chain's own binder names as its parameters, so references stay at index 0 with no shifting.
• The transitive live set falls out of countFreeRefs on the built helper bodies: because a helper's call site passes its live variables explicitly, those variables show up as free references one level up and propagate through the chain automatically.

When a cut's live set would exceed Lua's 60-upvalue cap (LUAI_MAXUPVALUES) the pass bails and leaves the chain nested rather than emit a function that also will not load. Packing the environment into a single table to cut that to one upvalue is a possible later upgrade.

Safety net: NestingCheck

A post-codegen check in Backend.compileModules measures the chunk's maximum nesting depth and rejects it with a clear NestingTooDeep error when it crosses a conservative threshold, instead of writing out Lua that no interpreter can load. The metric mirrors the recursive-descent parser: it counts function bodies, call arguments, and operators, but not the iterative spine of a curried call. This catches whatever flattenDeepBinds bails on, plus the deep-nesting shapes that are not flattened yet (see Scope below).

Tests

• Golden.LongMaybeBind: a runnable 300-step Maybe do block whose final result reads the first bound variable, forcing it through every lifted helper. The eval oracle is (Just 301). Without the fix the generated Lua fails to load; with it, stock Lua 5.1 runs it.
• Golden.LongMaybeBindModule: the same chain in module mode (no main), which exercises the IR/Lua goldens.
• Unit specs for the pass (free-reference preservation, length-independent output nesting, idempotence) and for the detector (depth metric, threshold, the curried-spine case).

The generated golden.lua loads and runs under stock Lua 5.1.5; max nesting is 43 against the ~200 cap. No existing golden changed.

Scope

This handles do/bind chains. Still not flattened, and now reported by the detector instead of silently breaking: applicative chains (ado/apply, bindFlipped), chains whose live set exceeds the upvalue budget, and deep nesting from non-bind constructs (large case trees, long <> concatenations, wide literals). A general Lua-AST-level nesting breaker covering those is filed separately.