The allocation-tracking snapshots show the formatter's arena reaching 525 MB for antd.js (6.7 MB source) — ~18× the parser's arena for the same file, while the live document is only ~61 MB. The arena is a bump allocator: any vector that grows inside it strands every grown-out-of allocation for the rest of the format run, and in-place growth almost never applies because other allocations (AstNode wrappers, nested buffers) land in between.

Per-phase measurement of Allocator::used_bytes() attributed the garbage to:

• intern() staging (~270 MB on antd.js): every interned island was built in an arena VecBuffer growing from capacity 0. The default call-arguments path interns each call's argument list, and a UMD bundle is one giant nested call expression, so nearly the whole document flows through interns (the root slice ends up with 294 elements; 67k interned islands hold the rest).
• Root buffer pre-allocation (~64 MB on antd.js): format() reserves 0.4×source-length elements in the arena up front, which is dead weight whenever content ends up in interned islands instead.
• (~71 MB of transient AstNode wrappers — not addressed here, needs a design change.)

Change

New HeapVecBuffer in oxc_formatter_core: a heap-backed staging twin of VecBuffer, drawing its backing vector from a LIFO scratch pool on FormatState (one buffer per nesting level, capacity retained across uses, so staging allocates nothing in the steady state). Sequences whose length isn't known up front are built on the heap — where growth reallocations are actually freed — and the arena receives one exactly-sized copy of the final content.

Converted call sites:

• Formatter::intern
• BestFitting variant construction
• the three grouped-argument variant builders in arguments.rs
• the assignment-like left-hand-side staging (replayed into the parent buffer via take_heap_vec; nothing lands in the arena at all)
• both document roots: JS format() and JSON format() (resolves the TODO there about pre-sizing)

VecBuffer::take_vec lost its last caller and is removed.

Results

Arena bytes after parse + IR build (Allocator::used_bytes()), tracked benchmark files:

Output is byte-identical on all of the files above, fixture/unit suites for oxc_formatter and oxc_formatter_json pass, and hyperfine shows parity to 1.03× faster (antd.js 146.8 → 142.9 ms mean); the heap-side churn stays flat thanks to the scratch pool.

The tasks/track_memory_allocations snapshots are not regenerated here — their byte lines are Linux-CI reference values, so they need the CI job's diff.

Investigated and implemented with Claude Code; reviewed and driven by me.