[Lorenzobattistela]

Fixes #1069.

A program the interpreter and JS run could fail bend -o with an arity over 247 whenever a segment kept more than 247 words live: a record built field by field with calls, a list literal of calls, values live across a fork, a closure's captures. Since 2.0.39 a real program hits it too (hapsland, reported on #1069): #1806 lets command_selected borrow command instead of moving it, so NativeRun.command_selected$k1063 keeps it live and goes from 243 to 254 words. #1806 is right; the limit is the problem, and that program has 27 segments between 200 and 247 words.

The 247 limit is the register bank's, but only some segments enter through it:

• A continuation reads its live words from the stack (seg_take, WL_ARGS); only its results ride registers, and the bank is already sized without it. It only needed a wider arity: Fid takes u16 fields when some arity passes 255, u8 otherwise, so other builds keep their table. On Metal all four fields must share one width: a u16 ar beside u8 fields leaves the device lane with "frontier drained" even in small programs.
• A fork join and a closure enter through registers (FID_ENTER's WL_LOAD, Clo~apply). seg_pack moves their live words past WIDE into one ~pack node of 2^c words, a constructor with its own CID, so a dropped closure's term_drop frees it and its fields. seg_open reads it back into locals at the segment's entry and frees it. Both join paths, parallel and sequential, pack the same tail. Words of any width pack, which covers the multiword captures fix(compiler): box wide continuation and closure captures #1788 boxed.
• term_drop reads 64 | (n - 240) only for constructors: a wide task or closure now exists.

Programs under the limit emit the same C as before, apart from the Fid typedef's position and that term_drop line (checked on 73 tests in tests/run and tests/reg).

Tests (tests/reg), each failing to build on main and passing on interpreter, JS and C at 1 and 4 threads:

• wide_frame: a 300-String record built by calls (continuations).
• wide_fork_join, wide_fork_join_gpu: 300 U32 live across a fork, on the host and under !.
• wide_closure_pack: closures over 300 Strings, applied and dropped.
• wide_capture_calls, wide_capture_closure: from fix(compiler): box wide continuation and closure captures #1788 (multiword captures).

What stays:

• A def whose own parameters pass WIDE in one-word values still fails; multiword parameters keep their boxing rule.
• Apple clang 21 crashes when a preserve_none function's frame passes 4 KB (ARM64 native emission triggers clang backend crashes; isolated LLVM14 IR reproducer and Apple clang21 report #1233). A segment with about 500 live words reaches it; -fno-stack-check builds it, and 600 live words then run correctly.
• Under !, very large programs (10+ MB of C) are slow or crash in Metal's compiler on main too.

Related: #1788 (multiword captures, superseded by this), #1494 (an earlier spill through the evaluator stack, closed).

Gates on 9d514f3: test 1789 / 1789, perf 124 / 124, ping 81 / 81, safe 1144 agree and 0 false reject.

🤖 Generated with Claude Code

[YidaWeng]

Verified against current main (00d29f44): all six new tests pass --check-only, interpreter, C and JS; the GPU test falls back to CPU here (no CUDA toolkit), so the device lane still needs a cluster run.

The regression tests are meaningful: on current main, wide_frame.bend and wide_fork_join.bend fail -o with Error: an arity over 247; this PR fixes both.

Blocker: repo-gate fails. Merged with current main, comp.ts is 66,572 ttok, 572 over the 66,000 cap. The PR's base is 9d514f3b, so the reported gate runs are stale.

Please:

1. Reduce comp.ts by at least 572 ttok by simplifying the change, not by moving code out.
2. Rerun the cluster gates on current main.
3. Check the seg_pack case where the live set is empty or res > WIDE.
4. Update the error text that still says "arity over WIDE" even though frames now allow 65535.
5. Report the GPU lane separately.

Happy to help with a token-diet patch if useful.