wgblas 1.2.1 → 2.1.0

package/src/shaders/f64/utils/add.wgsl

@@ -0,0 +1,77 @@
+// Requires f64/dekker.wgsl concatenated first for the DD struct.
+
+// ── A real compiler bug — read before touching anything below ──────────────
+//
+// twoSum/fastTwoSum's error term `e` should be nonzero (that's the point —
+// `s` is rounded). A front-end-optimizer bug zeros it anyway, on both NVIDIA
+// and Mesa (ANV + llvmpipe), via two different mechanisms needing two fixes:
+// bitcast-based subtraction (`fsub`/`negf`, fixes NVIDIA) and materializing
+// the sum through workgroup memory + workgroupBarrier() (fixes Mesa). Only
+// both together (ddAddProtected) is verified correct everywhere — the plain
+// twoSum/fastTwoSum/ddAdd below are reference-only, not safe to use.
+fn negf(x: f32) -> f32 {
+  return bitcast<f32>(bitcast<u32>(x) ^ 0x80000000u);
+}
+fn fsub(a: f32, b: f32) -> f32 {
+  return a + negf(b);
+}
+
+// Knuth/Møller's TwoSum: s = fl(a+b), e = exact rounding error, a+b == s+e.
+// Works for any a, b. UNPROTECTED — see header above.
+fn twoSum(a: f32, b: f32) -> DD {
+  let s = a + b;
+  let v = s - a;
+  let e = (a - (s - v)) + (b - v);
+  return DD(s, e);
+}
+
+// Dekker's Fast-Two-Sum: same contract, but only correct when |a| >= |b|.
+// UNPROTECTED — see header above.
+fn fastTwoSum(a: f32, b: f32) -> DD {
+  let s = a + b;
+  let e = b - (s - a);
+  return DD(s, e);
+}
+
+// Double-double addition (Dekker's Add2). UNPROTECTED — see header above.
+fn ddAdd(a: DD, b: DD) -> DD {
+  let s = twoSum(a.hi, b.hi);
+  let loSum = a.lo + b.lo;
+  return fastTwoSum(s.hi, s.lo + loSum);
+}
+
+// ── Protected variants — use these ──────────────────────────────────────────
+//
+// Bitcast subtraction + workgroup-barrier materialization, verified correct
+// on all three backends tested. Costs a real barrier: fine for O(1)-per-
+// thread or O(log n) reduction use, not a long per-element loop. A
+// workgroupBarrier() requires uniform control flow, so:
+//   - `threadSlot` must be unique per concurrent caller (e.g. local_invocation_index).
+//   - Every thread in the workgroup must call this the same number of times
+//     — including ones whose result gets discarded. Compute unconditionally;
+//     only the write-back should be conditional.
+var<workgroup> dekkerScratch: array<f32, 64>;
+
+fn twoSumProtected(a: f32, b: f32, threadSlot: u32) -> DD {
+  dekkerScratch[threadSlot] = a + b;
+  workgroupBarrier();
+  let s = dekkerScratch[threadSlot];
+  let v = fsub(s, a);
+  let e = fsub(a, fsub(s, v)) + fsub(b, v);
+  return DD(s, e);
+}
+
+fn fastTwoSumProtected(a: f32, b: f32, threadSlot: u32) -> DD {
+  dekkerScratch[threadSlot] = a + b;
+  workgroupBarrier();
+  let s = dekkerScratch[threadSlot];
+  let e = fsub(b, fsub(s, a));
+  return DD(s, e);
+}
+
+// Protected double-double addition — same contract as ddAdd, but exact.
+fn ddAddProtected(a: DD, b: DD, threadSlot: u32) -> DD {
+  let s = twoSumProtected(a.hi, b.hi, threadSlot);
+  let loSum = a.lo + b.lo;
+  return fastTwoSumProtected(s.hi, s.lo + loSum, threadSlot);
+}

package/src/shaders/f64/utils/equal.wgsl

@@ -0,0 +1,7 @@
+// Requires f64/dekker.wgsl concatenated first for the DD struct.
+
+// a == b for double-double pairs — exact field equality, no rounding
+// involved, so (like ddGreater) this needs no protection.
+fn ddEqual(a: DD, b: DD) -> bool {
+  return a.hi == b.hi && a.lo == b.lo;
+}

package/src/shaders/f64/utils/greater.wgsl

@@ -0,0 +1,12 @@
+// Requires f64/dekker.wgsl concatenated first for the DD struct.
+
+// a > b for double-double pairs. hi dominates (|lo| <= ulp(hi)/2 always), so
+// comparing hi alone is correct except on an exact hi tie, when lo breaks it.
+// A plain comparison, not a rounding-identity subtraction — no reassociation
+// risk, so unlike twoSum/fastTwoSum this needs no protection.
+fn ddGreater(a: DD, b: DD) -> bool {
+  if (a.hi != b.hi) {
+    return a.hi > b.hi;
+  }
+  return a.lo > b.lo;
+}

package/src/shaders/f64/utils/multiply.wgsl

@@ -0,0 +1,81 @@
+// Requires f64/dekker.wgsl concatenated first for the DD struct, and
+// f64/utils/add.wgsl for fsub/negf (bitcast-based subtraction/negation) and,
+// for ddMulProtected at the bottom, fastTwoSumProtected.
+//
+// Use twoProdBit — verified universal (0 corrupting failures across 3000+
+// random trials on NVIDIA/Intel-Mesa-ANV/llvmpipe), no barrier protection
+// needed. The classic approaches below (twoProd, twoProdFma) each fail on
+// one backend in a way barrier materialization doesn't fix; twoProdBit
+// sidesteps the bug instead by deriving the split via bitcast+bitmask
+// rather than an arithmetic identity, leaving nothing for a reassociating
+// compiler to fold. Intel Mesa ANV shows frequent last-bit-only diffs from
+// strict ground truth (never data-corrupting) — consistent with the driver
+// legitimately auto-fusing `x - y*z` into hardware FMA.
+const SPLIT_CONST: f32 = 4097.0;
+
+fn bitSplit(a: f32) -> DD {
+  let bits = bitcast<u32>(a);
+  let hiBits = bits & 0xFFFFF800u; // keep sign+exponent+top 12 mantissa bits
+  let hi = bitcast<f32>(hiBits);
+  let lo = fsub(a, hi); // exact by Sterbenz's lemma (hi, a share an exponent, are close)
+  return DD(hi, lo);
+}
+
+fn twoProdBit(a: f32, b: f32) -> DD {
+  let s = a * b;
+  let aSplit = bitSplit(a);
+  let bSplit = bitSplit(b);
+  let e = fsub(fsub(fsub(fsub(s, aSplit.hi * bSplit.hi), aSplit.lo * bSplit.hi), aSplit.hi * bSplit.lo), aSplit.lo * bSplit.lo);
+  return DD(s, negf(e));
+}
+
+// ── Unsafe historical reference — do not use ────────────────────────────
+// Both broken on one backend, confirmed via isolated cross-driver testing,
+// NOT fixed by barrier materialization (unlike addition's bug):
+//   - veltkampSplit/twoProd (Dekker's original): fails on NVIDIA — compiler
+//     folds `hi = c - (c - a)` to `= a` straight through fsub/negf, even
+//     with every intermediate barrier-materialized (11/11 fail, worse than
+//     unprotected's 6/11).
+//   - twoProdFma (Ogita/Rump/Oishi): fails on llvmpipe — its software fma()
+//     likely isn't genuinely fused, making `fma(a,b,-(a*b))` correctly (not
+//     buggily) zero. Materializing `s` doesn't change this.
+fn veltkampSplit(a: f32) -> DD {
+  let c = SPLIT_CONST * a;
+  let big = fsub(c, a);
+  let hi = fsub(c, big);
+  let lo = fsub(a, hi);
+  return DD(hi, lo);
+}
+
+fn twoProd(a: f32, b: f32) -> DD {
+  let s = a * b;
+  let aSplit = veltkampSplit(a);
+  let bSplit = veltkampSplit(b);
+  let e = fsub(fsub(fsub(fsub(s, aSplit.hi * bSplit.hi), aSplit.lo * bSplit.hi), aSplit.hi * bSplit.lo), aSplit.lo * bSplit.lo);
+  return DD(s, negf(e));
+}
+
+fn twoProdFma(a: f32, b: f32) -> DD {
+  let s = a * b;
+  let e = fma(a, b, negf(s));
+  return DD(s, e);
+}
+
+// DD × DD product (Dekker/Bailey): twoProdBit(a.hi, b.hi) already captures
+// the dominant term to full DD precision, and the cross terms are below the
+// ~48-bit floor anyway, so folding them in with plain f32 loses nothing —
+// only the final renormalization needs barrier protection. Split into
+// ddMulRaw (unprotected) and ddMulProtected (renormalizes via
+// fastTwoSumProtected) so callers with several products can batch them
+// through one shared barrier. ddMulRaw's result isn't a valid DD pair on
+// its own — it must be renormalized before use.
+fn ddMulRaw(a: DD, b: DD) -> DD {
+  let p = twoProdBit(a.hi, b.hi);
+  let crossAndLo = p.lo + (a.hi * b.lo + a.lo * b.hi);
+  return DD(p.hi, crossAndLo);
+}
+
+fn ddMulProtected(a: DD, b: DD, threadSlot: u32) -> DD {
+  let raw = ddMulRaw(a, b);
+  return fastTwoSumProtected(raw.hi, raw.lo, threadSlot);
+}

package/src/shaders/idamax.wgsl

@@ -0,0 +1,96 @@
+// idamax: returns index of element with largest absolute value (f64, double-double)
+// pass 1 dispatches exactly 2 * WGS workgroups; pass 2 uses reduction/argmaxF64.wgsl.
+// Concatenated after f64/dekker.wgsl (DD struct), f64/utils/abs.wgsl (ddAbs),
+// f64/utils/greater.wgsl (ddGreater), and f64/utils/equal.wgsl (ddEqual).
+
+@group(0) @binding(0) var<storage, read>       xHi:            array<f32>;
+@group(0) @binding(1) var<storage, read>       xLo:            array<f32>;
+@group(0) @binding(2) var<storage, read_write> partialsValHi:  array<f32>;
+@group(0) @binding(3) var<storage, read_write> partialsValLo:  array<f32>;
+@group(0) @binding(4) var<storage, read_write> partialsIdx:    array<u32>;
+@group(0) @binding(5) var<uniform>             params:         Params;
+
+struct Params {
+  n:     u32,
+  x_inc: u32,
+}
+
+const WGS: u32 = 64;
+
+var<workgroup> tile_val: array<DD, 64>;
+var<workgroup> tile_idx: array<u32, 64>;
+
+@compute @workgroup_size(64)
+fn idamax_main(
+  @builtin(global_invocation_id) gid:    vec3u,
+  @builtin(local_invocation_id)  lid:    vec3u,
+  @builtin(workgroup_id)         wgid:   vec3u,
+  @builtin(num_workgroups)       num_wg: vec3u,
+) {
+  // DD(-1.0, 0.0) is a safe sentinel: any |x[i]| >= 0 beats it,
+  // so workgroups with no elements lose gracefully in the epilogue.
+  var best_val0 = DD(-1.0, 0.0); var best_idx0: u32 = 0u;
+  var best_val1 = DD(-1.0, 0.0); var best_idx1: u32 = 0u;
+  var best_val2 = DD(-1.0, 0.0); var best_idx2: u32 = 0u;
+  var best_val3 = DD(-1.0, 0.0); var best_idx3: u32 = 0u;
+
+  let stride   = num_wg.x * WGS;
+  let n4_floor = (params.n / (4u * stride)) * (4u * stride);
+
+  for (var id = gid.x; id < n4_floor; id += 4u * stride) {
+    let i0 =  id                * params.x_inc;
+    let i1 = (id +      stride) * params.x_inc;
+    let i2 = (id + 2u * stride) * params.x_inc;
+    let i3 = (id + 3u * stride) * params.x_inc;
+    let v0 = ddAbs(DD(xHi[i0], xLo[i0]));
+    let v1 = ddAbs(DD(xHi[i1], xLo[i1]));
+    let v2 = ddAbs(DD(xHi[i2], xLo[i2]));
+    let v3 = ddAbs(DD(xHi[i3], xLo[i3]));
+    if (ddGreater(v0, best_val0)) { best_val0 = v0; best_idx0 = id; }
+    if (ddGreater(v1, best_val1)) { best_val1 = v1; best_idx1 = id +      stride; }
+    if (ddGreater(v2, best_val2)) { best_val2 = v2; best_idx2 = id + 2u * stride; }
+    if (ddGreater(v3, best_val3)) { best_val3 = v3; best_idx3 = id + 3u * stride; }
+  }
+  for (var id = n4_floor + gid.x; id < params.n; id += stride) {
+    let i = id * params.x_inc;
+    let v = ddAbs(DD(xHi[i], xLo[i]));
+    if (ddGreater(v, best_val0)) { best_val0 = v; best_idx0 = id; }
+  }
+
+  // merge 4 independent lanes; prefer lower index on tie (first occurrence wins)
+  if (ddGreater(best_val1, best_val0) ||
+      (ddEqual(best_val1, best_val0) && best_idx1 < best_idx0)) {
+    best_val0 = best_val1; best_idx0 = best_idx1;
+  }
+  if (ddGreater(best_val2, best_val0) ||
+      (ddEqual(best_val2, best_val0) && best_idx2 < best_idx0)) {
+    best_val0 = best_val2; best_idx0 = best_idx2;
+  }
+  if (ddGreater(best_val3, best_val0) ||
+      (ddEqual(best_val3, best_val0) && best_idx3 < best_idx0)) {
+    best_val0 = best_val3; best_idx0 = best_idx3;
+  }
+
+  tile_val[lid.x] = best_val0;
+  tile_idx[lid.x] = best_idx0;
+  workgroupBarrier();
+
+  for (var s = WGS / 2u; s > 0u; s >>= 1u) {
+    if (lid.x < s) {
+      let a_val = tile_val[lid.x];
+      let b_val = tile_val[lid.x + s];
+      if (ddGreater(b_val, a_val) ||
+          (ddEqual(b_val, a_val) && tile_idx[lid.x + s] < tile_idx[lid.x])) {
+        tile_val[lid.x] = b_val;
+        tile_idx[lid.x] = tile_idx[lid.x + s];
+      }
+    }
+    workgroupBarrier();
+  }
+
+  if (lid.x == 0u) {
+    partialsValHi[wgid.x] = tile_val[0].hi;
+    partialsValLo[wgid.x] = tile_val[0].lo;
+    partialsIdx[wgid.x]   = tile_idx[0];
+  }
+}

package/src/shaders/index.mjs

@@ -3,25 +3,175 @@
  *
  * `shaders/*.wgsl` — one WGSL compute shader per BLAS routine (sscal, saxpy, sdot, …).
  *
- * `shaders/browser-shaders.mjs` — the browser's runtime shader source. In Node.js, shaders are
- * read directly from disk via `readFileSync`. In the browser there is no filesystem, so this file
- * provides all shader strings inline. Vite bundles it by importing each `.wgsl` file as a string.
+ * `routineShaders` below is the single source of truth: routine name → the WGSL source(s)
+ * its `getPipeline()` calls actually reference, verified against every `src/<routine>/<routine>.mjs`
+ * rather than inferred from naming convention (see its doc comment for the exceptions). Each
+ * shader is imported right above the line that adds it — the import *is* the mapping entry, no
+ * separate block to cross-reference. `shaderSources`, the flat name → source registry the
+ * browser bundle's runtime lookup needs, is *derived* from `routineShaders` rather than
+ * hand-duplicated, so the two can never drift apart. In Node.js neither is read — shaders are
+ * `readFileSync` from disk directly; `scripts/build-browser.mjs` inlines this module into the
+ * browser's IIFE bundle via esbuild instead.
  *
  * ## Cross-shader patterns
  *
- * **Fixed workgroup size of 64.** Every shader declares `const WGS: u32 = 64` and
- * `@workgroup_size(64)`. 64 is the minimum `maxComputeInvocationsPerWorkgroup` guaranteed across
- * all WebGPU devices, so this works everywhere without querying device limits.
+ * **Single bind group.** Every shader with bindings uses `@group(0)` only — the JS side always
+ * calls `pipeline.getBindGroupLayout(0)`, no secondary groups to track. Binding order is
+ * consistent too: any read-only storage buffers come before read_write ones, with the
+ * `uniform Params` struct always last. `@binding` indices match the position of each resource in
+ * the array passed to `createBindGroup`, which appends `resultBuffer` last.
  *
- * **Single bind group.** All bindings use `@group(0)`. This means the JS side always calls
- * `pipeline.getBindGroupLayout(0)` — no secondary groups to track.
+ * **All counts and strides are `u32`.** `n`, `x_inc`, `y_inc`, and every other index/count field
+ * in a `Params` struct is unsigned, avoiding implicit sign-extension in index expressions like
+ * `id * params.x_inc`.
  *
- * The `@binding` indices must match the position of each resource in the array passed to
- * `createBindGroup` — it assigns `binding: 0, 1, 2 …` sequentially, with `resultBuffer` appended last.
- *
- * **All counts and strides are `u32`.** `n`, `x_inc`, `y_inc`, and any other index fields in the
- * `Params` uniform struct are unsigned. This avoids implicit sign-extension when they appear in
- * index expressions like `id * params.x_inc`.
+ * **Entry points don't have to be named `main`.** `loadShader` (`util/pipeline.mjs`)
+ * auto-detects the sole `@compute` function in a module instead of requiring a fixed name, so
+ * `dasum_main`, `strsv_invert_block_main`, etc. work without renaming.
  *
  * @module devdocs/shaders
  */
+
+/**
+ * Routine name → the WGSL source(s) its `getPipeline()` calls reference. Keys are the exact
+ * shader names `getPipeline(device, name)` is called with — most routines have one, some pick
+ * one of several conditionally (e.g. sgemv's `sgemv_n`/`sgemv_t`, by `trans`), and some have no
+ * dedicated shader at all:
+ *
+ * - `sgemmtr`/`ssyrk`/`ssyr2k` all dispatch through `sgemmtr_small`/`sgemmtr_large`.
+ * - `strsm` reuses `strsv_invert_block` and `sscal`, plus its own `block_transfer` and the
+ *   shared `sgemm_small`/`sgemm_large`.
+ * - `dasum`/`idamax` concatenate several f64 utility shaders with their own — see
+ *   `getPipeline`'s `shaderName: string[]` behaviour.
+ * - `random` has no entry — CPU-only, no `getPipeline()` call.
+ *
+ * Built up entry by entry so each import sits next to the mapping entry that uses it.
+ * @public
+ */
+export const routineShaders = {};
+
+import sscal from "./sscal.wgsl";
+routineShaders.sscal = { sscal };
+
+import sswap from "./sswap.wgsl";
+routineShaders.sswap = { sswap };
+
+import saxpy from "./saxpy.wgsl";
+routineShaders.saxpy = { saxpy };
+
+import scopy from "./scopy.wgsl";
+routineShaders.scopy = { scopy };
+
+import sdot from "./sdot.wgsl";
+import sum from "./reduction/sum.wgsl";
+routineShaders.sdot = { sdot, "reduction/sum": sum };
+
+import sasum from "./sasum.wgsl";
+routineShaders.sasum = { sasum, "reduction/sum": sum };
+
+import snrm2 from "./snrm2.wgsl";
+import scaledSum from "./reduction/scaledSum.wgsl";
+routineShaders.snrm2 = { snrm2, "reduction/scaledSum": scaledSum };
+
+import isamax from "./isamax.wgsl";
+import argmax from "./reduction/argmax.wgsl";
+routineShaders.isamax = { isamax, "reduction/argmax": argmax };
+
+import dekker from "./f64/dekker.wgsl";
+import ddAbs from "./f64/utils/abs.wgsl";
+import ddAddUtil from "./f64/utils/add.wgsl";
+import dasum from "./dasum.wgsl";
+import sumF64 from "./reduction/sumF64.wgsl";
+routineShaders.dasum = {
+  "f64/dekker": dekker,
+  "f64/utils/abs": ddAbs,
+  "f64/utils/add": ddAddUtil,
+  dasum,
+  "reduction/sumF64": sumF64,
+};
+
+import ddGreater from "./f64/utils/greater.wgsl";
+import ddEqual from "./f64/utils/equal.wgsl";
+import idamax from "./idamax.wgsl";
+import argmaxF64 from "./reduction/argmaxF64.wgsl";
+routineShaders.idamax = {
+  "f64/dekker": dekker,
+  "f64/utils/abs": ddAbs,
+  "f64/utils/greater": ddGreater,
+  "f64/utils/equal": ddEqual,
+  idamax,
+  "reduction/argmaxF64": argmaxF64,
+};
+
+import srot from "./srot.wgsl";
+routineShaders.srot = { srot };
+
+import srotm from "./srotm.wgsl";
+routineShaders.srotm = { srotm };
+
+import sgemv_n from "./sgemv_n.wgsl";
+import sgemv_t from "./sgemv_t.wgsl";
+routineShaders.sgemv = { sgemv_n, sgemv_t }; // one or the other, picked by trans
+
+import ssymv from "./ssymv.wgsl";
+routineShaders.ssymv = { ssymv };
+
+import strmv from "./strmv.wgsl";
+routineShaders.strmv = { strmv };
+
+import strsv_invert_block from "./strsv_invert_block.wgsl";
+import strsv_apply_inverse from "./strsv_apply_inverse.wgsl";
+import strsv_update from "./strsv_update.wgsl";
+routineShaders.strsv = {
+  strsv_invert_block,
+  strsv_apply_inverse,
+  strsv_update,
+};
+
+import sger from "./sger.wgsl";
+routineShaders.sger = { sger };
+
+import ssyr from "./ssyr.wgsl";
+routineShaders.ssyr = { ssyr };
+
+import ssyr2 from "./ssyr2.wgsl";
+routineShaders.ssyr2 = { ssyr2 };
+
+import sgemm_small from "./sgemm_small.wgsl";
+import sgemm_large from "./sgemm_large.wgsl";
+routineShaders.sgemm = { sgemm_small, sgemm_large }; // one or the other, picked by a tile-size threshold
+
+import sgemmtr_small from "./sgemmtr_small.wgsl";
+import sgemmtr_large from "./sgemmtr_large.wgsl";
+routineShaders.sgemmtr = { sgemmtr_small, sgemmtr_large };
+
+routineShaders.ssyrk = { sgemmtr_small, sgemmtr_large }; // no shader of its own — rides on sgemmtr's
+routineShaders.ssyr2k = { sgemmtr_small, sgemmtr_large }; // no shader of its own — rides on sgemmtr's
+
+import symmetrize from "./symmetrize.wgsl";
+routineShaders.ssymm = { sgemm_small, sgemm_large, symmetrize };
+
+import triangularize from "./triangularize.wgsl";
+routineShaders.strmm = { sgemm_small, sgemm_large, triangularize };
+
+import blockTransfer from "./block_transfer.wgsl";
+routineShaders.strsm = {
+  strsv_invert_block,
+  block_transfer: blockTransfer,
+  sscal,
+  sgemm_small,
+  sgemm_large,
+};
+
+/**
+ * Flat shader-name → WGSL source-string registry — what `getPipeline()`/`loadShader()` (see
+ * `util/pipeline.mjs`) actually look shaders up in, in the browser. Derived from
+ * `routineShaders` by merging every routine's shaders together; shared shaders (e.g.
+ * `"reduction/sum"`, used by two different routines above) collapse harmlessly here since
+ * every routine's copy is the same imported string, never independently authored text.
+ * @public
+ */
+export const shaderSources = Object.assign(
+  {},
+  ...Object.values(routineShaders),
+);

package/src/shaders/reduction/argmaxF64.wgsl

@@ -0,0 +1,50 @@
+// amax reduction (f64, double-double): collapses 2*WGS (value, index) pairs
+// into one index, using ddGreater/ddEqual instead of plain f32 `>`/`==` (see
+// reduction/argmax.wgsl for the f32 original this mirrors).
+// dispatch: 1 workgroup of WGS threads. partialsValHi/partialsValLo/
+// partialsIdx must have exactly 2*WGS entries each. Concatenated after
+// f64/dekker.wgsl (DD struct), f64/utils/greater.wgsl (ddGreater), and
+// f64/utils/equal.wgsl (ddEqual).
+
+@group(0) @binding(0) var<storage, read>       partialsValHi: array<f32>;
+@group(0) @binding(1) var<storage, read>       partialsValLo: array<f32>;
+@group(0) @binding(2) var<storage, read>       partialsIdx:   array<u32>;
+@group(0) @binding(3) var<storage, read_write> result:        array<u32>;
+
+const WGS: u32 = 64;
+
+var<workgroup> tile_val: array<DD, 64>;
+var<workgroup> tile_idx: array<u32, 64>;
+
+@compute @workgroup_size(64)
+fn reduce_f64(
+  @builtin(local_invocation_id) lid: vec3u,
+) {
+  let i = lid.x;
+  let a_val = DD(partialsValHi[i], partialsValLo[i]);
+  let b_val = DD(partialsValHi[i + WGS], partialsValLo[i + WGS]);
+  if (ddGreater(b_val, a_val) ||
+      (ddEqual(b_val, a_val) && partialsIdx[i + WGS] < partialsIdx[i])) {
+    tile_val[i] = b_val;
+    tile_idx[i] = partialsIdx[i + WGS];
+  } else {
+    tile_val[i] = a_val;
+    tile_idx[i] = partialsIdx[i];
+  }
+  workgroupBarrier();
+
+  for (var s = WGS / 2u; s > 0u; s >>= 1u) {
+    if (i < s) {
+      let c_val = tile_val[i];
+      let d_val = tile_val[i + s];
+      if (ddGreater(d_val, c_val) ||
+          (ddEqual(d_val, c_val) && tile_idx[i + s] < tile_idx[i])) {
+        tile_val[i] = d_val;
+        tile_idx[i] = tile_idx[i + s];
+      }
+    }
+    workgroupBarrier();
+  }
+
+  if (i == 0u) { result[0] = tile_idx[0]; }
+}

package/src/shaders/reduction/scaledSum.wgsl

@@ -0,0 +1,65 @@
+// scaledSum reduction: collapses 2*WGS (scale, ssq) partials from
+// snrm2.wgsl into the final norm — sqrt(scale² · ssq) == scale · sqrt(ssq).
+// Mirrors reduction/sum.wgsl's shape exactly, merging via ssqMerge (see
+// snrm2.wgsl for the derivation) instead of plain `+`, and taking the final
+// sqrt here rather than on the CPU — unlike sasum/sdot's plain sum, "sum of
+// squares" isn't a meaningful standalone value to hand back, only
+// scale·sqrt(ssq) is.
+// dispatch: 1 workgroup of WGS threads.
+// partialsScale/partialsSsq must have exactly 2*WGS entries each.
+
+@group(0) @binding(0) var<storage, read>       partialsScale: array<f32>;
+@group(0) @binding(1) var<storage, read>       partialsSsq:   array<f32>;
+@group(0) @binding(2) var<storage, read_write> result:        array<f32>;
+
+const WGS: u32 = 64;
+
+// True sum-of-squares represented so far == scale² · ssq — see snrm2.wgsl.
+struct ScaleSsq {
+  scale: f32,
+  ssq:   f32,
+}
+
+// Associative merge of two independent (scale, ssq) partials.
+fn ssqMerge(a: ScaleSsq, b: ScaleSsq) -> ScaleSsq {
+  if (a.scale == 0.0 && b.scale == 0.0) { return ScaleSsq(0.0, 1.0); }
+  if (a.scale >= b.scale) {
+    let r = b.scale / a.scale;
+    return ScaleSsq(a.scale, a.ssq + b.ssq * r * r);
+  }
+  let r = a.scale / b.scale;
+  return ScaleSsq(b.scale, b.ssq + a.ssq * r * r);
+}
+
+var<workgroup> tileScale: array<f32, 64>;
+var<workgroup> tileSsq:   array<f32, 64>;
+
+@compute @workgroup_size(64)
+fn reduce_scaled(
+  @builtin(local_invocation_id) lid: vec3u,
+) {
+  let i = lid.x;
+  let merged0 = ssqMerge(
+    ScaleSsq(partialsScale[i], partialsSsq[i]),
+    ScaleSsq(partialsScale[i + WGS], partialsSsq[i + WGS]),
+  );
+  tileScale[i] = merged0.scale;
+  tileSsq[i]   = merged0.ssq;
+  workgroupBarrier();
+
+  for (var s = WGS / 2u; s > 0u; s >>= 1u) {
+    if (i < s) {
+      let merged = ssqMerge(
+        ScaleSsq(tileScale[i], tileSsq[i]),
+        ScaleSsq(tileScale[i + s], tileSsq[i + s]),
+      );
+      tileScale[i] = merged.scale;
+      tileSsq[i]   = merged.ssq;
+    }
+    workgroupBarrier();
+  }
+
+  if (i == 0u) {
+    result[0] = tileScale[0] * sqrt(tileSsq[0]);
+  }
+}

package/src/shaders/reduction/sumF64.wgsl

@@ -2,8 +2,8 @@
 // into one, using ddAddProtected instead of plain f32 `+` (see
 // reduction/sum.wgsl for the f32 original this mirrors).
 // dispatch: 1 workgroup of WGS threads. partialsHi/partialsLo must have
-// exactly 2*WGS entries each. Concatenated after f64/dekker.wgsl for
-// DD/ddAddProtected (see it for why plain ddAdd isn't safe).
+// exactly 2*WGS entries each. Concatenated after f64/dekker.wgsl (DD struct)
+// and f64/utils/add.wgsl (ddAddProtected — see it for why plain ddAdd isn't safe).
 
 @group(0) @binding(0) var<storage, read>       partialsHi: array<f32>;
 @group(0) @binding(1) var<storage, read>       partialsLo: array<f32>;