@graphty/webgpu-graph-algorithms 0.6.14 → 0.6.16

package/dist/webgpu-graph-algorithms.js

@@ -1,6 +1,6 @@
-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 GRID_COARSEST_SIDE, j as GRID_MIN_SIDE, k as GRID_SORT_BITS, l as FA2_DEFAULTS, m as MAX_ITERATIONS_PER_STEP, n as MAX_1D_ITEMS, o as hasErrorCode, p as FA2_FLAG_FIRST, P as PARTIAL_BYTES, E as EXACT_TILES_PER_PASS, I as INDIRECT_ARGS_STRIDE, q as GRID_HUB_CELL, L as LAYOUT_TUNING_DEFAULTS, r as EXACT_MAX_NODES, s as SETTLE_FLOOR_UNBOUNDED, T as TRACE_RECORD_BYTES, t as GRID_BBOX_MARGIN, u as GRID_EXTENT_FLOOR, v as FR_ADAPTIVE_MAX_ITERATIONS, w as FR_START_TEMPERATURE, x as FA2_FLAG_ADAPTIVE, y as SETTLE_FLOOR_FRACTION, z as FR_REHEAT_FRACTION, A as FR_DEFAULTS, C as SE_DEFAULTS, D as SETTLE_FLOOR_REFERENCE_NODES, H as SE_SCALE_REFERENCE_NODES } from "./chunks/context-Bi6AhScG.js";
-import { J, G, K, N, O, Q } from "./chunks/context-Bi6AhScG.js";
-import { renumberPartition, INVALID_INDEX, makeMask, maskTest, expandEdges, fromEdgeArrays } from "@graphty/graph-format";
+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 {
   /**
    * Creates the ring buffer (`slots x UNIFORM_SLOT_BYTES` bytes, UNIFORM | COPY_DST) through the allocator.
@@ -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,364 @@ 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 */
+  `
+@compute @workgroup_size(WG)
+fn bc_backward(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    for (var i = linear_id(wid, lid.x); i < P.count; i = i + P.stride) {
+        let t = S[P.start + i];                                      // s * n + w
+        let w = t % P.n;
+        let base = t - w;                                            // s * n
+        let succ = depthK[t] + 1u;
+        let sw = f32(sigmaK[t]);
+        var acc = 0.0;
+        for (var a = rowPtr[w]; a < rowPtr[w + 1u]; a = a + 1u) {
+            let v = base + colIdx[a];
+            if (depthK[v] == succ) {                                 // v is a successor of w for source s
+                acc = acc + (sw / f32(sigmaK[v])) * (1.0 + deltaK[v]);
+            }
+        }
+        deltaK[t] = acc;                                             // written once per (w, s)
+    }
+}
+`
+);
+const bcEdgeGatherWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn bc_edge_gather(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    for (var a = linear_id(wid, lid.x); a < P.count; a = a + P.stride) {
+        var lo = 0u;                                                 // the row w with rowPtr[w] <= a < rowPtr[w + 1]
+        var hi = P.n;
+        loop {
+            if (lo >= hi) { break; }
+            let mid = (lo + hi) / 2u;
+            if (rowPtr[mid + 1u] <= a) { lo = mid + 1u; } else { hi = mid; }
+        }
+        let w = lo;
+        let nbr = colIdx[a];
+        var acc = arcScores[a];
+        for (var s = 0u; s < P.k; s = s + 1u) {
+            let base = s * P.n;
+            let dw = depthK[base + w];
+            if (dw != INVALID_INDEX && depthK[base + nbr] == dw + 1u) {   // (w, nbr) is on a shortest path from s
+                acc = acc + (f32(sigmaK[base + w]) / f32(sigmaK[base + nbr])) * (1.0 + deltaK[base + nbr]);
+            }
+        }
+        arcScores[a] = acc;
+    }
+}
+`
+);
+const bcFinalizeWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn bc_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
+    if (lid.x != 0u) { return; }                                     // one lane; no barrier follows (3.5 rule 1)
+    if (P.role == 1u) {                                              // the seed of a batch
+        for (var i = 0u; i < P.k; i = i + 1u) {
+            let t = S[i];
+            depthK[t] = 0u;                                          // the source is at depth 0
+            sigmaK[t] = 1u;                                          // with one shortest path, itself
+        }
+        ends[0] = 0u;
+        atomicStore(&counters[26], P.k);                             // stackTop: the seeds are the log's first k entries
+        atomicStore(&counters[27], 0u);                              // sigmaOverflow
+        atomicStore(&counters[11], U32_MAX);                         // level: the first boundary brings it to 0
+        atomicStore(&counters[15], 0u);                              // done
+        return;
+    }
+    if (atomicLoad(&counters[15]) != 0u) { return; }                 // done: a no-op level the host recorded past the end
+    let level = atomicLoad(&counters[11]) + 1u;
+    let top = atomicLoad(&counters[26]);
+    ends[level + 1u] = top;                                          // the level's entries end where the log ends now
+    let count = top - ends[level];
+    atomicStore(&counters[0], count);                                // frontierCount (the inspect seam reads it)
+    atomicStore(&counters[11], level);
+    atomicStore(&counters[15], select(0u, 1u, count == 0u));         // an empty level ends the batch
+}
+`
+);
+const bcForwardWgsl = (
+  /* wgsl */
+  `
+var<workgroup> sh: array<u32, WG>;                // the block's degrees, then their inclusive scan
+var<workgroup> rowStart: array<u32, WG>;          // the first arc of each entry's row
+var<workgroup> entryOf: array<u32, WG>;           // each entry, s * n + u
+var<workgroup> wstart: u32;                       // the level's first log index
+var<workgroup> wcount: u32;                       // the level's entry count
+var<workgroup> wwon: atomic<u32>;                 // the strip's winners
+var<workgroup> wbase: u32;                        // where the strip's winners go in the log
+
+@compute @workgroup_size(WG)
+fn bc_forward(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let level = atomicLoad(&counters[11]);
+    if (lid.x == 0u) {
+        let lo = ends[level];
+        wstart = lo;
+        wcount = ends[level + 1u] - lo;
+    }
+    let start = workgroupUniformLoad(&wstart);
+    let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers
+    let next = level + 1u;
+    for (var b0 = group_id(wid) * WG; b0 < count; b0 = b0 + P.stride) {   // grid-stride over blocks of WG entries
+        let i = b0 + lid.x;
+        var deg = 0u;
+        var first = 0u;
+        var entry = 0u;
+        if (i < count) {                                             // guarded loads into locals (3.5 rule 1)
+            entry = S[start + i];
+            let u = entry % P.n;
+            first = rowPtr[u];
+            deg = rowPtr[u + 1u] - first;
+        }
+        sh[lid.x] = deg;
+        rowStart[lid.x] = first;
+        entryOf[lid.x] = entry;
+        workgroupBarrier();
+        for (var s = 1u; s < WG; s = s * 2u) {                       // Hillis-Steele inclusive scan of the degrees
+            var t = 0u;
+            if (lid.x >= s) { t = sh[lid.x - s]; }
+            workgroupBarrier();
+            sh[lid.x] = sh[lid.x] + t;
+            workgroupBarrier();
+        }
+        let aggregate = workgroupUniformLoad(&sh[WG - 1u]);          // uniform; includes a barrier
+        for (var p0 = 0u; p0 < aggregate; p0 = p0 + WG) {            // strip [0, aggregate) WG arcs at a time
+            let p = p0 + lid.x;
+            var won = false;
+            var claimed = 0u;
+            if (p < aggregate) {
+                var lo = 0u;                                         // upper_bound: the first k with sh[k] > p owns arc p
+                var hi = WG;
+                loop {
+                    if (lo >= hi) { break; }
+                    let mid = (lo + hi) / 2u;
+                    if (sh[mid] > p) { hi = mid; } else { lo = mid + 1u; }
+                }
+                let k = lo;
+                var exclusive = 0u;
+                if (k > 0u) { exclusive = sh[k - 1u]; }
+                let origin = entryOf[k];                             // s * n + u
+                let x = (origin - (origin % P.n)) + colIdx[rowStart[k] + (p - exclusive)];   // s * n + x
+                if (atomicLoad(&depthK[x]) == INVALID_INDEX) {       // the pre-check of design 16.1
+                    won = atomicMin(&depthK[x], next) == INVALID_INDEX;   // the claim: the one winner appends
+                }
+                if (atomicLoad(&depthK[x]) == next) {                // the count: EVERY arc on a shortest path adds
+                    let add = atomicLoad(&sigmaK[origin]);
+                    let old = atomicAdd(&sigmaK[x], add);
+                    if (old + add < old) { atomicOr(&counters[27], 1u); }   // the u32 wrap, reported
+                }
+                claimed = x;
+            }
+            var slot = 0u;
+            if (won) { slot = atomicAdd(&wwon, 1u); }
+            workgroupBarrier();
+            if (lid.x == 0u) {
+                wbase = atomicAdd(&counters[26], atomicLoad(&wwon));   // stackTop: one global atomic per strip
+                atomicStore(&wwon, 0u);
+            }
+            workgroupBarrier();
+            if (won) { S[wbase + slot] = claimed; }
+        }
+        workgroupBarrier();                                          // sh, rowStart and entryOf are reused by the next block
+    }
+}
+`
+);
+const bcForwardEdgeWgsl = (
+  /* wgsl */
+  `
+var<workgroup> wlive: u32;                        // 1 when the level has entries
+var<workgroup> wwon: atomic<u32>;                 // the strip's winners
+var<workgroup> wbase: u32;                        // where the strip's winners go in the log
+
+fn claim(x: u32, next: u32) -> bool {
+    if (atomicLoad(&depthK[x]) != INVALID_INDEX) { return false; }   // the pre-check of design 16.1
+    return atomicMin(&depthK[x], next) == INVALID_INDEX;
+}
+
+fn count_paths(origin: u32, x: u32, next: u32) {
+    if (atomicLoad(&depthK[x]) == next) {                            // every arc on a shortest path adds
+        let add = atomicLoad(&sigmaK[origin]);
+        let old = atomicAdd(&sigmaK[x], add);
+        if (old + add < old) { atomicOr(&counters[27], 1u); }        // the u32 wrap, reported
+    }
+}
+
+@compute @workgroup_size(WG)
+fn bc_forward_edge(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let level = atomicLoad(&counters[11]);
+    if (lid.x == 0u) { wlive = select(0u, 1u, ends[level + 1u] > ends[level]); }
+    if (workgroupUniformLoad(&wlive) == 0u) { return; }              // uniform: nothing below runs on an empty level
+    let next = level + 1u;
+    for (var s = 0u; s < P.k; s = s + 1u) {
+        let base = s * P.n;
+        for (var e0 = group_id(wid) * WG; e0 < P.count; e0 = e0 + P.stride) {   // grid-stride over the edges
+            let e = e0 + lid.x;
+            var a = INVALID_INDEX;                                   // the claims this lane won
+            var b = INVALID_INDEX;
+            if (e < P.count) {
+                let u = base + edgeSrc[e];
+                let x = base + edgeDst[e];
+                if (atomicLoad(&depthK[u]) == level) {
+                    if (claim(x, next)) { a = x; }
+                    count_paths(u, x, next);
+                }
+                if (UNDIRECTED) {                                    // the other direction of an undirected edge
+                    if (atomicLoad(&depthK[x]) == level) {
+                        if (claim(u, next)) { b = u; }
+                        count_paths(x, u, next);
+                    }
+                }
+            }
+            let mine = select(0u, 1u, a != INVALID_INDEX) + select(0u, 1u, b != INVALID_INDEX);
+            var slot = 0u;
+            if (mine != 0u) { slot = atomicAdd(&wwon, mine); }
+            workgroupBarrier();
+            if (lid.x == 0u) {
+                wbase = atomicAdd(&counters[26], atomicLoad(&wwon));   // stackTop: one global atomic per strip
+                atomicStore(&wwon, 0u);
+            }
+            workgroupBarrier();
+            if (a != INVALID_INDEX) {
+                S[wbase + slot] = a;
+                slot = slot + 1u;
+            }
+            if (b != INVALID_INDEX) { S[wbase + slot] = b; }
+        }
+    }
+}
+`
+);
+const bcGatherWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn bc_gather(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    for (var w = linear_id(wid, lid.x); w < P.n; w = w + P.stride) {
+        var acc = bc[w];
+        for (var s = 0u; s < P.k; s = s + 1u) {
+            acc = acc + deltaK[s * P.n + w];
+        }
+        bc[w] = acc;
+    }
+}
+`
+);
 const bfRelaxWgsl = (
   /* wgsl */
   `
@@ -854,13 +1216,14 @@ const closenessReduceWgsl = (
 @compute @workgroup_size(WG)
 fn closeness_reduce(@builtin(local_invocation_id) lid: vec3<u32>) {
     if (lid.x != 0u) { return; }                                     // one lane; no barrier follows (3.5 rule 1)
-    if (P.role == 1u) {                                              // the seed of a batch: P.source is its first source
+    if (P.role != 0u) {                                              // the seed of a batch: P.source is its first source
         let k = min(32u, P.n - P.source);
         for (var s = 0u; s < k; s = s + 1u) {
-            let v = P.source + s;
+            var v = P.source + s;
+            if (P.role == 2u) { v = atomicLoad(&perSource[128u + P.bitsBase + P.source + s]); }   // a sampled run's list
             let bit = 1u << s;
-            bits[v] = bit;                                           // visited
-            bits[P.bitsBase + v] = bit;                              // the frontier level 0 reads (region 1: level 0's parity is 0)
+            bits[v] = bits[v] | bit;                                 // visited
+            bits[P.bitsBase + v] = bits[P.bitsBase + v] | bit;       // the frontier level 0 reads (region 1: level 0's parity is 0)
             bits[3u * P.bitsBase + v] = 1u;                          // flags: level 0's compact turns them into the list
         }
         atomicStore(&counters[0], k);                                // not done
@@ -908,11 +1271,16 @@ var<workgroup> rowStart: array<u32, WG>;          // the first bound arc of each
 var<workgroup> rowOf: array<u32, WG>;             // the frontier vertex of each entry (the source end of its arcs)
 var<workgroup> local: array<atomic<u32>, 32>;     // this workgroup's fresh claims per source
 var<workgroup> wcount: u32;                       // the frontier list's length
+var<workgroup> wdist: u32;                        // the distance of this level's claims
 
 @compute @workgroup_size(WG)
 fn closeness_sweep(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
-    if (lid.x == 0u) { wcount = atomicLoad(&counters[0]); }          // the frontier list's length (compact's total)
+    if (lid.x == 0u) {
+        wcount = atomicLoad(&counters[0]);                           // the frontier list's length (compact's total)
+        wdist = atomicLoad(&counters[11]) + 1u;                      // the level word: this level claims at level + 1
+    }
     let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers
+    let dist = workgroupUniformLoad(&wdist);
     let nextBase = select(2u * P.bitsBase, P.bitsBase, P.mode == 1u);   // the region that is next this level
     let frontierBase = 3u * P.bitsBase - nextBase;                   // the other one: the region that is the frontier
     for (var b0 = group_id(wid) * WG; b0 < count; b0 = b0 + P.stride) {   // grid-stride over blocks of WG entries
@@ -960,6 +1328,9 @@ fn closeness_sweep(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocat
                 if (fresh != 0u) {
                     atomicOr(&bits[nextBase + x], fresh);
                     atomicStore(&bits[3u * P.bitsBase + x], 1u);         // flags: x is in the next frontier list (compact reads it)
+                    if (P.perNode == 1u) {                               // a sampled run: x's distance to each source won
+                        atomicAdd(&perSource[128u + x], countOneBits(fresh) * dist);
+                    }
                     var b = fresh;
                     loop {                                               // one tally per set bit of fresh
                         if (b == 0u) { break; }
@@ -992,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 */
   `
@@ -1931,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 */
   `
@@ -1965,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 */
   `
@@ -2150,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 */
   `
@@ -2470,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 */
   `
@@ -2805,7 +3464,9 @@ const FRONTIER_COUNTERS = UniformBlock.define(
     ["thresholdBits", "u32"],
     ["deltaBits", "u32"],
     ["path", "u32"],
-    ["nextDegreeSum", "u32"]
+    ["nextDegreeSum", "u32"],
+    ["stackTop", "u32"],
+    ["sigmaOverflow", "u32"]
   ],
   { layout: "storage" }
 );
@@ -2828,9 +3489,19 @@ const FRONTIER_PARAMS = UniformBlock.define("FrontierParams", [
   ["stride", "u32"],
   ["firstOfSubmit", "u32"],
   ["iteration", "u32"],
-  ["pad1", "u32"],
+  ["perNode", "u32"],
   ["pad2", "u32"]
 ]);
+const BC_PARAMS = UniformBlock.define("BcParams", [
+  ["n", "u32"],
+  ["k", "u32"],
+  ["start", "u32"],
+  ["count", "u32"],
+  ["stride", "u32"],
+  ["role", "u32"],
+  ["pad0", "u32"],
+  ["pad1", "u32"]
+]);
 const BF_PARAMS = UniformBlock.define("BfParams", [
   ["edgeCount", "u32"],
   ["stride", "u32"],
@@ -2847,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 };
 }
@@ -3616,13 +4311,283 @@ const CLOSENESS_REDUCE = {
   snippetSlots: [],
   phase: "P8"
 };
-const REGISTRY = Object.freeze({
-  degree: DEGREE,
-  reduce: REDUCE,
-  fill: FILL,
-  "segmented-reduce": SEGMENTED_REDUCE,
-  "fa2-stats-finalize": FA2_STATS_FINALIZE,
-  "fa2-attraction": FA2_ATTRACTION,
+const BC_FINALIZE = {
+  id: "bc-finalize",
+  body: bcFinalizeWgsl,
+  entryPoint: "bc_finalize",
+  bindings: [
+    decl(1, 0, "counters", "storage", "array<atomic<u32>>"),
+    decl(1, 1, "ends", "storage", "array<u32>"),
+    decl(1, 2, "S", "storage-ro", "array<u32>"),
+    decl(1, 3, "depthK", "storage", "array<u32>"),
+    decl(1, 4, "sigmaK", "storage", "array<u32>"),
+    decl(2, 0, "P", "uniform", "BcParams")
+  ],
+  overrideDecls: [],
+  uniforms: [BC_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P9"
+};
+const BC_FORWARD = {
+  id: "bc-forward",
+  body: bcForwardWgsl,
+  entryPoint: "bc_forward",
+  bindings: [
+    decl(1, 0, "rowPtr", "storage-ro", "array<u32>"),
+    decl(1, 1, "colIdx", "storage-ro", "array<u32>"),
+    decl(1, 2, "S", "storage", "array<u32>"),
+    decl(1, 3, "ends", "storage-ro", "array<u32>"),
+    decl(1, 4, "counters", "storage", "array<atomic<u32>>"),
+    decl(1, 5, "depthK", "storage", "array<atomic<u32>>"),
+    decl(1, 6, "sigmaK", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "BcParams")
+  ],
+  overrideDecls: [],
+  uniforms: [BC_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P9"
+};
+const BC_BACKWARD = {
+  id: "bc-backward",
+  body: bcBackwardWgsl,
+  entryPoint: "bc_backward",
+  bindings: [
+    decl(1, 0, "rowPtr", "storage-ro", "array<u32>"),
+    decl(1, 1, "colIdx", "storage-ro", "array<u32>"),
+    decl(1, 2, "S", "storage-ro", "array<u32>"),
+    decl(1, 3, "depthK", "storage-ro", "array<u32>"),
+    decl(1, 4, "sigmaK", "storage-ro", "array<u32>"),
+    decl(1, 5, "deltaK", "storage", "array<f32>"),
+    decl(2, 0, "P", "uniform", "BcParams")
+  ],
+  overrideDecls: [],
+  uniforms: [BC_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P9"
+};
+const BC_GATHER = {
+  id: "bc-gather",
+  body: bcGatherWgsl,
+  entryPoint: "bc_gather",
+  bindings: [
+    decl(1, 0, "deltaK", "storage-ro", "array<f32>"),
+    decl(1, 1, "bc", "storage", "array<f32>"),
+    decl(2, 0, "P", "uniform", "BcParams")
+  ],
+  overrideDecls: [],
+  uniforms: [BC_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P9"
+};
+const BC_EDGE_GATHER = {
+  id: "bc-edge-gather",
+  body: bcEdgeGatherWgsl,
+  entryPoint: "bc_edge_gather",
+  bindings: [
+    decl(1, 0, "rowPtr", "storage-ro", "array<u32>"),
+    decl(1, 1, "colIdx", "storage-ro", "array<u32>"),
+    decl(1, 2, "depthK", "storage-ro", "array<u32>"),
+    decl(1, 3, "sigmaK", "storage-ro", "array<u32>"),
+    decl(1, 4, "deltaK", "storage-ro", "array<f32>"),
+    decl(1, 5, "arcScores", "storage", "array<f32>"),
+    decl(2, 0, "P", "uniform", "BcParams")
+  ],
+  overrideDecls: [],
+  uniforms: [BC_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P9"
+};
+const BC_FORWARD_EDGE = {
+  id: "bc-forward-edge",
+  body: bcForwardEdgeWgsl,
+  entryPoint: "bc_forward_edge",
+  bindings: [
+    decl(1, 0, "edgeSrc", "storage-ro", "array<u32>"),
+    decl(1, 1, "edgeDst", "storage-ro", "array<u32>"),
+    decl(1, 2, "S", "storage", "array<u32>"),
+    decl(1, 3, "ends", "storage-ro", "array<u32>"),
+    decl(1, 4, "counters", "storage", "array<atomic<u32>>"),
+    decl(1, 5, "depthK", "storage", "array<atomic<u32>>"),
+    decl(1, 6, "sigmaK", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "BcParams")
+  ],
+  overrideDecls: [{ name: "UNDIRECTED", type: "bool", default: false }],
+  uniforms: [BC_PARAMS],
+  needs: [],
+  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,
+  fill: FILL,
+  "segmented-reduce": SEGMENTED_REDUCE,
+  "fa2-stats-finalize": FA2_STATS_FINALIZE,
+  "fa2-attraction": FA2_ATTRACTION,
   "fa2-repulsion-exact": FA2_REPULSION_EXACT,
   "fa2-speed-finalize": FA2_SPEED_FINALIZE,
   "fa2-integrate": FA2_INTEGRATE,
@@ -3662,7 +4627,22 @@ const REGISTRY = Object.freeze({
   "sssp-relax": SSSP_RELAX,
   "bf-relax": BF_RELAX,
   "closeness-sweep": CLOSENESS_SWEEP,
-  "closeness-reduce": CLOSENESS_REDUCE
+  "closeness-reduce": CLOSENESS_REDUCE,
+  "bc-finalize": BC_FINALIZE,
+  "bc-forward": BC_FORWARD,
+  "bc-backward": BC_BACKWARD,
+  "bc-gather": BC_GATHER,
+  "bc-edge-gather": BC_EDGE_GATHER,
+  "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) {
@@ -3821,7 +4801,7 @@ class ScanPlannerImpl {
 }
 const POISON = 3735928559;
 const CHECK_BLOCKS = 32;
-const RING_SLOTS$6 = 8;
+const RING_SLOTS$9 = 8;
 const checked = /* @__PURE__ */ new WeakMap();
 function inputAt(i) {
   return i + 1;
@@ -3849,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$6, "device-check/ring");
+  const ring = new UniformRing(ctx.device, ctx.allocator, RING_SLOTS$9, "device-check/ring");
   try {
     const scope = {
       device: ctx.device,
@@ -4066,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;
   }
@@ -4095,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", {});
   }
@@ -4516,13 +5496,13 @@ function algorithmScope(ctx, label, slots) {
     ringOverruns: () => ring.overruns
   };
 }
-const ALGORITHM$4 = "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$5 = 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;
   }
@@ -4531,7 +5511,7 @@ function checkDest$4(dest, n) {
   }
   throw new WebGpuGraphError(
     "E_INVALID_ARGUMENT",
-    `${ALGORITHM$4}: 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})`,
@@ -4541,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$4);
+  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$8);
   return core;
 }
 function bindingOf$3(buffer, size) {
@@ -4600,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$4}: labels[${v}] = ${label} is not a node index`, {
-        label: `${ALGORITHM$4}/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})`
       });
     }
@@ -4617,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$4}: 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);
@@ -4636,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$4, RING_SLOTS$5);
+  const scope = algorithmScope(ctx, ALGORITHM$8, RING_SLOTS$8);
   try {
     const compBytes = 4 * (n + 1);
     const comp = scope.scratch(compBytes, "comp");
@@ -4660,12 +5640,12 @@ async function connectedComponents(ctx, s, options) {
       const params = wccParams({ items: n, stride: rowPlan.stride ?? n, r: 0, giant: U32_MAX$2 });
       compress.dispatch(pass2, compress.bind({ comp: compBinding, P: params.binding }), rowPlan, [params.offset]);
     };
-    const submit = (batch) => {
+    const submit2 = (batch) => {
       scope.flush();
       return batch.submit();
     };
     queue.writeBuffer(comp, 4 * flagIndex, zero);
-    const setup = new CommandBatch(ctx, `${ALGORITHM$4}/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(
@@ -4682,9 +5662,9 @@ async function connectedComponents(ctx, s, options) {
     }
     recordCompress(pass);
     setup.endPass();
-    await submit(setup).readback;
+    await submit2(setup).readback;
     ctx.assertReady();
-    const sampler = new CommandBatch(ctx, `${ALGORITHM$4}/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(
@@ -4695,14 +5675,14 @@ async function connectedComponents(ctx, s, options) {
     );
     sampler.endPass();
     const histRequest = sampler.readback(hist, 0, 4 * items);
-    const histBytes = await submit(sampler).readback;
+    const histBytes = await submit2(sampler).readback;
     ctx.assertReady();
     const giant = modeOf(new Uint32Array(histBytes, histRequest.offset, items));
     const edgeBindings = { edgeSrc: edges.bindings.src, edgeDst: edges.bindings.dst, comp: compBinding };
     let rounds = 0;
     for (; ; ) {
       queue.writeBuffer(comp, 4 * flagIndex, zero);
-      const batch = new CommandBatch(ctx, `${ALGORITHM$4}/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 });
@@ -4712,12 +5692,12 @@ async function connectedComponents(ctx, s, options) {
       }
       batch.endPass();
       const flagRequest = batch.readback(comp, 4 * flagIndex, 4);
-      const submitted = submit(batch);
+      const submitted = submit2(batch);
       const back = await submitted.readback;
       rounds += ROUNDS_PER_BATCH$1;
       ctx.assertReady();
       if (options?.signal?.aborted) {
-        throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$4}: the signal was aborted`, {
+        throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$8}: the signal was aborted`, {
           batchId: submitted.id
         });
       }
@@ -4727,15 +5707,15 @@ async function connectedComponents(ctx, s, options) {
       if (rounds >= MAX_WCC_ROUNDS) {
         throw new WebGpuGraphError(
           "E_VALIDATION",
-          `${ALGORITHM$4}: the changed flag never settled in ${MAX_WCC_ROUNDS} rounds`,
-          { label: ALGORITHM$4, 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$4}/final`);
+    const final = new CommandBatch(ctx, `${ALGORITHM$8}/final`);
     recordCompress(final.pass("compress"));
     final.endPass();
-    await submit(final).readback;
+    await submit2(final).readback;
     ctx.assertReady();
     const raw = !renumber && dest !== null ? dest : new Uint32Array(n);
     await ctx.readback.read(comp, 4 * n, raw);
@@ -4974,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) {
@@ -5098,8 +6090,8 @@ async function prepareSpmvPull(scope, rev, options) {
   return new SpmvPullPlannerImpl(scope, compiled, perm, options.weights);
 }
 const PR_BATCH = 8;
-const RING_SLOTS$4 = 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;
   }
@@ -5146,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);
   }
@@ -5176,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$4);
+  const scope = algorithmScope(ctx, algorithm, RING_SLOTS$7);
   let uploaded = null;
   try {
     const bytes = 4 * n;
@@ -5193,7 +6185,7 @@ async function run(ctx, s, personalization, options, algorithm) {
       uploaded = ctx.residency.array(personalization, `${algorithm}/personalization`);
     }
     await ctx.allocator.check();
-    const normaliser = await prepareSegmentedReduce(scope, weightedCore, {
+    const normaliser2 = await prepareSegmentedReduce(scope, weightedCore, {
       op: "sum",
       valueSnippet: "v = weight;",
       tiers: null
@@ -5226,7 +6218,7 @@ async function run(ctx, s, personalization, options, algorithm) {
       const batch = new CommandBatch(ctx, algorithm);
       let pass = batch.pass("iterations");
       if (iterationsRun === 0) {
-        normaliser.record(pass, weightedCore, outWeightSumBinding);
+        normaliser2.record(pass, weightedCore, outWeightSumBinding);
       }
       const last = iterationsRun + k === maxIterations;
       for (let i = 0; i < k + (last ? 1 : 0); i++) {
@@ -5339,8 +6331,8 @@ async function personalizedPageRank(ctx, s, personalization, options) {
   return run(ctx, s, normalised2, options, "personalizedPageRank");
 }
 const BATCH = 8;
-const RING_SLOTS$3 = 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;
   }
@@ -5378,7 +6370,7 @@ function whole(buffer, size) {
 }
 async function runPowerIteration(ctx, n, config) {
   await assertDeviceComputes(ctx);
-  const scope = algorithmScope(ctx, config.label, RING_SLOTS$3);
+  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(
@@ -5490,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);
   }
@@ -5646,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,
@@ -5666,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;
@@ -5822,7 +6814,9 @@ const W = Object.freeze({
   thresholdBits: 22,
   deltaBits: 23,
   path: 24,
-  nextDegreeSum: 25
+  nextDegreeSum: 25,
+  stackTop: 26,
+  sigmaOverflow: 27
 });
 function definedWords(words) {
   const out = {};
@@ -6156,7 +7150,7 @@ class RadixSortPlannerImpl {
     return src;
   }
 }
-const ALGORITHM$3 = "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);
@@ -6168,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;
   }
@@ -6177,7 +7171,7 @@ function checkDest$1(dest, n) {
   }
   throw new WebGpuGraphError(
     "E_INVALID_ARGUMENT",
-    `${ALGORITHM$3}: 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})`,
@@ -6192,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$3}: the ${name} view has no ${name} binding`, {
-      label: `${ALGORITHM$3}/${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`
     });
   }
@@ -6202,15 +7196,15 @@ function degreeView(ctx, s, name) {
 function aborted$1(batchId) {
   return new WebGpuGraphError(
     "E_ABORTED",
-    `${ALGORITHM$3}: 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$3}: counters.${name} did not decode to a number`, {
-      label: `${ALGORITHM$3}/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`
     });
   }
@@ -6221,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$3}: 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})`
@@ -6231,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$3}: 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,
@@ -6239,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) {
@@ -6250,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$3}: 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$3
+        algorithm: ALGORITHM$7
       }
     );
   }
@@ -6263,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$3, bfsRingSlots(forward.length, levelsPerSubmit));
+  const scope = algorithmScope(ctx, ALGORITHM$7, bfsRingSlots(forward.length, levelsPerSubmit));
   tuning.onScope?.(scope);
   try {
     const bytes = 4 * n;
@@ -6305,7 +7299,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
     const degreePlan = planGridStride(n, wg, ctx.caps, NEXT_DEGREE_MAX_GROUPS);
     const fusedPlan = planGridStride(n * wg, wg, ctx.caps);
     const bitsPlan = plan1d(bitsWords, wg, ctx.caps);
-    const recordFill = (pass2, dst, value, mode) => {
+    const recordFill2 = (pass2, dst, value, mode) => {
       const params = scope.params(FILL_PARAMS, { count: n, value, mode, pad0: 0 });
       fill.dispatch(pass2, fill.bind({ dst, P: params.binding }), fillPlan, [params.offset]);
     };
@@ -6323,16 +7317,16 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
         outIndex: 0
       });
     };
-    const submit = (batch) => {
+    const submit2 = (batch) => {
       scope.flush();
       return batch.submit();
     };
-    const setup = new CommandBatch(ctx, `${ALGORITHM$3}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$7}/setup`);
     const setupPass = setup.pass("fill");
-    recordFill(setupPass, depth, INVALID_INDEX, 0);
-    recordFill(setupPass, iota, 0, 1);
+    recordFill2(setupPass, depth, INVALID_INDEX, 0);
+    recordFill2(setupPass, iota, 0, 1);
     setup.endPass();
-    await submit(setup).readback;
+    await submit2(setup).readback;
     ctx.assertReady();
     queue.writeBuffer(depth.buffer, depth.offset + 4 * source, Uint32Array.of(0));
     frontier.reset(queue, source, { nextFrontierCount: 1, level: U32_MAX$2 });
@@ -6347,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$3}/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 });
@@ -6436,7 +7430,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
         frontier: batch.readback(frontier.input.buffer, frontier.input.offset, frontier.input.size),
         count: batch.readback(compactCount.buffer, compactCount.offset, 4)
       };
-      const submitted = submit(batch);
+      const submitted = submit2(batch);
       const back2 = await submitted.readback;
       levelsRecorded += levelsPerSubmit;
       submits += 1;
@@ -6457,8 +7451,8 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
       if (submits > n + 1) {
         throw new WebGpuGraphError(
           "E_VALIDATION",
-          `${ALGORITHM$3}: the done flag never rose in ${submits} submits (a traversal has at most ${n} levels)`,
-          { label: ALGORITHM$3, 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` }
         );
       }
     }
@@ -6472,12 +7466,12 @@ 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$3}/result`);
+    const result = new CommandBatch(ctx, `${ALGORITHM$7}/result`);
     result.copy(depth, keys, bytes);
     const pass = result.pass("result");
-    recordFill(pass, vals, 0, 1);
+    recordFill2(pass, vals, 0, 1);
     const sorted = sort.record(pass, keys, vals, n, 32, scratch);
-    recordFill(pass, parent, INVALID_INDEX, 0);
+    recordFill2(pass, parent, INVALID_INDEX, 0);
     const predPlan = planGridStride(n, wg, ctx.caps);
     for (const w of forward) {
       const predParams = scope.params(FRONTIER_PARAMS, {
@@ -6502,16 +7496,16 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
     const parentRequest = result.readback(parent.buffer, parent.offset, bytes);
     const orderRequest = result.readback(sorted.vals.buffer, sorted.vals.offset, bytes);
     const blockRequest = result.readback(counters.buffer, counters.offset, FRONTIER_COUNTERS.byteLength);
-    const back = await submit(result).readback;
+    const back = await submit2(result).readback;
     ctx.assertReady();
     const block = FRONTIER_COUNTERS.read(new DataView(back), blockRequest.offset);
     const visitedCount = wordOf$1(block, "visitedCount");
     if (visitedCount > n) {
       throw new WebGpuGraphError(
         "E_VALIDATION",
-        `${ALGORITHM$3}: visitedCount ${visitedCount} exceeds the ${n} vertices (a duplicate claim)`,
+        `${ALGORITHM$7}: visitedCount ${visitedCount} exceeds the ${n} vertices (a duplicate claim)`,
         {
-          label: `${ALGORITHM$3}/visitedCount`,
+          label: `${ALGORITHM$7}/visitedCount`,
           message: `the device counted ${visitedCount} visits of ${n} vertices`
         }
       );
@@ -6535,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$2 = "sssp";
+const ALGORITHM$6 = "sssp";
 const HALF_ALIGN = 64;
-const RING_SLOTS$2 = 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];
 }
@@ -6563,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$2}: counters.${name} did not decode to a number`, {
-      label: `${ALGORITHM$2}/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;
   }
@@ -6664,7 +7658,7 @@ function predBufferWords(n) {
   return 2 * Math.ceil(n / 64) * 64 + 64;
 }
 async function predecessorPass(input) {
-  const { algorithm, ctx, scope, predKernel, recordFill, graph, dist, pred, n, arcCount, source, mode } = input;
+  const { algorithm, ctx, scope, predKernel, recordFill: recordFill2, graph, dist, pred, n, arcCount, source, mode } = input;
   const wg = ctx.workgroupSize;
   const { queue } = ctx.device;
   const bytes = 4 * n;
@@ -6699,7 +7693,7 @@ async function predecessorPass(input) {
     for (let iteration = 0; iteration < MAX_LEVELS_PER_SUBMIT; iteration++) {
       recordRole(1, iteration);
     }
-    recordFill(pass, predArcs, n, INVALID_INDEX);
+    recordFill2(pass, predArcs, n, INVALID_INDEX);
     recordRole(2, 0);
     batch.endPass();
     const distRequest = batch.readback(dist.buffer, dist.offset, bytes);
@@ -6731,12 +7725,12 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
   ctx.assertReady();
   await assertDeviceComputes(ctx);
   const n = s.nodeCount;
-  assertSource(ALGORITHM$2, 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$2}: 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,
@@ -6745,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$2}: 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$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$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$2);
+    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$2}: 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$2}: 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$2);
+  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$2}: 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$2 }
+      `${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(
@@ -6789,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$2, RING_SLOTS$2);
+  const scope = algorithmScope(ctx, ALGORITHM$6, RING_SLOTS$5);
   try {
     const wg = ctx.workgroupSize;
     const bytes = 4 * n;
@@ -6819,20 +7813,20 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
     const { counters } = frontier;
     const nearIn = frontier.vertices[0];
     const farIn = frontier.vertices[1];
-    const recordFill = (pass, dst, count, value) => {
+    const recordFill2 = (pass, dst, count, value) => {
       const params = scope.params(FILL_PARAMS, { count, value, mode: 0, pad0: 0 });
       fill.dispatch(pass, fill.bind({ dst, P: params.binding }), plan1d(count, wg, ctx.caps), [params.offset]);
     };
-    const submit = (batch) => {
+    const submit2 = (batch) => {
       scope.flush();
       return batch.submit();
     };
-    const setup = new CommandBatch(ctx, `${ALGORITHM$2}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$6}/setup`);
     const setupPass = setup.pass("fill");
-    recordFill(setupPass, dist, n, F32_INF_BITS);
-    recordFill(setupPass, pred, predWords, INVALID_INDEX);
+    recordFill2(setupPass, dist, n, F32_INF_BITS);
+    recordFill2(setupPass, pred, predWords, INVALID_INDEX);
     setup.endPass();
-    await submit(setup).readback;
+    await submit2(setup).readback;
     ctx.assertReady();
     queue.writeBuffer(dist.buffer, dist.offset + 4 * source, Uint32Array.of(0));
     frontier.reset(queue, source, { nextFrontierCount: 1, thresholdBits: deltaBits, deltaBits });
@@ -6873,7 +7867,7 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
     let roundsRecorded = 0;
     let submits = 0;
     for (; ; ) {
-      const batch = new CommandBatch(ctx, `${ALGORITHM$2}/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 });
@@ -6890,13 +7884,13 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
       batch.endPass();
       const doneRequest = batch.readback(counters.buffer, counters.offset + 4 * W.done, 4);
       const inspect = tuning.onRound === void 0 ? null : batch.readback(counters.buffer, counters.offset, FRONTIER_COUNTERS.byteLength);
-      const submitted = submit(batch);
+      const submitted = submit2(batch);
       const back = await submitted.readback;
       roundsRecorded += roundsPerSubmit;
       submits += 1;
       ctx.assertReady();
       if (options?.signal?.aborted) {
-        throw aborted(ALGORITHM$2, submitted.id);
+        throw aborted(ALGORITHM$6, submitted.id);
       }
       options?.onProgress?.(Math.min(roundsRecorded, maxRounds), maxRounds);
       if (inspect !== null && tuning.onRound !== void 0) {
@@ -6921,30 +7915,30 @@ 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$2}: a raw pile of ${needed} entries overflowed its ${cap}-entry half`,
-            { needed, limit: cap, path: "sssp.pile", algorithm: ALGORITHM$2 }
+            `${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$2}: 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$2}: the done flag never rose in ${submits} submits (at most ${maxRounds} rounds)`,
-          { label: `${ALGORITHM$2}/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$2,
+      algorithm: ALGORITHM$6,
       ctx,
       scope,
       predKernel,
-      recordFill,
+      recordFill: recordFill2,
       graph,
       dist,
       pred,
@@ -6956,8 +7950,8 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
     if (passed.orphans !== 0) {
       throw new WebGpuGraphError(
         "E_VALIDATION",
-        `${ALGORITHM$2}: ${passed.orphans} reached node(s) the predecessor key never reached (a kernel bug)`,
-        { label: `${ALGORITHM$2}/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);
@@ -6976,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$1 = "bellmanFord";
+const ALGORITHM$5 = "bellmanFord";
 const ROUNDS_PER_BATCH = 8;
 const MAX_RETRIES = 16;
-const RING_SLOTS$1 = 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++) {
@@ -6987,7 +7981,7 @@ function assertSymmetric(s, vector2) {
     if (vector2[a] !== vector2[forward]) {
       throw new WebGpuGraphError(
         "E_UNSUPPORTED",
-        `${ALGORITHM$1}: 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" }
       );
     }
@@ -6997,10 +7991,10 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
   ctx.assertReady();
   await assertDeviceComputes(ctx);
   const n = s.nodeCount;
-  assertSource(ALGORITHM$1, 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$1}: 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"
@@ -7010,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$1}: 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,
@@ -7018,18 +8012,18 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
       }
     );
   }
-  const dest = checkDest(ALGORITHM$1, options?.dest, n);
-  const vector2 = resolveWeights$1(ALGORITHM$1, s, options?.weights);
-  const cutoff = normaliseCutoff(ALGORITHM$1, 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$1);
+    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$1}: 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"
     });
   }
@@ -7038,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$1);
+  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$1, RING_SLOTS$1);
+  const scope = algorithmScope(ctx, ALGORITHM$5, RING_SLOTS$4);
   try {
     const wg = ctx.workgroupSize;
     const bytes = 4 * n;
@@ -7068,23 +8062,23 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
     const predKernel = await ctx.pipelines.kernel(kernelSpec("sssp-pred", { ...overrides, MODE: 0 }));
     const fill = await ctx.pipelines.kernel(kernelSpec("fill"));
     const graph = graphBindings(core, null, weightsBinding);
-    const recordFill = (pass, dst, count, value, mode = 0) => {
+    const recordFill2 = (pass, dst, count, value, mode = 0) => {
       const params = scope.params(FILL_PARAMS, { count, value, mode, pad0: 0 });
       fill.dispatch(pass, fill.bind({ dst, P: params.binding }), plan1d(count, wg, ctx.caps), [params.offset]);
     };
-    const submit = (batch) => {
+    const submit2 = (batch) => {
       scope.flush();
       return batch.submit();
     };
-    const setup = new CommandBatch(ctx, `${ALGORITHM$1}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$5}/setup`);
     const setupPass = setup.pass("fill");
-    recordFill(setupPass, dist, n, F32_INF_BITS);
-    recordFill(setupPass, pred, predWords, INVALID_INDEX);
+    recordFill2(setupPass, dist, n, F32_INF_BITS);
+    recordFill2(setupPass, pred, predWords, INVALID_INDEX);
     if (iota !== null) {
-      recordFill(setupPass, iota, edgeCount, 0, 1);
+      recordFill2(setupPass, iota, edgeCount, 0, 1);
     }
     setup.endPass();
-    await submit(setup).readback;
+    await submit2(setup).readback;
     ctx.assertReady();
     queue.writeBuffer(dist.buffer, dist.offset + 4 * source, Uint32Array.of(0));
     const edgePlan = planGridStride(edgeCount, wg, ctx.caps);
@@ -7105,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$1}/${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 });
@@ -7114,7 +8108,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
       }
       batch.endPass();
       const request = batch.readback(flags.buffer, flags.offset, BF_FLAGS.byteLength);
-      const submitted = submit(batch);
+      const submitted = submit2(batch);
       const back = await submitted.readback;
       ctx.assertReady();
       const block = BF_FLAGS.read(new DataView(back), request.offset);
@@ -7130,9 +8124,9 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
         if (decision.retryExhausted !== 0) {
           throw new WebGpuGraphError(
             "E_VALIDATION",
-            `${ALGORITHM$1}: 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$1}/retry`,
+              label: `${ALGORITHM$5}/retry`,
               message: "retryExhausted in the decision round",
               batchId: decision.id
             }
@@ -7148,7 +8142,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
         retryExhaustedRounds += 1;
       }
       if (options?.signal?.aborted) {
-        throw aborted(ALGORITHM$1, batch.id);
+        throw aborted(ALGORITHM$5, batch.id);
       }
       options?.onProgress?.(rounds, n);
       if (batch.changed === 0 && batch.retryExhausted === 0) {
@@ -7156,11 +8150,11 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
       }
     }
     const passed = await predecessorPass({
-      algorithm: ALGORITHM$1,
+      algorithm: ALGORITHM$5,
       ctx,
       scope,
       predKernel,
-      recordFill,
+      recordFill: recordFill2,
       graph,
       dist,
       pred,
@@ -7172,7 +8166,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
     if (passed.orphans !== 0 && !hasNegativeCycle) {
       throw new WebGpuGraphError(
         "E_UNSUPPORTED",
-        `${ALGORITHM$1}: ${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"
@@ -7199,10 +8193,385 @@ 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 = "closenessCentrality";
+const ALGORITHM$4 = "betweennessCentrality";
+const BYTES_PER_NODE_SOURCE = 16;
+const SAMPLE_SEED = 2654435769;
+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$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));
+  const kByBudget = Math.floor(BC_BATCH_BUDGET_FRACTION * limits.maxBufferSize / (BYTES_PER_NODE_SOURCE * n));
+  return Math.max(1, Math.min(kByBinding, kByBudget, BC_MAX_BATCH, remaining));
+}
+function drawSources(n, k) {
+  const pool = Array.from({ length: n }, (_, i) => i);
+  let state = SAMPLE_SEED;
+  for (let i = 0; i < k; i++) {
+    state = state + 1831565813 >>> 0;
+    let t = Math.imul(state ^ state >>> 15, state | 1);
+    t = t + Math.imul(t ^ t >>> 7, t | 61) ^ t;
+    const unit = ((t ^ t >>> 14) >>> 0) / 2 ** 32;
+    const j = i + Math.floor(unit * (n - i));
+    [pool[i], pool[j]] = [pool[j], pool[i]];
+  }
+  return pool.slice(0, k);
+}
+function badArgument(argument, value, expected) {
+  return new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$4}: ${argument} must be ${expected}`, {
+    argument,
+    value,
+    expected
+  });
+}
+function resolveSources(options, n) {
+  const k = options?.k;
+  if (k !== void 0 && (!Number.isInteger(k) || k < 0 || k > n)) {
+    throw badArgument("k", k, `an integer in [0, ${n}]`);
+  }
+  const given = options?.sources;
+  if (given !== void 0) {
+    for (const v of given) {
+      if (!Number.isInteger(v) || v < 0 || v >= n) {
+        throw badArgument("sources", v, `node indices in [0, ${n})`);
+      }
+    }
+    if (k !== void 0 && k !== given.length) {
+      throw badArgument("k", k, `absent or equal to sources.length (${given.length})`);
+    }
+    return [...given];
+  }
+  if (k !== void 0) {
+    return drawSources(n, k);
+  }
+  return Array.from({ length: n }, (_, i) => i);
+}
+function recordFill(state, pass, dst, count, value) {
+  const { scope, fill, ctx } = state;
+  const params = scope.params(FILL_PARAMS, { count, value, mode: 0, pad0: 0 });
+  fill.dispatch(pass, fill.bind({ dst, P: params.binding }), plan1d(count, ctx.workgroupSize, ctx.caps), [
+    params.offset
+  ]);
+}
+function recordBc(state, pass, kernel, resources, fields, items) {
+  const { scope, ctx } = state;
+  const plan = planGridStride(items, ctx.workgroupSize, ctx.caps);
+  const params = scope.params(BC_PARAMS, { ...fields, stride: plan.stride ?? 0 });
+  let bound = state.bound.get(kernel);
+  if (bound === void 0) {
+    bound = kernel.bind({ ...resources, P: params.binding });
+    state.bound.set(kernel, bound);
+  }
+  kernel.dispatch(pass, bound, items === 0 ? plan1d(1, ctx.workgroupSize, ctx.caps) : plan, [params.offset]);
+}
+async function submit(state, batch, signal) {
+  state.scope.flush();
+  const submitted = batch.submit();
+  const back = await submitted.readback;
+  state.ctx.assertReady();
+  if (signal?.aborted) {
+    throw aborted(ALGORITHM$4, submitted.id);
+  }
+  return back;
+}
+async function runBatch(state, sources, form, levelsPerSubmit, tuning, signal) {
+  const { ctx, n, S, ends, depthK, sigmaK, deltaK, counters } = state;
+  const k = sources.length;
+  const words = n * k;
+  const seeds = Uint32Array.from(sources, (v, s) => s * n + v);
+  ctx.device.queue.writeBuffer(S.buffer, S.offset, seeds);
+  const forwardFields = { n, k, count: form === "edge" ? state.edgeCount : 0 };
+  const forwardItems = form === "edge" ? state.edgeCount : words;
+  let recorded = 0;
+  let levels = 0;
+  let overflow = false;
+  let endsWords = null;
+  for (let first = true; endsWords === null; first = false) {
+    const batch = new CommandBatch(ctx, `${ALGORITHM$4}/forward`);
+    const pass = batch.pass("forward");
+    if (first) {
+      recordFill(state, pass, depthK, words, 4294967295);
+      recordFill(state, pass, sigmaK, words, 0);
+      recordFill(state, pass, deltaK, words, 0);
+      recordBc(state, pass, state.finalize, { counters, ends, S, depthK, sigmaK }, { n, k, role: 1 }, 1);
+    }
+    for (let level = 0; level < levelsPerSubmit; level++) {
+      recordBc(state, pass, state.finalize, { counters, ends, S, depthK, sigmaK }, { n, k, role: 0 }, 1);
+      if (form === "edge" && state.forwardEdge !== null && state.edgeSrc !== null && state.edgeDst !== null) {
+        recordBc(
+          state,
+          pass,
+          state.forwardEdge,
+          { edgeSrc: state.edgeSrc, edgeDst: state.edgeDst, S, ends, counters, depthK, sigmaK },
+          forwardFields,
+          forwardItems
+        );
+      } else {
+        recordBc(
+          state,
+          pass,
+          state.forward,
+          { rowPtr: state.rowPtr, colIdx: state.colIdx, S, ends, counters, depthK, sigmaK },
+          forwardFields,
+          forwardItems
+        );
+      }
+    }
+    recorded += levelsPerSubmit;
+    batch.endPass();
+    const endsCount = Math.min(n + 2, recorded + 1);
+    const countersRequest = batch.readback(counters.buffer, counters.offset, FRONTIER_COUNTERS.byteLength);
+    const endsRequest = batch.readback(ends.buffer, ends.offset, 4 * endsCount);
+    const back = await submit(state, batch, signal);
+    const words32 = new Uint32Array(back, countersRequest.offset, FRONTIER_COUNTERS.byteLength / 4);
+    if (words32[W.done] !== 0) {
+      levels = words32[W.level];
+      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$4}: the done flag never rose in ${recorded} levels`, {
+        label: ALGORITHM$4,
+        message: `the done flag never rose in ${recorded} levels`
+      });
+    }
+  }
+  const backwardLevels = [];
+  for (let level = levels - 1; level >= 1; level--) {
+    backwardLevels.push(level);
+  }
+  let arrays = null;
+  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$4}/backward`);
+    const pass = batch.pass("backward");
+    for (const level of chunk) {
+      const start = endsWords[level];
+      const count = endsWords[level + 1] - start;
+      recordBc(
+        state,
+        pass,
+        state.backward,
+        { rowPtr: state.rowPtr, colIdx: state.colIdx, S, depthK, sigmaK, deltaK },
+        { n, k, start, count },
+        count
+      );
+    }
+    if (last) {
+      recordBc(state, pass, state.gather, { deltaK, bc: state.bc }, { n, k }, n);
+      if (state.edgeGather !== null && state.arcScores !== null) {
+        recordBc(
+          state,
+          pass,
+          state.edgeGather,
+          { rowPtr: state.rowPtr, colIdx: state.colIdx, depthK, sigmaK, deltaK, arcScores: state.arcScores },
+          { n, k, count: state.arcCount },
+          state.arcCount
+        );
+      }
+    }
+    batch.endPass();
+    const wantArrays = last && tuning.readArrays === true;
+    const requests = wantArrays ? [depthK, sigmaK, deltaK].map((b) => batch.readback(b.buffer, b.offset, 4 * words)) : [];
+    const back = await submit(state, batch, signal);
+    if (wantArrays) {
+      arrays = {
+        depthK: new Uint32Array(back, requests[0].offset, words).slice(),
+        sigmaK: new Uint32Array(back, requests[1].offset, words).slice(),
+        deltaK: new Float32Array(back, requests[2].offset, words).slice()
+      };
+    }
+    if (last) {
+      break;
+    }
+  }
+  tuning.onBatch?.({
+    sources,
+    forward: form,
+    levels,
+    ends: endsWords.slice(),
+    sigmaOverflow: overflow,
+    depthK: arrays?.depthK ?? null,
+    sigmaK: arrays?.sigmaK ?? null,
+    deltaK: arrays?.deltaK ?? null
+  });
+  return { levels, overflow };
+}
+async function runRaw(ctx, s, sources, withEdges, tuning, options) {
+  const n = s.nodeCount;
+  const pinned = tuning.forward ?? "auto";
+  const levelsPerSubmit = tuning.levelsPerSubmit ?? MAX_LEVELS_PER_SUBMIT;
+  if (!Number.isInteger(levelsPerSubmit) || levelsPerSubmit < 1 || levelsPerSubmit > MAX_LEVELS_PER_SUBMIT) {
+    throw badArgument("levelsPerSubmit", levelsPerSubmit, `an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`);
+  }
+  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$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$4, RING_SLOTS$3);
+  try {
+    const arrayBytes = 4 * n * kMax;
+    const lease = (bytes, label) => bindingOf(scope.scratch(bytes, label), bytes);
+    const arcBytes = 4 * Math.max(1, s.arcCount);
+    const [fill, finalize, forward, backward, gather] = await Promise.all(
+      ["fill", "bc-finalize", "bc-forward", "bc-backward", "bc-gather"].map(
+        (id) => ctx.pipelines.kernel(kernelSpec(id))
+      )
+    );
+    const forwardEdge = edgeView === null ? null : await ctx.pipelines.kernel(kernelSpec("bc-forward-edge", { UNDIRECTED: !s.directed }));
+    const edgeGather = withEdges ? await ctx.pipelines.kernel(kernelSpec("bc-edge-gather")) : null;
+    const state = {
+      ctx,
+      scope,
+      n,
+      S: lease(arrayBytes, "S"),
+      ends: lease(4 * (n + 2), "ends"),
+      depthK: lease(arrayBytes, "depthK"),
+      sigmaK: lease(arrayBytes, "sigmaK"),
+      deltaK: lease(arrayBytes, "deltaK"),
+      counters: lease(FRONTIER_COUNTERS.byteLength, "counters"),
+      bc: lease(4 * n, "bc"),
+      arcScores: withEdges ? lease(arcBytes, "arc-scores") : null,
+      rowPtr: core.rowPtr,
+      colIdx: core.colIdx ?? core.rowPtr,
+      edgeSrc: edgeView?.bindings.src ?? null,
+      edgeDst: edgeView?.bindings.dst ?? null,
+      edgeCount,
+      arcCount: s.arcCount,
+      fill,
+      finalize,
+      forward,
+      forwardEdge,
+      backward,
+      gather,
+      edgeGather,
+      bound: /* @__PURE__ */ new Map()
+    };
+    await ctx.allocator.check();
+    const setup = new CommandBatch(ctx, `${ALGORITHM$4}/setup`);
+    const setupPass = setup.pass("setup");
+    recordFill(state, setupPass, state.bc, n, 0);
+    if (state.arcScores !== null) {
+      recordFill(state, setupPass, state.arcScores, arcBytes / 4, 0);
+    }
+    setup.endPass();
+    await submit(state, setup, options?.signal);
+    let overflow = false;
+    let batches = 0;
+    let previousLevels = -1;
+    for (let start = 0; start < sources.length; ) {
+      const k = planBatchSize(n, sources.length - start, limits);
+      let form = pinned === "edge" ? "edge" : "frontier";
+      if (pinned === "auto" && previousLevels >= 0) {
+        form = previousLevels < BC_EDGE_PARALLEL_GAMMA * Math.log2(n) ? "edge" : "frontier";
+      }
+      if (state.forwardEdge === null) {
+        form = "frontier";
+      }
+      const batch = sources.slice(start, start + k);
+      const outcome = await runBatch(state, batch, form, levelsPerSubmit, tuning, options?.signal);
+      overflow = overflow || outcome.overflow;
+      previousLevels = outcome.levels;
+      start += k;
+      batches += 1;
+      options?.onProgress?.(start, sources.length);
+    }
+    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);
+    return {
+      vertex: new Float32Array(back, vertexRequest.offset, n).slice(),
+      perArc: arcRequest === null ? null : new Float32Array(back, arcRequest.offset, s.arcCount).slice(),
+      sourcesUsed: sources.length,
+      sigmaOverflow: overflow,
+      batches
+    };
+  } finally {
+    scope.dispose();
+  }
+}
+function normaliser(s, normalized) {
+  const n = s.nodeCount;
+  const factor = s.directed ? (n - 1) * (n - 2) : (n - 1) * (n - 2) / 2;
+  return normalized === true && factor > 0 ? factor : 1;
+}
+async function precheck(ctx, options) {
+  ctx.assertReady();
+  await assertDeviceComputes(ctx);
+  if (options?.endpoints === true) {
+    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"
+    });
+  }
+}
+async function betweennessWithTuning(ctx, s, options, tuning) {
+  await precheck(ctx, options);
+  const n = s.nodeCount;
+  const scores = checkDest$2(ALGORITHM$4, options?.dest, n) ?? new Float32Array(n);
+  const sources = resolveSources(options, n);
+  if (options?.signal?.aborted) {
+    throw aborted(ALGORITHM$4);
+  }
+  if (n === 0 || sources.length === 0) {
+    scores.fill(0);
+    return { scores, iterations: 0, converged: true, precision: "f32", sourcesUsed: 0, sigmaOverflow: false };
+  }
+  const raw = await runRaw(ctx, s, sources, false, tuning, options);
+  const divisor = (s.directed ? 1 : 2) * normaliser(s, options?.normalized);
+  for (let v = 0; v < n; v++) {
+    scores[v] = raw.vertex[v] / divisor;
+  }
+  return {
+    scores,
+    iterations: raw.batches,
+    converged: true,
+    precision: "f32",
+    sourcesUsed: raw.sourcesUsed,
+    sigmaOverflow: raw.sigmaOverflow
+  };
+}
+async function edgeBetweennessWithTuning(ctx, s, options, tuning, onArcs) {
+  await precheck(ctx, options);
+  const n = s.nodeCount;
+  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$4);
+  }
+  if (n === 0 || sources.length === 0 || s.arcCount === 0) {
+    scores.fill(0);
+    return { scores, precision: "f32", sourcesUsed: sources.length, sigmaOverflow: false };
+  }
+  const raw = await runRaw(ctx, s, sources, true, tuning, options);
+  const perArc = raw.perArc ?? new Float32Array(s.arcCount);
+  const folded = foldArcs(s, perArc, "sum");
+  const divisor = (s.directed ? 1 : 2) * normaliser(s, options?.normalized);
+  for (let e = 0; e < s.edgeCount; e++) {
+    scores[e] = folded[e] / divisor;
+  }
+  return { scores, precision: "f32", sourcesUsed: raw.sourcesUsed, sigmaOverflow: raw.sigmaOverflow };
+}
+function betweennessCentrality(ctx, s, options) {
+  return betweennessWithTuning(ctx, s, options, {});
+}
+function edgeBetweennessCentrality(ctx, s, options) {
+  return edgeBetweennessWithTuning(ctx, s, options, {});
+}
+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 {
@@ -7218,33 +8587,48 @@ function reusingScratch(scope) {
     }
   };
 }
-async function weightedRoute(ctx, s, scores, options) {
+async function weightedRoute(ctx, s, scores, sources, options) {
   const n = s.nodeCount;
-  for (let source = 0; source < n; source++) {
+  const count = sources?.length ?? n;
+  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 });
     let sum = 0;
     for (let v = 0; v < n; v++) {
       const d = dist[v];
       if (v !== source && d !== Infinity) {
-        sum += d;
+        if (totals === null) {
+          sum += d;
+        } else {
+          totals[v] += d;
+        }
       }
     }
-    scores[source] = sum === 0 ? 0 : 1 / sum;
-    options?.onProgress?.(source + 1, n);
+    if (totals === null) {
+      scores[source] = sum === 0 ? 0 : 1 / sum;
+    }
+    options?.onProgress?.(i + 1, count);
+  }
+  if (totals !== null) {
+    totals.forEach((sum, v) => {
+      scores[v] = sum === 0 ? 0 : 1 / sum;
+    });
   }
-  return { scores, iterations: n, converged: true, precision: "f32" };
+  return { scores, iterations: count, converged: true, precision: "f32", sourcesUsed: count };
 }
-async function sweepRoute(ctx, s, scores, levelsPerSubmit, options, tuning) {
+async function sweepRoute(ctx, s, scores, sources, levelsPerSubmit, options, tuning) {
   const n = s.nodeCount;
-  if (n === 0) {
-    return { scores, iterations: 0, converged: true, precision: "f32" };
+  const seedCount = sources?.length ?? n;
+  if (seedCount === 0) {
+    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;
@@ -7265,7 +8649,17 @@ async function sweepRoute(ctx, s, scores, levelsPerSubmit, options, tuning) {
       FRONTIER_COUNTERS.byteLength
     );
     const perSourceBytes = 4 * PER_SOURCE_WORDS;
-    const perSource = bindingOf(scope.scratch(perSourceBytes, "per-source"), perSourceBytes);
+    const zeroedWords = PER_SOURCE_WORDS + (sources === null ? 0 : bitsBase);
+    const perSourceAll = 4 * (zeroedWords + (sources === null ? 0 : sources.length));
+    const perSource = bindingOf(scope.scratch(perSourceAll, "per-source"), perSourceAll);
+    if (sources !== null) {
+      ctx.device.queue.writeBuffer(
+        perSource.buffer,
+        perSource.offset + 4 * zeroedWords,
+        Uint32Array.from(sources)
+      );
+    }
+    const totals = sources === null ? null : new Float64Array(n);
     await ctx.allocator.check();
     const compact = await prepareCompact(reusingScratch(scope));
     const sweep = await ctx.pipelines.kernel(kernelSpec("closeness-sweep", graphOverrides(core, null)));
@@ -7275,29 +8669,34 @@ async function sweepRoute(ctx, s, scores, levelsPerSubmit, options, tuning) {
     const onePlan = plan1d(1, wg, ctx.caps);
     const regionPlan = plan1d(bitsBase, wg, ctx.caps);
     const sweepPlan = planGridStride(n, wg, ctx.caps);
-    const recordFill = (pass, dst, count, mode) => {
+    const recordFill2 = (pass, dst, count, mode) => {
       const params = scope.params(FILL_PARAMS, { count, value: 0, mode, pad0: 0 });
       fill.dispatch(pass, fill.bind({ dst, P: params.binding }), plan1d(count, wg, ctx.caps), [params.offset]);
     };
-    const submit = (batch) => {
+    const submit2 = (batch) => {
       scope.flush();
       return batch.submit();
     };
-    const setup = new CommandBatch(ctx, `${ALGORITHM}/setup`);
-    recordFill(setup.pass("fill"), iota, n, 1);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$3}/setup`);
+    recordFill2(setup.pass("fill"), iota, n, 1);
     setup.endPass();
-    await submit(setup).readback;
+    await submit2(setup).readback;
     ctx.assertReady();
     let batches = 0;
-    for (let batchStart = 0; batchStart < n; batchStart += SOURCES_PER_BATCH) {
+    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) {
-          recordFill(pass, bits, 4 * bitsBase, 0);
-          recordFill(pass, perSource, PER_SOURCE_WORDS, 0);
-          const seed = scope.params(FRONTIER_PARAMS, { role: 1, n, bitsBase, source: batchStart });
+          recordFill2(pass, bits, 4 * bitsBase, 0);
+          recordFill2(pass, perSource, zeroedWords, 0);
+          const seed = scope.params(FRONTIER_PARAMS, {
+            role: sources === null ? 1 : 2,
+            n: seedCount,
+            bitsBase,
+            source: batchStart
+          });
           reduce.dispatch(pass, reduce.bind({ counters, perSource, bits, P: seed.binding }), onePlan, [
             seed.offset
           ]);
@@ -7315,7 +8714,8 @@ async function sweepRoute(ctx, s, scores, levelsPerSubmit, options, tuning) {
             arcBase: 0,
             arcEnd: s.arcCount,
             mode,
-            stride: sweepPlan.stride ?? wg
+            stride: sweepPlan.stride ?? wg,
+            perNode: sources === null ? 0 : 1
           });
           return {
             bound: sweep.bind({ ...graph, frontierList, counters, bits, perSource, P: params.binding }),
@@ -7340,18 +8740,26 @@ async function sweepRoute(ctx, s, scores, levelsPerSubmit, options, tuning) {
         batch.endPass();
         const doneRequest = batch.readback(counters.buffer, counters.offset + 4 * W.done, 4);
         const blockRequest = batch.readback(perSource.buffer, perSource.offset, perSourceBytes);
-        const submitted = submit(batch);
+        const nodeRequest = totals === null ? null : batch.readback(perSource.buffer, perSource.offset + perSourceBytes, 4 * n);
+        const submitted = submit2(batch);
         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);
-          const count = Math.min(SOURCES_PER_BATCH, n - batchStart);
-          for (let i = 0; i < count; i++) {
-            const sum = block[3 * SOURCES_PER_BATCH + i] * 2 ** 32 + block[2 * SOURCES_PER_BATCH + i];
-            scores[batchStart + i] = sum === 0 ? 0 : 1 / sum;
+          if (totals === null || nodeRequest === null) {
+            const count = Math.min(SOURCES_PER_BATCH, n - batchStart);
+            for (let i = 0; i < count; i++) {
+              const sum = block[3 * SOURCES_PER_BATCH + i] * 2 ** 32 + block[2 * SOURCES_PER_BATCH + i];
+              scores[batchStart + i] = sum === 0 ? 0 : 1 / sum;
+            }
+          } else {
+            const sums = new Uint32Array(back, nodeRequest.offset, n);
+            for (let v = 0; v < n; v++) {
+              totals[v] += sums[v];
+            }
           }
           tuning.onBatch?.(batchStart, block.slice());
           break;
@@ -7359,36 +8767,61 @@ async function sweepRoute(ctx, s, scores, levelsPerSubmit, options, tuning) {
         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` }
           );
         }
       }
       batches += 1;
-      options?.onProgress?.(Math.min(batchStart + SOURCES_PER_BATCH, n), n);
+      options?.onProgress?.(Math.min(batchStart + SOURCES_PER_BATCH, seedCount), seedCount);
     }
-    return { scores, iterations: batches, converged: true, precision: "f32" };
+    totals?.forEach((sum, v) => {
+      scores[v] = sum === 0 ? 0 : 1 / sum;
+    });
+    return { scores, iterations: batches, converged: true, precision: "f32", sourcesUsed: seedCount };
   } finally {
     scope.dispose();
   }
 }
+function checkSources(s, sources) {
+  if (sources === void 0) {
+    return null;
+  }
+  if (s.directed) {
+    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$3}: a source is not a node index`, {
+        argument: "sources",
+        value: v,
+        expected: `an integer in [0, ${s.nodeCount})`
+      });
+    }
+  }
+  return sources;
+}
 async function closenessWithTuning(ctx, s, options, tuning) {
   ctx.assertReady();
   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"
       });
     }
   }
   const n = s.nodeCount;
+  const sources = checkSources(s, options?.sources);
   const levelsPerSubmit = tuning.levelsPerSubmit ?? MAX_LEVELS_PER_SUBMIT;
   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,
@@ -7396,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"
@@ -7413,24 +8846,261 @@ 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"
       });
     }
-    return weightedRoute(ctx, s, scores, options);
+    return weightedRoute(ctx, s, scores, sources, options);
   }
-  return sweepRoute(ctx, s, scores, levelsPerSubmit, options, tuning);
+  return sweepRoute(ctx, s, scores, sources, levelsPerSubmit, options, tuning);
 }
 function closenessCentrality(ctx, s, options) {
   return closenessWithTuning(ctx, s, options, {});
 }
-const U32_MAX = 4294967295;
-async function prepareHistogram(scope) {
-  return prepareHistogramImpl(scope);
+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 };
 }
-async function prepareHistogramImpl(scope) {
-  const histogram = await scope.pipelines.kernel(kernelSpec("histogram"));
-  const fill = await scope.pipelines.kernel(kernelSpec("fill"));
+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) {
@@ -7439,7 +9109,7 @@ async function prepareCountingSort(scope) {
   const scatter = await scope.pipelines.kernel(kernelSpec("counting-scatter"));
   return new CountingSortPlannerImpl(scope, histogram, scan, scatter);
 }
-function checkWords(name, binding, words) {
+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,
@@ -7448,122 +9118,867 @@ function checkWords(name, binding, 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
-    });
+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
+    });
+  }
+  if (!Number.isSafeInteger(bins) || bins < 1 || bins > U32_MAX) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", "histogram: bins must be an integer in [1, 2^32)", {
+      argument: "bins",
+      value: bins
+    });
+  }
+  checkWords$1("keys", keys, count);
+  checkWords$1("hist", hist, bins);
+}
+class HistogramPlannerImpl {
+  /**
+   * Wraps the resolved kernels; use prepareHistogram().
+   * @param scope - the caller's scope
+   * @param histogram - the `histogram` kernel
+   * @param fill - the `fill` kernel
+   */
+  constructor(scope, histogram, fill) {
+    this.dispatches = 0;
+    this.scope = scope;
+    this.histogram = histogram;
+    this.fill = fill;
+  }
+  /**
+   * Dispatches the last record() issued.
+   * @returns the count
+   */
+  get lastDispatches() {
+    return this.dispatches;
+  }
+  /**
+   * Records the fill and the histogram (see the interface).
+   * @param pass - the compute pass
+   * @param keys - the keys
+   * @param count - the key count
+   * @param bins - the bin count
+   * @param hist - the counts
+   */
+  record(pass, keys, count, bins, hist) {
+    checkHistogramArguments(keys, count, bins, hist);
+    this.recordZero(pass, hist, bins);
+    this.dispatches = 1;
+    if (count === 0) {
+      return;
+    }
+    const params = this.scope.params(HIST_PARAMS, { count, bins, pad0: 0, pad1: 0 });
+    const bound = this.histogram.bind({ keys, hist, P: params.binding });
+    this.histogram.dispatch(pass, bound, plan1d(count, this.scope.workgroupSize, this.scope.caps), [params.offset]);
+    this.dispatches = 2;
+  }
+  /**
+   * Records a `fill` of `words` zeros into `dst` (PD-12: a dispatch inside the pass, never an encoder clear).
+   * @param pass - the compute pass
+   * @param dst - the words to zero
+   * @param words - how many (>= 1)
+   */
+  recordZero(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]);
+  }
+}
+class CountingSortPlannerImpl {
+  /**
+   * Wraps the resolved planners and kernel; use prepareCountingSort().
+   * @param scope - the caller's scope
+   * @param histogram - the histogram planner (also the zeroing of the cursor)
+   * @param scan - the scan planner
+   * @param scatter - the `counting-scatter` kernel
+   */
+  constructor(scope, histogram, scan, scatter) {
+    this.dispatches = 0;
+    this.scope = scope;
+    this.histogram = histogram;
+    this.scan = scan;
+    this.scatter = scatter;
+  }
+  /**
+   * Dispatches the last record() issued.
+   * @returns the count
+   */
+  get lastDispatches() {
+    return this.dispatches;
+  }
+  /**
+   * Records the four stages (see the interface).
+   * @param pass - the compute pass
+   * @param keys - the keys
+   * @param count - the key count
+   * @param bins - the bin count
+   * @param scratch - the histogram and cursor
+   * @param outIndex - the sorted indices
+   * @param outStart - the bin starts
+   */
+  record(pass, keys, count, bins, scratch, outIndex, outStart) {
+    checkHistogramArguments(keys, count, bins, scratch.hist);
+    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);
+    this.dispatches = this.histogram.lastDispatches + this.scan.lastDispatches + 1;
+    if (count === 0) {
+      return;
+    }
+    const params = this.scope.params(HIST_PARAMS, { count, bins, pad0: 0, pad1: 0 });
+    const bound = this.scatter.bind({ keys, start: outStart, cursor: scratch.cursor, outIndex, P: params.binding });
+    this.scatter.dispatch(pass, bound, plan1d(count, this.scope.workgroupSize, this.scope.caps), [params.offset]);
+    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;
   }
-  if (!Number.isSafeInteger(bins) || bins < 1 || bins > U32_MAX) {
-    throw new WebGpuGraphError("E_INVALID_ARGUMENT", "histogram: bins must be an integer in [1, 2^32)", {
-      argument: "bins",
-      value: bins
-    });
+  const inDegree = s.inDegree();
+  const bound = new Uint32Array(s.nodeCount);
+  for (let v = 0; v < bound.length; v++) {
+    bound[v] = out[v] + inDegree[v];
   }
-  checkWords("keys", keys, count);
-  checkWords("hist", hist, bins);
+  return bound;
 }
-class HistogramPlannerImpl {
-  /**
-   * Wraps the resolved kernels; use prepareHistogram().
-   * @param scope - the caller's scope
-   * @param histogram - the `histogram` kernel
-   * @param fill - the `fill` kernel
-   */
-  constructor(scope, histogram, fill) {
-    this.dispatches = 0;
-    this.scope = scope;
-    this.histogram = histogram;
-    this.fill = fill;
+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})`
+      });
+    }
   }
-  /**
-   * Dispatches the last record() issued.
-   * @returns the count
-   */
-  get lastDispatches() {
-    return this.dispatches;
+  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;
   }
-  /**
-   * Records the fill and the histogram (see the interface).
-   * @param pass - the compute pass
-   * @param keys - the keys
-   * @param count - the key count
-   * @param bins - the bin count
-   * @param hist - the counts
-   */
-  record(pass, keys, count, bins, hist) {
-    checkHistogramArguments(keys, count, bins, hist);
-    this.recordZero(pass, hist, bins);
-    this.dispatches = 1;
-    if (count === 0) {
-      return;
+  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 params = this.scope.params(HIST_PARAMS, { count, bins, pad0: 0, pad1: 0 });
-    const bound = this.histogram.bind({ keys, hist, P: params.binding });
-    this.histogram.dispatch(pass, bound, plan1d(count, this.scope.workgroupSize, this.scope.caps), [params.offset]);
-    this.dispatches = 2;
+    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();
   }
-  /**
-   * Records a `fill` of `words` zeros into `dst` (PD-12: a dispatch inside the pass, never an encoder clear).
-   * @param pass - the compute pass
-   * @param dst - the words to zero
-   * @param words - how many (>= 1)
-   */
-  recordZero(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]);
+}
+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 };
 }
-class CountingSortPlannerImpl {
-  /**
-   * Wraps the resolved planners and kernel; use prepareCountingSort().
-   * @param scope - the caller's scope
-   * @param histogram - the histogram planner (also the zeroing of the cursor)
-   * @param scan - the scan planner
-   * @param scatter - the `counting-scatter` kernel
-   */
-  constructor(scope, histogram, scan, scatter) {
-    this.dispatches = 0;
-    this.scope = scope;
-    this.histogram = histogram;
-    this.scan = scan;
-    this.scatter = scatter;
+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`, {});
   }
-  /**
-   * Dispatches the last record() issued.
-   * @returns the count
-   */
-  get lastDispatches() {
-    return this.dispatches;
+  if (n === 0) {
+    options?.onProgress?.(1, 1);
+    return epilogue(dest ?? new Uint32Array(0), new Uint32Array(1));
   }
-  /**
-   * Records the four stages (see the interface).
-   * @param pass - the compute pass
-   * @param keys - the keys
-   * @param count - the key count
-   * @param bins - the bin count
-   * @param scratch - the histogram and cursor
-   * @param outIndex - the sorted indices
-   * @param outStart - the bin starts
-   */
-  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);
-    this.histogram.record(pass, keys, count, bins, scratch.hist);
-    this.scan.record(pass, scratch.hist, bins, outStart);
-    this.histogram.recordZero(pass, scratch.cursor, bins);
-    this.dispatches = this.histogram.lastDispatches + this.scan.lastDispatches + 1;
-    if (count === 0) {
-      return;
+  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]
+      );
     }
-    const params = this.scope.params(HIST_PARAMS, { count, bins, pad0: 0, pad1: 0 });
-    const bound = this.scatter.bind({ keys, start: outStart, cursor: scratch.cursor, outIndex, P: params.binding });
-    this.scatter.dispatch(pass, bound, plan1d(count, this.scope.workgroupSize, this.scope.caps), [params.offset]);
-    this.dispatches += 1;
+    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) {
@@ -12412,6 +14827,15 @@ function copyBetweenness(defaults) {
   }
   return Object.freeze(copy);
 }
+function withBetweennessDefaults(defaults, options, nodeCount) {
+  if (defaults === void 0 || options?.sources !== void 0 || options?.k !== void 0) {
+    return options;
+  }
+  if (defaults.sources !== void 0) {
+    return { ...options, sources: defaults.sources.filter((v) => v < nodeCount) };
+  }
+  return { ...options, k: defaults.k !== void 0 && defaults.k < nodeCount ? defaults.k : void 0 };
+}
 function copyAlgorithms(algorithms) {
   const copy = { ...algorithms };
   if (algorithms.betweenness !== void 0) {
@@ -12573,17 +14997,95 @@ function createAccelerator(ctx, options) {
       ctx.assertReady();
       return await bellmanFord(ctx, gs, source, o);
     },
+    /**
+     * Betweenness centrality on the device (spec 8.4): exact, or sampled through `sources` / `k` (the call's own,
+     * else the accelerator's `algorithms.betweenness` defaults), the unscaled sum over the sources run.
+     * `endpoints: true` is refused.
+     * @param gs - the snapshot
+     * @param o - the seam's `BetweennessAcceleratorOptions`
+     * @returns the f32 scores with `sourcesUsed` and `sigmaOverflow`
+     */
+    async betweennessCentrality(gs, o) {
+      ctx.assertReady();
+      return await betweennessCentrality(
+        ctx,
+        gs,
+        withBetweennessDefaults(frozen.algorithms?.betweenness, o, gs.nodeCount)
+      );
+    },
+    /**
+     * Edge betweenness on the device (spec 8.4): one score per edge, arcs summed and halved when undirected; sampling
+     * and defaults as `betweennessCentrality`.
+     * @param gs - the snapshot
+     * @param o - the seam's `BetweennessAcceleratorOptions`
+     * @returns the f32 per-edge scores with `sourcesUsed` and `sigmaOverflow`
+     */
+    async edgeBetweennessCentrality(gs, o) {
+      ctx.assertReady();
+      return await edgeBetweennessCentrality(
+        ctx,
+        gs,
+        withBetweennessDefaults(frozen.algorithms?.betweenness, o, gs.nodeCount)
+      );
+    },
     /**
      * Closeness centrality on the device (spec 8.4; P8-T13): the bit-parallel multi-source sweep, or one `sssp`
      * per source when `weighted`. `maxIterations` / `tolerance` are refused when defined (P8 PD-25).
      * @param gs - the snapshot
-     * @param o - the seam's placeholder `HitsOptionsLike` (`weighted`)
-     * @returns the f32 scores with `precision: "f32"` (spec 9.7)
+     * @param o - `weighted`, and a sampled run's `sources` (undirected snapshots only)
+     * @returns the f32 scores with `precision: "f32"` (spec 9.7) and `sourcesUsed`
      */
     async closenessCentrality(gs, o) {
       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
@@ -12693,7 +15195,7 @@ async function calibrateLayout(ctx, options) {
   };
 }
 export {
-  J as ARC_WINDOW_ALIGN,
+  a0 as ARC_WINDOW_ALIGN,
   EXACT_MAX_NODES,
   FA2_DEFAULTS,
   FR_DEFAULTS,
@@ -12701,12 +15203,14 @@ export {
   LAYOUT_TUNING_DEFAULTS,
   MAX_1D_ITEMS,
   MAX_WORKGROUPS_PER_DIM,
-  K as PASSTHROUGH_FORMAT_CODES,
+  a1 as PASSTHROUGH_FORMAT_CODES,
   SE_DEFAULTS,
-  N as STORAGE_ALIGN,
-  O as WORKGROUP_SIZE,
+  a2 as STORAGE_ALIGN,
+  a3 as WORKGROUP_SIZE,
   WebGpuGraphError,
+  allPairsShortestPath,
   bellmanFord,
+  betweennessCentrality,
   breadthFirstSearch,
   calibrateLayout,
   closenessCentrality,
@@ -12716,16 +15220,19 @@ export {
   createFruchtermanReingold,
   createSpringElectrical,
   degree,
+  edgeBetweennessCentrality,
   eigenvectorCentrality,
   hasErrorCode,
   hits,
-  Q as isSoftwareAdapter,
+  a4 as isSoftwareAdapter,
   isWebGpuGraphError,
   katzCentrality,
+  labelPropagation,
   pageRank,
   personalizedPageRank,
   seedPositions,
   sssp,
+  triangleCount,
   verifyDevice
 };
 //# sourceMappingURL=webgpu-graph-algorithms.js.map