Arrays grow by doubling (#453 step 3)

[ASDAlexander77]

Step 3 of #453 (spec section 6, docs/superpowers/specs/2026-10-03-array-reference-design.md).

#480 is merged; main is merged into this branch, so the diff is this PR's own.

What changes

• ArrayLayout::ensureCapacity(arrayType, header, needed): when needed is past the header's capacity the data block grows to max(4, 2 * capacity, needed) elements and the slots past the old capacity are zeroed; it returns the data pointer, already stored in the header. It still goes through MemoryRealloc, so an rc data block keeps its count across a move and a block grown from null is born with the header's reference.
• push, unshift and splice call it instead of reallocating to the exact new length on every call; with room left they write into the block they have.
• pop, shift, a shrinking splice and a smaller length = keep the block and zero each slot they vacate, so gc does not keep a removed element alive and a later growth reads zero. pop/shift of an empty array leave it empty and give a zeroed element (before, they read the slot before the first, an rc block's count word, and set the length to -1).
• length = n zeroes the slots between the old and the new length in every model, gc included (the needsGCRuntime() exception is gone): after a pop the slots past length are no longer fresh memory from the allocator. The comment in SetLengthOfOpLowering says why; the default library's Set, Map and Array.map still rely on new slots reading zero.
• A smaller length = now releases the elements it drops under rc and own before zeroing their slots (it leaked on main too). The loop of 10 pushed strings then length = 0, 200k rounds, peaks at 4.4 MB under rc and own (was 65.9 MB), the same as the splice loop.
• view() clamps its range at run time (offset to [0, length], count to what is left), so an out-of-range end no longer copies, and under rc retains, memory past the array.
• main refuses an array-typed parameter in any position in non-DLL builds (JIT, exe, obj). A one-parameter main(args: string[]) compiled ahead of time used to segfault. argv is Ref<string> only.
• LengthOf no longer has a struct fallback, so no ARRAY_*_INDEX remains outside ArrayLayout.h/Defines.h.
• Docs: the spec and plan are brought up to date. This covers ABI (old and new objects most likely link, then fail at run time, so rebuild everything including the default library), rc strings over array data (A string cast over an array's data block dangles after the array grows; under rc it counts a block it does not own #481), and the empty pop/shift and shrink release behaviour.
• New test 00array_growth.ts (1000 pushes through an alias, a popped slot reading zero when length grows again, shift/unshift/push around a growth, class elements across growth and pops), registered as compile, JIT and corpus tests. It also pins this PR's edges: empty pop/shift, 20 unshifts across growth, a shrinking splice then length = reading zero, a growing 9-item splice insert, and the shrink release. 00array_view.ts gains the clamped cases, 00array_rest_copy.ts a push onto an empty rest and [...all] = src, and a new lowering-error test covers the one-parameter main.

Timing

1,000,000 pushes onto a number[], AOT (--emit=obj --opt --opt_level=3, the test runner's link line), median of 3 runs:

model	before	after
gc	515 ms	18 ms
rc	2282 ms	15 ms

Gates

• Windows Release suite (ctest -C Release -j 12 --timeout 300, staged default library): 3743/3743 passed, 0 failed (1 disabled test not run).
• WSL Linux suite: 3728/3728 passed, 0 failed (1 disabled test not run).
• -mm=own corpus check (every test compiled with --emit=llvm -mm=own, plain and --opt): no test changes between ok and not ok against An array is a reference to a header that never moves (#453, #477) #480; 455/594 and 453/594 ok (the +1 is the new test).
• 00array_growth.ts and an edge-case program (empty pop/shift, splice delete/insert past capacity/replace, 100 unshifts then 99 shifts, string and nested arrays across shrink and regrow) pass under gc, rc, none and own, with and without --opt.

Not changed

• An array inside an unannotated constant tuple literal (Pushing onto an array inside a constant tuple literal crashes (realloc of static data) #479) is still a static header in constant memory: push crashes, and pop/shift/splice/length = on it give wrong results. Not fixed here.
• A string cast over an array's data block dangles once the array grows (A string cast over an array's data block dangles after the array grows; under rc it counts a block it does not own #481, every model, pre-existing).

🤖 Generated with Claude Code