comp.ts back under its cap by removing mechanisms at their root: a global File, one way to read a shared cell, and effects that park themselves

[nicolas-abril]

Context

#1285 brought comp.ts back under its permanent 64,000 cap, but only just: main is at 63,980 ttok. This PR brings it to 62,798.

The cuts are simplifications at the root rather than trimming: each removes a mechanism that existed only because another part behaved a certain way, or a second way of doing one job. Each was traced to the commit that added it, to check the reason no longer holds.

Changes (one commit each)

• The compiler's File is global and holds every cache. The caches were module globals cleared per book, so the compiler already held one book at a time, yet 40 functions took book or fl only to reach it. FL is now the book being compiled and everything memoized about it; FL.memo holds what one def's walk memoizes. type File lists every field, FL.memo's too. show_main now reads this book's caches, not the previous book's (it ran before the caches were cleared): this restores Initialize compiler caches before building printer layouts #961's fix, which main has lost. Two books compiled in one process now each emit what a fresh compile emits; on main the second either gets the first's stale layout or throws.
• Intr.call goes: an intrinsic that arr_op lays out has C: null; the flag's third use (blocking a fold rebuild) was redundant.
• A foreign def's segment opens and returns through emit_open/emit_put, like any def's.
• A constructor's own binders open as DUMMY, so a constructor's erased binder cannot pass for the def's parameter (6200daa), and the local flag threaded through facts_hot/facts_ctr goes. FL.ctrs memoizes those telescopes.
• lit_call goes: a Nat literal past 256 is read like any literal, not as U32.to_nat(word) (942573f's compatibility shim). Literals are capped at 2^32-1 by the parser, so a constant never nears the 2^48 immediate. nat_pattern_deep takes its 300 from U32.to_nat, so it still exercises the rebuild it pins.
• No scan for the word undefined in the emitted C: a leaked one is an undeclared name, which clang refuses.
• corpus_eval is one loop with one post-condition, and three guards for states that cannot occur go.
• A redirect cell has one read, term_peek (one relaxed 64-bit load, as A shared Array's redirect is read without a race and without an atomic on the device, once per spin (#975) #1155 made blk_loc do), and rfc_view goes; ctr_take acquires only as the last holder, before it owns the node. Shared Array redirect lookup races with atomic reference-count updates #975's reproducer under ThreadSanitizer: 0 reports in 10 runs on both trees (and 6 with the read made plain, as a control).
• A JS foreign op is a node tagged with its def's name, as in C, and an IO.OP match keeps its default arm in both lanes, so the JS-only $FFI goes.
• An effect that waits parks itself: io_eff takes no need, and the loop runs every request one way. IO.sleep parks on its deadline; TCP.accept and UDP.recv_from already parked themselves on EAGAIN.
• The book and the emitter's scope are two things: FL is the File being compiled, and a Scope (segment, local names, bindings, spare nodes, def) is where the emitter writes, so a nested arm, closure or fork copies only its scope.

Breaking

• The effect API: io_eff(cid, run) takes no need. A third argument is a compile error in C, and JS ignores it. Every waiting effect already had the self-parking form (io_wait_on / io_park_on), so nothing becomes impossible; guide/EFFECTS.md says so and shows how to wait on time alone. All 62 C registrations in bend2/effs and tests are updated.
• JS registry check: a foreign def without a registered JS effect fails when its request runs ("an alien request"), as in C, not at load.

Checks

After the rebase onto main (a3f1782), on an Apple M4:

• Emitted output: for all 1626 .bend files under tests/, bench/ and demos/, each commit that says its output is byte-identical emits byte-identical C, JS and .mjs against its parent. The lit_call commit changes the same 32 C files and no JS, as before.
• Local full suite (gates/test.ts's shard script run on this Mac): 1541/1543. The two failures are gfx_clicks and gfx_window, which need a display.
• Cluster gates (gates/_run.ts): repo 50/50, test 1543/1543, perf 121/124. Rerun back to back with main, alternating, perf scored 124/124 and 123/124 on this branch and 121/124 and 124/124 on main. Every cell over 1.15x, on either tree, was a PAR-GPU time under 0.1 s (mandelbrot, merkle, nbody). ping was skipped because the site repo is not checked out here.
• Demos: all build in C and JS.
• Not re-run since the rebase: the JS-lane timings and the commit audit below.

Before the rebase, on an Apple M4 against main (fb6f32a):

• Emitted output: the compiler-only commits keep the emitted C, JS and .mjs byte-identical for all 1608 .bend files under tests/, bench/ and demos/; the rest change it as described in their messages.
• Local full suite (gates/test.ts's shard script run on this Mac; every lane, Metal for the ! tests): all pass but gfx_clicks and gfx_window, which need no display and fail on main too.
• Cluster gates: repo 49/49, test 1526/1526, perf 115/117 against main's 117/117 back to back (geomeans: compiler 1.032, SEQ 0.993, PAR-CPU 1.015, PAR-GPU 1.035). The two cells over 1.15 are Metal times (nbody 1.17, terrain 1.19), which swing that much between runs on main too; on this M4, interleaved best of 3, Metal is 0.997 of main (nbody 1.018, terrain 0.991).
• JS lane (no gate covers it): the 16 benches compiled to JS, 2-3 interleaved runs each, geomean 0.983, every bench within ±2%; within_busy 0.75.
• Demos: all 15 build in C and JS.
• Audit of every commit since 2.0.0 (453 commits, a7e0600 to fb6f32a): for each, what it did, whether it aimed at compile or runtime performance or an edge case, its linked issues and PRs, and whether comp.ts back under its cap by removing mechanisms at their root: a global File, one way to read a shared cell, and effects that park themselves #1281 touches the same mechanism; where it does, the commit's or issue's reproducer was run on both trees. 123 preserved (verified), 329 no interaction, 1 regression, fixed: removing FID_EXIT's continuation fast path (87a1e9c) cost 28% more instructions at 8 threads in code that applies a closure which may fork (9.03G -> 11.54G; no bench takes that path), so the fast path stays. The 34 commits that aimed at performance are all preserved or untouched.
• Tried and dropped, with measurements: removing FID_EXIT's fast path (above), element-wise block copy (10% slower on a block-heavy micro-benchmark), a shared device/host drain loop (Metal compiled the work loop twice), JS Nat matches through == (a host's raw BigInt), dropping fl.consts (b84b004's 8 s compile guard), and two emitter shortcuts that relied on term identity.
• Not run: CUDA (the device read path and the CUDA gpu_make change are untested) and Linux.

🤖 Generated with Claude Code