@graphty/webgpu-graph-algorithms 0.6.15 → 0.6.16

package/dist/webgpu-graph-algorithms.js

@@ -1,5 +1,5 @@
-import { W as WebGpuGraphError, U as UNIFORM_SLOT_BYTES, B as BufferUsage, M as MAX_WORKGROUPS_PER_DIM, a as WGSL_RESERVED_WORDS, S as STATE_HEADER_BYTES, d as deviceLostError, i as isWebGpuGraphError, b as U32_MAX$2, c as MAX_LEVELS_PER_SUBMIT, R as RADIX_BINS, F as FUSED_FRONTIER_MAX, e as BEAMER_BETA, f as SSSP_DELTA_FACTOR, g as F32_INF_BITS, h as BC_EDGE_PARALLEL_GAMMA, j as BC_BATCH_BUDGET_FRACTION, k as BC_MAX_BATCH, l as BC_BACKWARD_LEVELS_PER_SUBMIT, m as GRID_COARSEST_SIDE, n as GRID_MIN_SIDE, o as GRID_SORT_BITS, p as FA2_DEFAULTS, q as MAX_ITERATIONS_PER_STEP, r as MAX_1D_ITEMS, s as hasErrorCode, t as FA2_FLAG_FIRST, P as PARTIAL_BYTES, E as EXACT_TILES_PER_PASS, I as INDIRECT_ARGS_STRIDE, u as GRID_HUB_CELL, L as LAYOUT_TUNING_DEFAULTS, v as EXACT_MAX_NODES, w as SETTLE_FLOOR_UNBOUNDED, T as TRACE_RECORD_BYTES, x as GRID_BBOX_MARGIN, y as GRID_EXTENT_FLOOR, z as FR_ADAPTIVE_MAX_ITERATIONS, A as FR_START_TEMPERATURE, C as FA2_FLAG_ADAPTIVE, D as SETTLE_FLOOR_FRACTION, H as FR_REHEAT_FRACTION, J as FR_DEFAULTS, K as SE_DEFAULTS, N as SETTLE_FLOOR_REFERENCE_NODES, O as SE_SCALE_REFERENCE_NODES } from "./chunks/context-oXphO3yj.js";
-import { Q, G, V, X, Y, Z } from "./chunks/context-oXphO3yj.js";
+import { W as WebGpuGraphError, U as UNIFORM_SLOT_BYTES, B as BufferUsage, M as MAX_WORKGROUPS_PER_DIM, a as WGSL_RESERVED_WORDS, S as STATE_HEADER_BYTES, d as deviceLostError, i as isWebGpuGraphError, b as U32_MAX$2, c as MAX_LEVELS_PER_SUBMIT, R as RADIX_BINS, F as FUSED_FRONTIER_MAX, e as BEAMER_BETA, f as SSSP_DELTA_FACTOR, g as F32_INF_BITS, h as BC_EDGE_PARALLEL_GAMMA, j as BC_BATCH_BUDGET_FRACTION, k as BC_MAX_BATCH, l as BC_BACKWARD_LEVELS_PER_SUBMIT, A as APSP_MAX_DISPATCHES_PER_SUBMIT, m as APSP_TILE, n as GROUP_ROW_THREAD_MAX, o as GROUP_ROW_THREAD_LIMIT, p as GROUP_HASH_LOAD_FACTOR, P as PARALLEL_MERGE_LIMIT, L as LABEL_PROP_PASSES_PER_SUBMIT, q as GRID_COARSEST_SIDE, r as GRID_MIN_SIDE, s as GRID_SORT_BITS, t as FA2_DEFAULTS, u as MAX_ITERATIONS_PER_STEP, v as MAX_1D_ITEMS, w as hasErrorCode, x as FA2_FLAG_FIRST, y as PARTIAL_BYTES, E as EXACT_TILES_PER_PASS, I as INDIRECT_ARGS_STRIDE, z as GRID_HUB_CELL, C as LAYOUT_TUNING_DEFAULTS, D as EXACT_MAX_NODES, H as SETTLE_FLOOR_UNBOUNDED, T as TRACE_RECORD_BYTES, J as GRID_BBOX_MARGIN, K as GRID_EXTENT_FLOOR, N as FR_ADAPTIVE_MAX_ITERATIONS, O as FR_START_TEMPERATURE, Q as FA2_FLAG_ADAPTIVE, V as SETTLE_FLOOR_FRACTION, X as FR_REHEAT_FRACTION, Y as FR_DEFAULTS, Z as SE_DEFAULTS, _ as SETTLE_FLOOR_REFERENCE_NODES, $ as SE_SCALE_REFERENCE_NODES } from "./chunks/context-VIvatQOo.js";
+import { a0, G, a1, a2, a3, a4 } from "./chunks/context-VIvatQOo.js";
 import { renumberPartition, INVALID_INDEX, foldArcs, makeMask, maskTest, expandEdges, fromEdgeArrays } from "@graphty/graph-format";
 class UniformRing {
   /**
@@ -211,6 +211,10 @@ function plan1d(items, wg, caps) {
   assertWorkgroupSize(wg);
   return grid(Math.ceil(items / wg), items, caps);
 }
+function plan2d(groups, caps) {
+  assertCount$1("groups", groups);
+  return grid(groups, groups, caps);
+}
 function planGridStride(items, wg, caps, maxGroups) {
   assertCount$1("items", items);
   assertWorkgroupSize(wg);
@@ -605,6 +609,116 @@ fn advance_expand(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocati
 }
 `
 );
+const apspFwWgsl = (
+  /* wgsl */
+  `
+var<workgroup> tileA: array<f32, APSP_TILE * APSP_TILE>;
+var<workgroup> tileB: array<f32, APSP_TILE * APSP_TILE>;
+
+fn tile_row(block: vec2<u32>, c: u32) -> u32 { return block.x * APSP_TILE + c / APSP_TILE; }
+fn tile_col(block: vec2<u32>, c: u32) -> u32 { return block.y * APSP_TILE + c % APSP_TILE; }
+
+fn load_cell(block: vec2<u32>, c: u32) -> f32 {
+    let i = tile_row(block, c);
+    let j = tile_col(block, c);
+    if (i < P.n && j < P.n) { return dist[i * P.n + j]; }
+    return bitcast<f32>(P.infBits);                                   // outside the matrix: no path through it
+}
+
+fn store_cell(block: vec2<u32>, c: u32, v: f32) {
+    let i = tile_row(block, c);
+    let j = tile_col(block, c);
+    if (i >= P.n || j >= P.n) { return; }                            // an edge tile stores nothing outside n x n
+    dist[i * P.n + j] = v;
+}
+
+@compute @workgroup_size(WG)
+fn apsp_fw(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let g = group_id(wid);
+    let r = P.round;
+    let others = max(P.blocks, 2u) - 1u;                             // the blocks of a strip, the pivot excluded
+    let cells = APSP_TILE * APSP_TILE;
+    var count = 1u;
+    var own = vec2<u32>(r, r);                                        // the block this workgroup updates
+    var a = vec2<u32>(r, r);                                          // staged in tileA
+    var b = vec2<u32>(r, r);                                          // staged in tileB
+    if (PHASE == 1u) {
+        count = 2u * others;
+        let s = g % others;
+        let o = select(s, s + 1u, s >= r);                            // a strip skips the pivot block
+        own = select(vec2<u32>(o, r), vec2<u32>(r, o), g < others);   // block row r first, then block column r
+        b = own;
+    }
+    if (PHASE == 2u) {
+        count = others * others;
+        let i = g / others;
+        let j = g % others;
+        own = vec2<u32>(select(i, i + 1u, i >= r), select(j, j + 1u, j >= r));
+        a = vec2<u32>(own.x, r);                                      // the pivot-column block (i, r)
+        b = vec2<u32>(r, own.y);                                      // the pivot-row block (r, j)
+    }
+    if (g >= count) { return; }                                       // uniform: the workgroup id and uniforms only
+
+    for (var c = lid.x; c < cells; c = c + WG) {
+        tileA[c] = load_cell(a, c);
+        if (PHASE != 0u) { tileB[c] = load_cell(b, c); }
+    }
+    workgroupBarrier();                                               // every staged cell is visible
+
+    if (PHASE == 2u) {
+        for (var c = lid.x; c < cells; c = c + WG) {
+            let x = c / APSP_TILE;
+            let y = c % APSP_TILE;
+            var v = load_cell(own, c);
+            for (var kr = 0u; kr < APSP_TILE; kr = kr + 1u) {
+                v = min(v, tileA[x * APSP_TILE + kr] + tileB[kr * APSP_TILE + y]);
+            }
+            store_cell(own, c, v);
+        }
+        return;
+    }
+
+    let pivotRow = PHASE == 1u && own.x == r;                          // block row r reads d[x][k] from the pivot
+    for (var k = 0u; k < APSP_TILE; k = k + 1u) {
+        for (var c = lid.x; c < cells; c = c + WG) {
+            let x = c / APSP_TILE;
+            let y = c % APSP_TILE;
+            if (PHASE == 0u) {
+                let via = tileA[x * APSP_TILE + k] + tileA[k * APSP_TILE + y];
+                if (via < tileA[c]) { tileA[c] = via; }
+            } else {
+                let left = select(tileB[x * APSP_TILE + k], tileA[x * APSP_TILE + k], pivotRow);
+                let right = select(tileA[k * APSP_TILE + y], tileB[k * APSP_TILE + y], pivotRow);
+                let via = left + right;
+                if (via < tileB[c]) { tileB[c] = via; }
+            }
+        }
+        workgroupBarrier();                                           // step k is complete before step k + 1 reads
+    }
+    for (var c = lid.x; c < cells; c = c + WG) {
+        store_cell(own, c, select(tileB[c], tileA[c], PHASE == 0u));
+    }
+}
+`
+);
+const apspInitWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn apsp_init(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let u = linear_id(wid, lid.x);
+    if (u >= P.n) { return; }
+    let rowBase = u * P.n;
+    let end = rowPtr[u + 1u];
+    for (var a = rowPtr[u]; a < end; a = a + 1u) {
+        let v = colIdx[a];
+        let w = select(1.0, weights[a], HAS_WEIGHTS);
+        dist[rowBase + v] = min(dist[rowBase + v], w);               // parallel arcs collapse to the cheapest
+    }
+    dist[rowBase + u] = 0.0;                                          // last: a self-loop never displaces the zero
+}
+`
+);
 const bcBackwardWgsl = (
   /* wgsl */
   `
@@ -1249,6 +1363,54 @@ fn compact_scatter(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocat
 }
 `
 );
+const cooEmitWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn coo_emit(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let i = linear_id(wid, lid.x);
+    if (i >= P.count) { return; }                                  // no barrier follows
+    var a = i;
+    if (INDEXED) { a = order[i]; }                                 // the arc this position takes
+    let e = a / 2u;                                                // arc 2e is edge e as declared, arc 2e + 1 its reverse
+    let forward = (a % 2u) == 0u;
+    let u = edgeSrc[e];
+    let v = edgeDst[e];
+    var w = 1.0;
+    if (WEIGHTED) { w = edgeWeight[e]; }
+    if (u == v) {                                                  // a self-loop is dropped: both arcs sort last and never open a run
+        outSrc[i] = INVALID_INDEX;
+        outDst[i] = INVALID_INDEX;
+        outWeight[i] = 0.0;
+        return;
+    }
+    outSrc[i] = select(v, u, forward);
+    outDst[i] = select(u, v, forward);
+    outWeight[i] = w;
+}
+`
+);
+const cooScatterWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn coo_scatter(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let i = linear_id(wid, lid.x);
+    if (i >= P.count) { return; }                                  // no barrier follows
+    let s = src[i];
+    var slot = 0u;
+    if (SORTED_INPUT) {
+        if (i > 0u && s < src[i - 1u]) { atomicStore(&cursors[0], 1u); }   // unsorted input: the flag the driver refuses
+        let within = i - rowPtr[s];                                // the arc's place in its row
+        slot = rowPtr[s] + within;
+    } else {
+        slot = rowPtr[s] + atomicAdd(&cursors[s], 1u);             // race order: the row is not sorted in this mode
+    }
+    colIdx[slot] = dst[i];
+    if (WEIGHTED) { outWeight[slot] = weight[i]; }
+}
+`
+);
 const countingScatterWgsl = (
   /* wgsl */
   `
@@ -2188,6 +2350,130 @@ fn grid_near_field(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocat
 }
 `
 );
+const groupByKeyRowWgsl = (
+  /* wgsl */
+  `
+var<workgroup> shMax: array<f32, WG>;
+var<workgroup> shKey: array<u32, WG>;
+var<workgroup> shSum: array<u32, WG>;
+
+fn weight_of(a: u32) -> f32 {
+    if (WEIGHTED) { return weights[a]; }
+    return 1.0;
+}
+fn scale_of(maxW: f32, d: u32) -> f32 {                            // 2^s, maxW x d x 2^s in [2^28, 2^30), from exponents alone
+    let em = i32((bitcast<u32>(maxW) >> 23u) & 255u) - 127;
+    let ed = i32(firstLeadingBit(max(d, 1u)));
+    let s = clamp(28 - em - ed, -126, 126);
+    return bitcast<f32>(u32(s + 127) << 23u);
+}
+fn inverse_of(scale: f32) -> f32 {                                 // 2^-s, exact
+    let s = i32((bitcast<u32>(scale) >> 23u) & 255u) - 127;
+    return bitcast<f32>(u32(127 - s) << 23u);
+}
+fn quantize(w: f32, scale: f32) -> u32 {                           // nearest integer, halves up; every step exact
+    let x = max(w * scale, 0.0);
+    let i = u32(x);
+    return select(i, i + 1u, x - f32(i) >= 0.5);
+}
+fn better(sum: u32, key: u32, bestSum: u32, bestKey0: u32) -> bool { return sum > bestSum || (sum == bestSum && key < bestKey0); }
+
+fn row_thread(v: u32) {
+    let lo = rowPtr[v];
+    let hi = rowPtr[v + 1u];
+    var maxW = 0.0;
+    for (var a = lo; a < hi; a = a + 1u) { maxW = max(maxW, weight_of(a)); }
+    let scale = scale_of(maxW, hi - lo);
+    var bk = INVALID_INDEX;
+    var bs = 0u;
+    for (var a = lo; a < hi; a = a + 1u) {
+        let k = keyIn[colIdx[a]];
+        var seen = false;
+        for (var b = lo; b < a; b = b + 1u) { if (keyIn[colIdx[b]] == k) { seen = true; break; } }
+        if (seen) { continue; }                                    // this key was summed at its first arc
+        var sum = 0u;
+        for (var b = a; b < hi; b = b + 1u) { if (keyIn[colIdx[b]] == k) { sum = sum + quantize(weight_of(b), scale); } }
+        if (better(sum, k, bs, bk)) { bk = k; bs = sum; }
+    }
+    bestKey[v] = bk;
+    bestScore[v] = f32(bs) * inverse_of(scale);
+}
+
+fn row_hash(g: u32, lid: u32) {
+    let v = rows[P.rowsBase + g];
+    let base = rows[P.basesBase + g];
+    let lo = rowPtr[v];
+    let hi = rowPtr[v + 1u];
+    let cap = GROUP_HASH_LOAD_FACTOR * (hi - lo);
+    var m = 0.0;
+    for (var a = lo + lid; a < hi; a = a + WG) { m = max(m, weight_of(a)); }
+    shMax[lid] = m;
+    workgroupBarrier();
+    for (var s = WG / 2u; s > 0u; s = s / 2u) {
+        if (lid < s) { shMax[lid] = max(shMax[lid], shMax[lid + s]); }
+        workgroupBarrier();
+    }
+    let scale = scale_of(shMax[0], hi - lo);
+    for (var j = lid; j < cap; j = j + WG) {                       // the region is this workgroup's alone: clear it
+        atomicStore(&hashRegion[base + 2u * j], INVALID_INDEX);
+        atomicStore(&hashRegion[base + 2u * j + 1u], 0u);
+    }
+    storageBarrier();
+    var exhausted = false;
+    for (var a = lo + lid; a < hi; a = a + WG) {
+        let k = keyIn[colIdx[a]];
+        let q = quantize(weight_of(a), scale);
+        var slot = lowbias32(k) % cap;
+        var steps = 0u;
+        loop {
+            if (steps >= cap + 64u) { exhausted = true; break; }   // bounded: a spurious compare-exchange failure is legal (WGSL 17.8.5)
+            steps = steps + 1u;
+            let r = atomicCompareExchangeWeak(&hashRegion[base + 2u * slot], INVALID_INDEX, k);
+            if (r.exchanged || r.old_value == k) { atomicAdd(&hashRegion[base + 2u * slot + 1u], q); break; }
+            if (r.old_value == INVALID_INDEX) { continue; }        // a spurious failure: the same slot again
+            slot = (slot + 1u) % cap;                              // linear probing
+        }
+    }
+    if (exhausted) { atomicStore(&hashRegion[0], 1u); }
+    storageBarrier();
+    var bk = INVALID_INDEX;
+    var bs = 0u;
+    for (var j = lid; j < cap; j = j + WG) {
+        let k = atomicLoad(&hashRegion[base + 2u * j]);
+        if (k != INVALID_INDEX) {
+            let sum = atomicLoad(&hashRegion[base + 2u * j + 1u]);
+            if (better(sum, k, bs, bk)) { bk = k; bs = sum; }
+        }
+    }
+    shKey[lid] = bk;
+    shSum[lid] = bs;
+    workgroupBarrier();
+    for (var s = WG / 2u; s > 0u; s = s / 2u) {
+        if (lid < s && better(shSum[lid + s], shKey[lid + s], shSum[lid], shKey[lid])) {
+            shKey[lid] = shKey[lid + s];
+            shSum[lid] = shSum[lid + s];
+        }
+        workgroupBarrier();
+    }
+    if (lid == 0u) {
+        bestKey[v] = shKey[0];
+        bestScore[v] = f32(shSum[0]) * inverse_of(scale);
+    }
+}
+
+@compute @workgroup_size(WG)
+fn group_by_key_row(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    if (TIER == 0u) {
+        let i = linear_id(wid, lid.x);
+        if (i < P.count) { row_thread(rows[P.rowsBase + i]); }
+        return;                                                    // TIER is an override: uniform
+    }
+    let g = group_id(wid);
+    if (g >= P.count) { return; }                                  // uniform: the workgroup id and a uniform
+    row_hash(g, lid.x);
+}
+`
+);
 const histogramWgsl = (
   /* wgsl */
   `
@@ -2222,6 +2508,51 @@ fn indirect_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
 }
 `
 );
+const lpaStepWgsl = (
+  /* wgsl */
+  `
+var<workgroup> moved: atomic<u32>;
+
+@compute @workgroup_size(WG)
+fn lpa_step(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    if (lid.x == 0u) { atomicStore(&moved, 0u); }
+    workgroupBarrier();
+    let v = linear_id(wid, lid.x);
+    if (v < P.n) {
+        let cur = labelsIn[v];
+        let best = bestKey[v];
+        var next = cur;
+        if (best != INVALID_INDEX && best != cur) {
+            let down = best < cur;
+            if (down == (P.direction == 0u)) { next = best; }        // the alternating direction rule
+        }
+        labelsOut[v] = next;
+        if (next != cur) { atomicAdd(&moved, 1u); }
+    }
+    workgroupBarrier();                                            // every lane, unconditionally
+    if (lid.x == 0u) {
+        let m = atomicLoad(&moved);
+        if (m > 0u) { atomicAdd(&counters[P.counterIndex], m); }  // one atomic per workgroup
+    }
+}
+`
+);
+const orientFlagsWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn orient_flags(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let a = linear_id(wid, lid.x);
+    if (a >= P.count) { return; }                                  // no barrier follows
+    let u = src[a];
+    let v = colIdx[a];
+    let du = rowPtr[u + 1u] - rowPtr[u];
+    let dv = rowPtr[v + 1u] - rowPtr[v];
+    let keep = dv > du || (dv == du && v > u);                     // (degree, id) of the target above the source's
+    flags[a] = select(0u, 1u, keep);
+}
+`
+);
 const prFinalizeWgsl = (
   /* wgsl */
   `
@@ -2407,6 +2738,20 @@ fn reduce(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) l
 }
 `
 );
+const runFlagsWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn run_flags(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let i = linear_id(wid, lid.x);
+    if (i >= P.count) { return; }                                  // no barrier follows
+    let a = keysA[i];
+    var first = a != INVALID_INDEX;                                // a dropped arc never opens a run
+    if (i > 0u) { first = first && (a != keysA[i - 1u] || keysB[i] != keysB[i - 1u]); }
+    flags[i] = select(0u, 1u, first);
+}
+`
+);
 const scanAddWgsl = (
   /* wgsl */
   `
@@ -2727,6 +3072,63 @@ fn sssp_relax(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_i
 }
 `
 );
+const triIntersectWgsl = (
+  /* wgsl */
+  `
+fn contains(lo0: u32, hi0: u32, x: u32) -> bool {                  // binary search of x in colIdx[lo0, hi0), sorted ascending
+    var lo = lo0;
+    var hi = hi0;
+    loop {
+        if (lo >= hi) { break; }
+        let mid = lo + (hi - lo) / 2u;
+        let y = colIdx[mid];
+        if (y == x) { return true; }
+        if (y < x) { lo = mid + 1u; } else { hi = mid; }
+    }
+    return false;
+}
+
+@compute @workgroup_size(WG)
+fn tri_intersect(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let a = linear_id(wid, lid.x);
+    if (a >= P.count) { return; }                                  // no barrier follows
+    let u = src[a];
+    let v = colIdx[a];
+    let uLo = rowPtr[u];
+    let uHi = rowPtr[u + 1u];
+    let vLo = rowPtr[v];
+    let vHi = rowPtr[v + 1u];
+    let du = uHi - uLo;
+    let dv = vHi - vLo;
+    var search = SEARCH == 2u;
+    if (SEARCH == 0u) { search = du / TRIANGLE_BINARY_SEARCH_RATIO > dv || dv / TRIANGLE_BINARY_SEARCH_RATIO > du; }
+    var found = 0u;
+    if (search) {
+        var sLo = uLo;
+        var sHi = uHi;
+        var lLo = vLo;
+        var lHi = vHi;
+        if (du > dv) { sLo = vLo; sHi = vHi; lLo = uLo; lHi = uHi; }
+        for (var k = sLo; k < sHi; k = k + 1u) {
+            let w = colIdx[k];
+            if (contains(lLo, lHi, w)) { atomicAdd(&counts[w], 1u); found = found + 1u; }
+        }
+    } else {
+        var i = uLo;
+        var j = vLo;
+        loop {
+            if (i >= uHi || j >= vHi) { break; }
+            let x = colIdx[i];
+            let y = colIdx[j];
+            if (x == y) { atomicAdd(&counts[x], 1u); found = found + 1u; i = i + 1u; j = j + 1u; }
+            else if (x < y) { i = i + 1u; }
+            else { j = j + 1u; }
+        }
+    }
+    if (found > 0u) { atomicAdd(&counts[u], found); atomicAdd(&counts[v], found); }
+}
+`
+);
 const wccCompressWgsl = (
   /* wgsl */
   `
@@ -3116,6 +3518,30 @@ const BF_FLAGS = UniformBlock.define(
   ],
   { layout: "storage" }
 );
+const APSP_PARAMS = UniformBlock.define("ApspParams", [
+  ["n", "u32"],
+  ["round", "u32"],
+  ["blocks", "u32"],
+  ["infBits", "u32"]
+]);
+const COO_PARAMS = UniformBlock.define("CooParams", [
+  ["count", "u32"],
+  ["pad0", "u32"],
+  ["pad1", "u32"],
+  ["pad2", "u32"]
+]);
+const GROUP_PARAMS = UniformBlock.define("GroupParams", [
+  ["rowsBase", "u32"],
+  ["basesBase", "u32"],
+  ["count", "u32"],
+  ["pad0", "u32"]
+]);
+const LPA_PARAMS = UniformBlock.define("LpaParams", [
+  ["n", "u32"],
+  ["direction", "u32"],
+  ["counterIndex", "u32"],
+  ["pad0", "u32"]
+]);
 function decl(group, binding, name, kind, wgslType) {
   return { group, binding, name, kind, wgslType };
 }
@@ -3996,6 +4422,165 @@ const BC_FORWARD_EDGE = {
   snippetSlots: [],
   phase: "P9"
 };
+const APSP_INIT = {
+  id: "apsp-init",
+  body: apspInitWgsl,
+  entryPoint: "apsp_init",
+  bindings: GRAPH_SLOTS.concat(decl(1, 0, "dist", "storage", "array<f32>"), decl(2, 0, "P", "uniform", "ApspParams")),
+  overrideDecls: [],
+  uniforms: [APSP_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P9"
+};
+const APSP_FW = {
+  id: "apsp-fw",
+  body: apspFwWgsl,
+  entryPoint: "apsp_fw",
+  bindings: [decl(1, 0, "dist", "storage", "array<f32>"), decl(2, 0, "P", "uniform", "ApspParams")],
+  overrideDecls: [{ name: "PHASE", type: "u32", default: 0 }],
+  uniforms: [APSP_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P9"
+};
+const COO_EMIT = {
+  id: "coo-emit",
+  body: cooEmitWgsl,
+  entryPoint: "coo_emit",
+  bindings: [
+    decl(1, 0, "edgeSrc", "storage-ro", "array<u32>"),
+    decl(1, 1, "edgeDst", "storage-ro", "array<u32>"),
+    decl(1, 2, "edgeWeight", "storage-ro", "array<f32>"),
+    decl(1, 3, "order", "storage-ro", "array<u32>"),
+    decl(1, 4, "outSrc", "storage", "array<u32>"),
+    decl(1, 5, "outDst", "storage", "array<u32>"),
+    decl(1, 6, "outWeight", "storage", "array<f32>"),
+    decl(2, 0, "P", "uniform", "CooParams")
+  ],
+  overrideDecls: [
+    { name: "INDEXED", type: "bool", default: false },
+    { name: "WEIGHTED", type: "bool", default: false }
+  ],
+  uniforms: [COO_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P11"
+};
+const RUN_FLAGS = {
+  id: "run-flags",
+  body: runFlagsWgsl,
+  entryPoint: "run_flags",
+  bindings: [
+    decl(1, 0, "keysA", "storage-ro", "array<u32>"),
+    decl(1, 1, "keysB", "storage-ro", "array<u32>"),
+    decl(1, 2, "flags", "storage", "array<u32>"),
+    decl(2, 0, "P", "uniform", "CooParams")
+  ],
+  overrideDecls: [],
+  uniforms: [COO_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P11"
+};
+const COO_SCATTER = {
+  id: "coo-scatter",
+  body: cooScatterWgsl,
+  entryPoint: "coo_scatter",
+  bindings: [
+    decl(1, 0, "src", "storage-ro", "array<u32>"),
+    decl(1, 1, "dst", "storage-ro", "array<u32>"),
+    decl(1, 2, "weight", "storage-ro", "array<f32>"),
+    decl(1, 3, "rowPtr", "storage-ro", "array<u32>"),
+    decl(1, 4, "cursors", "storage", "array<atomic<u32>>"),
+    decl(1, 5, "colIdx", "storage", "array<u32>"),
+    decl(1, 6, "outWeight", "storage", "array<f32>"),
+    decl(2, 0, "P", "uniform", "CooParams")
+  ],
+  overrideDecls: [
+    { name: "SORTED_INPUT", type: "bool", default: false },
+    { name: "WEIGHTED", type: "bool", default: false }
+  ],
+  uniforms: [COO_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P11"
+};
+const ORIENT_FLAGS = {
+  id: "orient-flags",
+  body: orientFlagsWgsl,
+  entryPoint: "orient_flags",
+  bindings: [
+    decl(1, 0, "rowPtr", "storage-ro", "array<u32>"),
+    decl(1, 1, "colIdx", "storage-ro", "array<u32>"),
+    decl(1, 2, "src", "storage-ro", "array<u32>"),
+    decl(1, 3, "flags", "storage", "array<u32>"),
+    decl(2, 0, "P", "uniform", "CooParams")
+  ],
+  overrideDecls: [],
+  uniforms: [COO_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P11"
+};
+const TRI_INTERSECT = {
+  id: "tri-intersect",
+  body: triIntersectWgsl,
+  entryPoint: "tri_intersect",
+  bindings: [
+    decl(1, 0, "rowPtr", "storage-ro", "array<u32>"),
+    decl(1, 1, "colIdx", "storage-ro", "array<u32>"),
+    decl(1, 2, "src", "storage-ro", "array<u32>"),
+    decl(1, 3, "counts", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "CooParams")
+  ],
+  overrideDecls: [{ name: "SEARCH", type: "u32", default: 0 }],
+  uniforms: [COO_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P11"
+};
+const GROUP_BY_KEY_ROW = {
+  id: "group-by-key-row",
+  body: groupByKeyRowWgsl,
+  entryPoint: "group_by_key_row",
+  bindings: [
+    decl(1, 0, "rowPtr", "storage-ro", "array<u32>"),
+    decl(1, 1, "colIdx", "storage-ro", "array<u32>"),
+    decl(1, 2, "weights", "storage-ro", "array<f32>"),
+    decl(1, 3, "keyIn", "storage-ro", "array<u32>"),
+    decl(1, 4, "rows", "storage-ro", "array<u32>"),
+    decl(1, 5, "hashRegion", "storage", "array<atomic<u32>>"),
+    decl(1, 6, "bestKey", "storage", "array<u32>"),
+    decl(1, 7, "bestScore", "storage", "array<f32>"),
+    decl(2, 0, "P", "uniform", "GroupParams")
+  ],
+  overrideDecls: [
+    { name: "TIER", type: "u32", default: 0 },
+    { name: "WEIGHTED", type: "bool", default: false }
+  ],
+  uniforms: [GROUP_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P11"
+};
+const LPA_STEP = {
+  id: "lpa-step",
+  body: lpaStepWgsl,
+  entryPoint: "lpa_step",
+  bindings: [
+    decl(1, 0, "labelsIn", "storage-ro", "array<u32>"),
+    decl(1, 1, "bestKey", "storage-ro", "array<u32>"),
+    decl(1, 2, "labelsOut", "storage", "array<u32>"),
+    decl(1, 3, "counters", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "LpaParams")
+  ],
+  overrideDecls: [],
+  uniforms: [LPA_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P11"
+};
 const REGISTRY = Object.freeze({
   degree: DEGREE,
   reduce: REDUCE,
@@ -4048,7 +4633,16 @@ const REGISTRY = Object.freeze({
   "bc-backward": BC_BACKWARD,
   "bc-gather": BC_GATHER,
   "bc-edge-gather": BC_EDGE_GATHER,
-  "bc-forward-edge": BC_FORWARD_EDGE
+  "bc-forward-edge": BC_FORWARD_EDGE,
+  "apsp-init": APSP_INIT,
+  "apsp-fw": APSP_FW,
+  "coo-emit": COO_EMIT,
+  "run-flags": RUN_FLAGS,
+  "coo-scatter": COO_SCATTER,
+  "orient-flags": ORIENT_FLAGS,
+  "tri-intersect": TRI_INTERSECT,
+  "group-by-key-row": GROUP_BY_KEY_ROW,
+  "lpa-step": LPA_STEP
 });
 const bodyOverrides = /* @__PURE__ */ new Map();
 function entryOf(id) {
@@ -4207,7 +4801,7 @@ class ScanPlannerImpl {
 }
 const POISON = 3735928559;
 const CHECK_BLOCKS = 32;
-const RING_SLOTS$7 = 8;
+const RING_SLOTS$9 = 8;
 const checked = /* @__PURE__ */ new WeakMap();
 function inputAt(i) {
   return i + 1;
@@ -4235,7 +4829,7 @@ async function runCheck(ctx) {
   const count = CHECK_BLOCKS * wg + 1;
   const bytes = 4 * count;
   const lease = ctx.pool.lease();
-  const ring = new UniformRing(ctx.device, ctx.allocator, RING_SLOTS$7, "device-check/ring");
+  const ring = new UniformRing(ctx.device, ctx.allocator, RING_SLOTS$9, "device-check/ring");
   try {
     const scope = {
       device: ctx.device,
@@ -4452,7 +5046,7 @@ function coreOfView(v, arcCount) {
     hasWeights: weights !== null
   });
 }
-function checkDest$5(dest, n) {
+function checkDest$7(dest, n) {
   if (dest === void 0) {
     return null;
   }
@@ -4481,7 +5075,7 @@ async function degree(ctx, s, options) {
   ctx.assertReady();
   await assertDeviceComputes(ctx);
   const n = s.nodeCount;
-  const dest = checkDest$5(options?.dest, n);
+  const dest = checkDest$7(options?.dest, n);
   if (options?.signal?.aborted) {
     throw new WebGpuGraphError("E_ABORTED", "degree: the signal was aborted before any work started", {});
   }
@@ -4902,13 +5496,13 @@ function algorithmScope(ctx, label, slots) {
     ringOverruns: () => ring.overruns
   };
 }
-const ALGORITHM$5 = "connectedComponents";
+const ALGORITHM$8 = "connectedComponents";
 const ROUNDS_PER_BATCH$1 = 4;
 const MAX_WCC_ROUNDS = 64;
 const SAMPLE_SIZE = 1024;
 const MAX_STEPS = 1024;
-const RING_SLOTS$6 = 2 * ROUNDS_PER_BATCH$1;
-function checkDest$4(dest, n) {
+const RING_SLOTS$8 = 2 * ROUNDS_PER_BATCH$1;
+function checkDest$6(dest, n) {
   if (dest === void 0) {
     return null;
   }
@@ -4917,7 +5511,7 @@ function checkDest$4(dest, n) {
   }
   throw new WebGpuGraphError(
     "E_INVALID_ARGUMENT",
-    `${ALGORITHM$5}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
+    `${ALGORITHM$8}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
     {
       argument: "dest",
       value: `${dest.constructor.name}(${dest.length})`,
@@ -4927,7 +5521,7 @@ function checkDest$4(dest, n) {
 }
 function coreOf$2(ctx, s) {
   const core = ctx.residency.core(s);
-  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$5);
+  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$8);
   return core;
 }
 function bindingOf$3(buffer, size) {
@@ -4986,8 +5580,8 @@ function checkLabels(raw) {
   for (let v = 0; v < n; v++) {
     const label = raw[v];
     if (label >= n) {
-      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$5}: labels[${v}] = ${label} is not a node index`, {
-        label: `${ALGORITHM$5}/labels`,
+      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$8}: labels[${v}] = ${label} is not a node index`, {
+        label: `${ALGORITHM$8}/labels`,
         message: `the device produced a label outside [0, ${n})`
       });
     }
@@ -5003,9 +5597,9 @@ async function connectedComponents(ctx, s, options) {
   await assertDeviceComputes(ctx);
   const n = s.nodeCount;
   const renumber = options?.renumber !== false;
-  const dest = checkDest$4(options?.dest, n);
+  const dest = checkDest$6(options?.dest, n);
   if (options?.signal?.aborted) {
-    throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$5}: the signal was aborted before any work started`, {});
+    throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$8}: the signal was aborted before any work started`, {});
   }
   if (n === 0) {
     options?.onProgress?.(1, 1);
@@ -5022,7 +5616,7 @@ async function connectedComponents(ctx, s, options) {
   }
   const edges = ctx.residency.view(s, "edgeList");
   const edgeCount = edges.scalars.edgeCount[0];
-  const scope = algorithmScope(ctx, ALGORITHM$5, RING_SLOTS$6);
+  const scope = algorithmScope(ctx, ALGORITHM$8, RING_SLOTS$8);
   try {
     const compBytes = 4 * (n + 1);
     const comp = scope.scratch(compBytes, "comp");
@@ -5051,7 +5645,7 @@ async function connectedComponents(ctx, s, options) {
       return batch.submit();
     };
     queue.writeBuffer(comp, 4 * flagIndex, zero);
-    const setup = new CommandBatch(ctx, `${ALGORITHM$5}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$8}/setup`);
     let pass = setup.pass("sample-rounds");
     const fillParams = scope.params(FILL_PARAMS, { count: n, value: 0, mode: 1, pad0: 0 });
     fill.dispatch(
@@ -5070,7 +5664,7 @@ async function connectedComponents(ctx, s, options) {
     setup.endPass();
     await submit2(setup).readback;
     ctx.assertReady();
-    const sampler = new CommandBatch(ctx, `${ALGORITHM$5}/sample`);
+    const sampler = new CommandBatch(ctx, `${ALGORITHM$8}/sample`);
     pass = sampler.pass("sample");
     const sampleParams = wccParams({ items, stride: 0, r: 0, giant: U32_MAX$2 });
     sample.dispatch(
@@ -5088,7 +5682,7 @@ async function connectedComponents(ctx, s, options) {
     let rounds = 0;
     for (; ; ) {
       queue.writeBuffer(comp, 4 * flagIndex, zero);
-      const batch = new CommandBatch(ctx, `${ALGORITHM$5}/rounds`);
+      const batch = new CommandBatch(ctx, `${ALGORITHM$8}/rounds`);
       pass = batch.pass("edge-rounds");
       for (let i = 0; i < ROUNDS_PER_BATCH$1; i++) {
         const params = wccParams({ items: edgeCount, stride: edgePlan.stride ?? edgeCount, r: 0, giant });
@@ -5103,7 +5697,7 @@ async function connectedComponents(ctx, s, options) {
       rounds += ROUNDS_PER_BATCH$1;
       ctx.assertReady();
       if (options?.signal?.aborted) {
-        throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$5}: the signal was aborted`, {
+        throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$8}: the signal was aborted`, {
           batchId: submitted.id
         });
       }
@@ -5113,12 +5707,12 @@ async function connectedComponents(ctx, s, options) {
       if (rounds >= MAX_WCC_ROUNDS) {
         throw new WebGpuGraphError(
           "E_VALIDATION",
-          `${ALGORITHM$5}: the changed flag never settled in ${MAX_WCC_ROUNDS} rounds`,
-          { label: ALGORITHM$5, message: `the changed flag never settled in ${MAX_WCC_ROUNDS} rounds` }
+          `${ALGORITHM$8}: the changed flag never settled in ${MAX_WCC_ROUNDS} rounds`,
+          { label: ALGORITHM$8, message: `the changed flag never settled in ${MAX_WCC_ROUNDS} rounds` }
         );
       }
     }
-    const final = new CommandBatch(ctx, `${ALGORITHM$5}/final`);
+    const final = new CommandBatch(ctx, `${ALGORITHM$8}/final`);
     recordCompress(final.pass("compress"));
     final.endPass();
     await submit2(final).readback;
@@ -5360,8 +5954,20 @@ class TieredPlanner {
 async function prepareSegmentedReduce(scope, core, options) {
   const op = opCode(options.op);
   validateValueSnippet(options.valueSnippet);
-  const perm = null;
-  const ranges = [{ tier: 0, start: 0, end: rowCountOf(core, "segmentedReduce") }];
+  const { tiers } = options;
+  const perm = tiers?.perm ?? null;
+  if (tiers !== null && scope.workgroupSize < MID_TIER_LANES) {
+    throw new WebGpuGraphError(
+      "E_UNSUPPORTED",
+      `segmentedReduce: the mid tier folds ${MID_TIER_LANES} lanes per row, more than the workgroup size ${scope.workgroupSize}`,
+      { feature: "segmentedReduce.tiers" }
+    );
+  }
+  const ranges = tiers === null ? [{ tier: 0, start: 0, end: rowCountOf(core, "segmentedReduce") }] : [
+    { tier: 2, start: 0, end: tiers.segmentOffsets[1] },
+    { tier: 1, start: tiers.segmentOffsets[1], end: tiers.segmentOffsets[2] },
+    { tier: 0, start: tiers.segmentOffsets[2], end: tiers.segmentOffsets[4] }
+  ];
   const compiled = [];
   for (const range of ranges) {
     if (range.tier !== 0 && range.end <= range.start) {
@@ -5484,8 +6090,8 @@ async function prepareSpmvPull(scope, rev, options) {
   return new SpmvPullPlannerImpl(scope, compiled, perm, options.weights);
 }
 const PR_BATCH = 8;
-const RING_SLOTS$5 = 2 * PR_BATCH + 2;
-function checkDest$3(dest, n, algorithm) {
+const RING_SLOTS$7 = 2 * PR_BATCH + 2;
+function checkDest$5(dest, n, algorithm) {
   if (dest === void 0) {
     return null;
   }
@@ -5532,7 +6138,7 @@ async function run(ctx, s, personalization, options, algorithm) {
       expected: "a positive integer"
     });
   }
-  const dest = checkDest$3(options?.dest, n, algorithm);
+  const dest = checkDest$5(options?.dest, n, algorithm);
   if (options?.signal?.aborted) {
     throw aborted$3(algorithm);
   }
@@ -5562,7 +6168,7 @@ async function run(ctx, s, personalization, options, algorithm) {
   const weights = useWeights ? void 0 : null;
   const weightedCore = useWeights ? core : { ...core, weights: null, hasWeights: false };
   const weightedRev = useWeights ? rev : { ...rev, weights: null, hasWeights: false };
-  const scope = algorithmScope(ctx, algorithm, RING_SLOTS$5);
+  const scope = algorithmScope(ctx, algorithm, RING_SLOTS$7);
   let uploaded = null;
   try {
     const bytes = 4 * n;
@@ -5725,8 +6331,8 @@ async function personalizedPageRank(ctx, s, personalization, options) {
   return run(ctx, s, normalised2, options, "personalizedPageRank");
 }
 const BATCH = 8;
-const RING_SLOTS$4 = 4 * BATCH + 8;
-function checkDest$2(dest, n, algorithm) {
+const RING_SLOTS$6 = 4 * BATCH + 8;
+function checkDest$4(dest, n, algorithm) {
   if (dest === void 0) {
     return null;
   }
@@ -5764,7 +6370,7 @@ function whole(buffer, size) {
 }
 async function runPowerIteration(ctx, n, config) {
   await assertDeviceComputes(ctx);
-  const scope = algorithmScope(ctx, config.label, RING_SLOTS$4);
+  const scope = algorithmScope(ctx, config.label, RING_SLOTS$6);
   try {
     const bytes = 4 * n;
     const ring = (config.alternate === null ? ["rankA", "rankB"] : ["rankA", "rankB", "rankC"]).map(
@@ -5876,7 +6482,7 @@ function resolve(ctx, s, options, algorithm) {
       expected: "a positive integer"
     });
   }
-  const dest = checkDest$2(options?.dest, n, algorithm);
+  const dest = checkDest$4(options?.dest, n, algorithm);
   if (options?.signal?.aborted) {
     throw aborted$2(algorithm);
   }
@@ -6032,7 +6638,7 @@ function checkCount(what, count) {
     });
   }
 }
-function checkWords$1(what, name, binding, words) {
+function checkWords$3(what, name, binding, words) {
   if (binding.size < 4 * words) {
     throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${what}: ${name} is smaller than 4 x ${words} bytes`, {
       argument: name,
@@ -6052,15 +6658,15 @@ function checkWordIndex(what, name, index, block) {
 }
 function checkCompactArguments(r) {
   checkCount("compact", r.count);
-  checkWords$1("compact", "queue", r.queue, r.count);
-  checkWords$1("compact", "flags", r.flags, r.count);
-  checkWords$1("compact", "out", r.out, r.count);
+  checkWords$3("compact", "queue", r.queue, r.count);
+  checkWords$3("compact", "flags", r.flags, r.count);
+  checkWords$3("compact", "out", r.out, r.count);
   checkWordIndex("compact", "outIndex", r.outIndex, r.outCount);
 }
 function checkDedupeArguments(r) {
   checkCount("dedupe", r.count);
-  checkWords$1("dedupe", "queue", r.queue, r.count);
-  checkWords$1("dedupe", "out", r.out, Math.min(r.count, Math.floor(r.owner.size / 4)));
+  checkWords$3("dedupe", "queue", r.queue, r.count);
+  checkWords$3("dedupe", "out", r.out, Math.min(r.count, Math.floor(r.owner.size / 4)));
   checkWordIndex("dedupe", "outIndex", r.outIndex, r.outCount);
   if (r.countIndex === U32_MAX$2) {
     return;
@@ -6544,7 +7150,7 @@ class RadixSortPlannerImpl {
     return src;
   }
 }
-const ALGORITHM$4 = "breadthFirstSearch";
+const ALGORITHM$7 = "breadthFirstSearch";
 const NEXT_DEGREE_MAX_GROUPS = 128;
 function bfsRingSlots(windows, levelsPerSubmit) {
   return Math.max((5 + 4 * windows) * levelsPerSubmit + 16, RESULT_BATCH_SLOTS + windows);
@@ -6556,7 +7162,7 @@ function normaliseMaxDepth(maxDepth) {
   }
   return Math.max(0, Math.ceil(maxDepth));
 }
-function checkDest$1(dest, n) {
+function checkDest$3(dest, n) {
   if (dest === void 0) {
     return null;
   }
@@ -6565,7 +7171,7 @@ function checkDest$1(dest, n) {
   }
   throw new WebGpuGraphError(
     "E_INVALID_ARGUMENT",
-    `${ALGORITHM$4}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
+    `${ALGORITHM$7}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
     {
       argument: "dest",
       value: `${dest.constructor.name}(${dest.length})`,
@@ -6580,8 +7186,8 @@ function degreeView(ctx, s, name) {
   const { bindings } = ctx.residency.view(s, name);
   const { [name]: binding } = bindings;
   if (binding === void 0) {
-    throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$4}: the ${name} view has no ${name} binding`, {
-      label: `${ALGORITHM$4}/${name}`,
+    throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$7}: the ${name} view has no ${name} binding`, {
+      label: `${ALGORITHM$7}/${name}`,
       message: `the ${name} view has no ${name} binding`
     });
   }
@@ -6590,15 +7196,15 @@ function degreeView(ctx, s, name) {
 function aborted$1(batchId) {
   return new WebGpuGraphError(
     "E_ABORTED",
-    `${ALGORITHM$4}: the signal was aborted`,
+    `${ALGORITHM$7}: the signal was aborted`,
     batchId === void 0 ? {} : { batchId }
   );
 }
 function wordOf$1(block, name) {
   const value = block[name];
   if (typeof value !== "number") {
-    throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$4}: counters.${name} did not decode to a number`, {
-      label: `${ALGORITHM$4}/counters`,
+    throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$7}: counters.${name} did not decode to a number`, {
+      label: `${ALGORITHM$7}/counters`,
       message: `the field ${name} did not decode to a number`
     });
   }
@@ -6609,7 +7215,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
   await assertDeviceComputes(ctx);
   const n = s.nodeCount;
   if (!Number.isInteger(source) || source < 0 || source >= n) {
-    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$4}: source ${source} is outside [0, ${n})`, {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$7}: source ${source} is outside [0, ${n})`, {
       argument: "source",
       value: source,
       expected: `an integer in [0, ${n})`
@@ -6619,7 +7225,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
   if (!Number.isInteger(levelsPerSubmit) || levelsPerSubmit < 1 || levelsPerSubmit > MAX_LEVELS_PER_SUBMIT) {
     throw new WebGpuGraphError(
       "E_INVALID_ARGUMENT",
-      `${ALGORITHM$4}: levelsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
+      `${ALGORITHM$7}: levelsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
       {
         argument: "levelsPerSubmit",
         value: levelsPerSubmit,
@@ -6627,7 +7233,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
       }
     );
   }
-  const dest = checkDest$1(options?.dest, n);
+  const dest = checkDest$3(options?.dest, n);
   const maxDepth = normaliseMaxDepth(options?.maxDepth);
   const predKind = tuning.predKind ?? 1;
   if (options?.signal?.aborted) {
@@ -6638,12 +7244,12 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
   if (s.directed && 4 * s.arcCount > ctx.caps.limits.maxStorageBufferBindingSize) {
     throw new WebGpuGraphError(
       "E_TOO_LARGE",
-      `${ALGORITHM$4}: the reverse adjacency of a directed snapshot (${4 * s.arcCount} bytes) needs arc windows, which no view executes (spec 4.3); the bottom-up sweep binds it whole`,
+      `${ALGORITHM$7}: the reverse adjacency of a directed snapshot (${4 * s.arcCount} bytes) needs arc windows, which no view executes (spec 4.3); the bottom-up sweep binds it whole`,
       {
         needed: 4 * s.arcCount,
         limit: ctx.caps.limits.maxStorageBufferBindingSize,
         path: "windowed",
-        algorithm: ALGORITHM$4
+        algorithm: ALGORITHM$7
       }
     );
   }
@@ -6651,7 +7257,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
   const backward = coreWindows(reverse);
   const outDegree = degreeView(ctx, s, "outDegree");
   const inDegree = degreeView(ctx, s, "inDegree");
-  const scope = algorithmScope(ctx, ALGORITHM$4, bfsRingSlots(forward.length, levelsPerSubmit));
+  const scope = algorithmScope(ctx, ALGORITHM$7, bfsRingSlots(forward.length, levelsPerSubmit));
   tuning.onScope?.(scope);
   try {
     const bytes = 4 * n;
@@ -6715,7 +7321,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
       scope.flush();
       return batch.submit();
     };
-    const setup = new CommandBatch(ctx, `${ALGORITHM$4}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$7}/setup`);
     const setupPass = setup.pass("fill");
     recordFill2(setupPass, depth, INVALID_INDEX, 0);
     recordFill2(setupPass, iota, 0, 1);
@@ -6735,7 +7341,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
     let submits = 0;
     for (; ; ) {
       queue.writeBuffer(counters.buffer, counters.offset + 4 * W.unvisitedCount, new Uint32Array(3));
-      const batch = new CommandBatch(ctx, `${ALGORITHM$4}/levels`);
+      const batch = new CommandBatch(ctx, `${ALGORITHM$7}/levels`);
       const pass2 = batch.pass("bfs");
       recordRebuild(pass2);
       const bitsParams = scope.params(FILL_PARAMS, { count: bitsWords, value: 0, mode: 0, pad0: 0 });
@@ -6845,8 +7451,8 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
       if (submits > n + 1) {
         throw new WebGpuGraphError(
           "E_VALIDATION",
-          `${ALGORITHM$4}: the done flag never rose in ${submits} submits (a traversal has at most ${n} levels)`,
-          { label: ALGORITHM$4, message: `the done flag never rose in ${submits} submits` }
+          `${ALGORITHM$7}: the done flag never rose in ${submits} submits (a traversal has at most ${n} levels)`,
+          { label: ALGORITHM$7, message: `the done flag never rose in ${submits} submits` }
         );
       }
     }
@@ -6860,7 +7466,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
       offsets: bindingOf$1(scope.scratch(histBytes, "order/offsets"), histBytes)
     };
     const parent = bindingOf$1(scope.scratch(bytes, "parent"), bytes);
-    const result = new CommandBatch(ctx, `${ALGORITHM$4}/result`);
+    const result = new CommandBatch(ctx, `${ALGORITHM$7}/result`);
     result.copy(depth, keys, bytes);
     const pass = result.pass("result");
     recordFill2(pass, vals, 0, 1);
@@ -6897,9 +7503,9 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
     if (visitedCount > n) {
       throw new WebGpuGraphError(
         "E_VALIDATION",
-        `${ALGORITHM$4}: visitedCount ${visitedCount} exceeds the ${n} vertices (a duplicate claim)`,
+        `${ALGORITHM$7}: visitedCount ${visitedCount} exceeds the ${n} vertices (a duplicate claim)`,
         {
-          label: `${ALGORITHM$4}/visitedCount`,
+          label: `${ALGORITHM$7}/visitedCount`,
           message: `the device counted ${visitedCount} visits of ${n} vertices`
         }
       );
@@ -6923,9 +7529,9 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
 function breadthFirstSearch(ctx, s, source, options) {
   return bfsWithTuning(ctx, s, source, options, {});
 }
-const ALGORITHM$3 = "sssp";
+const ALGORITHM$6 = "sssp";
 const HALF_ALIGN = 64;
-const RING_SLOTS$3 = 4 * MAX_LEVELS_PER_SUBMIT + 40;
+const RING_SLOTS$5 = 4 * MAX_LEVELS_PER_SUBMIT + 40;
 function bitsOf(value) {
   return new Uint32Array(Float32Array.of(value).buffer)[0];
 }
@@ -6951,14 +7557,14 @@ function assertSource(algorithm, source, n) {
 function wordOf(block, name) {
   const value = block[name];
   if (typeof value !== "number") {
-    throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$3}: counters.${name} did not decode to a number`, {
-      label: `${ALGORITHM$3}/counters`,
+    throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$6}: counters.${name} did not decode to a number`, {
+      label: `${ALGORITHM$6}/counters`,
       message: `the field ${name} did not decode to a number`
     });
   }
   return value;
 }
-function checkDest(algorithm, dest, n) {
+function checkDest$2(algorithm, dest, n) {
   if (dest === void 0) {
     return null;
   }
@@ -7119,12 +7725,12 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
   ctx.assertReady();
   await assertDeviceComputes(ctx);
   const n = s.nodeCount;
-  assertSource(ALGORITHM$3, source, n);
+  assertSource(ALGORITHM$6, source, n);
   const roundsPerSubmit = tuning.roundsPerSubmit ?? MAX_LEVELS_PER_SUBMIT;
   if (!Number.isInteger(roundsPerSubmit) || roundsPerSubmit < 1 || roundsPerSubmit > MAX_LEVELS_PER_SUBMIT) {
     throw new WebGpuGraphError(
       "E_INVALID_ARGUMENT",
-      `${ALGORITHM$3}: roundsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
+      `${ALGORITHM$6}: roundsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
       {
         argument: "roundsPerSubmit",
         value: roundsPerSubmit,
@@ -7133,42 +7739,42 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
     );
   }
   if (tuning.delta !== void 0 && !(Number.isFinite(tuning.delta) && tuning.delta > 0)) {
-    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$3}: delta must be a finite positive number`, {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$6}: delta must be a finite positive number`, {
       argument: "delta",
       value: tuning.delta,
       expected: "a finite positive number"
     });
   }
-  const dest = checkDest(ALGORITHM$3, options?.dest, n);
-  const vector2 = resolveWeights$1(ALGORITHM$3, s, options?.weights);
-  const cutoff = normaliseCutoff(ALGORITHM$3, options?.cutoff);
+  const dest = checkDest$2(ALGORITHM$6, options?.dest, n);
+  const vector2 = resolveWeights$1(ALGORITHM$6, s, options?.weights);
+  const cutoff = normaliseCutoff(ALGORITHM$6, options?.cutoff);
   if (options?.signal?.aborted) {
-    throw aborted(ALGORITHM$3);
+    throw aborted(ALGORITHM$6);
   }
   if (vector2 === null || vector2.allOne) {
     return unitWeightRoute(ctx, s, source, cutoff, dest, options);
   }
   if (!vector2.nonNegative) {
-    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$3}: a negative weight has no shortest path here`, {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$6}: a negative weight has no shortest path here`, {
       feature: "sssp.negativeWeights",
       hint: "use bellmanFord"
     });
   }
   if (!vector2.finite) {
-    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$3}: a NaN or infinite weight has no bit-pattern order`, {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$6}: a NaN or infinite weight has no bit-pattern order`, {
       feature: "sssp.nonFiniteWeights"
     });
   }
   const { arcCount } = s;
   const core = ctx.residency.core(s);
   const limit = ctx.caps.limits.maxStorageBufferBindingSize;
-  assertWholeCore(core, arcCount, limit, ALGORITHM$3);
+  assertWholeCore(core, arcCount, limit, ALGORITHM$6);
   const cap = Math.ceil(Math.max(1, arcCount) / HALF_ALIGN) * HALF_ALIGN;
   if (8 * cap > limit) {
     throw new WebGpuGraphError(
       "E_TOO_LARGE",
-      `${ALGORITHM$3}: the near-far queue of ${cap} entries per half needs ${8 * cap} bytes, above the ${limit}-byte binding limit (the relax is never windowed)`,
-      { needed: 8 * cap, limit, path: "sssp.queue", algorithm: ALGORITHM$3 }
+      `${ALGORITHM$6}: the near-far queue of ${cap} entries per half needs ${8 * cap} bytes, above the ${limit}-byte binding limit (the relax is never windowed)`,
+      { needed: 8 * cap, limit, path: "sssp.queue", algorithm: ALGORITHM$6 }
     );
   }
   const delta = Math.fround(
@@ -7177,7 +7783,7 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
   const deltaBits = bitsOf(delta);
   const maxRounds = n + Math.ceil(vector2.sum / delta) + 1;
   const maxSubmits = Math.ceil((maxRounds + 1) / roundsPerSubmit) + 1;
-  const scope = algorithmScope(ctx, ALGORITHM$3, RING_SLOTS$3);
+  const scope = algorithmScope(ctx, ALGORITHM$6, RING_SLOTS$5);
   try {
     const wg = ctx.workgroupSize;
     const bytes = 4 * n;
@@ -7215,7 +7821,7 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
       scope.flush();
       return batch.submit();
     };
-    const setup = new CommandBatch(ctx, `${ALGORITHM$3}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$6}/setup`);
     const setupPass = setup.pass("fill");
     recordFill2(setupPass, dist, n, F32_INF_BITS);
     recordFill2(setupPass, pred, predWords, INVALID_INDEX);
@@ -7261,7 +7867,7 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
     let roundsRecorded = 0;
     let submits = 0;
     for (; ; ) {
-      const batch = new CommandBatch(ctx, `${ALGORITHM$3}/rounds`);
+      const batch = new CommandBatch(ctx, `${ALGORITHM$6}/rounds`);
       const pass = batch.pass("sssp");
       const near = scope.params(FRONTIER_PARAMS, { ...relaxFields, role: 0 });
       const far = scope.params(FRONTIER_PARAMS, { ...relaxFields, role: 1 });
@@ -7284,7 +7890,7 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
       submits += 1;
       ctx.assertReady();
       if (options?.signal?.aborted) {
-        throw aborted(ALGORITHM$3, submitted.id);
+        throw aborted(ALGORITHM$6, submitted.id);
       }
       options?.onProgress?.(Math.min(roundsRecorded, maxRounds), maxRounds);
       if (inspect !== null && tuning.onRound !== void 0) {
@@ -7309,26 +7915,26 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
           const needed = Math.max(wordOf(block, "nextFrontierCount"), wordOf(block, "nextFarCount"));
           throw new WebGpuGraphError(
             "E_TOO_LARGE",
-            `${ALGORITHM$3}: a raw pile of ${needed} entries overflowed its ${cap}-entry half`,
-            { needed, limit: cap, path: "sssp.pile", algorithm: ALGORITHM$3 }
+            `${ALGORITHM$6}: a raw pile of ${needed} entries overflowed its ${cap}-entry half`,
+            { needed, limit: cap, path: "sssp.pile", algorithm: ALGORITHM$6 }
           );
         }
         throw new WebGpuGraphError(
           "E_UNSUPPORTED",
-          `${ALGORITHM$3}: the f32 threshold ${wordOf(block, "thresholdBits")} absorbed the delta ${deltaBits} (as bit patterns); the far pile can no longer be bucketed`,
+          `${ALGORITHM$6}: the f32 threshold ${wordOf(block, "thresholdBits")} absorbed the delta ${deltaBits} (as bit patterns); the far pile can no longer be bucketed`,
           { feature: "sssp.thresholdAbsorbed", hint: "the distances outgrew the delta's f32 precision" }
         );
       }
       if (submits > maxSubmits) {
         throw new WebGpuGraphError(
           "E_VALIDATION",
-          `${ALGORITHM$3}: the done flag never rose in ${submits} submits (at most ${maxRounds} rounds)`,
-          { label: `${ALGORITHM$3}/rounds`, message: `the done flag never rose in ${submits} submits` }
+          `${ALGORITHM$6}: the done flag never rose in ${submits} submits (at most ${maxRounds} rounds)`,
+          { label: `${ALGORITHM$6}/rounds`, message: `the done flag never rose in ${submits} submits` }
         );
       }
     }
     const passed = await predecessorPass({
-      algorithm: ALGORITHM$3,
+      algorithm: ALGORITHM$6,
       ctx,
       scope,
       predKernel,
@@ -7344,8 +7950,8 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
     if (passed.orphans !== 0) {
       throw new WebGpuGraphError(
         "E_VALIDATION",
-        `${ALGORITHM$3}: ${passed.orphans} reached node(s) the predecessor key never reached (a kernel bug)`,
-        { label: `${ALGORITHM$3}/pred`, message: `${passed.orphans} orphan(s) in the predecessor pass` }
+        `${ALGORITHM$6}: ${passed.orphans} reached node(s) the predecessor key never reached (a kernel bug)`,
+        { label: `${ALGORITHM$6}/pred`, message: `${passed.orphans} orphan(s) in the predecessor pass` }
       );
     }
     const distOut = dest ?? new Float32Array(n);
@@ -7364,10 +7970,10 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
 function sssp(ctx, s, source, options) {
   return ssspWithTuning(ctx, s, source, options, {});
 }
-const ALGORITHM$2 = "bellmanFord";
+const ALGORITHM$5 = "bellmanFord";
 const ROUNDS_PER_BATCH = 8;
 const MAX_RETRIES = 16;
-const RING_SLOTS$2 = MAX_LEVELS_PER_SUBMIT + 16;
+const RING_SLOTS$4 = MAX_LEVELS_PER_SUBMIT + 16;
 function assertSymmetric(s, vector2) {
   const { arcToEdge, edgeToArc } = s;
   for (let a = 0; a < s.arcCount; a++) {
@@ -7375,7 +7981,7 @@ function assertSymmetric(s, vector2) {
     if (vector2[a] !== vector2[forward]) {
       throw new WebGpuGraphError(
         "E_UNSUPPORTED",
-        `${ALGORITHM$2}: weights[${a}] = ${vector2[a]} differs from weights[${forward}] = ${vector2[forward]}, the forward arc of the same undirected edge; the kernel reads one weight per edge`,
+        `${ALGORITHM$5}: weights[${a}] = ${vector2[a]} differs from weights[${forward}] = ${vector2[forward]}, the forward arc of the same undirected edge; the kernel reads one weight per edge`,
         { feature: "bellmanFord.asymmetricUndirectedWeights", hint: "use a directed snapshot" }
       );
     }
@@ -7385,10 +7991,10 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
   ctx.assertReady();
   await assertDeviceComputes(ctx);
   const n = s.nodeCount;
-  assertSource(ALGORITHM$2, source, n);
+  assertSource(ALGORITHM$5, source, n);
   const maxRetries = tuning.maxRetries ?? MAX_RETRIES;
   if (!Number.isInteger(maxRetries) || maxRetries < 1) {
-    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$2}: maxRetries must be an integer >= 1`, {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$5}: maxRetries must be an integer >= 1`, {
       argument: "maxRetries",
       value: maxRetries,
       expected: "an integer >= 1"
@@ -7398,7 +8004,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
   if (!Number.isInteger(roundsPerBatch) || roundsPerBatch < 1 || roundsPerBatch > MAX_LEVELS_PER_SUBMIT) {
     throw new WebGpuGraphError(
       "E_INVALID_ARGUMENT",
-      `${ALGORITHM$2}: roundsPerBatch must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
+      `${ALGORITHM$5}: roundsPerBatch must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
       {
         argument: "roundsPerBatch",
         value: roundsPerBatch,
@@ -7406,18 +8012,18 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
       }
     );
   }
-  const dest = checkDest(ALGORITHM$2, options?.dest, n);
-  const vector2 = resolveWeights$1(ALGORITHM$2, s, options?.weights);
-  const cutoff = normaliseCutoff(ALGORITHM$2, options?.cutoff);
+  const dest = checkDest$2(ALGORITHM$5, options?.dest, n);
+  const vector2 = resolveWeights$1(ALGORITHM$5, s, options?.weights);
+  const cutoff = normaliseCutoff(ALGORITHM$5, options?.cutoff);
   if (options?.signal?.aborted) {
-    throw aborted(ALGORITHM$2);
+    throw aborted(ALGORITHM$5);
   }
   if (vector2 === null || vector2.allOne) {
     const unit = await unitWeightRoute(ctx, s, source, cutoff, dest, options);
     return { result: { ...unit, hasNegativeCycle: false }, rounds: 0, retryExhaustedRounds: 0 };
   }
   if (!vector2.finite) {
-    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$2}: a NaN or infinite weight has no shortest path`, {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$5}: a NaN or infinite weight has no shortest path`, {
       feature: "bellmanFord.nonFiniteWeights"
     });
   }
@@ -7426,10 +8032,10 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
   }
   const { arcCount } = s;
   const core = ctx.residency.core(s, ["rowPtr", "colIdx", "weights", "edgeToArc"]);
-  assertWholeCore(core, arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$2);
+  assertWholeCore(core, arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$5);
   const edges = ctx.residency.view(s, "edgeList");
   const edgeCount = edges.scalars.edgeCount[0];
-  const scope = algorithmScope(ctx, ALGORITHM$2, RING_SLOTS$2);
+  const scope = algorithmScope(ctx, ALGORITHM$5, RING_SLOTS$4);
   try {
     const wg = ctx.workgroupSize;
     const bytes = 4 * n;
@@ -7464,7 +8070,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
       scope.flush();
       return batch.submit();
     };
-    const setup = new CommandBatch(ctx, `${ALGORITHM$2}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$5}/setup`);
     const setupPass = setup.pass("fill");
     recordFill2(setupPass, dist, n, F32_INF_BITS);
     recordFill2(setupPass, pred, predWords, INVALID_INDEX);
@@ -7493,7 +8099,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
     const zero = new Uint32Array(BF_FLAGS.byteLength / 4);
     const runRounds = async (count, label) => {
       queue.writeBuffer(flags.buffer, flags.offset, zero);
-      const batch = new CommandBatch(ctx, `${ALGORITHM$2}/${label}`);
+      const batch = new CommandBatch(ctx, `${ALGORITHM$5}/${label}`);
       const pass = batch.pass("relax");
       const params = scope.params(BF_PARAMS, relaxFields);
       const bound = relax.bind({ ...relaxBindings, P: params.binding });
@@ -7518,9 +8124,9 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
         if (decision.retryExhausted !== 0) {
           throw new WebGpuGraphError(
             "E_VALIDATION",
-            `${ALGORITHM$2}: a lane exhausted the ${maxRetries}-retry compare-exchange bound in the decision round, so its change is not a verdict`,
+            `${ALGORITHM$5}: a lane exhausted the ${maxRetries}-retry compare-exchange bound in the decision round, so its change is not a verdict`,
             {
-              label: `${ALGORITHM$2}/retry`,
+              label: `${ALGORITHM$5}/retry`,
               message: "retryExhausted in the decision round",
               batchId: decision.id
             }
@@ -7536,7 +8142,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
         retryExhaustedRounds += 1;
       }
       if (options?.signal?.aborted) {
-        throw aborted(ALGORITHM$2, batch.id);
+        throw aborted(ALGORITHM$5, batch.id);
       }
       options?.onProgress?.(rounds, n);
       if (batch.changed === 0 && batch.retryExhausted === 0) {
@@ -7544,7 +8150,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
       }
     }
     const passed = await predecessorPass({
-      algorithm: ALGORITHM$2,
+      algorithm: ALGORITHM$5,
       ctx,
       scope,
       predKernel,
@@ -7560,7 +8166,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
     if (passed.orphans !== 0 && !hasNegativeCycle) {
       throw new WebGpuGraphError(
         "E_UNSUPPORTED",
-        `${ALGORITHM$2}: ${passed.orphans} reached node(s) the tight subgraph never reaches (a cycle of weights below one f32 ulp relaxed once)`,
+        `${ALGORITHM$5}: ${passed.orphans} reached node(s) the tight subgraph never reaches (a cycle of weights below one f32 ulp relaxed once)`,
         {
           feature: "bellmanFord.roundedCycle",
           hint: "a cycle of weights below one f32 ulp relaxed once at a distance above 2^24; scale the weights or shorten the distances"
@@ -7587,17 +8193,17 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
 async function bellmanFord(ctx, s, source, options) {
   return (await bellmanFordWithTuning(ctx, s, source, options, {})).result;
 }
-const ALGORITHM$1 = "betweennessCentrality";
+const ALGORITHM$4 = "betweennessCentrality";
 const BYTES_PER_NODE_SOURCE = 16;
 const SAMPLE_SEED = 2654435769;
-const RING_SLOTS$1 = BC_BACKWARD_LEVELS_PER_SUBMIT + 16;
+const RING_SLOTS$3 = BC_BACKWARD_LEVELS_PER_SUBMIT + 16;
 function planBatchSize(n, remaining, limits) {
   const needed = 4 * (n + 2);
   if (needed > limits.maxStorageBufferBindingSize) {
     throw new WebGpuGraphError(
       "E_TOO_LARGE",
-      `${ALGORITHM$1}: one source needs ${needed} bytes in its largest binding at n = ${n}, above maxStorageBufferBindingSize = ${limits.maxStorageBufferBindingSize}; a limit of at least ${needed} admits one source per batch`,
-      { needed, limit: limits.maxStorageBufferBindingSize, path: "binding", algorithm: ALGORITHM$1 }
+      `${ALGORITHM$4}: one source needs ${needed} bytes in its largest binding at n = ${n}, above maxStorageBufferBindingSize = ${limits.maxStorageBufferBindingSize}; a limit of at least ${needed} admits one source per batch`,
+      { needed, limit: limits.maxStorageBufferBindingSize, path: "binding", algorithm: ALGORITHM$4 }
     );
   }
   const kByBinding = Math.floor(limits.maxStorageBufferBindingSize / (4 * n));
@@ -7618,7 +8224,7 @@ function drawSources(n, k) {
   return pool.slice(0, k);
 }
 function badArgument(argument, value, expected) {
-  return new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$1}: ${argument} must be ${expected}`, {
+  return new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$4}: ${argument} must be ${expected}`, {
     argument,
     value,
     expected
@@ -7670,7 +8276,7 @@ async function submit(state, batch, signal) {
   const back = await submitted.readback;
   state.ctx.assertReady();
   if (signal?.aborted) {
-    throw aborted(ALGORITHM$1, submitted.id);
+    throw aborted(ALGORITHM$4, submitted.id);
   }
   return back;
 }
@@ -7687,7 +8293,7 @@ async function runBatch(state, sources, form, levelsPerSubmit, tuning, signal) {
   let overflow = false;
   let endsWords = null;
   for (let first = true; endsWords === null; first = false) {
-    const batch = new CommandBatch(ctx, `${ALGORITHM$1}/forward`);
+    const batch = new CommandBatch(ctx, `${ALGORITHM$4}/forward`);
     const pass = batch.pass("forward");
     if (first) {
       recordFill(state, pass, depthK, words, 4294967295);
@@ -7729,8 +8335,8 @@ async function runBatch(state, sources, form, levelsPerSubmit, tuning, signal) {
       overflow = words32[W.sigmaOverflow] !== 0;
       endsWords = new Uint32Array(back, endsRequest.offset, endsCount).slice(0, levels + 1);
     } else if (recorded > n + 2) {
-      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$1}: the done flag never rose in ${recorded} levels`, {
-        label: ALGORITHM$1,
+      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$4}: the done flag never rose in ${recorded} levels`, {
+        label: ALGORITHM$4,
         message: `the done flag never rose in ${recorded} levels`
       });
     }
@@ -7743,7 +8349,7 @@ async function runBatch(state, sources, form, levelsPerSubmit, tuning, signal) {
   for (let i = 0; ; i += BC_BACKWARD_LEVELS_PER_SUBMIT) {
     const chunk = backwardLevels.slice(i, i + BC_BACKWARD_LEVELS_PER_SUBMIT);
     const last = i + BC_BACKWARD_LEVELS_PER_SUBMIT >= backwardLevels.length;
-    const batch = new CommandBatch(ctx, `${ALGORITHM$1}/backward`);
+    const batch = new CommandBatch(ctx, `${ALGORITHM$4}/backward`);
     const pass = batch.pass("backward");
     for (const level of chunk) {
       const start = endsWords[level];
@@ -7807,11 +8413,11 @@ async function runRaw(ctx, s, sources, withEdges, tuning, options) {
   const limits = tuning.limits ?? ctx.caps.limits;
   const kMax = planBatchSize(n, sources.length, limits);
   const core = ctx.residency.core(s);
-  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$1);
+  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$4);
   const { edgeCount } = s;
   const mayRunEdge = pinned === "edge" || pinned === "auto" && sources.length > kMax;
   const edgeView = mayRunEdge && edgeCount > 0 ? ctx.residency.view(s, "edgeList") : null;
-  const scope = algorithmScope(ctx, ALGORITHM$1, RING_SLOTS$1);
+  const scope = algorithmScope(ctx, ALGORITHM$4, RING_SLOTS$3);
   try {
     const arrayBytes = 4 * n * kMax;
     const lease = (bytes, label) => bindingOf(scope.scratch(bytes, label), bytes);
@@ -7851,7 +8457,7 @@ async function runRaw(ctx, s, sources, withEdges, tuning, options) {
       bound: /* @__PURE__ */ new Map()
     };
     await ctx.allocator.check();
-    const setup = new CommandBatch(ctx, `${ALGORITHM$1}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$4}/setup`);
     const setupPass = setup.pass("setup");
     recordFill(state, setupPass, state.bc, n, 0);
     if (state.arcScores !== null) {
@@ -7879,7 +8485,7 @@ async function runRaw(ctx, s, sources, withEdges, tuning, options) {
       batches += 1;
       options?.onProgress?.(start, sources.length);
     }
-    const result = new CommandBatch(ctx, `${ALGORITHM$1}/result`);
+    const result = new CommandBatch(ctx, `${ALGORITHM$4}/result`);
     const vertexRequest = result.readback(state.bc.buffer, state.bc.offset, 4 * n);
     const arcRequest = state.arcScores === null ? null : result.readback(state.arcScores.buffer, state.arcScores.offset, 4 * s.arcCount);
     const back = await submit(state, result, options?.signal);
@@ -7903,7 +8509,7 @@ async function precheck(ctx, options) {
   ctx.assertReady();
   await assertDeviceComputes(ctx);
   if (options?.endpoints === true) {
-    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$1}: endpoints: true is not supported`, {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$4}: endpoints: true is not supported`, {
       feature: "betweenness.endpoints",
       hint: "the CPU endpoints branch in algorithms/src/algorithms/centrality/betweenness.ts (predecessors.length === 0 && w !== source) never fires, so there is no convention to match"
     });
@@ -7912,10 +8518,10 @@ async function precheck(ctx, options) {
 async function betweennessWithTuning(ctx, s, options, tuning) {
   await precheck(ctx, options);
   const n = s.nodeCount;
-  const scores = checkDest(ALGORITHM$1, options?.dest, n) ?? new Float32Array(n);
+  const scores = checkDest$2(ALGORITHM$4, options?.dest, n) ?? new Float32Array(n);
   const sources = resolveSources(options, n);
   if (options?.signal?.aborted) {
-    throw aborted(ALGORITHM$1);
+    throw aborted(ALGORITHM$4);
   }
   if (n === 0 || sources.length === 0) {
     scores.fill(0);
@@ -7938,10 +8544,10 @@ async function betweennessWithTuning(ctx, s, options, tuning) {
 async function edgeBetweennessWithTuning(ctx, s, options, tuning, onArcs) {
   await precheck(ctx, options);
   const n = s.nodeCount;
-  const scores = checkDest("edgeBetweennessCentrality", options?.dest, s.edgeCount) ?? new Float32Array(s.edgeCount);
+  const scores = checkDest$2("edgeBetweennessCentrality", options?.dest, s.edgeCount) ?? new Float32Array(s.edgeCount);
   const sources = resolveSources(options, n);
   if (options?.signal?.aborted) {
-    throw aborted(ALGORITHM$1);
+    throw aborted(ALGORITHM$4);
   }
   if (n === 0 || sources.length === 0 || s.arcCount === 0) {
     scores.fill(0);
@@ -7962,10 +8568,10 @@ function betweennessCentrality(ctx, s, options) {
 function edgeBetweennessCentrality(ctx, s, options) {
   return edgeBetweennessWithTuning(ctx, s, options, {});
 }
-const ALGORITHM = "closenessCentrality";
+const ALGORITHM$3 = "closenessCentrality";
 const SOURCES_PER_BATCH = 32;
 const PER_SOURCE_WORDS = 4 * SOURCES_PER_BATCH;
-const RING_SLOTS = 8 * MAX_LEVELS_PER_SUBMIT + 16;
+const RING_SLOTS$2 = 8 * MAX_LEVELS_PER_SUBMIT + 16;
 function reusingScratch(scope) {
   const held = /* @__PURE__ */ new Map();
   return {
@@ -7987,7 +8593,7 @@ async function weightedRoute(ctx, s, scores, sources, options) {
   const totals = sources === null ? null : new Float64Array(n);
   for (let i = 0; i < count; i++) {
     if (options?.signal?.aborted) {
-      throw aborted(ALGORITHM);
+      throw aborted(ALGORITHM$3);
     }
     const source = sources === null ? i : sources[i];
     const { dist } = await sssp(ctx, s, source, { signal: options?.signal });
@@ -8021,8 +8627,8 @@ async function sweepRoute(ctx, s, scores, sources, levelsPerSubmit, options, tun
     return { scores, iterations: 0, converged: true, precision: "f32", sourcesUsed: 0 };
   }
   const core = ctx.residency.core(s);
-  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM);
-  const scope = algorithmScope(ctx, ALGORITHM, RING_SLOTS);
+  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$3);
+  const scope = algorithmScope(ctx, ALGORITHM$3, RING_SLOTS$2);
   try {
     const wg = ctx.workgroupSize;
     const bytes = 4 * n;
@@ -8071,7 +8677,7 @@ async function sweepRoute(ctx, s, scores, sources, levelsPerSubmit, options, tun
       scope.flush();
       return batch.submit();
     };
-    const setup = new CommandBatch(ctx, `${ALGORITHM}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$3}/setup`);
     recordFill2(setup.pass("fill"), iota, n, 1);
     setup.endPass();
     await submit2(setup).readback;
@@ -8080,7 +8686,7 @@ async function sweepRoute(ctx, s, scores, sources, levelsPerSubmit, options, tun
     for (let batchStart = 0; batchStart < seedCount; batchStart += SOURCES_PER_BATCH) {
       let level = 0;
       for (let first = true; ; first = false) {
-        const batch = new CommandBatch(ctx, `${ALGORITHM}/levels`);
+        const batch = new CommandBatch(ctx, `${ALGORITHM$3}/levels`);
         const pass = batch.pass("closeness");
         if (first) {
           recordFill2(pass, bits, 4 * bitsBase, 0);
@@ -8139,7 +8745,7 @@ async function sweepRoute(ctx, s, scores, sources, levelsPerSubmit, options, tun
         const back = await submitted.readback;
         ctx.assertReady();
         if (options?.signal?.aborted) {
-          throw aborted(ALGORITHM, submitted.id);
+          throw aborted(ALGORITHM$3, submitted.id);
         }
         if (new Uint32Array(back, doneRequest.offset, 1)[0] !== 0) {
           const block = new Uint32Array(back, blockRequest.offset, PER_SOURCE_WORDS);
@@ -8161,8 +8767,8 @@ async function sweepRoute(ctx, s, scores, sources, levelsPerSubmit, options, tun
         if (level > n + 3) {
           throw new WebGpuGraphError(
             "E_VALIDATION",
-            `${ALGORITHM}: the done flag never rose in ${level} levels of the batch at ${batchStart}`,
-            { label: ALGORITHM, message: `the done flag never rose in ${level} levels` }
+            `${ALGORITHM$3}: the done flag never rose in ${level} levels of the batch at ${batchStart}`,
+            { label: ALGORITHM$3, message: `the done flag never rose in ${level} levels` }
           );
         }
       }
@@ -8182,14 +8788,14 @@ function checkSources(s, sources) {
     return null;
   }
   if (s.directed) {
-    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM}: sampled sources need an undirected snapshot`, {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$3}: sampled sources need an undirected snapshot`, {
       feature: "closenessCentrality.directedSources",
       hint: "run the CPU port, which searches the in-arcs"
     });
   }
   for (const v of sources) {
     if (!Number.isInteger(v) || v < 0 || v >= s.nodeCount) {
-      throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM}: a source is not a node index`, {
+      throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$3}: a source is not a node index`, {
         argument: "sources",
         value: v,
         expected: `an integer in [0, ${s.nodeCount})`
@@ -8203,7 +8809,7 @@ async function closenessWithTuning(ctx, s, options, tuning) {
   await assertDeviceComputes(ctx);
   for (const key of ["maxIterations", "tolerance"]) {
     if (options?.[key] !== void 0) {
-      throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM}: ${key} has no meaning for an exact traversal`, {
+      throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$3}: ${key} has no meaning for an exact traversal`, {
         option: key,
         hint: "closeness is an exact traversal; the option has no meaning here"
       });
@@ -8215,7 +8821,7 @@ async function closenessWithTuning(ctx, s, options, tuning) {
   if (!Number.isInteger(levelsPerSubmit) || levelsPerSubmit < 1 || levelsPerSubmit > MAX_LEVELS_PER_SUBMIT) {
     throw new WebGpuGraphError(
       "E_INVALID_ARGUMENT",
-      `${ALGORITHM}: levelsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
+      `${ALGORITHM$3}: levelsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
       {
         argument: "levelsPerSubmit",
         value: levelsPerSubmit,
@@ -8223,16 +8829,16 @@ async function closenessWithTuning(ctx, s, options, tuning) {
       }
     );
   }
-  const scores = checkDest(ALGORITHM, options?.dest, n) ?? new Float32Array(n);
+  const scores = checkDest$2(ALGORITHM$3, options?.dest, n) ?? new Float32Array(n);
   const weighted = options?.weighted ?? s.flags.weighted;
   if (options?.signal?.aborted) {
-    throw aborted(ALGORITHM);
+    throw aborted(ALGORITHM$3);
   }
   if (weighted && s.weights !== null && !s.flags.allWeightsOne) {
     if (!s.flags.nonNegativeWeights) {
       throw new WebGpuGraphError(
         "E_UNSUPPORTED",
-        `${ALGORITHM}: a negative weight has no shortest-path distance to sum`,
+        `${ALGORITHM$3}: a negative weight has no shortest-path distance to sum`,
         {
           feature: "closenessCentrality.negativeWeights",
           hint: "pass weighted: false to ignore the column"
@@ -8240,7 +8846,7 @@ async function closenessWithTuning(ctx, s, options, tuning) {
       );
     }
     if (!s.flags.finiteWeights) {
-      throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM}: a NaN or infinite weight has no shortest path`, {
+      throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$3}: a NaN or infinite weight has no shortest path`, {
         feature: "closenessCentrality.nonFiniteWeights"
       });
     }
@@ -8251,32 +8857,269 @@ async function closenessWithTuning(ctx, s, options, tuning) {
 function closenessCentrality(ctx, s, options) {
   return closenessWithTuning(ctx, s, options, {});
 }
-const U32_MAX = 4294967295;
-async function prepareHistogram(scope) {
-  return prepareHistogramImpl(scope);
-}
-async function prepareHistogramImpl(scope) {
-  const histogram = await scope.pipelines.kernel(kernelSpec("histogram"));
-  const fill = await scope.pipelines.kernel(kernelSpec("fill"));
-  return new HistogramPlannerImpl(scope, histogram, fill);
-}
-async function prepareCountingSort(scope) {
-  const histogram = await prepareHistogramImpl(scope);
-  const scan = await prepareScan(scope);
-  const scatter = await scope.pipelines.kernel(kernelSpec("counting-scatter"));
-  return new CountingSortPlannerImpl(scope, histogram, scan, scatter);
-}
-function checkWords(name, binding, words) {
-  if (binding.size < 4 * words) {
-    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `histogram: ${name} is smaller than 4 x ${words} bytes`, {
-      argument: name,
-      value: binding.size,
-      expected: 4 * words
-    });
+const ALGORITHM$2 = "allPairsShortestPath";
+const DEFAULT_ROUNDS_PER_SUBMIT = Math.floor(APSP_MAX_DISPATCHES_PER_SUBMIT / 3);
+function allPairsCeiling(limits) {
+  const binding = limits.maxStorageBufferBindingSize;
+  const bufferSize = limits.maxBufferSize;
+  const limitName = bufferSize < binding ? "maxBufferSize" : "maxStorageBufferBindingSize";
+  const limit = Math.min(binding, bufferSize);
+  let maxNodes = Math.floor(Math.sqrt(limit / 4));
+  while (4 * maxNodes * maxNodes > limit) {
+    maxNodes -= 1;
+  }
+  while (4 * (maxNodes + 1) * (maxNodes + 1) <= limit) {
+    maxNodes += 1;
   }
+  return { maxNodes, limit, limitName };
 }
-function checkHistogramArguments(keys, count, bins, hist) {
-  if (!Number.isSafeInteger(count) || count < 0 || count > U32_MAX) {
+async function allPairsWithTuning(ctx, s, options, tuning) {
+  ctx.assertReady();
+  const n = s.nodeCount;
+  const roundsPerSubmit = tuning.roundsPerSubmit ?? DEFAULT_ROUNDS_PER_SUBMIT;
+  if (!Number.isInteger(roundsPerSubmit) || roundsPerSubmit < 1 || roundsPerSubmit > DEFAULT_ROUNDS_PER_SUBMIT) {
+    throw new WebGpuGraphError(
+      "E_INVALID_ARGUMENT",
+      `${ALGORITHM$2}: roundsPerSubmit must be an integer in [1, ${DEFAULT_ROUNDS_PER_SUBMIT}]`,
+      {
+        argument: "roundsPerSubmit",
+        value: roundsPerSubmit,
+        expected: `an integer in [1, ${DEFAULT_ROUNDS_PER_SUBMIT}]`
+      }
+    );
+  }
+  const { maxNodes, limit, limitName } = allPairsCeiling(ctx.caps.limits);
+  if (n > maxNodes) {
+    throw new WebGpuGraphError(
+      "E_TOO_LARGE",
+      `${ALGORITHM$2}: ${n} nodes need a ${4 * n * n}-byte distance matrix in one storage binding; this device's ${limitName} of ${limit} bytes holds at most ${maxNodes} nodes -- raise it through GpuContextOptions.limits`,
+      {
+        needed: 4 * n * n,
+        limit,
+        path: "allPairs.matrix",
+        algorithm: ALGORITHM$2,
+        nodes: n,
+        maxNodes,
+        limitName,
+        hint: `raise ${limitName} through GpuContextOptions.limits`
+      }
+    );
+  }
+  const dist = checkDest$2(ALGORITHM$2, options?.dest, n * n) ?? new Float32Array(n * n);
+  const weighted = (options?.weighted ?? s.weights !== null) && s.weights !== null && !s.flags.allWeightsOne;
+  if (weighted && !s.flags.nonNegativeWeights) {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$2}: a negative weight is not supported`, {
+      feature: "allPairs.negativeWeights",
+      hint: "the blocked Floyd-Warshall sweep needs non-negative weights; pass weighted: false for hop counts"
+    });
+  }
+  if (weighted && !s.flags.finiteWeights) {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$2}: a NaN or infinite weight has no shortest path`, {
+      feature: "allPairs.nonFiniteWeights"
+    });
+  }
+  if (options?.signal?.aborted) {
+    throw aborted(ALGORITHM$2);
+  }
+  if (n === 0) {
+    return { dist, n };
+  }
+  await assertDeviceComputes(ctx);
+  const core = ctx.residency.core(s);
+  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$2);
+  const blocks = Math.ceil(n / APSP_TILE);
+  const scope = algorithmScope(ctx, ALGORITHM$2, Math.min(roundsPerSubmit, blocks) + 2);
+  try {
+    const wg = ctx.workgroupSize;
+    const bytes = 4 * n * n;
+    const matrix = bindingOf(scope.scratch(bytes, "dist"), bytes);
+    await ctx.allocator.check();
+    const weightsBinding = weighted ? void 0 : null;
+    const fill = await ctx.pipelines.kernel(kernelSpec("fill"));
+    const init = await ctx.pipelines.kernel(kernelSpec("apsp-init", graphOverrides(core, null, weightsBinding)));
+    const phases = await Promise.all(
+      [0, 1, 2].map((phase) => ctx.pipelines.kernel(kernelSpec("apsp-fw", { PHASE: phase })))
+    );
+    const graph = graphBindings(core, null, weightsBinding);
+    const others = blocks - 1;
+    const phasePlans = [plan2d(1, ctx.caps), plan2d(2 * others, ctx.caps), plan2d(others * others, ctx.caps)];
+    for (let first = 0; first < blocks; first += roundsPerSubmit) {
+      const batch = new CommandBatch(ctx, `${ALGORITHM$2}/sweep`);
+      const pass = batch.pass("apsp");
+      if (first === 0) {
+        const fillParams = scope.params(FILL_PARAMS, { count: n * n, value: F32_INF_BITS, mode: 0, pad0: 0 });
+        fill.dispatch(pass, fill.bind({ dst: matrix, P: fillParams.binding }), plan1d(n * n, wg, ctx.caps), [
+          fillParams.offset
+        ]);
+        const initParams = scope.params(APSP_PARAMS, { n, round: 0, blocks, infBits: F32_INF_BITS });
+        init.dispatch(
+          pass,
+          init.bind({ ...graph, dist: matrix, P: initParams.binding }),
+          plan1d(n, wg, ctx.caps),
+          [initParams.offset]
+        );
+      }
+      const last = Math.min(first + roundsPerSubmit, blocks);
+      for (let round = first; round < last; round++) {
+        const params = scope.params(APSP_PARAMS, { n, round, blocks, infBits: F32_INF_BITS });
+        for (let phase = 0; phase < 3; phase++) {
+          const kernel = phases[phase];
+          kernel.dispatch(pass, kernel.bind({ dist: matrix, P: params.binding }), phasePlans[phase], [
+            params.offset
+          ]);
+        }
+      }
+      batch.endPass();
+      scope.flush();
+      const submitted = batch.submit();
+      await submitted.readback;
+      ctx.assertReady();
+      options?.onProgress?.(last, blocks);
+      if (options?.signal?.aborted) {
+        throw aborted(ALGORITHM$2, submitted.id);
+      }
+    }
+    await ctx.readback.read(matrix.buffer, bytes, dist);
+    ctx.assertReady();
+    return { dist, n };
+  } finally {
+    scope.dispose();
+  }
+}
+function allPairsShortestPath(ctx, s, options) {
+  return allPairsWithTuning(ctx, s, options, {});
+}
+function planGroupRows(lengthBound, threadMax = GROUP_ROW_THREAD_MAX) {
+  if (!Number.isInteger(threadMax) || threadMax < 0 || threadMax > GROUP_ROW_THREAD_LIMIT) {
+    throw new WebGpuGraphError(
+      "E_INVALID_ARGUMENT",
+      `planGroupRows: threadMax must be an integer in [0, ${GROUP_ROW_THREAD_LIMIT}]`,
+      { argument: "threadMax", value: threadMax, expected: `[0, ${GROUP_ROW_THREAD_LIMIT}]` }
+    );
+  }
+  const n = lengthBound.length;
+  const thread = [];
+  const hash = [];
+  for (let v = 0; v < n; v++) {
+    (lengthBound[v] <= threadMax ? thread : hash).push(v);
+  }
+  const words = new Uint32Array(thread.length + 2 * hash.length);
+  words.set(thread, 0);
+  words.set(hash, thread.length);
+  let next = 1;
+  for (let g = 0; g < hash.length; g++) {
+    words[thread.length + hash.length + g] = next;
+    next += 2 * GROUP_HASH_LOAD_FACTOR * lengthBound[hash[g]];
+  }
+  return { words, threadCount: thread.length, hashCount: hash.length, regionWords: next };
+}
+async function prepareGroupByKeyRow(scope) {
+  const kernels = /* @__PURE__ */ new Map();
+  for (const tier of [0, 1]) {
+    for (const weighted of [false, true]) {
+      const spec = kernelSpec("group-by-key-row", { TIER: tier, WEIGHTED: weighted });
+      kernels.set(`${tier}/${weighted}`, await scope.pipelines.kernel(spec));
+    }
+  }
+  return new GroupByKeyPlannerImpl(scope, kernels);
+}
+function checkWords$2(name, binding, words) {
+  if (binding.size < 4 * words) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `groupByKeyRow: ${name} is smaller than 4 x ${words} bytes`, {
+      argument: name,
+      value: binding.size,
+      expected: 4 * words
+    });
+  }
+}
+class GroupByKeyPlannerImpl {
+  /**
+   * Wraps the compiled variants; use prepareGroupByKeyRow().
+   * @param scope - the caller's scope
+   * @param kernels - the variants by `tier/weighted`
+   */
+  constructor(scope, kernels) {
+    this.scope = scope;
+    this.kernels = kernels;
+  }
+  /**
+   * Records the tier dispatches (see the interface).
+   * @param pass - the compute pass
+   * @param r - the record
+   */
+  record(pass, r) {
+    const { threadCount, hashCount } = r.plan;
+    const rows = threadCount + hashCount;
+    checkWords$2("rows", r.rows, rows + hashCount);
+    checkWords$2("hashRegion", r.hashRegion, r.plan.regionWords);
+    checkWords$2("rowPtr", r.rowPtr, rows + 1);
+    if (rows === 0) {
+      return;
+    }
+    const weighted = r.weights !== null;
+    const tiers = [
+      [0, 0, threadCount],
+      [1, threadCount, hashCount]
+    ];
+    for (const [tier, rowsBase, count] of tiers) {
+      if (count === 0) {
+        continue;
+      }
+      const kernel = this.kernels.get(`${tier}/${weighted}`);
+      if (kernel === void 0) {
+        throw new WebGpuGraphError("E_INVALID_ARGUMENT", "groupByKeyRow: no variant was prepared", {
+          argument: "tier",
+          value: tier
+        });
+      }
+      const params = this.scope.params(GROUP_PARAMS, {
+        rowsBase,
+        basesBase: threadCount + hashCount,
+        count,
+        pad0: 0
+      });
+      const bound = kernel.bind({
+        rowPtr: r.rowPtr,
+        colIdx: r.colIdx,
+        weights: r.weights ?? r.colIdx,
+        keyIn: r.keyIn,
+        rows: r.rows,
+        hashRegion: r.hashRegion,
+        bestKey: r.bestKey,
+        bestScore: r.bestScore,
+        P: params.binding
+      });
+      const plan = tier === 0 ? plan1d(count, this.scope.workgroupSize, this.scope.caps) : plan2d(count, this.scope.caps);
+      kernel.dispatch(pass, bound, plan, [params.offset]);
+    }
+  }
+}
+const U32_MAX = 4294967295;
+async function prepareHistogram(scope) {
+  return prepareHistogramImpl(scope);
+}
+async function prepareHistogramImpl(scope) {
+  const histogram = await scope.pipelines.kernel(kernelSpec("histogram"));
+  const fill = await scope.pipelines.kernel(kernelSpec("fill"));
+  return new HistogramPlannerImpl(scope, histogram, fill);
+}
+async function prepareCountingSort(scope) {
+  const histogram = await prepareHistogramImpl(scope);
+  const scan = await prepareScan(scope);
+  const scatter = await scope.pipelines.kernel(kernelSpec("counting-scatter"));
+  return new CountingSortPlannerImpl(scope, histogram, scan, scatter);
+}
+function checkWords$1(name, binding, words) {
+  if (binding.size < 4 * words) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `histogram: ${name} is smaller than 4 x ${words} bytes`, {
+      argument: name,
+      value: binding.size,
+      expected: 4 * words
+    });
+  }
+}
+function checkHistogramArguments(keys, count, bins, hist) {
+  if (!Number.isSafeInteger(count) || count < 0 || count > U32_MAX) {
     throw new WebGpuGraphError("E_INVALID_ARGUMENT", "histogram: count must be a non-negative integer below 2^32", {
       argument: "count",
       value: count
@@ -8288,8 +9131,8 @@ function checkHistogramArguments(keys, count, bins, hist) {
       value: bins
     });
   }
-  checkWords("keys", keys, count);
-  checkWords("hist", hist, bins);
+  checkWords$1("keys", keys, count);
+  checkWords$1("hist", hist, bins);
 }
 class HistogramPlannerImpl {
   /**
@@ -8377,9 +9220,9 @@ class CountingSortPlannerImpl {
    */
   record(pass, keys, count, bins, scratch, outIndex, outStart) {
     checkHistogramArguments(keys, count, bins, scratch.hist);
-    checkWords("cursor", scratch.cursor, bins);
-    checkWords("outIndex", outIndex, count);
-    checkWords("outStart", outStart, bins);
+    checkWords$1("cursor", scratch.cursor, bins);
+    checkWords$1("outIndex", outIndex, count);
+    checkWords$1("outStart", outStart, bins);
     this.histogram.record(pass, keys, count, bins, scratch.hist);
     this.scan.record(pass, scratch.hist, bins, outStart);
     this.histogram.recordZero(pass, scratch.cursor, bins);
@@ -8393,6 +9236,751 @@ class CountingSortPlannerImpl {
     this.dispatches += 1;
   }
 }
+async function prepareCooToCsr(scope) {
+  const histogram = await prepareHistogram(scope);
+  const scan = await prepareScan(scope);
+  const fill = await scope.pipelines.kernel(kernelSpec("fill"));
+  const scatter = /* @__PURE__ */ new Map();
+  for (const sorted of [false, true]) {
+    for (const weighted of [false, true]) {
+      const spec = kernelSpec("coo-scatter", { SORTED_INPUT: sorted, WEIGHTED: weighted });
+      scatter.set(`${sorted}/${weighted}`, await scope.pipelines.kernel(spec));
+    }
+  }
+  return new CooToCsrPlannerImpl(scope, histogram, scan, fill, scatter);
+}
+function checkWords(name, binding, words) {
+  if (binding.size < 4 * words) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `cooToCsr: ${name} is smaller than 4 x ${words} bytes`, {
+      argument: name,
+      value: binding.size,
+      expected: 4 * words
+    });
+  }
+}
+function checkRecord(r) {
+  for (const [name, value] of [
+    ["count", r.count],
+    ["n", r.n]
+  ]) {
+    if (!Number.isSafeInteger(value) || value < 0 || value >= U32_MAX$2) {
+      throw new WebGpuGraphError("E_INVALID_ARGUMENT", `cooToCsr: ${name} must be an integer in [0, 2^32 - 1)`, {
+        argument: name,
+        value
+      });
+    }
+  }
+  if (r.weights === null !== (r.out.weights === null)) {
+    throw new WebGpuGraphError(
+      "E_INVALID_ARGUMENT",
+      "cooToCsr: weights and out.weights must be both present or both null",
+      {
+        argument: "weights",
+        value: r.weights === null ? "null" : "present",
+        expected: r.out.weights === null ? "null" : "present"
+      }
+    );
+  }
+  checkWords("src", r.src, r.count);
+  checkWords("dst", r.dst, r.count);
+  checkWords("out.rowPtr", r.out.rowPtr, r.n + 1);
+  checkWords("out.colIdx", r.out.colIdx, r.count);
+  checkWords("out.flag", r.out.flag, 1);
+  if (r.weights !== null && r.out.weights !== null) {
+    checkWords("weights", r.weights, r.count);
+    checkWords("out.weights", r.out.weights, r.count);
+  }
+}
+class CooToCsrPlannerImpl {
+  /**
+   * Wraps the resolved planners and kernels; use prepareCooToCsr().
+   * @param scope - the caller's scope
+   * @param histogram - the histogram planner
+   * @param scan - the scan planner
+   * @param fill - the `fill` kernel
+   * @param scatter - the `coo-scatter` variants by `sorted/weighted`
+   */
+  constructor(scope, histogram, scan, fill, scatter) {
+    this.scope = scope;
+    this.histogram = histogram;
+    this.scan = scan;
+    this.fill = fill;
+    this.scatter = scatter;
+  }
+  /**
+   * Records one build (see the interface).
+   * @param pass - the compute pass
+   * @param r - the arcs and the output
+   */
+  record(pass, r) {
+    checkRecord(r);
+    const { scope } = this;
+    const wg = scope.workgroupSize;
+    const degreeBytes = 4 * (r.n + 1);
+    const degrees = {
+      buffer: scope.scratch(degreeBytes, "cooToCsr/degrees"),
+      offset: 0,
+      size: degreeBytes,
+      window: null
+    };
+    this.histogram.record(pass, r.src, r.count, r.n + 1, degrees);
+    this.scan.record(pass, degrees, r.n + 1, r.out.rowPtr);
+    let cursors = r.out.flag;
+    if (r.sortedInput) {
+      this.zero(pass, r.out.flag, 1);
+    } else if (r.n > 0) {
+      const bytes = 4 * r.n;
+      cursors = { buffer: scope.scratch(bytes, "cooToCsr/cursors"), offset: 0, size: bytes, window: null };
+      this.zero(pass, cursors, r.n);
+    }
+    if (r.count === 0) {
+      return;
+    }
+    const weighted = r.weights !== null;
+    const kernel = this.scatter.get(`${r.sortedInput}/${weighted}`);
+    if (kernel === void 0) {
+      throw new WebGpuGraphError("E_INVALID_ARGUMENT", "cooToCsr: no scatter variant was prepared", {
+        argument: "sortedInput",
+        value: r.sortedInput
+      });
+    }
+    const outWeight = r.out.weights ?? {
+      buffer: scope.scratch(4, "cooToCsr/weight-dummy"),
+      offset: 0,
+      size: 4,
+      window: null
+    };
+    const params = scope.params(COO_PARAMS, { count: r.count, pad0: 0, pad1: 0, pad2: 0 });
+    const bound = kernel.bind({
+      src: r.src,
+      dst: r.dst,
+      weight: r.weights ?? r.dst,
+      rowPtr: r.out.rowPtr,
+      cursors,
+      colIdx: r.out.colIdx,
+      outWeight,
+      P: params.binding
+    });
+    kernel.dispatch(pass, bound, plan1d(r.count, wg, scope.caps), [params.offset]);
+  }
+  /**
+   * Records a `fill` of `words` zeros.
+   * @param pass - the compute pass
+   * @param dst - the words
+   * @param words - how many (>= 1)
+   */
+  zero(pass, dst, words) {
+    const params = this.scope.params(FILL_PARAMS, { count: words, value: 0, mode: 0, pad0: 0 });
+    const bound = this.fill.bind({ dst, P: params.binding });
+    this.fill.dispatch(pass, bound, plan1d(words, this.scope.workgroupSize, this.scope.caps), [params.offset]);
+  }
+}
+function sortBitsFor(n) {
+  for (const bits of [8, 16, 24]) {
+    if (n < 2 ** bits) {
+      return bits;
+    }
+  }
+  return 32;
+}
+function scratchWords(scope, words, label) {
+  const size = 4 * Math.max(1, words);
+  return { buffer: scope.scratch(size, label), offset: 0, size, window: null };
+}
+function assertBindable(ctx, needed, path, algorithm) {
+  const limit = ctx.caps.limits.maxStorageBufferBindingSize;
+  if (needed > limit) {
+    throw new WebGpuGraphError(
+      "E_TOO_LARGE",
+      `${algorithm}: ${path} needs ${needed} bytes in one binding, above the device limit of ${limit}`,
+      { needed, limit, path, algorithm }
+    );
+  }
+}
+function assertMergeable(n, src, dst, algorithm) {
+  const incident = new Uint32Array(n);
+  for (let e = 0; e < src.length; e++) {
+    if (src[e] !== dst[e]) {
+      incident[src[e]]++;
+      incident[dst[e]]++;
+    }
+  }
+  const heavy = /* @__PURE__ */ new Map();
+  for (let v = 0; v < n; v++) {
+    if (incident[v] > PARALLEL_MERGE_LIMIT) {
+      heavy.set(v, heavy.size);
+    }
+  }
+  if (heavy.size < 2) {
+    return;
+  }
+  const pairs = new Uint32Array(heavy.size * heavy.size);
+  for (let e = 0; e < src.length; e++) {
+    const a = heavy.get(src[e]);
+    const b = heavy.get(dst[e]);
+    if (a === void 0 || b === void 0 || a === b) {
+      continue;
+    }
+    const key = Math.min(a, b) * heavy.size + Math.max(a, b);
+    if (++pairs[key] > PARALLEL_MERGE_LIMIT) {
+      throw new WebGpuGraphError(
+        "E_UNSUPPORTED",
+        `${algorithm}: nodes ${src[e]} and ${dst[e]} are joined by more than ${PARALLEL_MERGE_LIMIT} parallel edges, more than one weighted merge sums`,
+        { feature: `${algorithm}.parallelEdges`, hint: "run it unweighted, or merge the parallel edges first" }
+      );
+    }
+  }
+}
+function assertBuildSorted(bytes, build, label) {
+  if (new Uint32Array(bytes, build.flag.offset, 1)[0] !== 0) {
+    throw new WebGpuGraphError("E_VALIDATION", `${label}: the simple graph's arcs reached cooToCsr out of order`, {
+      label: `${label}/simple-graph`,
+      message: "the sorted-input precondition of cooToCsr failed on the device"
+    });
+  }
+}
+async function buildSimpleSymmetric(ctx, s, scope, withWeights, label) {
+  const n = s.nodeCount;
+  const wg = ctx.workgroupSize;
+  const cooToCsr = await prepareCooToCsr(scope);
+  const flag = scratchWords(scope, 1, "simple/flag");
+  const rowPtr = scratchWords(scope, n + 1, "simple/rowPtr");
+  const { edgeCount } = s;
+  const list = s.edgeList();
+  let selfLoops = 0;
+  for (let e = 0; e < edgeCount; e++) {
+    if (list.src[e] === list.dst[e]) {
+      selfLoops++;
+    }
+  }
+  const valid = 2 * (edgeCount - selfLoops);
+  const empty2 = () => {
+    const batch = new CommandBatch(ctx, `${label}/simple-graph`);
+    cooToCsr.record(batch.pass("simple-graph"), {
+      src: flag,
+      dst: flag,
+      weights: null,
+      count: 0,
+      n,
+      sortedInput: true,
+      out: { rowPtr, colIdx: flag, weights: null, flag }
+    });
+    batch.endPass();
+    const graph2 = { n, arcCount: 0, rowPtr, colIdx: null, weights: null, src: null };
+    return { graph: graph2, batch, flag: batch.readback(flag.buffer, 0, 4) };
+  };
+  if (valid === 0) {
+    return empty2();
+  }
+  const arcs = 2 * edgeCount;
+  const tableBytes = Math.max(4, radixHistBytes(arcs, wg));
+  assertBindable(ctx, Math.max(4 * (arcs + 1), tableBytes), "the simple graph's arc arrays", label);
+  if (withWeights) {
+    assertMergeable(n, list.src, list.dst, label);
+  }
+  ctx.residency.core(s, ["rowPtr"]);
+  const edges = ctx.residency.view(s, "edgeList");
+  const edgeWeights = edges.bindings.weights ?? null;
+  const emitPlan = plan1d(arcs, wg, ctx.caps);
+  const emit = /* @__PURE__ */ new Map();
+  for (const indexed of [false, true]) {
+    const spec = kernelSpec("coo-emit", { INDEXED: indexed, WEIGHTED: edgeWeights !== null });
+    emit.set(indexed, await ctx.pipelines.kernel(spec));
+  }
+  const fill = await ctx.pipelines.kernel(kernelSpec("fill"));
+  const runFlags = await ctx.pipelines.kernel(kernelSpec("run-flags"));
+  const sort = await prepareRadixSort(scope);
+  const scan = await prepareScan(scope);
+  const compact = await prepareCompact(scope);
+  const aSrc = scratchWords(scope, arcs, "simple/aSrc");
+  const aDst = scratchWords(scope, arcs, "simple/aDst");
+  const aW = scratchWords(scope, arcs, "simple/aW");
+  const vals = scratchWords(scope, arcs, "simple/vals");
+  const sKeys = scratchWords(scope, arcs, "simple/sortKeys");
+  const sVals = scratchWords(scope, arcs, "simple/sortVals");
+  const hist = {
+    buffer: scope.scratch(tableBytes, "simple/hist"),
+    offset: 0,
+    size: tableBytes,
+    window: null
+  };
+  const offsets = {
+    buffer: scope.scratch(tableBytes, "simple/offsets"),
+    offset: 0,
+    size: tableBytes,
+    window: null
+  };
+  const sortedSrc = scratchWords(scope, arcs, "simple/sortedSrc");
+  const sortedDst = scratchWords(scope, arcs, "simple/sortedDst");
+  const sortedW = scratchWords(scope, arcs, "simple/sortedW");
+  const flags = scratchWords(scope, arcs, "simple/flags");
+  const runIndex = scratchWords(scope, arcs, "simple/runIndex");
+  const dummy = scratchWords(scope, 1, "simple/dummy");
+  await ctx.allocator.check();
+  const recordEmit = (pass3, order, out) => {
+    const kernel = emit.get(order !== null);
+    if (kernel === void 0) {
+      throw new WebGpuGraphError("E_INVALID_ARGUMENT", "buildSimpleSymmetric: no coo-emit variant", {
+        argument: "order",
+        value: order === null ? "null" : "present"
+      });
+    }
+    const params2 = scope.params(COO_PARAMS, { count: arcs, pad0: 0, pad1: 0, pad2: 0 });
+    const bound = kernel.bind({
+      edgeSrc: edges.bindings.src,
+      edgeDst: edges.bindings.dst,
+      edgeWeight: edgeWeights ?? edges.bindings.src,
+      order: order ?? dummy,
+      outSrc: out[0],
+      outDst: out[1],
+      outWeight: out[2],
+      P: params2.binding
+    });
+    kernel.dispatch(pass3, bound, emitPlan, [params2.offset]);
+  };
+  const recordIota = (pass3, dst, words) => {
+    const params2 = scope.params(FILL_PARAMS, { count: words, value: 0, mode: 1, pad0: 0 });
+    fill.dispatch(pass3, fill.bind({ dst, P: params2.binding }), plan1d(words, wg, ctx.caps), [params2.offset]);
+  };
+  const bits = sortBitsFor(n);
+  const first = new CommandBatch(ctx, `${label}/simple-sort`);
+  const pass = first.pass("simple-sort");
+  recordEmit(pass, null, [aSrc, aDst, aW]);
+  recordIota(pass, vals, arcs);
+  const byTarget = sort.record(pass, aDst, vals, arcs, bits, { keys: sKeys, vals: sVals, hist, offsets });
+  recordEmit(pass, byTarget.vals, [aSrc, aDst, aW]);
+  const free = byTarget.vals.buffer === vals.buffer ? sVals : vals;
+  const bySource = sort.record(pass, aSrc, byTarget.vals, arcs, bits, {
+    keys: byTarget.keys.buffer === aDst.buffer ? sKeys : aDst,
+    vals: free,
+    hist,
+    offsets
+  });
+  recordEmit(pass, bySource.vals, [sortedSrc, sortedDst, sortedW]);
+  const params = scope.params(COO_PARAMS, { count: arcs, pad0: 0, pad1: 0, pad2: 0 });
+  runFlags.dispatch(pass, runFlags.bind({ keysA: sortedSrc, keysB: sortedDst, flags, P: params.binding }), emitPlan, [
+    params.offset
+  ]);
+  const total = scan.record(pass, flags, arcs, runIndex);
+  first.endPass();
+  const totalRequest = first.readback(total.binding.buffer, total.binding.offset + 4 * total.index, 4);
+  scope.flush();
+  const back = await first.submit().readback;
+  ctx.assertReady();
+  const unique = new Uint32Array(back, totalRequest.offset, 1)[0];
+  if (unique === 0 || unique > valid) {
+    throw new WebGpuGraphError("E_VALIDATION", `${label}: ${unique} distinct arcs from ${valid} valid ones`, {
+      label: `${label}/simple-graph`,
+      message: "the run count of the simple graph build is outside [1, valid arcs]"
+    });
+  }
+  const uSrc = scratchWords(scope, arcs, "simple/src");
+  const uDst = scratchWords(scope, arcs, "simple/dst");
+  const runStart = scratchWords(scope, arcs + 1, "simple/runStart");
+  const counts = scratchWords(scope, 1, "simple/count");
+  const colIdx = scratchWords(scope, unique, "simple/colIdx");
+  const weights = withWeights ? scratchWords(scope, unique, "simple/weights") : null;
+  const merged = withWeights ? scratchWords(scope, unique, "simple/merged") : null;
+  ctx.device.queue.writeBuffer(runStart.buffer, 4 * unique, Uint32Array.of(valid));
+  const reduce = merged === null ? null : await prepareSegmentedReduce(scope, runCore(runStart, unique, sortedDst, sortedW, valid), {
+    op: "sum",
+    valueSnippet: "v = weight;",
+    tiers: null
+  });
+  const second = new CommandBatch(ctx, `${label}/simple-graph`);
+  const pass2 = second.pass("simple-graph");
+  const positions = vals;
+  recordIota(pass2, positions, arcs);
+  for (const [queue, out] of [
+    [sortedSrc, uSrc],
+    [sortedDst, uDst],
+    [positions, runStart]
+  ]) {
+    compact.record(pass2, { queue, flags, count: arcs, out, outCount: counts, outIndex: 0 });
+  }
+  if (reduce !== null && merged !== null) {
+    reduce.record(pass2, runCore(runStart, unique, sortedDst, sortedW, valid), merged);
+  }
+  cooToCsr.record(pass2, {
+    src: uSrc,
+    dst: uDst,
+    weights: merged,
+    count: unique,
+    n,
+    sortedInput: true,
+    out: { rowPtr, colIdx, weights, flag }
+  });
+  second.endPass();
+  const graph = { n, arcCount: unique, rowPtr, colIdx, weights, src: uSrc };
+  return { graph, batch: second, flag: second.readback(flag.buffer, 0, 4) };
+}
+function runCore(runStart, runs, sortedDst, sortedW, valid) {
+  return {
+    serial: -1,
+    plan: "perArray",
+    rowPtr: { ...runStart, size: 4 * (runs + 1) },
+    colIdx: { ...sortedDst, size: 4 * valid },
+    weights: { ...sortedW, size: 4 * valid },
+    arcToEdge: null,
+    edgeToArc: null,
+    windows: null,
+    arcBuffers: null,
+    hasWeights: true
+  };
+}
+const ALGORITHM$1 = "labelPropagation";
+const DEFAULT_MAX_ITERATIONS = 100;
+const RING_SLOTS$1 = 1024;
+function checkDest$1(dest, n) {
+  if (dest === void 0) {
+    return null;
+  }
+  if (dest instanceof Uint32Array && dest.length === n && dest.buffer instanceof ArrayBuffer) {
+    return dest;
+  }
+  throw new WebGpuGraphError(
+    "E_INVALID_ARGUMENT",
+    `${ALGORITHM$1}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
+    {
+      argument: "dest",
+      value: `${dest.constructor.name}(${dest.length})`,
+      expected: `Uint32Array(${n}) over an ArrayBuffer`
+    }
+  );
+}
+function maxIterationsOf(value) {
+  if (value === void 0) {
+    return DEFAULT_MAX_ITERATIONS;
+  }
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$1}: maxIterations must be a non-negative integer`, {
+      argument: "maxIterations",
+      value,
+      expected: "a non-negative integer"
+    });
+  }
+  return value;
+}
+function neighbourBound(s) {
+  const out = s.outDegree();
+  if (!s.directed) {
+    return out;
+  }
+  const inDegree = s.inDegree();
+  const bound = new Uint32Array(s.nodeCount);
+  for (let v = 0; v < bound.length; v++) {
+    bound[v] = out[v] + inDegree[v];
+  }
+  return bound;
+}
+function resultOf(raw, dest) {
+  const n = raw.length;
+  for (let v = 0; v < n; v++) {
+    if (raw[v] >= n) {
+      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$1}: labels[${v}] = ${raw[v]} is not a node index`, {
+        label: `${ALGORITHM$1}/labels`,
+        message: `the device produced a label outside [0, ${n})`
+      });
+    }
+  }
+  const { labels, count } = renumberPartition(raw, dest ?? void 0);
+  return labelResult(labels, count);
+}
+function identityResult(n, dest) {
+  const labels = dest ?? new Uint32Array(n);
+  for (let v = 0; v < n; v++) {
+    labels[v] = v;
+  }
+  return labelResult(labels, n);
+}
+async function labelPropagation(ctx, s, options) {
+  ctx.assertReady();
+  await assertDeviceComputes(ctx);
+  const n = s.nodeCount;
+  const dest = checkDest$1(options?.dest, n);
+  const maxIterations = maxIterationsOf(options?.maxIterations);
+  const weighted = options?.weighted !== false;
+  if (options?.signal?.aborted) {
+    throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$1}: the signal was aborted before any work started`, {});
+  }
+  if (n === 0 || s.edgeCount === 0 || maxIterations === 0) {
+    options?.onProgress?.(1, 1);
+    return identityResult(n, dest);
+  }
+  const plan = planGroupRows(neighbourBound(s));
+  assertBindable(ctx, 4 * plan.regionWords, "the group-by hash region", ALGORITHM$1);
+  const scope = algorithmScope(ctx, ALGORITHM$1, RING_SLOTS$1);
+  try {
+    const build = await buildSimpleSymmetric(ctx, s, scope, weighted, ALGORITHM$1);
+    const { graph } = build;
+    if (graph.colIdx === null) {
+      scope.flush();
+      const bytes = await build.batch.submit().readback;
+      ctx.assertReady();
+      assertBuildSorted(bytes, build, ALGORITHM$1);
+      options?.onProgress?.(1, 1);
+      return identityResult(n, dest);
+    }
+    const wg = ctx.workgroupSize;
+    const words = (count, label) => {
+      const size = 4 * Math.max(1, count);
+      return { buffer: scope.scratch(size, label), offset: 0, size, window: null };
+    };
+    const rows = words(plan.words.length, "rows");
+    const region = words(plan.regionWords, "hashRegion");
+    const labelsA = words(n, "labelsA");
+    const labelsB = words(n, "labelsB");
+    const bestKey = words(n, "bestKey");
+    const bestScore = words(n, "bestScore");
+    const counters = words(LABEL_PROP_PASSES_PER_SUBMIT, "counters");
+    await ctx.allocator.check();
+    const { queue } = ctx.device;
+    queue.writeBuffer(rows.buffer, 0, plan.words);
+    queue.writeBuffer(region.buffer, 0, new Uint32Array(1));
+    const groupBy = await prepareGroupByKeyRow(scope);
+    const step = await ctx.pipelines.kernel(kernelSpec("lpa-step"));
+    const fill = await ctx.pipelines.kernel(kernelSpec("fill"));
+    const nodePlan = plan1d(n, wg, ctx.caps);
+    let { batch } = build;
+    let first = true;
+    let cur = labelsA;
+    let next = labelsB;
+    let done = 0;
+    let previousLast = -1;
+    for (; ; ) {
+      const k = Math.min(LABEL_PROP_PASSES_PER_SUBMIT, maxIterations - done);
+      queue.writeBuffer(counters.buffer, 0, new Uint32Array(k));
+      const pass = batch.pass("passes");
+      if (first) {
+        const iota = scope.params(FILL_PARAMS, { count: n, value: 0, mode: 1, pad0: 0 });
+        fill.dispatch(pass, fill.bind({ dst: labelsA, P: iota.binding }), nodePlan, [iota.offset]);
+      }
+      for (let i = 0; i < k; i++) {
+        groupBy.record(pass, {
+          rowPtr: graph.rowPtr,
+          colIdx: graph.colIdx,
+          weights: weighted ? graph.weights : null,
+          keyIn: cur,
+          plan,
+          rows,
+          hashRegion: region,
+          bestKey,
+          bestScore
+        });
+        const params = scope.params(LPA_PARAMS, {
+          n,
+          direction: (done + i) % 2,
+          counterIndex: i,
+          pad0: 0
+        });
+        step.dispatch(
+          pass,
+          step.bind({ labelsIn: cur, bestKey, labelsOut: next, counters, P: params.binding }),
+          nodePlan,
+          [params.offset]
+        );
+        [cur, next] = [next, cur];
+      }
+      batch.endPass();
+      const movesRequest = batch.readback(counters.buffer, 0, 4 * k);
+      const exhaustedRequest = batch.readback(region.buffer, 0, 4);
+      scope.flush();
+      const submitted = batch.submit();
+      const bytes = await submitted.readback;
+      ctx.assertReady();
+      if (first) {
+        assertBuildSorted(bytes, build, ALGORITHM$1);
+        first = false;
+      }
+      if (new Uint32Array(bytes, exhaustedRequest.offset, 1)[0] !== 0) {
+        throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$1}: a hash probe exhausted its bound`, {
+          label: `${ALGORITHM$1}/group-by-key`,
+          message: "a compare-exchange loop of the workgroup tier ran out of steps"
+        });
+      }
+      const moves = new Uint32Array(bytes, movesRequest.offset, k);
+      done += k;
+      const lastTwo = k >= 2 ? moves[k - 2] + moves[k - 1] : previousLast + moves[0];
+      previousLast = moves[k - 1];
+      if (options?.signal?.aborted) {
+        throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$1}: the signal was aborted`, {
+          batchId: submitted.id
+        });
+      }
+      options?.onProgress?.(done, maxIterations);
+      if (lastTwo === 0 || done >= maxIterations) {
+        break;
+      }
+      batch = new CommandBatch(ctx, `${ALGORITHM$1}/passes`);
+    }
+    const raw = new Uint32Array(n);
+    await ctx.readback.read(cur.buffer, 4 * n, raw);
+    ctx.assertReady();
+    return resultOf(raw, dest);
+  } finally {
+    scope.dispose();
+  }
+}
+const ALGORITHM = "triangleCount";
+const RING_SLOTS = 1024;
+function checkDest(dest, n) {
+  if (dest === void 0) {
+    return null;
+  }
+  if (dest instanceof Uint32Array && dest.length === n && dest.buffer instanceof ArrayBuffer) {
+    return dest;
+  }
+  throw new WebGpuGraphError(
+    "E_INVALID_ARGUMENT",
+    `${ALGORITHM}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
+    {
+      argument: "dest",
+      value: `${dest.constructor.name}(${dest.length})`,
+      expected: `Uint32Array(${n}) over an ArrayBuffer`
+    }
+  );
+}
+function epilogue(perNode, rowPtr) {
+  const n = perNode.length;
+  const coefficient = new Float32Array(n);
+  let sum = 0;
+  let triples = 0;
+  for (let v = 0; v < n; v++) {
+    const d = rowPtr[v + 1] - rowPtr[v];
+    const t = perNode[v];
+    sum += t;
+    if (d >= 2) {
+      const pairs = d * (d - 1) / 2;
+      triples += pairs;
+      coefficient[v] = t / pairs;
+    }
+  }
+  return { perNode, total: sum / 3, coefficient, transitivity: triples === 0 ? 0 : sum / triples };
+}
+async function triangleCount(ctx, s, options) {
+  return await triangleCountWithSearch(ctx, s, 0, options);
+}
+async function triangleCountWithSearch(ctx, s, search, options) {
+  ctx.assertReady();
+  await assertDeviceComputes(ctx);
+  const n = s.nodeCount;
+  const dest = checkDest(options?.dest, n);
+  if (options?.signal?.aborted) {
+    throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM}: the signal was aborted before any work started`, {});
+  }
+  if (n === 0) {
+    options?.onProgress?.(1, 1);
+    return epilogue(dest ?? new Uint32Array(0), new Uint32Array(1));
+  }
+  const scope = algorithmScope(ctx, ALGORITHM, RING_SLOTS);
+  try {
+    const build = await buildSimpleSymmetric(ctx, s, scope, false, ALGORITHM);
+    const { graph, batch } = build;
+    const wg = ctx.workgroupSize;
+    const countsBytes = 4 * n;
+    const counts = {
+      buffer: scope.scratch(countsBytes, "counts"),
+      offset: 0,
+      size: countsBytes,
+      window: null
+    };
+    const fill = await ctx.pipelines.kernel(kernelSpec("fill"));
+    const pass = batch.pass("triangles");
+    let orientedFlag = null;
+    const zero = scope.params(FILL_PARAMS, { count: n, value: 0, mode: 0, pad0: 0 });
+    fill.dispatch(pass, fill.bind({ dst: counts, P: zero.binding }), plan1d(n, wg, ctx.caps), [zero.offset]);
+    if (graph.arcCount > 0 && graph.colIdx !== null && graph.src !== null) {
+      const oriented = graph.arcCount / 2;
+      const orient = await ctx.pipelines.kernel(kernelSpec("orient-flags"));
+      const intersect = await ctx.pipelines.kernel(kernelSpec("tri-intersect", { SEARCH: search }));
+      const compact = await prepareCompact(scope);
+      const cooToCsr = await prepareCooToCsr(scope);
+      const words = (count, label) => ({
+        buffer: scope.scratch(4 * count, label),
+        offset: 0,
+        size: 4 * count,
+        window: null
+      });
+      const flags = words(graph.arcCount, "orient/flags");
+      const oSrc = words(graph.arcCount, "orient/src");
+      const oDst = words(graph.arcCount, "orient/dst");
+      const oRowPtr = words(n + 1, "orient/rowPtr");
+      const oColIdx = words(oriented, "orient/colIdx");
+      const scratch = words(1, "orient/count");
+      const oFlag = words(1, "orient/flag");
+      const arcPlan = plan1d(graph.arcCount, wg, ctx.caps);
+      const p1 = scope.params(COO_PARAMS, { count: graph.arcCount, pad0: 0, pad1: 0, pad2: 0 });
+      orient.dispatch(
+        pass,
+        orient.bind({ rowPtr: graph.rowPtr, colIdx: graph.colIdx, src: graph.src, flags, P: p1.binding }),
+        arcPlan,
+        [p1.offset]
+      );
+      compact.record(pass, {
+        queue: graph.src,
+        flags,
+        count: graph.arcCount,
+        out: oSrc,
+        outCount: scratch,
+        outIndex: 0
+      });
+      compact.record(pass, {
+        queue: graph.colIdx,
+        flags,
+        count: graph.arcCount,
+        out: oDst,
+        outCount: scratch,
+        outIndex: 0
+      });
+      cooToCsr.record(pass, {
+        src: oSrc,
+        dst: oDst,
+        weights: null,
+        count: oriented,
+        n,
+        sortedInput: true,
+        out: { rowPtr: oRowPtr, colIdx: oColIdx, weights: null, flag: oFlag }
+      });
+      orientedFlag = oFlag;
+      const p2 = scope.params(COO_PARAMS, { count: oriented, pad0: 0, pad1: 0, pad2: 0 });
+      intersect.dispatch(
+        pass,
+        intersect.bind({ rowPtr: oRowPtr, colIdx: oColIdx, src: oSrc, counts, P: p2.binding }),
+        plan1d(oriented, wg, ctx.caps),
+        [p2.offset]
+      );
+    }
+    batch.endPass();
+    const countsRequest = batch.readback(counts.buffer, 0, countsBytes);
+    const rowsRequest = batch.readback(graph.rowPtr.buffer, 0, 4 * (n + 1));
+    const orientedRequest = orientedFlag === null ? null : batch.readback(orientedFlag.buffer, 0, 4);
+    scope.flush();
+    const submitted = batch.submit();
+    const bytes = await submitted.readback;
+    ctx.assertReady();
+    if (options?.signal?.aborted) {
+      throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM}: the signal was aborted`, { batchId: submitted.id });
+    }
+    assertBuildSorted(bytes, build, ALGORITHM);
+    if (orientedRequest !== null && new Uint32Array(bytes, orientedRequest.offset, 1)[0] !== 0) {
+      throw new WebGpuGraphError(
+        "E_VALIDATION",
+        `${ALGORITHM}: the oriented arcs reached cooToCsr out of order`,
+        {
+          label: `${ALGORITHM}/oriented`,
+          message: "the sorted-input precondition of cooToCsr failed on the device"
+        }
+      );
+    }
+    const perNode = dest ?? new Uint32Array(n);
+    perNode.set(new Uint32Array(bytes, countsRequest.offset, n));
+    const rowPtr = new Uint32Array(bytes, rowsRequest.offset, n + 1);
+    options?.onProgress?.(1, 1);
+    return epilogue(perNode, rowPtr);
+  } finally {
+    scope.dispose();
+  }
+}
 function nextPow2(x) {
   let p = 1;
   while (p < x) {
@@ -13451,6 +15039,53 @@ function createAccelerator(ctx, options) {
       ctx.assertReady();
       return await closenessCentrality(ctx, gs, o);
     },
+    /**
+     * All-pairs shortest paths on the device (design 8.7): blocked Floyd-Warshall, `E_TOO_LARGE` above the device's
+     * storage-binding ceiling. The seam passes `SsspOptions`; neither of its keys has an all-pairs meaning, so a
+     * defined `cutoff` (it would change what `+Infinity` means) or `weights` (a per-arc override is a different
+     * matrix from the snapshot's resident column) is `E_UNSUPPORTED { option }`, never silently dropped.
+     * @param gs - the snapshot
+     * @param o - the seam's `SsspOptions`; both keys refused when defined
+     * @returns the row-major `n x n` distances and `n` (spec 3.3 line 835)
+     */
+    async allPairsShortestPath(gs, o) {
+      ctx.assertReady();
+      for (const key of ["cutoff", "weights"]) {
+        if (o?.[key] !== void 0) {
+          throw new WebGpuGraphError("E_UNSUPPORTED", `allPairsShortestPath: ${key} is not supported`, {
+            option: key,
+            hint: "all-pairs shortest paths runs over the snapshot's own weights with no cutoff"
+          });
+        }
+      }
+      return await allPairsShortestPath(ctx, gs);
+    },
+    /**
+     * Triangle counting with the clustering coefficient and the transitivity (design 8.5; P11).
+     * @param gs - the snapshot
+     * @returns perNode, total, coefficient and transitivity
+     */
+    async triangleCount(gs) {
+      ctx.assertReady();
+      return await triangleCount(ctx, gs);
+    },
+    /**
+     * Label propagation (design 8.6; P11): `maxIterations` and `weighted` are honoured, `tolerance` is refused when
+     * defined (a label propagation stops at a fixed point, not below a tolerance).
+     * @param gs - the snapshot
+     * @param o - the seam's placeholder `HitsOptionsLike`
+     * @returns the labels dense in first-seen order, the community count and groups()
+     */
+    async labelPropagation(gs, o) {
+      ctx.assertReady();
+      if (o?.tolerance !== void 0) {
+        throw new WebGpuGraphError("E_UNSUPPORTED", "labelPropagation: tolerance has no meaning here", {
+          option: "tolerance",
+          hint: "label propagation stops at a fixed point or after maxIterations passes"
+        });
+      }
+      return await labelPropagation(ctx, gs, { maxIterations: o?.maxIterations, weighted: o?.weighted });
+    },
     /**
      * Destroys every device buffer recorded for the snapshot (spec 4.5); delegates to ctx.release.
      * @param s - the snapshot the app is done with
@@ -13560,7 +15195,7 @@ async function calibrateLayout(ctx, options) {
   };
 }
 export {
-  Q as ARC_WINDOW_ALIGN,
+  a0 as ARC_WINDOW_ALIGN,
   EXACT_MAX_NODES,
   FA2_DEFAULTS,
   FR_DEFAULTS,
@@ -13568,11 +15203,12 @@ export {
   LAYOUT_TUNING_DEFAULTS,
   MAX_1D_ITEMS,
   MAX_WORKGROUPS_PER_DIM,
-  V as PASSTHROUGH_FORMAT_CODES,
+  a1 as PASSTHROUGH_FORMAT_CODES,
   SE_DEFAULTS,
-  X as STORAGE_ALIGN,
-  Y as WORKGROUP_SIZE,
+  a2 as STORAGE_ALIGN,
+  a3 as WORKGROUP_SIZE,
   WebGpuGraphError,
+  allPairsShortestPath,
   bellmanFord,
   betweennessCentrality,
   breadthFirstSearch,
@@ -13588,13 +15224,15 @@ export {
   eigenvectorCentrality,
   hasErrorCode,
   hits,
-  Z as isSoftwareAdapter,
+  a4 as isSoftwareAdapter,
   isWebGpuGraphError,
   katzCentrality,
+  labelPropagation,
   pageRank,
   personalizedPageRank,
   seedPositions,
   sssp,
+  triangleCount,
   verifyDevice
 };
 //# sourceMappingURL=webgpu-graph-algorithms.js.map