Logic pass: CPU attention mirrors get the same int32 bound as the GPU kernels (peers refuse identically); gpuMlpChain returns pooled buffers when the row-max guard throws

web/TEST_RESULTS.md

@@ -18,7 +18,7 @@ against the verified units at init.
 | `test_unit_backward.js` | int8 STE gradients do not damage convergence | PASS — units/float loss ratio 1.007 |
 | `test_b2b.js` | the chained GPU MLP's CPU mirror: gemm1 byte-identical to the un-chained GEMM, deterministic, +0.5 quantize FMA-contraction-immune | PASS — chained transformer converges 4.7384 → 2.0512 |
 | `test_nonfinite.js` | every quantizer refuses NaN/Inf instead of zeroing the layer | PASS — 13/13; the old quantizers fail 12 (added 2026-09-27) |
-| `test_reductions.js` | the GPU row-max guard is complete, `averageGrads` refuses wrong-length / non-finite gradients, int32 accumulators refuse K > 131,071 | PASS — 17/17; the old code fails 11 (added 2026-09-30) |
+| `test_reductions.js` | the GPU row-max guard is complete, `averageGrads` refuses wrong-length / non-finite gradients, int32 accumulators refuse K > 131,071 | PASS — 19/19; the old code fails 13 (added 2026-09-30) |
 
 ## The IEEE-754 oracle (`test_ieee.js`)
 

web/public/verified_core.js

@@ -447,6 +447,9 @@
   // d.acc=true returns the raw int32 accumulator (exact oracle for the kernel gate)
   function attScoresJS(qq, kq, qs, ks, d, L) {
     const { B, T, heads, hd } = d, C = heads * hd, mul = L.mul, raw = !!d.acc;
+    // the WGSL kernel sums these in i32; this mirror sums in doubles. Bound both identically so
+    // a CPU peer and a GPU peer refuse the same shapes instead of one halting alone.
+    accBound(hd, "attScoresJS");
     const out = raw ? new Int32Array(B * heads * T * T) : new Float32Array(B * heads * T * T);
     for (let bi = 0; bi < B; bi++) for (let h = 0; h < heads; h++) {
       const bz = bi * heads + h;
@@ -465,6 +468,7 @@
   // ctx[(bi,ti),(h,j)] = Σ_tj a[bz,ti,tj]·v[(bi,tj),(h,j)] — scatter fused into BT×C
   function attCtxJS(aq, vq, as, vs, d, L) {
     const { B, T, heads, hd } = d, C = heads * hd, mul = L.mul, raw = !!d.acc;
+    accBound(T, "attCtxJS");                       // contracts over keys, like gpuAttCtx
     const out = raw ? new Int32Array(B * T * C) : new Float32Array(B * T * C);
     for (let bi = 0; bi < B; bi++) for (let h = 0; h < heads; h++) {
       const bz = bi * heads + h;

web/public/webgpu.js

@@ -856,7 +856,12 @@
     const mx = new Float32Array(readM.getMappedRange(0, m * 4).slice(0)); readM.unmap();
     // scale derivation in JS f64 — exactly rounded, identical on every device
     // (WGSL division is 2.5 ULP, which is why it never runs on the GPU)
-    const sc = root.Verified.scalesFromAbsMax(mx);
+    let sc;
+    try { sc = root.Verified.scalesFromAbsMax(mx); }   // refuses a non-finite row max
+    catch (e) {                                        // hand the pooled buffers back first
+      release(device, [bufX, bufW1, bufW2, bufRs, bufCs1, bufCs2, bufH, bufMX, bufD1, bufDM, readH, readM]);
+      throw e;
+    }
     const bufInv = up(device, sc.inv, SU), bufHs = up(device, sc.scale, SU);
     const bufQ = mk(device, m * hw * 4, GPUBufferUsage.STORAGE);
     const bufDQ = up(device, new Uint32Array([m, h, hw, 0]), UU);

web/test_reductions.js

@@ -77,6 +77,12 @@ ck("(context) Int32Array really wraps 2^31 to -2^31 -- the silent failure being
 ck("bgemmJS refuses the same K",
    throwsName(() => V.bgemmJS(worst, worst, new Float32Array(1), new Float32Array(1),
                               { m: 1, k: K, n: 1 }, L), "AccumulatorBoundError"));
+ck("attScoresJS refuses head width hd > 131071 (the CPU mirror of gpuAttScores)",
+   throwsName(() => V.attScoresJS(worst, worst, new Float32Array(1), new Float32Array(1),
+                                  { B: 1, T: 1, heads: 1, hd: K }, L), "AccumulatorBoundError"));
+ck("attCtxJS refuses T > 131071 (it contracts over keys, like gpuAttCtx)",
+   throwsName(() => V.attCtxJS(new Int8Array(1), new Int8Array(1), new Float32Array(1), new Float32Array(1),
+                               { B: 1, T: K, heads: 1, hd: 1 }, L), "AccumulatorBoundError"));
 const okK = worst.subarray(0, V.MAX_INT32_K);
 ck("K = 131071 still runs and is exact (131071 * 16384)",
    V.lutMatmulJS(okK, okK, 1, V.MAX_INT32_K, 1, L)[0] === 131071 * 16384);