@graphty/webgpu-graph-algorithms 0.6.13 → 0.6.15

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, m as GRID_COARSEST_SIDE, n as GRID_MIN_SIDE, o as GRID_SORT_BITS, p as FA2_DEFAULTS, q as MAX_ITERATIONS_PER_STEP, r as MAX_1D_ITEMS, s as hasErrorCode, t as FA2_FLAG_FIRST, P as PARTIAL_BYTES, E as EXACT_TILES_PER_PASS, I as INDIRECT_ARGS_STRIDE, u as GRID_HUB_CELL, L as LAYOUT_TUNING_DEFAULTS, v as EXACT_MAX_NODES, w as SETTLE_FLOOR_UNBOUNDED, T as TRACE_RECORD_BYTES, x as GRID_BBOX_MARGIN, y as GRID_EXTENT_FLOOR, z as FR_ADAPTIVE_MAX_ITERATIONS, A as FR_START_TEMPERATURE, C as FA2_FLAG_ADAPTIVE, D as SETTLE_FLOOR_FRACTION, H as FR_REHEAT_FRACTION, J as FR_DEFAULTS, K as SE_DEFAULTS, N as SETTLE_FLOOR_REFERENCE_NODES, O as SE_SCALE_REFERENCE_NODES } from "./chunks/context-oXphO3yj.js";
+import { Q, G, V, X, Y, Z } from "./chunks/context-oXphO3yj.js";
+import { 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.
@@ -605,6 +605,254 @@ fn advance_expand(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocati
 }
 `
 );
+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 +1102,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 +1157,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 +1214,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; }
@@ -2805,7 +3062,9 @@ const FRONTIER_COUNTERS = UniformBlock.define(
     ["thresholdBits", "u32"],
     ["deltaBits", "u32"],
     ["path", "u32"],
-    ["nextDegreeSum", "u32"]
+    ["nextDegreeSum", "u32"],
+    ["stackTop", "u32"],
+    ["sigmaOverflow", "u32"]
   ],
   { layout: "storage" }
 );
@@ -2828,9 +3087,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"],
@@ -3616,6 +3885,117 @@ const CLOSENESS_REDUCE = {
   snippetSlots: [],
   phase: "P8"
 };
+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 REGISTRY = Object.freeze({
   degree: DEGREE,
   reduce: REDUCE,
@@ -3662,7 +4042,13 @@ 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
 });
 const bodyOverrides = /* @__PURE__ */ new Map();
 function entryOf(id) {
@@ -3821,7 +4207,7 @@ class ScanPlannerImpl {
 }
 const POISON = 3735928559;
 const CHECK_BLOCKS = 32;
-const RING_SLOTS$6 = 8;
+const RING_SLOTS$7 = 8;
 const checked = /* @__PURE__ */ new WeakMap();
 function inputAt(i) {
   return i + 1;
@@ -3849,7 +4235,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$7, "device-check/ring");
   try {
     const scope = {
       device: ctx.device,
@@ -4516,12 +4902,12 @@ function algorithmScope(ctx, label, slots) {
     ringOverruns: () => ring.overruns
   };
 }
-const ALGORITHM$4 = "connectedComponents";
+const ALGORITHM$5 = "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;
+const RING_SLOTS$6 = 2 * ROUNDS_PER_BATCH$1;
 function checkDest$4(dest, n) {
   if (dest === void 0) {
     return null;
@@ -4531,7 +4917,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$5}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
     {
       argument: "dest",
       value: `${dest.constructor.name}(${dest.length})`,
@@ -4541,7 +4927,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$5);
   return core;
 }
 function bindingOf$3(buffer, size) {
@@ -4600,8 +4986,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$5}: labels[${v}] = ${label} is not a node index`, {
+        label: `${ALGORITHM$5}/labels`,
         message: `the device produced a label outside [0, ${n})`
       });
     }
@@ -4619,7 +5005,7 @@ async function connectedComponents(ctx, s, options) {
   const renumber = options?.renumber !== false;
   const dest = checkDest$4(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$5}: the signal was aborted before any work started`, {});
   }
   if (n === 0) {
     options?.onProgress?.(1, 1);
@@ -4636,7 +5022,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$5, RING_SLOTS$6);
   try {
     const compBytes = 4 * (n + 1);
     const comp = scope.scratch(compBytes, "comp");
@@ -4660,12 +5046,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$5}/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 +5068,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$5}/sample`);
     pass = sampler.pass("sample");
     const sampleParams = wccParams({ items, stride: 0, r: 0, giant: U32_MAX$2 });
     sample.dispatch(
@@ -4695,14 +5081,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$5}/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 +5098,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$5}: the signal was aborted`, {
           batchId: submitted.id
         });
       }
@@ -4727,15 +5113,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$5}: the changed flag never settled in ${MAX_WCC_ROUNDS} rounds`,
+          { label: ALGORITHM$5, message: `the changed flag never settled in ${MAX_WCC_ROUNDS} rounds` }
         );
       }
     }
-    const final = new CommandBatch(ctx, `${ALGORITHM$4}/final`);
+    const final = new CommandBatch(ctx, `${ALGORITHM$5}/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);
@@ -5098,7 +5484,7 @@ 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;
+const RING_SLOTS$5 = 2 * PR_BATCH + 2;
 function checkDest$3(dest, n, algorithm) {
   if (dest === void 0) {
     return null;
@@ -5176,7 +5562,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$5);
   let uploaded = null;
   try {
     const bytes = 4 * n;
@@ -5193,7 +5579,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 +5612,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,7 +5725,7 @@ async function personalizedPageRank(ctx, s, personalization, options) {
   return run(ctx, s, normalised2, options, "personalizedPageRank");
 }
 const BATCH = 8;
-const RING_SLOTS$3 = 4 * BATCH + 8;
+const RING_SLOTS$4 = 4 * BATCH + 8;
 function checkDest$2(dest, n, algorithm) {
   if (dest === void 0) {
     return null;
@@ -5378,7 +5764,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$4);
   try {
     const bytes = 4 * n;
     const ring = (config.alternate === null ? ["rankA", "rankB"] : ["rankA", "rankB", "rankC"]).map(
@@ -5822,7 +6208,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 +6544,7 @@ class RadixSortPlannerImpl {
     return src;
   }
 }
-const ALGORITHM$3 = "breadthFirstSearch";
+const ALGORITHM$4 = "breadthFirstSearch";
 const NEXT_DEGREE_MAX_GROUPS = 128;
 function bfsRingSlots(windows, levelsPerSubmit) {
   return Math.max((5 + 4 * windows) * levelsPerSubmit + 16, RESULT_BATCH_SLOTS + windows);
@@ -6177,7 +6565,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$4}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
     {
       argument: "dest",
       value: `${dest.constructor.name}(${dest.length})`,
@@ -6192,8 +6580,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$4}: the ${name} view has no ${name} binding`, {
+      label: `${ALGORITHM$4}/${name}`,
       message: `the ${name} view has no ${name} binding`
     });
   }
@@ -6202,15 +6590,15 @@ function degreeView(ctx, s, name) {
 function aborted$1(batchId) {
   return new WebGpuGraphError(
     "E_ABORTED",
-    `${ALGORITHM$3}: the signal was aborted`,
+    `${ALGORITHM$4}: 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$4}: counters.${name} did not decode to a number`, {
+      label: `${ALGORITHM$4}/counters`,
       message: `the field ${name} did not decode to a number`
     });
   }
@@ -6221,7 +6609,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$4}: source ${source} is outside [0, ${n})`, {
       argument: "source",
       value: source,
       expected: `an integer in [0, ${n})`
@@ -6231,7 +6619,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$4}: levelsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
       {
         argument: "levelsPerSubmit",
         value: levelsPerSubmit,
@@ -6250,12 +6638,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$4}: the reverse adjacency of a directed snapshot (${4 * s.arcCount} bytes) needs arc windows, which no view executes (spec 4.3); the bottom-up sweep binds it whole`,
       {
         needed: 4 * s.arcCount,
         limit: ctx.caps.limits.maxStorageBufferBindingSize,
         path: "windowed",
-        algorithm: ALGORITHM$3
+        algorithm: ALGORITHM$4
       }
     );
   }
@@ -6263,7 +6651,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$4, bfsRingSlots(forward.length, levelsPerSubmit));
   tuning.onScope?.(scope);
   try {
     const bytes = 4 * n;
@@ -6305,7 +6693,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 +6711,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$4}/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 +6735,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$4}/levels`);
       const pass2 = batch.pass("bfs");
       recordRebuild(pass2);
       const bitsParams = scope.params(FILL_PARAMS, { count: bitsWords, value: 0, mode: 0, pad0: 0 });
@@ -6436,7 +6824,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 +6845,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$4}: the done flag never rose in ${submits} submits (a traversal has at most ${n} levels)`,
+          { label: ALGORITHM$4, message: `the done flag never rose in ${submits} submits` }
         );
       }
     }
@@ -6472,12 +6860,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$4}/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 +6890,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$4}: visitedCount ${visitedCount} exceeds the ${n} vertices (a duplicate claim)`,
         {
-          label: `${ALGORITHM$3}/visitedCount`,
+          label: `${ALGORITHM$4}/visitedCount`,
           message: `the device counted ${visitedCount} visits of ${n} vertices`
         }
       );
@@ -6535,9 +6923,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$3 = "sssp";
 const HALF_ALIGN = 64;
-const RING_SLOTS$2 = 4 * MAX_LEVELS_PER_SUBMIT + 40;
+const RING_SLOTS$3 = 4 * MAX_LEVELS_PER_SUBMIT + 40;
 function bitsOf(value) {
   return new Uint32Array(Float32Array.of(value).buffer)[0];
 }
@@ -6563,8 +6951,8 @@ 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$3}: counters.${name} did not decode to a number`, {
+      label: `${ALGORITHM$3}/counters`,
       message: `the field ${name} did not decode to a number`
     });
   }
@@ -6664,7 +7052,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 +7087,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 +7119,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$3, 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$3}: roundsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
       {
         argument: "roundsPerSubmit",
         value: roundsPerSubmit,
@@ -6745,42 +7133,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$3}: 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(ALGORITHM$3, options?.dest, n);
+  const vector2 = resolveWeights$1(ALGORITHM$3, s, options?.weights);
+  const cutoff = normaliseCutoff(ALGORITHM$3, options?.cutoff);
   if (options?.signal?.aborted) {
-    throw aborted(ALGORITHM$2);
+    throw aborted(ALGORITHM$3);
   }
   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$3}: 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$3}: 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$3);
   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$3}: the near-far queue of ${cap} entries per half needs ${8 * cap} bytes, above the ${limit}-byte binding limit (the relax is never windowed)`,
+      { needed: 8 * cap, limit, path: "sssp.queue", algorithm: ALGORITHM$3 }
     );
   }
   const delta = Math.fround(
@@ -6789,7 +7177,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$3, RING_SLOTS$3);
   try {
     const wg = ctx.workgroupSize;
     const bytes = 4 * n;
@@ -6819,20 +7207,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$3}/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 +7261,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$3}/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 +7278,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$3, submitted.id);
       }
       options?.onProgress?.(Math.min(roundsRecorded, maxRounds), maxRounds);
       if (inspect !== null && tuning.onRound !== void 0) {
@@ -6921,30 +7309,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$3}: a raw pile of ${needed} entries overflowed its ${cap}-entry half`,
+            { needed, limit: cap, path: "sssp.pile", algorithm: ALGORITHM$3 }
           );
         }
         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$3}: 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$3}: the done flag never rose in ${submits} submits (at most ${maxRounds} rounds)`,
+          { label: `${ALGORITHM$3}/rounds`, message: `the done flag never rose in ${submits} submits` }
         );
       }
     }
     const passed = await predecessorPass({
-      algorithm: ALGORITHM$2,
+      algorithm: ALGORITHM$3,
       ctx,
       scope,
       predKernel,
-      recordFill,
+      recordFill: recordFill2,
       graph,
       dist,
       pred,
@@ -6956,8 +7344,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$3}: ${passed.orphans} reached node(s) the predecessor key never reached (a kernel bug)`,
+        { label: `${ALGORITHM$3}/pred`, message: `${passed.orphans} orphan(s) in the predecessor pass` }
       );
     }
     const distOut = dest ?? new Float32Array(n);
@@ -6976,10 +7364,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$2 = "bellmanFord";
 const ROUNDS_PER_BATCH = 8;
 const MAX_RETRIES = 16;
-const RING_SLOTS$1 = MAX_LEVELS_PER_SUBMIT + 16;
+const RING_SLOTS$2 = MAX_LEVELS_PER_SUBMIT + 16;
 function assertSymmetric(s, vector2) {
   const { arcToEdge, edgeToArc } = s;
   for (let a = 0; a < s.arcCount; a++) {
@@ -6987,7 +7375,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$2}: weights[${a}] = ${vector2[a]} differs from weights[${forward}] = ${vector2[forward]}, the forward arc of the same undirected edge; the kernel reads one weight per edge`,
         { feature: "bellmanFord.asymmetricUndirectedWeights", hint: "use a directed snapshot" }
       );
     }
@@ -6997,10 +7385,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$2, 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$2}: maxRetries must be an integer >= 1`, {
       argument: "maxRetries",
       value: maxRetries,
       expected: "an integer >= 1"
@@ -7010,7 +7398,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$2}: roundsPerBatch must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
       {
         argument: "roundsPerBatch",
         value: roundsPerBatch,
@@ -7018,18 +7406,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(ALGORITHM$2, options?.dest, n);
+  const vector2 = resolveWeights$1(ALGORITHM$2, s, options?.weights);
+  const cutoff = normaliseCutoff(ALGORITHM$2, options?.cutoff);
   if (options?.signal?.aborted) {
-    throw aborted(ALGORITHM$1);
+    throw aborted(ALGORITHM$2);
   }
   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$2}: a NaN or infinite weight has no shortest path`, {
       feature: "bellmanFord.nonFiniteWeights"
     });
   }
@@ -7038,10 +7426,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$2);
   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$2, RING_SLOTS$2);
   try {
     const wg = ctx.workgroupSize;
     const bytes = 4 * n;
@@ -7068,23 +7456,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$2}/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 +7493,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$2}/${label}`);
       const pass = batch.pass("relax");
       const params = scope.params(BF_PARAMS, relaxFields);
       const bound = relax.bind({ ...relaxBindings, P: params.binding });
@@ -7114,7 +7502,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 +7518,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$2}: 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$2}/retry`,
               message: "retryExhausted in the decision round",
               batchId: decision.id
             }
@@ -7148,7 +7536,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
         retryExhaustedRounds += 1;
       }
       if (options?.signal?.aborted) {
-        throw aborted(ALGORITHM$1, batch.id);
+        throw aborted(ALGORITHM$2, batch.id);
       }
       options?.onProgress?.(rounds, n);
       if (batch.changed === 0 && batch.retryExhausted === 0) {
@@ -7156,11 +7544,11 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
       }
     }
     const passed = await predecessorPass({
-      algorithm: ALGORITHM$1,
+      algorithm: ALGORITHM$2,
       ctx,
       scope,
       predKernel,
-      recordFill,
+      recordFill: recordFill2,
       graph,
       dist,
       pred,
@@ -7172,7 +7560,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$2}: ${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,6 +7587,381 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
 async function bellmanFord(ctx, s, source, options) {
   return (await bellmanFordWithTuning(ctx, s, source, options, {})).result;
 }
+const ALGORITHM$1 = "betweennessCentrality";
+const BYTES_PER_NODE_SOURCE = 16;
+const SAMPLE_SEED = 2654435769;
+const RING_SLOTS$1 = BC_BACKWARD_LEVELS_PER_SUBMIT + 16;
+function planBatchSize(n, remaining, limits) {
+  const needed = 4 * (n + 2);
+  if (needed > limits.maxStorageBufferBindingSize) {
+    throw new WebGpuGraphError(
+      "E_TOO_LARGE",
+      `${ALGORITHM$1}: one source needs ${needed} bytes in its largest binding at n = ${n}, above maxStorageBufferBindingSize = ${limits.maxStorageBufferBindingSize}; a limit of at least ${needed} admits one source per batch`,
+      { needed, limit: limits.maxStorageBufferBindingSize, path: "binding", algorithm: ALGORITHM$1 }
+    );
+  }
+  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$1}: ${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$1, 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$1}/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$1}: the done flag never rose in ${recorded} levels`, {
+        label: ALGORITHM$1,
+        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$1}/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$1);
+  const { edgeCount } = s;
+  const mayRunEdge = pinned === "edge" || pinned === "auto" && sources.length > kMax;
+  const edgeView = mayRunEdge && edgeCount > 0 ? ctx.residency.view(s, "edgeList") : null;
+  const scope = algorithmScope(ctx, ALGORITHM$1, RING_SLOTS$1);
+  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$1}/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$1}/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$1}: 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(ALGORITHM$1, options?.dest, n) ?? new Float32Array(n);
+  const sources = resolveSources(options, n);
+  if (options?.signal?.aborted) {
+    throw aborted(ALGORITHM$1);
+  }
+  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("edgeBetweennessCentrality", options?.dest, s.edgeCount) ?? new Float32Array(s.edgeCount);
+  const sources = resolveSources(options, n);
+  if (options?.signal?.aborted) {
+    throw aborted(ALGORITHM$1);
+  }
+  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 = "closenessCentrality";
 const SOURCES_PER_BATCH = 32;
 const PER_SOURCE_WORDS = 4 * SOURCES_PER_BATCH;
@@ -7218,29 +7981,44 @@ 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);
     }
+    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);
   }
-  return { scores, iterations: n, converged: true, precision: "f32" };
+  if (totals !== null) {
+    totals.forEach((sum, v) => {
+      scores[v] = sum === 0 ? 0 : 1 / sum;
+    });
+  }
+  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);
@@ -7265,7 +8043,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 +8063,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);
+    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 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 +8108,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,7 +8134,8 @@ 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) {
@@ -7348,10 +8143,17 @@ async function sweepRoute(ctx, s, scores, levelsPerSubmit, options, tuning) {
         }
         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;
@@ -7365,13 +8167,37 @@ async function sweepRoute(ctx, s, scores, levelsPerSubmit, options, tuning) {
         }
       }
       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}: sampled sources need an undirected snapshot`, {
+      feature: "closenessCentrality.directedSources",
+      hint: "run the CPU port, which searches the in-arcs"
+    });
+  }
+  for (const v of sources) {
+    if (!Number.isInteger(v) || v < 0 || v >= s.nodeCount) {
+      throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM}: a source is not a node index`, {
+        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);
@@ -7384,6 +8210,7 @@ async function closenessWithTuning(ctx, s, options, tuning) {
     }
   }
   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(
@@ -7417,9 +8244,9 @@ async function closenessWithTuning(ctx, s, options, tuning) {
         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, {});
@@ -12412,6 +13239,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,12 +13409,43 @@ 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();
@@ -12693,7 +13560,7 @@ async function calibrateLayout(ctx, options) {
   };
 }
 export {
-  J as ARC_WINDOW_ALIGN,
+  Q as ARC_WINDOW_ALIGN,
   EXACT_MAX_NODES,
   FA2_DEFAULTS,
   FR_DEFAULTS,
@@ -12701,12 +13568,13 @@ export {
   LAYOUT_TUNING_DEFAULTS,
   MAX_1D_ITEMS,
   MAX_WORKGROUPS_PER_DIM,
-  K as PASSTHROUGH_FORMAT_CODES,
+  V as PASSTHROUGH_FORMAT_CODES,
   SE_DEFAULTS,
-  N as STORAGE_ALIGN,
-  O as WORKGROUP_SIZE,
+  X as STORAGE_ALIGN,
+  Y as WORKGROUP_SIZE,
   WebGpuGraphError,
   bellmanFord,
+  betweennessCentrality,
   breadthFirstSearch,
   calibrateLayout,
   closenessCentrality,
@@ -12716,10 +13584,11 @@ export {
   createFruchtermanReingold,
   createSpringElectrical,
   degree,
+  edgeBetweennessCentrality,
   eigenvectorCentrality,
   hasErrorCode,
   hits,
-  Q as isSoftwareAdapter,
+  Z as isSoftwareAdapter,
   isWebGpuGraphError,
   katzCentrality,
   pageRank,