js: the write round — flat writes 1.89x, round_trip 1.47x; 461% -> 313% of generated C++

[gafferongames]

Laggard round for generated JavaScript (#173): the flat tier's write side dragged the blended row — reads were already native-class. This is the write-side profile and the levers it justified.

Headline (--only js --quick, both halves in one sitting minutes apart, bench_mixed, family gen, codec flat, checks=contract, corpus 6b213fbfa1a03a99, max rates per §2.2, spreads ≤ 0.9%):

path	before max	after max
write	1,353,222	2,562,534	1.89x
round_trip	764,875	1,121,647	1.47x

Against the arm64 sitting-2 certification reference at the same corpus_id (cpp round_trip max 3,512,100 — the LOCKed reference, untouched by this round): 459.2% → 313.1% on this pair's own before leg (the ledger's standing 461% reproduced within 0.3%) of generated C++ on the canonical round_trip blend; on write 553% → 292%. Derived read moved 1.76 → 2.00 M msg/s as a side effect of the wide-lane lever — the read side was not traded away. The measurement CSVs live outside bench/results/ (scratch, per the round's rules); the numbers above are their rows verbatim.

1. MEASURE FIRST — where write time actually was

node --prof over the conformant quick leg (BENCH-STANDARD §2.8; node 26.7, M2, production mode):

• 51% of total ticks inside writeBenchMixedFlatProduction itself — straight-line merge arithmetic, no calls;
• 27% in V8 C++ runtime calls made from the hot functions (macOS symbolication renders them as one bogus nearest-symbol; the callers and the code say what they are: BigInt traffic) — the issue's prime suspect, confirmed;
• GC 1.5% — BigInt intermediates.

The per-field merge carried two data-dependent branches (a s < 32 lane split and the 64-bit flush) plus an s > 0 guard; every 128-bit field paid ~7 allocating BigInt steps; every &/>>/Number()/truncating-asUintN BigInt op allocates and calls the runtime.

The micro that ranked the primitives (interleaved arms, node 26, M2): DataView BigInt scratch stores consume a BigInt into plain memory without allocating — setBigUint64+2×getUint32 runs 674 M ops/s where the & 0xffffffffn / >> 32n / Number() chain runs 29 M. That asymmetry is the whole write-side BigInt story.

2. THE LEVERS, each landed as one commit with its paired numbers

#	lever	micro	leg (write / round_trip)
L1	Single-word 32-bit merge replaces the two-lane 64-bit staging pair: one shift-or, one literal add, one flush branch storing one word	1.44x on a mixed-width group	1.35→1.49 (+10%) / 0.77→0.82
L2/3	Write-side BigInt lane discipline: every wide value reaches the wire through SC.setBigUint64 (ToBigUint64 IS the asUintN(64) wrap; shift-then-wrap equals the asUintN(128) high half, so no reduction ever allocates ahead of the store); flags ≤32 and the >32-storage int32-range truncation (SC.getInt32 ≡ asIntN(32)) ride the same scratch	128-bit split 5.6x; sub-32 truncation 6.1x	1.49→2.22 (+49%) / 0.82→1.01 (+23%)
L4	Wide (>64-bit) read assembly through the scratch — two number-domain halves, one shift-or, instead of four BigInt(v) constructions chained through three shift-ors	3.2x on the 128-bit assembly	— / 1.01→1.06; derived read 1.86→2.07
L5	Chunked write merges — the family's grouping lever (go #198's runs, cs #208's word codec): adjacent ≤32-bit pure-expression fields pack into ONE staged word with literal relative shifts, which are static even where the absolute cursor is dynamic, so the lever reaches the loop bodies (stats: 2 merges/element → 1; entity: ~14 → ~7)	—	2.22→2.48 (+12%) / 1.06→1.11
L6	String/bytes bodies at 4 bytes per merge with a byte tail — measured first as a hand-patched ceiling on the generated leg, then landed	+3.6% ceiling	2.48→2.55 / 1.11→1.12

Refused by measurement

• Static cursor constant-folding for straight-line runs (the header is mostly aligned 32-bit stores — the classic AOT lever): hand-patched its ideal form into the generated header (13 merges → 11 direct word stores at literal offsets, golden gate still green) and measured 2.48 → 2.47 M msg/s: zero. V8 predicts the dynamic form's branches; the bottleneck is elsewhere. Refused — the emitter complexity would buy nothing.
• Chunking the flags-through-scratch piece via dedicated temps (Damage breaks an entity chunk): bounded at ~1–2%, not taken.
• Unrolling small fixed scalar arrays (cs: the codec pass — union batch cores, scoped batches, and the flat word codec (write 1.59x, round_trip 1.60x; 361% -> 219% of generated C++) #208's lever G): not taken, same reasoning as there.

Named follow-on (land-and-expand, not this round)

Read-side window chunking: the same relative-shift argument applies to reads — one 64-bit window load can feed several extractions where today every field reloads two words. The issue rules reads out of this round ("the read side needs nothing"); it is the next pass if the blend is chased further.

3. Runtime-side lever, reported not implemented

serialize.js's own BitWriter.writeBits (src/bitpacker.js) carries the exact two-lane 64-bit staging form this round retired in the flat tier — L1's micro (1.44x on a mixed-width group) prices a single-word 32-bit staging rewrite there. It would move the js bits family rows (the runtime bitpacker), not the flat gen rows, and it touches the four fused copies the file itself warns about plus flush/reset invariants — a serialize.js PR, not a schema one.

4. Discipline

• Wire held: full nine-language make test green; testdata/wire untouched (the re-pin commit touches SOURCE goldens only); the bench leg's §1.5 golden + 64-variant decode→re-encode gates pass at corpus_id 6b213fbfa1a03a99; degenerate corpus (The bench corpus cannot see fixed scalar arrays, bare float units, or run-cap-split nested structs #203) included, both NODE_ENV modes.
• Byte-equivalence argument for L1/L5, stated: an LSB-first packer into consecutive little-endian 32-bit words emits the identical byte stream to the 64-bit pair form, and merging a concatenation of fields equals merging them in sequence; the gates then prove it on every pinned instance and variant.
• Negative control, run rather than assumed: with the chunker's shift composition broken by one bit, test/js produces 100 failure lines and exits non-zero; restored, green, regenerated tree byte-identical.
• Chunk-boundary law in the emitter: chunks never cross a scope boundary or a statement-form merge (flush at every loop, branch, switch, align, scratch field); a temp-based piece flushes around itself so no piece outlives its inputs — the go: the flat word codec — 712% to 248% of generated C/C++ #198 fallback-class hazard designed out rather than tested away.
• Coverage of the new paths is pinned: chunked emission appears in every flat module of the conformance corpus; the scratch wide lanes are exercised by bench_mixed (64/48/128-bit fields) and the ludicrous suite (128-bit family), all byte-compared against C++-pinned wire.
• One commit per lever, paired numbers per commit; refusals measured on the same instrument.
• Quality gates: gofmt clean, go vet clean, modernize clean, shape-gate clean, generated tree current.
• bench/LOCK untouched: nothing under internal/codegen/{c,cpp} or generated/{c,cpp,c-ludicrous} moved.

🤖 Generated with Claude Code

Certification pair committed under bench/results/2026-09-01-jswrites-{before,after}-quick-arm64-macbook.csv — spreads 0.22–0.82%, recomputable forever. Adversarially reviewed: differential oracle (five seeds × ~600 rounds × four corpora, checked+production modes, cross read-back) zero divergence; every dropped-reduction equivalence claim verified with failed falsifications; negative control reproduced. Verdict: MERGE.