@graphty/webgpu-graph-algorithms 0.6.3 → 0.6.5

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, R as RADIX_BINS, c as GRID_COARSEST_SIDE, e as GRID_MIN_SIDE, f as GRID_SORT_BITS, F as FA2_DEFAULTS, g as MAX_ITERATIONS_PER_STEP, h as MAX_1D_ITEMS, j as hasErrorCode, k as FA2_FLAG_FIRST, P as PARTIAL_BYTES, I as INDIRECT_ARGS_STRIDE, l as GRID_HUB_CELL, L as LAYOUT_TUNING_DEFAULTS, E as EXACT_MAX_NODES, T as TRACE_RECORD_BYTES, m as GRID_BBOX_MARGIN, n as GRID_EXTENT_FLOOR, o as FR_ADAPTIVE_MAX_ITERATIONS, p as FR_START_TEMPERATURE, q as FA2_FLAG_ADAPTIVE, r as FR_REHEAT_FRACTION, s as FR_DEFAULTS, t as SE_DEFAULTS, u as SE_SCALE_REFERENCE_NODES } from "./chunks/context-BXqgCifx.js";
-import { A, G, v, w, x, y } from "./chunks/context-BXqgCifx.js";
-import { renumberPartition, 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 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, I as INDIRECT_ARGS_STRIDE, q as GRID_HUB_CELL, L as LAYOUT_TUNING_DEFAULTS, E as EXACT_MAX_NODES, T as TRACE_RECORD_BYTES, r as GRID_BBOX_MARGIN, s as GRID_EXTENT_FLOOR, t as FR_ADAPTIVE_MAX_ITERATIONS, u as FR_START_TEMPERATURE, v as FA2_FLAG_ADAPTIVE, w as FR_REHEAT_FRACTION, x as FR_DEFAULTS, y as SE_DEFAULTS, z as SE_SCALE_REFERENCE_NODES } from "./chunks/context-hzGggHeM.js";
+import { A, G, C, D, H, J } from "./chunks/context-hzGggHeM.js";
+import { renumberPartition, INVALID_INDEX, 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.
@@ -10,6 +10,7 @@ class UniformRing {
    * @param label - the buffer label
    */
   constructor(device, allocator, slots, label) {
+    this.overruns = 0;
     this.next = 0;
     this.dirtyLo = -1;
     this.dirtyHi = -1;
@@ -31,6 +32,7 @@ class UniformRing {
     this.label = label;
     this.shadow = new ArrayBuffer(slots * UNIFORM_SLOT_BYTES);
     this.view = new DataView(this.shadow);
+    this.dirty = new Uint8Array(slots);
     this.buffer = allocator.createBuffer({
       label,
       size: slots * UNIFORM_SLOT_BYTES,
@@ -79,6 +81,9 @@ class UniformRing {
     }
     const first = this.next;
     this.next += count;
+    if (this.dirty.subarray(first, first + count).includes(1)) {
+      this.overruns += 1;
+    }
     return first;
   }
   /**
@@ -91,6 +96,7 @@ class UniformRing {
     this.checkSlot(slot);
     this.assertFits(block);
     block.write(this.view, values, slot * UNIFORM_SLOT_BYTES);
+    this.dirty[slot] = 1;
     if (this.dirtyLo < 0 || slot < this.dirtyLo) {
       this.dirtyLo = slot;
     }
@@ -110,6 +116,7 @@ class UniformRing {
     const begin = this.dirtyLo * UNIFORM_SLOT_BYTES;
     const end = (this.dirtyHi + 1) * UNIFORM_SLOT_BYTES;
     this.device.queue.writeBuffer(this.buffer, begin, this.shadow, begin, end - begin);
+    this.dirty.fill(0);
     this.dirtyLo = -1;
     this.dirtyHi = -1;
   }
@@ -153,7 +160,7 @@ class UniformRing {
 function perDimension(caps) {
   return Math.min(MAX_WORKGROUPS_PER_DIM, caps.limits.maxComputeWorkgroupsPerDimension);
 }
-function assertCount(argument, value) {
+function assertCount$1(argument, value) {
   if (!Number.isInteger(value) || value < 0) {
     throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${argument} must be a non-negative integer, got ${value}`, {
       argument,
@@ -183,8 +190,8 @@ function grid(groups, items, caps) {
   if (groups <= limit) {
     return { x: groups, y: 1, z: 1, items, stride: null };
   }
-  const y2 = Math.ceil(groups / limit);
-  if (y2 > limit) {
+  const y = Math.ceil(groups / limit);
+  if (y > limit) {
     throw new WebGpuGraphError(
       "E_TOO_LARGE",
       `${groups} workgroups exceed the 2D dispatch limit of ${limit * limit}`,
@@ -197,15 +204,15 @@ function grid(groups, items, caps) {
       }
     );
   }
-  return { x: limit, y: y2, z: 1, items, stride: null };
+  return { x: limit, y, z: 1, items, stride: null };
 }
 function plan1d(items, wg, caps) {
-  assertCount("items", items);
+  assertCount$1("items", items);
   assertWorkgroupSize(wg);
   return grid(Math.ceil(items / wg), items, caps);
 }
 function planGridStride(items, wg, caps, maxGroups) {
-  assertCount("items", items);
+  assertCount$1("items", items);
   assertWorkgroupSize(wg);
   if (items === 0) {
     return { x: 0, y: 1, z: 1, items, stride: null };
@@ -544,6 +551,432 @@ ${lines.join("\n")}
     return lanes;
   }
 }
+const advanceExpandWgsl = (
+  /* wgsl */
+  `
+var<workgroup> sh: array<u32, WG>;          // the block's degrees, then their inclusive scan
+var<workgroup> rowStart: array<u32, WG>;    // the first bound arc of each entry's row
+var<workgroup> base: u32;                   // the block's reserved span in the edge queue
+var<workgroup> wcount: u32;                 // the frontier's length on a two-phase level, 0 on any other
+
+@compute @workgroup_size(WG)
+fn advance_expand(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    if (lid.x == 0u) { wcount = select(0u, atomicLoad(&counters[0]), atomicLoad(&counters[24]) == 1u); }   // frontierCount, on the two-phase path only (the path word)
+    let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers
+    for (var b0 = group_id(wid) * WG; b0 < count; b0 = b0 + P.stride) {   // grid-stride over blocks of WG entries (a direct dispatch of the plan's groups)
+        let i = b0 + lid.x;                                          // this lane's frontier entry
+        var deg = 0u;
+        var start = 0u;
+        if (i < count) {                                                 // guarded loads into locals (3.5 rule 1)
+            let v = frontierIn[i];
+            let lo = max(rowPtr[v], P.arcBase);                          // the row clipped to the bound window (P8-T12)
+            let hi = min(rowPtr[v + 1u], P.arcEnd);
+            start = lo;
+            deg = select(0u, hi - lo, hi > lo);
+        }
+        let inclusive = wg_scan_u32(deg, lid.x);                         // the prelude's inclusive scan in LANE order (P8-T1 Step 5); the twin
+        sh[lid.x] = inclusive;                                           // sh is monotone in lid.x, the index the binary search walks
+        rowStart[lid.x] = start;
+        workgroupBarrier();
+        let aggregate = workgroupUniformLoad(&sh[WG - 1u]);              // uniform; includes a barrier
+        if (lid.x == 0u) {
+            base = atomicAdd(&counters[8], aggregate);                   // edgeCount: ONE reservation per workgroup, not one per arc
+            atomicAdd(&counters[9], aggregate);                          // edgeCountUnclamped: the overflow detector (PD-23)
+            atomicAdd(&counters[2], aggregate);                          // frontierDegreeSum: Beamer's m_f (P8-T8)
+        }
+        workgroupBarrier();
+        for (var p = lid.x; p < aggregate; p = p + WG) {                 // strip [0, aggregate): lane j takes j, j + WG, ...
+            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 arc = rowStart[k] + (p - exclusive);
+            let q = base + p;
+            if (q < P.edgeCapacity) { edgeQueue[q] = colIdx[arc - P.arcBase]; }   // the clamp of PD-23; the queue holds the target vertex only (PD-24)
+        }
+        workgroupBarrier();                                              // sh, rowStart and base are reused by the next block
+    }
+}
+`
+);
+const bfRelaxWgsl = (
+  /* wgsl */
+  `
+fn relax(v: u32, nd: f32) {
+    var cur = atomicLoad(&dist[v]);
+    var tries = 0u;
+    loop {
+        if (!(nd < bitcast<f32>(cur))) { break; }                     // no improvement; +Inf is greater than every finite nd
+        let r = atomicCompareExchangeWeak(&dist[v], cur, bitcast<u32>(nd));
+        if (r.exchanged) { atomicStore(&flags[0], 1u); break; }        // changed
+        cur = r.old_value;
+        tries = tries + 1u;
+        if (tries >= P.maxRetries) { atomicStore(&flags[1], 1u); break; }   // retryExhausted (PD-12)
+    }
+}
+
+@compute @workgroup_size(WG)
+fn bf_relax(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let first = linear_id(wid, lid.x);
+    let cutoff = bitcast<f32>(P.cutoffBits);
+    for (var e = first; e < P.edgeCount; e = e + P.stride) {          // each logical edge once (edgeList)
+        let u = edgeSrc[e];
+        let v = edgeDst[e];
+        let w = weights[edgeToArc[e]];                                 // the edge's weight through its forward arc
+        let du = atomicLoad(&dist[u]);
+        if (du != F32_INF_BITS) {                                      // unreached is tested as the bit pattern, as sssp-pred does
+            let nd = bitcast<f32>(du) + w;
+            if (nd <= cutoff) { relax(v, nd); }
+        }
+        if (UNDIRECTED) {                                              // the other direction of an undirected edge
+            let dv = atomicLoad(&dist[v]);
+            if (dv != F32_INF_BITS) {
+                let nd = bitcast<f32>(dv) + w;
+                if (nd <= cutoff) { relax(u, nd); }
+            }
+        }
+    }
+}
+`
+);
+const bfsBitsetBuildWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn bfs_bitset_build(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let count = select(0u, atomicLoad(&counters[0]), atomicLoad(&counters[24]) == 3u);   // frontierCount, on the bottom-up path only (the path word)
+    for (var i = linear_id(wid, lid.x); i < count; i = i + P.stride) {   // grid-stride; no barrier anywhere
+        let v = frontierIn[i];
+        atomicOr(&bits[P.bitsBase + (v >> 5u)], 1u << (v & 31u));
+    }
+}
+`
+);
+const bfsBottomUpWgsl = (
+  /* wgsl */
+  `
+var<workgroup> sh: array<u32, WG>;
+var<workgroup> base: u32;
+var<workgroup> wcount: u32;                                          // the unvisited list's length on a bottom-up level, 0 on any other
+
+@compute @workgroup_size(WG)
+fn bfs_bottom_up(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let claim = atomicLoad(&counters[11]) + 1u;
+    if (lid.x == 0u) { wcount = select(0u, atomicLoad(&counters[7]), atomicLoad(&counters[24]) == 3u); }   // unvisitedListLen, on the bottom-up path only (the path word)
+    let len = workgroupUniformLoad(&wcount);                         // uniform: the block loop below holds barriers
+    for (var b0 = group_id(wid) * WG; b0 < len; b0 = b0 + P.stride) {   // grid-stride over blocks of WG entries
+        let i = b0 + lid.x;
+        var won = 0u;
+        var v = 0u;
+        var reads = 0u;
+        if (i < len) {                                                   // guarded work into locals
+            v = sweepIn[i];
+            if (atomicLoad(&depth[v]) == INVALID_INDEX) {                // a stale entry, claimed since the rebuild, is skipped
+                let end = min(rowPtr[v + 1u], P.arcEnd);
+                for (var a = max(rowPtr[v], P.arcBase); a < end; a = a + 1u) {   // in-neighbours through the reverse core
+                    reads = reads + 1u;
+                    let u = colIdx[a - P.arcBase];
+                    if (mask_bit(sweepIn[P.bitsBase + (u >> 5u)], u)) { won = 1u; break; }   // the early exit: a real break, never a flag
+                }
+            }
+        }
+        sh[lid.x] = won;
+        workgroupBarrier();
+        for (var s = 1u; s < WG; s = s * 2u) {                           // Hillis-Steele inclusive scan of won (bfs-contract's)
+            var t = 0u;
+            if (lid.x >= s) { t = sh[lid.x - s]; }
+            workgroupBarrier();
+            sh[lid.x] = sh[lid.x] + t;
+            workgroupBarrier();
+        }
+        let inclusive = sh[lid.x];
+        let readsTotal = wg_reduce_u32(reads, lid.x, 0u);                // arcsScanned, one atomic per workgroup (the sabotage witness, Step 6)
+        if (lid.x == WG - 1u) { base = atomicAdd(&counters[1], inclusive); }
+        if (lid.x == 0u) { atomicAdd(&counters[16], readsTotal); }
+        workgroupBarrier();
+        if (won == 1u) {
+            atomicStore(&depth[v], claim);                               // no claim race: the list holds v once and the sweep is vertex-parallel
+            frontierOut[base + inclusive - 1u] = v;
+        }
+        workgroupBarrier();                                              // sh and base are reused by the next block
+    }
+}
+`
+);
+const bfsContractWgsl = (
+  /* wgsl */
+  `
+var<workgroup> sh: array<u32, WG>;
+var<workgroup> base: u32;
+var<workgroup> wcount: u32;                                          // the clamped edge count on a two-phase level, 0 on any other
+
+@compute @workgroup_size(WG)
+fn bfs_contract(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    if (lid.x == 0u) { wcount = select(0u, atomicLoad(&counters[8]), atomicLoad(&counters[24]) == 1u); }   // edgeCount, clamped by role 1; the two-phase path only (the path word)
+    let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers
+    let claim = atomicLoad(&counters[11]) + 1u;                      // the depth this level assigns
+    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 won = 0u;
+        var v = 0u;
+        if (i < count) {                                                 // guarded work into locals
+            v = edgeQueue[i];
+            let old = atomicMin(&depth[v], claim);
+            won = select(0u, 1u, old == INVALID_INDEX);                  // PD-6: the unique winner
+        }
+        sh[lid.x] = won;
+        workgroupBarrier();
+        for (var s = 1u; s < WG; s = s * 2u) {                           // Hillis-Steele inclusive scan of won
+            var t = 0u;
+            if (lid.x >= s) { t = sh[lid.x - s]; }
+            workgroupBarrier();
+            sh[lid.x] = sh[lid.x] + t;
+            workgroupBarrier();
+        }
+        let inclusive = sh[lid.x];
+        if (lid.x == WG - 1u) { base = atomicAdd(&counters[1], inclusive); }   // nextFrontierCount: one reservation per workgroup
+        workgroupBarrier();
+        if (won == 1u) { frontierOut[base + inclusive - 1u] = v; }
+        workgroupBarrier();                                              // sh and base are reused by the next block
+    }
+}
+`
+);
+const bfsFusedWgsl = (
+  /* wgsl */
+  `
+var<workgroup> sh: array<u32, WG>;
+var<workgroup> wdeg: u32;
+var<workgroup> wstart: u32;
+var<workgroup> base: u32;
+var<workgroup> wcount: u32;                                          // the frontier's length on a fused or retry level, 0 on any other
+
+@compute @workgroup_size(WG)
+fn bfs_fused(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let claim = atomicLoad(&counters[11]) + 1u;
+    if (lid.x == 0u) {
+        let path = atomicLoad(&counters[24]);                        // 2 the fused level, 4 the overflow retry (PD-23)
+        wcount = select(0u, atomicLoad(&counters[0]), path == 2u || path == 4u);
+    }
+    let count = workgroupUniformLoad(&wcount);                       // uniform: the entry loop below holds barriers
+    for (var g = group_id(wid); g < count; g = g + P.stride) {       // one workgroup per frontier entry; P.stride is the dispatch's GROUP count
+        if (lid.x == 0u) {
+            let u = frontierIn[g];
+            let a0 = max(rowPtr[u], P.arcBase);
+            let a1 = min(rowPtr[u + 1u], P.arcEnd);
+            let d = select(0u, a1 - a0, a1 > a0);
+            wdeg = d;
+            wstart = a0;
+            atomicAdd(&counters[2], d);                                  // frontierDegreeSum, so Beamer's test (P8-T8) sees fused levels too
+        }
+        let deg = workgroupUniformLoad(&wdeg);                           // uniform: the loop below may hold barriers
+        let start = workgroupUniformLoad(&wstart);
+        for (var p0 = 0u; p0 < deg; p0 = p0 + WG) {                      // strip the row WG arcs at a time
+            let p = p0 + lid.x;
+            var won = 0u;
+            var v = 0u;
+            if (p < deg) {                                               // guarded claim into locals
+                v = colIdx[start + p - P.arcBase];
+                let old = atomicMin(&depth[v], claim);
+                won = select(0u, 1u, old == INVALID_INDEX);
+            }
+            sh[lid.x] = won;
+            workgroupBarrier();
+            for (var s = 1u; s < WG; s = s * 2u) {                       // Hillis-Steele inclusive scan of won (bfs-contract's, verbatim)
+                var t = 0u;
+                if (lid.x >= s) { t = sh[lid.x - s]; }
+                workgroupBarrier();
+                sh[lid.x] = sh[lid.x] + t;
+                workgroupBarrier();
+            }
+            let inclusive = sh[lid.x];
+            if (lid.x == WG - 1u) { base = atomicAdd(&counters[1], inclusive); }
+            workgroupBarrier();
+            if (won == 1u) { frontierOut[base + inclusive - 1u] = v; }
+            workgroupBarrier();                                          // sh and base are reused by the next strip
+        }
+    }
+}
+`
+);
+const bfsUnvisitedFlagsWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn bfs_unvisited_flags(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let first = linear_id(wid, lid.x);
+    var cnt = 0u;
+    var degSum = 0u;
+    var len = 0u;
+    for (var v = first; v < P.n; v = v + P.stride) {                 // no barrier inside: the trip count is per lane
+        let unv = depth[v] == INVALID_INDEX;
+        let listed = unv && (inDegree[v] != 0u);
+        flags[v] = select(0u, 1u, listed);
+        cnt = cnt + select(0u, 1u, unv);
+        degSum = degSum + select(0u, outDegree[v], unv);             // the OUT-degree: Beamer's m_u counts the edges top-down would examine
+        len = len + select(0u, 1u, listed);
+    }
+    let c = wg_reduce_u32(cnt, lid.x, 0u);                           // the prelude's workgroup sum (combine_u's sum code); uniform: after the loop
+    let d = wg_reduce_u32(degSum, lid.x, 0u);
+    let l = wg_reduce_u32(len, lid.x, 0u);
+    if (lid.x == 0u) {                                               // ONE atomic per word per workgroup
+        atomicAdd(&counters[5], c);
+        atomicAdd(&counters[6], d);
+        atomicAdd(&counters[7], l);
+    }
+}
+`
+);
+const closenessReduceWgsl = (
+  /* wgsl */
+  `
+@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
+        let k = min(32u, P.n - P.source);
+        for (var s = 0u; s < k; s = s + 1u) {
+            let v = P.source + s;
+            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[3u * P.bitsBase + v] = 1u;                          // flags: level 0's compact turns them into the list
+        }
+        atomicStore(&counters[0], k);                                // not done
+        atomicStore(&counters[11], U32_MAX);                         // level: the first boundary brings it to 0
+        atomicStore(&counters[15], 0u);                              // done
+        return;
+    }
+    // role 0: the level boundary -- done from the previous level's compacted count, then the accumulation
+    let count = atomicLoad(&counters[0]);
+    atomicStore(&counters[15], select(0u, 1u, count == 0u));
+    let level = atomicLoad(&counters[11]);
+    let d = level + 1u;                                              // the distance of the claims the level just run made
+    for (var s = 0u; s < 32u; s = s + 1u) {
+        let c = atomicLoad(&perSource[s]);                           // newCount[s]
+        atomicStore(&perSource[32u + s], atomicLoad(&perSource[32u + s]) + c);   // reached[s]
+        // sum[s] += c x d in 64 bits: the 16-bit split product (pLo, pHi), then the add with its carry
+        let cLo = c & 0xFFFFu;
+        let cHi = c >> 16u;
+        let dLo = d & 0xFFFFu;
+        let dHi = d >> 16u;
+        let ll = cLo * dLo;
+        let lh = cLo * dHi;
+        let hl = cHi * dLo;
+        let mid = (ll >> 16u) + (lh & 0xFFFFu) + (hl & 0xFFFFu);
+        let pLo = (ll & 0xFFFFu) | ((mid & 0xFFFFu) << 16u);
+        let pHi = (cHi * dHi) + (lh >> 16u) + (hl >> 16u) + (mid >> 16u);
+        var lo = atomicLoad(&perSource[64u + s]);                    // sumLo[s]
+        var hi = atomicLoad(&perSource[96u + s]);                    // sumHi[s]
+        let before = lo;
+        lo = lo + pLo;
+        hi = hi + pHi + select(0u, 1u, lo < before);
+        atomicStore(&perSource[64u + s], lo);
+        atomicStore(&perSource[96u + s], hi);
+        atomicStore(&perSource[s], 0u);
+    }
+    atomicStore(&counters[11], level + 1u);
+}
+`
+);
+const closenessSweepWgsl = (
+  /* wgsl */
+  `
+var<workgroup> sh: array<u32, WG>;                // the block's degrees, then their inclusive scan
+var<workgroup> rowStart: array<u32, WG>;          // the first bound arc of each entry's row
+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
+
+@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)
+    let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers
+    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
+        let i = b0 + lid.x;                                          // this lane's frontier entry
+        var deg = 0u;
+        var start = 0u;
+        var u = 0u;
+        if (i < count) {                                                 // guarded loads into locals (3.5 rule 1)
+            u = frontierList[i];
+            let lo = max(rowPtr[u], P.arcBase);
+            let hi = min(rowPtr[u + 1u], P.arcEnd);
+            start = lo;
+            deg = select(0u, hi - lo, hi > lo);
+        }
+        if (lid.x < 32u) { atomicStore(&local[lid.x], 0u); }            // zeroed before the strip loop (WebGPU zero-initialises workgroup memory; said anyway)
+        sh[lid.x] = deg;
+        rowStart[lid.x] = start;
+        rowOf[lid.x] = u;
+        workgroupBarrier();
+        for (var s = 1u; s < WG; s = s * 2u) {                           // Hillis-Steele inclusive scan of the degrees (bfs-contract's, inlined)
+            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 p = lid.x; p < aggregate; p = p + WG) {                 // strip [0, aggregate): lane j takes j, j + WG, ...
+            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 arc = rowStart[k] + (p - exclusive);
+            let x = colIdx[arc - P.arcBase];
+            let mask = atomicLoad(&bits[frontierBase + rowOf[k]]) & ~atomicLoad(&bits[x]);   // the sources at u that have not reached x
+            if (mask != 0u) {
+                let old = atomicOr(&bits[x], mask);                      // visited: the claim, one read-modify-write
+                let fresh = mask & ~old;                                 // the sources whose claim this lane won
+                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)
+                    var b = fresh;
+                    loop {                                               // one tally per set bit of fresh
+                        if (b == 0u) { break; }
+                        let s = firstTrailingBit(b);
+                        atomicAdd(&local[s], 1u);
+                        b = b & (b - 1u);
+                    }
+                }
+            }
+        }
+        workgroupBarrier();                                              // uniform: the loop's bound is the uniform aggregate
+        if (lid.x < 32u) {                                               // ONE global atomic per source per workgroup
+            let c = atomicLoad(&local[lid.x]);
+            if (c != 0u) { atomicAdd(&perSource[lid.x], c); }            // newCount[s]
+        }
+        workgroupBarrier();                                              // sh, rowStart, rowOf and local are reused by the next block
+    }
+}
+`
+);
+const compactScatterWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn compact_scatter(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let i = linear_id(wid, lid.x);
+    if (i == 0u) { outCount[P.outIndex] = offsets[P.count - 1u] + flags[P.count - 1u]; }   // the exclusive scan's total; the planner never dispatches for count 0
+    if (i >= P.count) { return; }                                                          // no barrier follows
+    if (flags[i] != 0u) { out[offsets[i]] = queue[i]; }
+}
+`
+);
 const countingScatterWgsl = (
   /* wgsl */
   `
@@ -557,6 +990,57 @@ fn counting_scatter(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invoca
 }
 `
 );
+const dedupeClaimWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn dedupe_claim(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    var count = P.count;
+    if (P.countIndex != U32_MAX) { count = min(atomicLoad(&counters[P.countIndex]), P.count); }   // a device-side count, clamped to the capacity
+    for (var i = linear_id(wid, lid.x); i < count; i = i + P.stride) {   // grid-stride; no barrier anywhere
+        atomicStore(&owner[queue[i]], i);
+    }
+}
+`
+);
+const dedupeFilterWgsl = (
+  /* wgsl */
+  `
+var<workgroup> sh: array<u32, WG>;
+var<workgroup> base: u32;
+var<workgroup> wcount: u32;
+
+@compute @workgroup_size(WG)
+fn dedupe_filter(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    if (lid.x == 0u) {
+        var count = P.count;
+        if (P.countIndex != U32_MAX) { count = min(atomicLoad(&outCount[P.countIndex]), P.count); }   // the same count source as the claim
+        wcount = count;
+    }
+    let count = workgroupUniformLoad(&wcount);                                            // uniform: the block loop below holds barriers
+    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 keep = 0u;
+        var v = 0u;
+        if (i < count) { v = queue[i]; keep = select(0u, 1u, atomicLoad(&owner[v]) == i); }   // guarded work into locals
+        sh[lid.x] = keep;
+        workgroupBarrier();                                                                   // every lane, unconditionally (3.5 rule 1)
+        for (var s = 1u; s < WG; s = s * 2u) {                                                // Hillis-Steele inclusive scan of keep
+            var t = 0u;
+            if (lid.x >= s) { t = sh[lid.x - s]; }
+            workgroupBarrier();
+            sh[lid.x] = sh[lid.x] + t;
+            workgroupBarrier();
+        }
+        let inclusive = sh[lid.x];
+        if (lid.x == WG - 1u) { base = atomicAdd(&outCount[P.outIndex], inclusive); }         // ONE atomic per workgroup: the block's aggregate
+        workgroupBarrier();
+        if (keep == 1u) { out[base + inclusive - 1u] = v; }
+        workgroupBarrier();                                                                   // sh and base are reused by the next block
+    }
+}
+`
+);
 const degreeWgsl = (
   /* wgsl */
   `
@@ -988,6 +1472,121 @@ fn fill(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid
 }
 `
 );
+const frontierFinalizeWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn frontier_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 == 0u) {                                                // the level boundary
+        if (atomicLoad(&counters[15]) != 0u) {                         // done already: a no-op level the host recorded past the end
+            atomicStore(&counters[24], 0u);                            // the path word is the only word that moves (P8-T6's levels formula reads the rest)
+            return;
+        }
+        let finished = atomicLoad(&counters[0]);
+        let next = atomicLoad(&counters[1]);
+        let degSum = atomicLoad(&counters[2]);
+        atomicStore(&counters[3], finished);                           // prevFrontierCount
+        atomicStore(&counters[4], degSum);                             // prevDegreeSum
+        atomicStore(&counters[0], next);                               // the rotation
+        atomicStore(&counters[1], 0u);
+        atomicStore(&counters[2], 0u);
+        atomicStore(&counters[8], 0u);                                 // edgeCount
+        atomicStore(&counters[9], 0u);                                 // edgeCountUnclamped
+        atomicStore(&counters[12], atomicLoad(&counters[12]) + next);  // visitedCount
+        if (P.firstOfSubmit >= 1u) {                                   // b = the boundary's index inside its submit, clamped to 2 (P8-T8, PD-18)
+            atomicStore(&counters[5], atomicLoad(&counters[5]) - next);    // unvisitedCount (exact): F_b was inside the submit's rebuilt sum iff b >= 1
+        }
+        if (P.firstOfSubmit >= 2u) {
+            atomicStore(&counters[6], atomicLoad(&counters[6]) - degSum);  // unvisitedDegreeSum (one level stale): F_{b-1} was inside it iff b >= 2
+        }
+        let level = atomicLoad(&counters[11]) + 1u;                    // the seed is U32_MAX, so the first boundary lands on 0
+        atomicStore(&counters[11], level);
+        let done = (next == 0u) || (level >= P.maxDepth);
+        atomicStore(&counters[15], select(0u, 1u, done));
+        var direction = atomicLoad(&counters[14]);
+        if (P.mode == 1u) {
+            direction = 0u;                                                 // top-down only (the test seam)
+        } else if (direction == 0u) {
+            if (degSum > atomicLoad(&counters[6]) / P.alpha && next > finished) { direction = 1u; }   // m_f > m_u / alpha and growing
+        } else {
+            if (next * P.beta < atomicLoad(&counters[5]) && next < finished) { direction = 0u; }      // next * beta < unvisited and shrinking
+        }
+        if (direction != atomicLoad(&counters[14])) { atomicStore(&counters[13], atomicLoad(&counters[13]) + 1u); }   // switches
+        var path = 0u;                                                 // word 24: what the level's kernels run (0 nothing, 1 two-phase, 2 fused, 3 bottom-up; role 1 writes 4 for the retry)
+        if (done) {
+            path = 0u;
+        } else if (direction == 1u) {                                  // the bottom-up level (P8-T8): the bits fill, the bitset build, the sweep
+            path = 3u;
+            atomicStore(&counters[19], atomicLoad(&counters[19]) + 1u);
+        } else if (next < P.fusedMax) {                                // P8-T7 makes this branch reachable (fusedMax is 0 until then)
+            path = 2u;                                                 // bfs-fused: one WORKGROUP per frontier entry
+            atomicStore(&counters[17], atomicLoad(&counters[17]) + 1u);
+        } else {
+            path = 1u;                                                 // advance-expand, then role 1 and bfs-contract
+        }
+        atomicStore(&counters[14], direction);
+        atomicStore(&counters[24], path);
+    } else if (P.role == 1u) {                                         // the edge queue is filled
+        if (atomicLoad(&counters[24]) != 1u) {                         // role 0 did not choose the two-phase path (done, fused or bottom-up): nothing to clamp, nothing to count
+            return;
+        }
+        let clamped = min(atomicLoad(&counters[8]), P.edgeCapacity);
+        atomicStore(&counters[8], clamped);
+        if (atomicLoad(&counters[9]) > P.edgeCapacity) {               // PD-23: the fused retry
+            atomicStore(&counters[24], 4u);                            // the path word: bfs-fused runs the retry over frontierCount, bfs-contract nothing
+            atomicStore(&counters[10], atomicLoad(&counters[10]) + 1u);
+            atomicStore(&counters[17], atomicLoad(&counters[17]) + 1u);
+        } else {
+            atomicStore(&counters[18], atomicLoad(&counters[18]) + 1u);   // twoPhaseLevels counts the CHOICE role 0 made, even for zero edges (P8-T7 Step 4's invariant)
+        }
+    } else if (P.role == 2u) {                                         // the SSSP round boundary (P8-T9, PD-20): which pile this round relaxes
+        atomicStore(&counters[8], 0u);                                 // the dedupe counts (words 8 and 9, the SSSP sense) and the path word: nothing unless a pile is chosen below
+        atomicStore(&counters[9], 0u);
+        atomicStore(&counters[24], 0u);
+        if (atomicLoad(&counters[15]) != 0u) {                         // done already: a no-op round the host recorded past the end (rule 1)
+            return;
+        }
+        let nearRaw = atomicLoad(&counters[1]);                        // the raw near half's appends, unclamped
+        let farRaw = atomicLoad(&counters[21]);                        // the raw far half's appends, unclamped
+        if (nearRaw > P.edgeCapacity || farRaw > P.edgeCapacity) {     // a pile overflowed its half: the host raises E_TOO_LARGE
+            atomicStore(&counters[15], 2u);
+            return;
+        }
+        if (nearRaw != 0u) {                                           // a near round: dedupe the near half into nearIn
+            atomicStore(&counters[0], 0u);                             // the deduped near count, accumulated by dedupe-filter
+            atomicStore(&counters[14], 0u);                            // mode 0
+            atomicStore(&counters[8], nearRaw);                        // the near dedupe's count word (dedupe-claim, dedupe-filter over the near half)
+            atomicStore(&counters[24], 5u);                            // the path word: sssp-relax role 0 runs, role 1 nothing
+            atomicStore(&counters[11], atomicLoad(&counters[11]) + 1u);   // rounds dispatched (the done boundary is not counted)
+        } else if (farRaw != 0u) {                                     // the near pile is empty: raise the threshold and re-bucket the far pile
+            let threshold = bitcast<f32>(atomicLoad(&counters[22]));
+            let raised = threshold + bitcast<f32>(atomicLoad(&counters[23]));   // ONE f32 add on the bit patterns (PD-9)
+            if (raised == threshold) {                                 // the delta is below the threshold's ulp: the host raises E_UNSUPPORTED
+                atomicStore(&counters[15], 3u);
+                return;
+            }
+            atomicStore(&counters[4], atomicLoad(&counters[22]));      // prevThresholdBits: what the pass-through drops below
+            atomicStore(&counters[22], bitcast<u32>(raised));
+            atomicStore(&counters[20], 0u);                            // the deduped far count, accumulated by dedupe-filter
+            atomicStore(&counters[14], 1u);                            // mode 1
+            atomicStore(&counters[9], farRaw);                         // the far dedupe's count word (dedupe-claim, dedupe-filter over the far half)
+            atomicStore(&counters[24], 6u);                            // the path word: sssp-relax role 1 runs, role 0 nothing
+            atomicStore(&counters[11], atomicLoad(&counters[11]) + 1u);
+        } else {                                                       // both piles empty: finished
+            atomicStore(&counters[15], 1u);
+        }
+    } else if (P.role == 3u) {                                         // the piles are deduped: restart the raw half the round consumed
+        if (atomicLoad(&counters[15]) != 0u) { return; }               // role 2 chose no pile this round
+        if (atomicLoad(&counters[14]) == 0u) {
+            atomicStore(&counters[1], 0u);                             // the raw near half restarts (sssp-relax role 0 sizes itself from word 0)
+        } else {
+            atomicStore(&counters[21], 0u);                            // the raw far half restarts (the pass-through re-appends what stays far; role 1 sizes itself from word 20)
+        }
+    }
+}
+`
+);
 const gridCellKeyWgsl = (
   /* wgsl */
   `
@@ -1729,6 +2328,108 @@ fn spmv_pull(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id
 }
 `
 );
+const ssspPredWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn sssp_pred(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let first = linear_id(wid, lid.x);
+    let hb = ((P.n + 63u) / 64u) * 64u;                              // MODE 0 only: hops[v] is pred[hb + v]; pred[2 hb] is the changed word, pred[2 hb + 1] the orphan word (PD-27)
+    if (P.role == 1u && P.iteration != 0u && atomicLoad(&pred[2u * hb]) < P.iteration) { return; }   // the previous hop pass changed nothing: converged (no barrier anywhere, so the early return is legal)
+    for (var u = first; u < P.n; u = u + P.stride) {                 // grid-stride over the rows (planGridStride(n)); no barrier anywhere
+        let du = dist[u];
+        var unreached = false;
+        if (MODE == 1u) { unreached = du == INVALID_INDEX; } else { unreached = du == F32_INF_BITS; }
+        if (unreached) { continue; }
+        var hu = 0u;                                                 // u's hop count (MODE 0, roles 1 and 2)
+        if (MODE == 0u && P.role != 0u) {
+            hu = atomicLoad(&pred[hb + u]);
+            if (hu == INVALID_INDEX) {                               // the key has not reached u yet
+                if (P.role == 2u && u != P.source) { atomicAdd(&pred[2u * hb + 1u], 1u); }   // an orphan: only bellmanFord can make one (P8-T10 Step 3)
+                continue;
+            }
+        }
+        let end = min(rowPtr[u + 1u], P.arcEnd);
+        for (var a = max(rowPtr[u], P.arcBase); a < end; a = a + 1u) {
+            let v = colIdx[a - P.arcBase];
+            if (v == P.source) { continue; }                         // the source keeps INVALID_INDEX whatever attains it (a zero-weight arc could)
+            let dv = dist[v];
+            var tight = false;                                       // the arc explains dist[v]
+            var below = false;                                       // and its source sits at a strictly smaller distance
+            if (MODE == 1u) {
+                tight = (du + 1u) == dv;                             // depth mode: BFS parent, one depth down
+            } else {
+                let w = select(1.0, weights[a - P.arcBase], HAS_WEIGHTS);
+                tight = (dv != F32_INF_BITS) && (bitcast<u32>(bitcast<f32>(du) + w) == dv);   // one f32 add, compared as the bit pattern PD-9 stores; never into an unreached v (an overflowed sum is +Inf too)
+                below = bitcast<f32>(du) < bitcast<f32>(dv);
+            }
+            if (!tight) { continue; }
+            var admit = false;                                       // this arc is one key step below v
+            if (MODE == 1u) {
+                admit = true;
+            } else if (P.role == 0u) {                               // the roots pass (the plateau rule only; bellmanFord seeds the source alone)
+                if (P.mode == 0u && below) { atomicMin(&pred[hb + v], 0u); }
+            } else if (P.role == 1u) {                               // a hop pass: one hop along a plateau arc (mode 0) or along any tight arc (mode 1)
+                if (P.mode == 1u || du == dv) {
+                    let old = atomicMin(&pred[hb + v], hu + 1u);
+                    if (hu + 1u < old) { atomicMax(&pred[2u * hb], P.iteration + 1u); }   // this pass changed something
+                }
+            } else {                                                 // the predecessor pass: the smallest tight arc one key step below v
+                let hv = atomicLoad(&pred[hb + v]);
+                if (P.mode == 1u) { admit = hu + 1u == hv; } else if (hv == 0u) { admit = below; } else { admit = (du == dv) && (hu + 1u == hv); }
+            }
+            if (admit) { atomicMin(&pred[v], select(a, u, P.predKind == 1u)); }
+        }
+    }
+}
+`
+);
+const ssspRelaxWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn sssp_relax(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let first = linear_id(wid, lid.x);
+    let mine = select(5u, 6u, P.role == 1u);                           // the path word role 2 wrote: 5 a near round, 6 a far pass-through
+    let chosen = atomicLoad(&counters[24]) == mine;                    // the other role's dispatch of the round is a no-op
+    let count = select(0u, min(atomicLoad(&counters[select(0u, 20u, P.role == 1u)]), P.n), chosen);   // the deduped near or far pile
+    let threshold = bitcast<f32>(atomicLoad(&counters[22]));
+    let cutoff = bitcast<f32>(P.cutoffBits);
+    for (var i = first; i < count; i = i + P.stride) {                // no barrier anywhere: the loops may be per lane
+        let u = queueIn[i];
+        let du = bitcast<f32>(atomicLoad(&dist[u]));
+        if (P.role == 1u) {                                            // the pass-through (PD-20): re-bucket a far entry
+            if (du < bitcast<f32>(atomicLoad(&counters[4]))) { continue; }   // below the previous threshold: relaxed in an earlier bucket
+            if (du < threshold) {
+                let q = atomicAdd(&counters[1], 1u);
+                if (q < P.edgeCapacity) { queueOut[q] = u; }
+            } else {
+                let q = atomicAdd(&counters[21], 1u);
+                if (q < P.edgeCapacity) { queueOut[P.edgeCapacity + q] = u; }
+            }
+            continue;
+        }
+        let end = rowPtr[u + 1u];
+        for (var a = rowPtr[u]; a < end; a = a + 1u) {                 // the whole row: never windowed (DEP-P8-E)
+            let v = colIdx[a];
+            let nd = du + select(1.0, weights[a], HAS_WEIGHTS);         // ONE f32 add (PD-9)
+            if (nd > cutoff) { continue; }                             // SsspOptions.cutoff: the CPU port's dv <= cutoff
+            let bits = bitcast<u32>(nd);
+            let old = atomicMin(&dist[v], bits);                       // exact on non-negative floats
+            if (bits < old) {                                          // this lane improved v, so it owns the append
+                if (nd < threshold) {
+                    let q = atomicAdd(&counters[1], 1u);
+                    if (q < P.edgeCapacity) { queueOut[q] = v; }
+                } else {
+                    let q = atomicAdd(&counters[21], 1u);
+                    if (q < P.edgeCapacity) { queueOut[P.edgeCapacity + q] = v; }
+                }
+            }
+        }
+    }
+}
+`
+);
 const wccCompressWgsl = (
   /* wgsl */
   `
@@ -2029,6 +2730,81 @@ const RADIX_PARAMS = UniformBlock.define("RadixParams", [
   ["groups", "u32"],
   ["pad0", "u32"]
 ]);
+const COMPACT_PARAMS = UniformBlock.define("CompactParams", [
+  ["count", "u32"],
+  ["outIndex", "u32"],
+  ["countIndex", "u32"],
+  ["stride", "u32"]
+]);
+const FRONTIER_COUNTERS = UniformBlock.define(
+  "FrontierCounters",
+  [
+    ["frontierCount", "u32"],
+    ["nextFrontierCount", "u32"],
+    ["frontierDegreeSum", "u32"],
+    ["prevFrontierCount", "u32"],
+    ["prevDegreeSum", "u32"],
+    ["unvisitedCount", "u32"],
+    ["unvisitedDegreeSum", "u32"],
+    ["unvisitedListLen", "u32"],
+    ["edgeCount", "u32"],
+    ["edgeCountUnclamped", "u32"],
+    ["overflowLevels", "u32"],
+    ["level", "u32"],
+    ["visitedCount", "u32"],
+    ["switches", "u32"],
+    ["direction", "u32"],
+    ["done", "u32"],
+    ["arcsScanned", "u32"],
+    ["fusedLevels", "u32"],
+    ["twoPhaseLevels", "u32"],
+    ["bottomUpLevels", "u32"],
+    ["farCount", "u32"],
+    ["nextFarCount", "u32"],
+    ["thresholdBits", "u32"],
+    ["deltaBits", "u32"],
+    ["path", "u32"]
+  ],
+  { layout: "storage" }
+);
+const FRONTIER_PARAMS = UniformBlock.define("FrontierParams", [
+  ["role", "u32"],
+  ["wg", "u32"],
+  ["alpha", "u32"],
+  ["beta", "u32"],
+  ["fusedMax", "u32"],
+  ["edgeCapacity", "u32"],
+  ["maxDepth", "u32"],
+  ["n", "u32"],
+  ["mode", "u32"],
+  ["cutoffBits", "u32"],
+  ["arcBase", "u32"],
+  ["arcEnd", "u32"],
+  ["predKind", "u32"],
+  ["bitsBase", "u32"],
+  ["source", "u32"],
+  ["stride", "u32"],
+  ["firstOfSubmit", "u32"],
+  ["iteration", "u32"],
+  ["pad1", "u32"],
+  ["pad2", "u32"]
+]);
+const BF_PARAMS = UniformBlock.define("BfParams", [
+  ["edgeCount", "u32"],
+  ["stride", "u32"],
+  ["maxRetries", "u32"],
+  ["cutoffBits", "u32"]
+]);
+const BF_FLAGS = UniformBlock.define(
+  "BfFlags",
+  [
+    ["changed", "u32"],
+    ["retryExhausted", "u32"],
+    ["pad0", "u32"],
+    ["pad1", "u32"]
+  ],
+  { layout: "storage" }
+);
 function decl(group, binding, name, kind, wgslType) {
   return { group, binding, name, kind, wgslType };
 }
@@ -2535,37 +3311,299 @@ const GRID_NEAR_FIELD = {
   snippetSlots: [],
   phase: "P4"
 };
-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,
-  "fa2-to-scene": FA2_TO_SCENE,
-  "spmv-pull": SPMV_PULL,
-  "pr-scale": PR_SCALE,
-  "pr-finalize": PR_FINALIZE,
-  "wcc-link-sample": WCC_LINK_SAMPLE,
-  "wcc-link-edges": WCC_LINK_EDGES,
-  "wcc-compress": WCC_COMPRESS,
-  "wcc-sample": WCC_SAMPLE,
-  "indirect-finalize": INDIRECT_FINALIZE,
-  "scan-block": SCAN_BLOCK,
-  "scan-add": SCAN_ADD,
-  histogram: HISTOGRAM,
-  "counting-scatter": COUNTING_SCATTER,
-  "radix-hist": RADIX_HIST,
-  "radix-scatter": RADIX_SCATTER,
-  "grid-cell-key": GRID_CELL_KEY,
-  "grid-centroid": GRID_CENTROID,
-  "grid-centroid-hub": GRID_CENTROID_HUB,
+const COMPACT_SCATTER = {
+  id: "compact-scatter",
+  body: compactScatterWgsl,
+  entryPoint: "compact_scatter",
+  bindings: [
+    decl(1, 0, "queue", "storage-ro", "array<u32>"),
+    decl(1, 1, "flags", "storage-ro", "array<u32>"),
+    decl(1, 2, "offsets", "storage-ro", "array<u32>"),
+    decl(1, 3, "out", "storage", "array<u32>"),
+    decl(1, 4, "outCount", "storage", "array<u32>"),
+    decl(2, 0, "P", "uniform", "CompactParams")
+  ],
+  overrideDecls: [],
+  uniforms: [COMPACT_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P8"
+};
+const DEDUPE_CLAIM = {
+  id: "dedupe-claim",
+  body: dedupeClaimWgsl,
+  entryPoint: "dedupe_claim",
+  bindings: [
+    decl(1, 0, "queue", "storage-ro", "array<u32>"),
+    decl(1, 1, "owner", "storage", "array<atomic<u32>>"),
+    decl(1, 2, "counters", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "CompactParams")
+  ],
+  overrideDecls: [],
+  uniforms: [COMPACT_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P8"
+};
+const DEDUPE_FILTER = {
+  id: "dedupe-filter",
+  body: dedupeFilterWgsl,
+  entryPoint: "dedupe_filter",
+  bindings: [
+    decl(1, 0, "queue", "storage-ro", "array<u32>"),
+    decl(1, 1, "owner", "storage", "array<atomic<u32>>"),
+    decl(1, 2, "out", "storage", "array<u32>"),
+    decl(1, 3, "outCount", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "CompactParams")
+  ],
+  overrideDecls: [],
+  uniforms: [COMPACT_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P8"
+};
+const FRONTIER_FINALIZE = {
+  id: "frontier-finalize",
+  body: frontierFinalizeWgsl,
+  entryPoint: "frontier_finalize",
+  bindings: [decl(1, 0, "counters", "storage", "array<atomic<u32>>"), decl(2, 0, "P", "uniform", "FrontierParams")],
+  overrideDecls: [],
+  uniforms: [FRONTIER_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P8"
+};
+const ADVANCE_EXPAND = {
+  id: "advance-expand",
+  body: advanceExpandWgsl,
+  entryPoint: "advance_expand",
+  bindings: GRAPH_SLOTS.concat(
+    decl(1, 0, "frontierIn", "storage-ro", "array<u32>"),
+    decl(1, 1, "counters", "storage", "array<atomic<u32>>"),
+    decl(1, 2, "edgeQueue", "storage", "array<u32>"),
+    decl(2, 0, "P", "uniform", "FrontierParams")
+  ),
+  overrideDecls: [],
+  uniforms: [FRONTIER_PARAMS],
+  needs: ["subgroups"],
+  snippetSlots: [],
+  phase: "P8"
+};
+const BFS_CONTRACT = {
+  id: "bfs-contract",
+  body: bfsContractWgsl,
+  entryPoint: "bfs_contract",
+  bindings: [
+    decl(1, 0, "edgeQueue", "storage-ro", "array<u32>"),
+    decl(1, 1, "counters", "storage", "array<atomic<u32>>"),
+    decl(1, 2, "depth", "storage", "array<atomic<u32>>"),
+    decl(1, 3, "frontierOut", "storage", "array<u32>"),
+    decl(2, 0, "P", "uniform", "FrontierParams")
+  ],
+  overrideDecls: [],
+  uniforms: [FRONTIER_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P8"
+};
+const SSSP_PRED = {
+  id: "sssp-pred",
+  body: ssspPredWgsl,
+  entryPoint: "sssp_pred",
+  bindings: GRAPH_SLOTS.concat(
+    decl(1, 0, "dist", "storage-ro", "array<u32>"),
+    decl(1, 1, "pred", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "FrontierParams")
+  ),
+  overrideDecls: [{ name: "MODE", type: "u32", default: 0 }],
+  uniforms: [FRONTIER_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P8"
+};
+const BFS_FUSED = {
+  id: "bfs-fused",
+  body: bfsFusedWgsl,
+  entryPoint: "bfs_fused",
+  bindings: GRAPH_SLOTS.concat(
+    decl(1, 0, "frontierIn", "storage-ro", "array<u32>"),
+    decl(1, 1, "counters", "storage", "array<atomic<u32>>"),
+    decl(1, 2, "depth", "storage", "array<atomic<u32>>"),
+    decl(1, 3, "frontierOut", "storage", "array<u32>"),
+    decl(2, 0, "P", "uniform", "FrontierParams")
+  ),
+  overrideDecls: [],
+  uniforms: [FRONTIER_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P8"
+};
+const BFS_BOTTOM_UP = {
+  id: "bfs-bottom-up",
+  body: bfsBottomUpWgsl,
+  entryPoint: "bfs_bottom_up",
+  bindings: GRAPH_SLOTS.concat(
+    decl(1, 0, "sweepIn", "storage-ro", "array<u32>"),
+    decl(1, 1, "counters", "storage", "array<atomic<u32>>"),
+    decl(1, 2, "depth", "storage", "array<atomic<u32>>"),
+    decl(1, 3, "frontierOut", "storage", "array<u32>"),
+    decl(2, 0, "P", "uniform", "FrontierParams")
+  ),
+  overrideDecls: [],
+  uniforms: [FRONTIER_PARAMS],
+  needs: ["subgroups"],
+  snippetSlots: [],
+  phase: "P8"
+};
+const BFS_BITSET_BUILD = {
+  id: "bfs-bitset-build",
+  body: bfsBitsetBuildWgsl,
+  entryPoint: "bfs_bitset_build",
+  bindings: [
+    decl(1, 0, "frontierIn", "storage-ro", "array<u32>"),
+    decl(1, 1, "counters", "storage", "array<atomic<u32>>"),
+    decl(1, 2, "bits", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "FrontierParams")
+  ],
+  overrideDecls: [],
+  uniforms: [FRONTIER_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P8"
+};
+const BFS_UNVISITED_FLAGS = {
+  id: "bfs-unvisited-flags",
+  body: bfsUnvisitedFlagsWgsl,
+  entryPoint: "bfs_unvisited_flags",
+  bindings: [
+    decl(1, 0, "outDegree", "storage-ro", "array<u32>"),
+    decl(1, 1, "inDegree", "storage-ro", "array<u32>"),
+    decl(1, 2, "depth", "storage-ro", "array<u32>"),
+    decl(1, 3, "flags", "storage", "array<u32>"),
+    decl(1, 4, "counters", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "FrontierParams")
+  ],
+  overrideDecls: [],
+  uniforms: [FRONTIER_PARAMS],
+  needs: ["subgroups"],
+  snippetSlots: [],
+  phase: "P8"
+};
+const SSSP_RELAX = {
+  id: "sssp-relax",
+  body: ssspRelaxWgsl,
+  entryPoint: "sssp_relax",
+  bindings: GRAPH_SLOTS.concat(
+    decl(1, 0, "dist", "storage", "array<atomic<u32>>"),
+    decl(1, 1, "counters", "storage", "array<atomic<u32>>"),
+    decl(1, 2, "queueIn", "storage-ro", "array<u32>"),
+    decl(1, 3, "queueOut", "storage", "array<u32>"),
+    decl(2, 0, "P", "uniform", "FrontierParams")
+  ),
+  overrideDecls: [],
+  uniforms: [FRONTIER_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P8"
+};
+const BF_RELAX = {
+  id: "bf-relax",
+  body: bfRelaxWgsl,
+  entryPoint: "bf_relax",
+  bindings: [
+    decl(1, 0, "edgeSrc", "storage-ro", "array<u32>"),
+    decl(1, 1, "edgeDst", "storage-ro", "array<u32>"),
+    decl(1, 2, "edgeToArc", "storage-ro", "array<u32>"),
+    decl(1, 3, "weights", "storage-ro", "array<f32>"),
+    decl(1, 4, "dist", "storage", "array<atomic<u32>>"),
+    decl(1, 5, "flags", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "BfParams")
+  ],
+  overrideDecls: [{ name: "UNDIRECTED", type: "bool", default: false }],
+  uniforms: [BF_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P8"
+};
+const CLOSENESS_SWEEP = {
+  id: "closeness-sweep",
+  body: closenessSweepWgsl,
+  entryPoint: "closeness_sweep",
+  bindings: GRAPH_SLOTS.concat(
+    decl(1, 0, "frontierList", "storage-ro", "array<u32>"),
+    decl(1, 1, "counters", "storage", "array<atomic<u32>>"),
+    decl(1, 2, "bits", "storage", "array<atomic<u32>>"),
+    decl(1, 3, "perSource", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "FrontierParams")
+  ),
+  overrideDecls: [],
+  uniforms: [FRONTIER_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P8"
+};
+const CLOSENESS_REDUCE = {
+  id: "closeness-reduce",
+  body: closenessReduceWgsl,
+  entryPoint: "closeness_reduce",
+  bindings: [
+    decl(1, 0, "counters", "storage", "array<atomic<u32>>"),
+    decl(1, 1, "perSource", "storage", "array<atomic<u32>>"),
+    decl(1, 2, "bits", "storage", "array<u32>"),
+    decl(2, 0, "P", "uniform", "FrontierParams")
+  ],
+  overrideDecls: [],
+  uniforms: [FRONTIER_PARAMS],
+  needs: [],
+  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,
+  "fa2-repulsion-exact": FA2_REPULSION_EXACT,
+  "fa2-speed-finalize": FA2_SPEED_FINALIZE,
+  "fa2-integrate": FA2_INTEGRATE,
+  "fa2-to-scene": FA2_TO_SCENE,
+  "spmv-pull": SPMV_PULL,
+  "pr-scale": PR_SCALE,
+  "pr-finalize": PR_FINALIZE,
+  "wcc-link-sample": WCC_LINK_SAMPLE,
+  "wcc-link-edges": WCC_LINK_EDGES,
+  "wcc-compress": WCC_COMPRESS,
+  "wcc-sample": WCC_SAMPLE,
+  "indirect-finalize": INDIRECT_FINALIZE,
+  "scan-block": SCAN_BLOCK,
+  "scan-add": SCAN_ADD,
+  histogram: HISTOGRAM,
+  "counting-scatter": COUNTING_SCATTER,
+  "radix-hist": RADIX_HIST,
+  "radix-scatter": RADIX_SCATTER,
+  "grid-cell-key": GRID_CELL_KEY,
+  "grid-centroid": GRID_CENTROID,
+  "grid-centroid-hub": GRID_CENTROID_HUB,
   "grid-downsample": GRID_DOWNSAMPLE,
   "grid-far-field": GRID_FAR_FIELD,
-  "grid-near-field": GRID_NEAR_FIELD
+  "grid-near-field": GRID_NEAR_FIELD,
+  "compact-scatter": COMPACT_SCATTER,
+  "dedupe-claim": DEDUPE_CLAIM,
+  "dedupe-filter": DEDUPE_FILTER,
+  "frontier-finalize": FRONTIER_FINALIZE,
+  "advance-expand": ADVANCE_EXPAND,
+  "bfs-contract": BFS_CONTRACT,
+  "sssp-pred": SSSP_PRED,
+  "bfs-fused": BFS_FUSED,
+  "bfs-bottom-up": BFS_BOTTOM_UP,
+  "bfs-bitset-build": BFS_BITSET_BUILD,
+  "bfs-unvisited-flags": BFS_UNVISITED_FLAGS,
+  "sssp-relax": SSSP_RELAX,
+  "bf-relax": BF_RELAX,
+  "closeness-sweep": CLOSENESS_SWEEP,
+  "closeness-reduce": CLOSENESS_REDUCE
 });
 const bodyOverrides = /* @__PURE__ */ new Map();
 function entryOf(id) {
@@ -2724,7 +3762,7 @@ class ScanPlannerImpl {
 }
 const POISON = 3735928559;
 const CHECK_BLOCKS = 32;
-const RING_SLOTS$3 = 8;
+const RING_SLOTS$6 = 8;
 const checked = /* @__PURE__ */ new WeakMap();
 function inputAt(i) {
   return i + 1;
@@ -2752,7 +3790,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$3, "device-check/ring");
+  const ring = new UniformRing(ctx.device, ctx.allocator, RING_SLOTS$6, "device-check/ring");
   try {
     const scope = {
       device: ctx.device,
@@ -2892,8 +3930,8 @@ function rowCountOf(core, primitive) {
 function arcCountOf(core) {
   return core.colIdx === null ? 0 : core.colIdx.size / 4;
 }
-function windowBinding(core, name, w2) {
-  const buffer = core.arcBuffers?.[name][w2.bufferIndex];
+function windowBinding(core, name, w) {
+  const buffer = core.arcBuffers?.[name][w.bufferIndex];
   if (buffer === void 0) {
     throw new WebGpuGraphError("E_INVALID_ARGUMENT", `windowBinding: the core has no window buffers of ${name}`, {
       argument: "core",
@@ -2901,7 +3939,21 @@ function windowBinding(core, name, w2) {
       expected: "a windowed core whose plan uploaded the array"
     });
   }
-  return { buffer, offset: w2.offset, size: 4 * (w2.end - w2.start), window: w2 };
+  return { buffer, offset: w.offset, size: 4 * (w.end - w.start), window: w };
+}
+function coreWindows(core) {
+  if (core.windows === null) {
+    return [{ arcBase: 0, arcEnd: arcCountOf(core), core }];
+  }
+  return core.windows.map((w, k, all) => ({
+    arcBase: w.start,
+    arcEnd: k + 1 < all.length ? all[k + 1].start : w.end,
+    core: {
+      ...core,
+      colIdx: windowBinding(core, "colIdx", w),
+      weights: core.weights === null ? null : windowBinding(core, "weights", w)
+    }
+  }));
 }
 function assertNotWindowed(core, primitive) {
   if (core.plan === "windowed" || core.windows !== null) {
@@ -2919,22 +3971,22 @@ function assertWholeCore(core, arcCount, limit, algorithm) {
     );
   }
 }
-function coreOfView(v2, arcCount) {
-  const { rowPtr } = v2.bindings;
+function coreOfView(v, arcCount) {
+  const { rowPtr } = v.bindings;
   if (rowPtr === void 0) {
-    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `the ${v2.view} view has no rowPtr binding`, {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `the ${v.view} view has no rowPtr binding`, {
       argument: "view",
-      value: v2.view,
+      value: v.view,
       expected: "a view with a rowPtr binding (reverse)"
     });
   }
-  const colIdx = v2.bindings.colIdx ?? null;
-  const weights = v2.bindings.weights ?? null;
+  const colIdx = v.bindings.colIdx === void 0 || v.bindings.colIdx.size === 0 ? null : v.bindings.colIdx;
+  const weights = v.bindings.weights === void 0 || v.bindings.weights.size === 0 ? null : v.bindings.weights;
   const bound = colIdx === null ? 0 : colIdx.size / 4;
   if (bound !== arcCount) {
     throw new WebGpuGraphError(
       "E_INVALID_ARGUMENT",
-      `the ${v2.view} view binds ${bound} arcs but its arcCount scalar says ${arcCount}`,
+      `the ${v.view} view binds ${bound} arcs but its arcCount scalar says ${arcCount}`,
       {
         argument: "arcCount",
         value: arcCount,
@@ -2955,7 +4007,7 @@ function coreOfView(v2, arcCount) {
     hasWeights: weights !== null
   });
 }
-function checkDest$3(dest, n) {
+function checkDest$5(dest, n) {
   if (dest === void 0) {
     return null;
   }
@@ -2984,7 +4036,7 @@ async function degree(ctx, s, options) {
   ctx.assertReady();
   await assertDeviceComputes(ctx);
   const n = s.nodeCount;
-  const dest = checkDest$3(options?.dest, n);
+  const dest = checkDest$5(options?.dest, n);
   if (options?.signal?.aborted) {
     throw new WebGpuGraphError("E_ABORTED", "degree: the signal was aborted before any work started", {});
   }
@@ -3021,22 +4073,22 @@ async function degree(ctx, s, options) {
       const fill = await ctx.pipelines.kernel(kernelSpec("fill"));
       const zero = fill.bind({ dst: outBinding, P: params(FILL_PARAMS, { count: n, value: 0, mode: 0 }) });
       fill.dispatch(pass, zero, plan1d(n, ctx.workgroupSize, ctx.caps), [0]);
-      for (const w2 of core.windows) {
+      for (const w of core.windows) {
         const windowed = {
           ...core,
-          colIdx: windowBinding(core, "colIdx", w2),
-          weights: core.weights === null ? null : windowBinding(core, "weights", w2)
+          colIdx: windowBinding(core, "colIdx", w),
+          weights: core.weights === null ? null : windowBinding(core, "weights", w)
         };
         const P = params(RANGE_PARAMS, {
-          start: w2.rowFirst,
-          end: w2.rowLast + 1,
-          arcBase: w2.start,
-          arcEnd: w2.end,
+          start: w.rowFirst,
+          end: w.rowLast + 1,
+          arcBase: w.start,
+          arcEnd: w.end,
           accumulate: 1,
           n
         });
         const bound = kernel.bind({ ...graphBindings(windowed, null), out: outBinding, P });
-        kernel.dispatch(pass, bound, plan1d(w2.rowLast - w2.rowFirst + 1, ctx.workgroupSize, ctx.caps), [0]);
+        kernel.dispatch(pass, bound, plan1d(w.rowLast - w.rowFirst + 1, ctx.workgroupSize, ctx.caps), [0]);
       }
     }
     pass.end();
@@ -3342,9 +4394,9 @@ class CommandBatch {
   countDispatches(pass) {
     const direct = pass.dispatchWorkgroups.bind(pass);
     const indirect = pass.dispatchWorkgroupsIndirect.bind(pass);
-    pass.dispatchWorkgroups = (x2, y2, z) => {
+    pass.dispatchWorkgroups = (x, y, z) => {
       this.dispatchCount += 1;
-      direct(x2, y2, z);
+      direct(x, y, z);
       return void 0;
     };
     pass.dispatchWorkgroupsIndirect = (buffer, offset) => {
@@ -3401,16 +4453,17 @@ function algorithmScope(ctx, label, slots) {
     dispose() {
       ring.destroy();
       lease.release();
-    }
+    },
+    ringOverruns: () => ring.overruns
   };
 }
-const ALGORITHM = "connectedComponents";
-const ROUNDS_PER_BATCH = 4;
+const ALGORITHM$4 = "connectedComponents";
+const ROUNDS_PER_BATCH$1 = 4;
 const MAX_WCC_ROUNDS = 64;
 const SAMPLE_SIZE = 1024;
 const MAX_STEPS = 1024;
-const RING_SLOTS$2 = 2 * ROUNDS_PER_BATCH;
-function checkDest$2(dest, n) {
+const RING_SLOTS$5 = 2 * ROUNDS_PER_BATCH$1;
+function checkDest$4(dest, n) {
   if (dest === void 0) {
     return null;
   }
@@ -3419,7 +4472,7 @@ function checkDest$2(dest, n) {
   }
   throw new WebGpuGraphError(
     "E_INVALID_ARGUMENT",
-    `${ALGORITHM}: 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})`,
@@ -3429,10 +4482,10 @@ function checkDest$2(dest, n) {
 }
 function coreOf$2(ctx, s) {
   const core = ctx.residency.core(s);
-  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM);
+  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$4);
   return core;
 }
-function bindingOf$1(buffer, size) {
+function bindingOf$3(buffer, size) {
   return { buffer, offset: 0, size, window: null };
 }
 function labelResult(labels, count) {
@@ -3448,19 +4501,19 @@ function labelResult(labels, count) {
       const dense = new Uint32Array(n).fill(U32_MAX$2);
       const sizes = new Uint32Array(count);
       let next = 0;
-      for (let v2 = 0; v2 < n; v2++) {
-        let k = dense[labels[v2]];
+      for (let v = 0; v < n; v++) {
+        let k = dense[labels[v]];
         if (k === U32_MAX$2) {
           k = next++;
-          dense[labels[v2]] = k;
+          dense[labels[v]] = k;
         }
         sizes[k]++;
       }
       const built = Array.from(sizes, (size) => new Uint32Array(size));
       const filled = new Uint32Array(count);
-      for (let v2 = 0; v2 < n; v2++) {
-        const k = dense[labels[v2]];
-        built[k][filled[k]++] = v2;
+      for (let v = 0; v < n; v++) {
+        const k = dense[labels[v]];
+        built[k][filled[k]++] = v;
       }
       groups = built;
       return built;
@@ -3485,11 +4538,11 @@ function checkLabels(raw) {
   const n = raw.length;
   const seen = new Uint8Array(n);
   let count = 0;
-  for (let v2 = 0; v2 < n; v2++) {
-    const label = raw[v2];
+  for (let v = 0; v < n; v++) {
+    const label = raw[v];
     if (label >= n) {
-      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM}: labels[${v2}] = ${label} is not a node index`, {
-        label: `${ALGORITHM}/labels`,
+      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$4}: labels[${v}] = ${label} is not a node index`, {
+        label: `${ALGORITHM$4}/labels`,
         message: `the device produced a label outside [0, ${n})`
       });
     }
@@ -3505,9 +4558,9 @@ async function connectedComponents(ctx, s, options) {
   await assertDeviceComputes(ctx);
   const n = s.nodeCount;
   const renumber = options?.renumber !== false;
-  const dest = checkDest$2(options?.dest, n);
+  const dest = checkDest$4(options?.dest, n);
   if (options?.signal?.aborted) {
-    throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM}: the signal was aborted before any work started`, {});
+    throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$4}: the signal was aborted before any work started`, {});
   }
   if (n === 0) {
     options?.onProgress?.(1, 1);
@@ -3516,15 +4569,15 @@ async function connectedComponents(ctx, s, options) {
   const core = coreOf$2(ctx, s);
   if (s.arcCount === 0) {
     const labels = dest ?? new Uint32Array(n);
-    for (let v2 = 0; v2 < n; v2++) {
-      labels[v2] = v2;
+    for (let v = 0; v < n; v++) {
+      labels[v] = v;
     }
     options?.onProgress?.(1, 1);
     return labelResult(labels, n);
   }
   const edges = ctx.residency.view(s, "edgeList");
   const edgeCount = edges.scalars.edgeCount[0];
-  const scope = algorithmScope(ctx, ALGORITHM, RING_SLOTS$2);
+  const scope = algorithmScope(ctx, ALGORITHM$4, RING_SLOTS$5);
   try {
     const compBytes = 4 * (n + 1);
     const comp = scope.scratch(compBytes, "comp");
@@ -3537,8 +4590,8 @@ async function connectedComponents(ctx, s, options) {
     const compress = await ctx.pipelines.kernel(kernelSpec("wcc-compress", {}));
     const sample = await ctx.pipelines.kernel(kernelSpec("wcc-sample", {}));
     const { queue } = ctx.device;
-    const compBinding = bindingOf$1(comp, compBytes);
-    const histBinding = bindingOf$1(hist, 4 * items);
+    const compBinding = bindingOf$3(comp, compBytes);
+    const histBinding = bindingOf$3(hist, 4 * items);
     const rowPlan = planGridStride(n, ctx.workgroupSize, ctx.caps);
     const edgePlan = planGridStride(edgeCount, ctx.workgroupSize, ctx.caps);
     const flagIndex = n;
@@ -3553,12 +4606,12 @@ async function connectedComponents(ctx, s, options) {
       return batch.submit();
     };
     queue.writeBuffer(comp, 4 * flagIndex, zero);
-    const setup = new CommandBatch(ctx, `${ALGORITHM}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$4}/setup`);
     let pass = setup.pass("sample-rounds");
     const fillParams = scope.params(FILL_PARAMS, { count: n, value: 0, mode: 1, pad0: 0 });
     fill.dispatch(
       pass,
-      fill.bind({ dst: bindingOf$1(comp, 4 * n), P: fillParams.binding }),
+      fill.bind({ dst: bindingOf$3(comp, 4 * n), P: fillParams.binding }),
       plan1d(n, ctx.workgroupSize, ctx.caps),
       [fillParams.offset]
     );
@@ -3572,7 +4625,7 @@ async function connectedComponents(ctx, s, options) {
     setup.endPass();
     await submit(setup).readback;
     ctx.assertReady();
-    const sampler = new CommandBatch(ctx, `${ALGORITHM}/sample`);
+    const sampler = new CommandBatch(ctx, `${ALGORITHM$4}/sample`);
     pass = sampler.pass("sample");
     const sampleParams = wccParams({ items, stride: 0, r: 0, giant: U32_MAX$2 });
     sample.dispatch(
@@ -3590,9 +4643,9 @@ async function connectedComponents(ctx, s, options) {
     let rounds = 0;
     for (; ; ) {
       queue.writeBuffer(comp, 4 * flagIndex, zero);
-      const batch = new CommandBatch(ctx, `${ALGORITHM}/rounds`);
+      const batch = new CommandBatch(ctx, `${ALGORITHM$4}/rounds`);
       pass = batch.pass("edge-rounds");
-      for (let i = 0; i < ROUNDS_PER_BATCH; i++) {
+      for (let i = 0; i < ROUNDS_PER_BATCH$1; i++) {
         const params = wccParams({ items: edgeCount, stride: edgePlan.stride ?? edgeCount, r: 0, giant });
         const bound = linkEdges.bind({ ...edgeBindings, P: params.binding });
         linkEdges.dispatch(pass, bound, edgePlan, [params.offset]);
@@ -3602,10 +4655,10 @@ async function connectedComponents(ctx, s, options) {
       const flagRequest = batch.readback(comp, 4 * flagIndex, 4);
       const submitted = submit(batch);
       const back = await submitted.readback;
-      rounds += ROUNDS_PER_BATCH;
+      rounds += ROUNDS_PER_BATCH$1;
       ctx.assertReady();
       if (options?.signal?.aborted) {
-        throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM}: the signal was aborted`, {
+        throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$4}: the signal was aborted`, {
           batchId: submitted.id
         });
       }
@@ -3615,12 +4668,12 @@ async function connectedComponents(ctx, s, options) {
       if (rounds >= MAX_WCC_ROUNDS) {
         throw new WebGpuGraphError(
           "E_VALIDATION",
-          `${ALGORITHM}: the changed flag never settled in ${MAX_WCC_ROUNDS} rounds`,
-          { label: ALGORITHM, message: `the changed flag never settled in ${MAX_WCC_ROUNDS} rounds` }
+          `${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` }
         );
       }
     }
-    const final = new CommandBatch(ctx, `${ALGORITHM}/final`);
+    const final = new CommandBatch(ctx, `${ALGORITHM$4}/final`);
     recordCompress(final.pass("compress"));
     final.endPass();
     await submit(final).readback;
@@ -3801,13 +4854,13 @@ class TieredPlanner {
       this.dispatches++;
     }
     const { windows } = core;
-    windows.forEach((w2, k) => {
+    windows.forEach((w, k) => {
       const windowed = {
         ...core,
-        colIdx: windowBinding(core, "colIdx", w2),
-        weights: core.weights === null ? null : windowBinding(core, "weights", w2)
+        colIdx: windowBinding(core, "colIdx", w),
+        weights: core.weights === null ? null : windowBinding(core, "weights", w)
       };
-      this.recordWindow(pass, windowed, out, n, w2, k + 1 < windows.length ? windows[k + 1].start : w2.end);
+      this.recordWindow(pass, windowed, out, n, w, k + 1 < windows.length ? windows[k + 1].start : w.end);
     });
   }
   /**
@@ -3824,16 +4877,16 @@ class TieredPlanner {
    * @param w - the window, or null for the single whole-core dispatch
    * @param nextStart - the next window's first arc (w.end for the last window)
    */
-  recordWindow(pass, core, out, n, w2, nextStart) {
+  recordWindow(pass, core, out, n, w, nextStart) {
     const wg = this.scope.workgroupSize;
     for (const { tier, kernel, start, end } of this.tiers) {
       let first = start;
       let last = tier === 0 ? n : end;
-      let arcEnd = w2 === null ? arcCountOf(core) : Math.min(w2.end, nextStart);
-      if (w2 !== null && this.perm === null) {
-        first = w2.rowFirst;
-        last = w2.rowLast + 1;
-        arcEnd = w2.end;
+      let arcEnd = w === null ? arcCountOf(core) : Math.min(w.end, nextStart);
+      if (w !== null && this.perm === null) {
+        first = w.rowFirst;
+        last = w.rowLast + 1;
+        arcEnd = w.end;
       }
       const rows = last - first;
       if (rows <= 0) {
@@ -3842,9 +4895,9 @@ class TieredPlanner {
       const params = this.scope.params(RANGE_PARAMS, {
         start: first,
         end: last,
-        arcBase: w2 === null ? 0 : w2.start,
+        arcBase: w === null ? 0 : w.start,
         arcEnd,
-        accumulate: w2 !== null || this.accumulate ? 1 : 0,
+        accumulate: w !== null || this.accumulate ? 1 : 0,
         n
       });
       const bound = kernel.bind({ ...graphBindings(core, this.perm), out, P: params.binding });
@@ -3986,8 +5039,8 @@ async function prepareSpmvPull(scope, rev, options) {
   return new SpmvPullPlannerImpl(scope, compiled, perm, options.weights);
 }
 const PR_BATCH = 8;
-const RING_SLOTS$1 = 2 * PR_BATCH + 1;
-function checkDest$1(dest, n, algorithm) {
+const RING_SLOTS$4 = 2 * PR_BATCH + 1;
+function checkDest$3(dest, n, algorithm) {
   if (dest === void 0) {
     return null;
   }
@@ -4009,10 +5062,10 @@ function coreOf$1(ctx, s, algorithm) {
   assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, algorithm);
   return core;
 }
-function bindingOf(buffer, size) {
+function bindingOf$2(buffer, size) {
   return { buffer, offset: 0, size, window: null };
 }
-function aborted$1(algorithm, batchId) {
+function aborted$3(algorithm, batchId) {
   return new WebGpuGraphError(
     "E_ABORTED",
     `${algorithm}: the signal was aborted`,
@@ -4034,9 +5087,9 @@ async function run(ctx, s, personalization, options, algorithm) {
       expected: "a positive integer"
     });
   }
-  const dest = checkDest$1(options?.dest, n, algorithm);
+  const dest = checkDest$3(options?.dest, n, algorithm);
   if (options?.signal?.aborted) {
-    throw aborted$1(algorithm);
+    throw aborted$3(algorithm);
   }
   if (n === 0) {
     options?.onProgress?.(maxIterations, maxIterations);
@@ -4064,7 +5117,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$1);
+  const scope = algorithmScope(ctx, algorithm, RING_SLOTS$4);
   let uploaded = null;
   try {
     const bytes = 4 * n;
@@ -4100,10 +5153,10 @@ async function run(ctx, s, personalization, options, algorithm) {
     const header = new ArrayBuffer(PR_PARTIAL.byteLength);
     PR_PARTIAL.write(new DataView(header), { firstConverged: U32_MAX$2, iteration: 0 });
     queue.writeBuffer(partials, 0, header);
-    const rank = [bindingOf(rankA, bytes), bindingOf(rankB, bytes)];
-    const xNormBinding = bindingOf(xNorm, bytes);
-    const outWeightSumBinding = bindingOf(outWeightSum, bytes);
-    const partialsBinding = bindingOf(partials, partialsBytes);
+    const rank = [bindingOf$2(rankA, bytes), bindingOf$2(rankB, bytes)];
+    const xNormBinding = bindingOf$2(xNorm, bytes);
+    const outWeightSumBinding = bindingOf$2(outWeightSum, bytes);
+    const partialsBinding = bindingOf$2(partials, partialsBytes);
     const coefficients = { alpha, beta: 1 - alpha, uniformP: 1 / n };
     let cur = 0;
     let iterationsRun = 0;
@@ -4156,7 +5209,7 @@ async function run(ctx, s, personalization, options, algorithm) {
       iterationsRun += k;
       ctx.assertReady();
       if (options?.signal?.aborted) {
-        throw aborted$1(algorithm, submitted.id);
+        throw aborted$3(algorithm, submitted.id);
       }
       options?.onProgress?.(iterationsRun, maxIterations);
       const folded = PR_PARTIAL.read(new DataView(back), headerRequest.offset);
@@ -4199,8 +5252,8 @@ async function personalizedPageRank(ctx, s, personalization, options) {
     );
   }
   let total = 0;
-  for (let v2 = 0; v2 < n; v2++) {
-    const mass = personalization[v2];
+  for (let v = 0; v < n; v++) {
+    const mass = personalization[v];
     if (!Number.isFinite(mass) || mass < 0) {
       throw invalid2(mass, "finite and non-negative in every entry");
     }
@@ -4210,14 +5263,14 @@ async function personalizedPageRank(ctx, s, personalization, options) {
     throw invalid2(total, "a vector whose entries sum to a positive number");
   }
   const normalised2 = new Float32Array(n);
-  for (let v2 = 0; v2 < n; v2++) {
-    normalised2[v2] = personalization[v2] / total;
+  for (let v = 0; v < n; v++) {
+    normalised2[v] = personalization[v] / total;
   }
   return run(ctx, s, normalised2, options, "personalizedPageRank");
 }
 const BATCH = 8;
-const RING_SLOTS = 4 * BATCH + 8;
-function checkDest(dest, n, algorithm) {
+const RING_SLOTS$3 = 4 * BATCH + 8;
+function checkDest$2(dest, n, algorithm) {
   if (dest === void 0) {
     return null;
   }
@@ -4243,7 +5296,7 @@ function reverseOf(ctx, s) {
   const view = ctx.residency.view(s, "reverse");
   return coreOfView(view, view.scalars.arcCount[0]);
 }
-function aborted(algorithm, batchId) {
+function aborted$2(algorithm, batchId) {
   return new WebGpuGraphError(
     "E_ABORTED",
     `${algorithm}: the signal was aborted`,
@@ -4255,7 +5308,7 @@ function whole(buffer, size) {
 }
 async function runPowerIteration(ctx, n, config) {
   await assertDeviceComputes(ctx);
-  const scope = algorithmScope(ctx, config.label, RING_SLOTS);
+  const scope = algorithmScope(ctx, config.label, RING_SLOTS$3);
   try {
     const bytes = 4 * n;
     const ring = (config.alternate === null ? ["rankA", "rankB"] : ["rankA", "rankB", "rankC"]).map(
@@ -4328,7 +5381,7 @@ async function runPowerIteration(ctx, n, config) {
       iterationsRun += k;
       ctx.assertReady();
       if (config.signal?.aborted === true) {
-        throw aborted(config.label, submitted.id);
+        throw aborted$2(config.label, submitted.id);
       }
       config.onProgress?.(iterationsRun, config.maxIterations);
       const folded = PR_PARTIAL.read(new DataView(back), headerRequest.offset);
@@ -4363,9 +5416,9 @@ function resolve(ctx, s, options, algorithm) {
       expected: "a positive integer"
     });
   }
-  const dest = checkDest(options?.dest, n, algorithm);
+  const dest = checkDest$2(options?.dest, n, algorithm);
   if (options?.signal?.aborted) {
-    throw aborted(algorithm);
+    throw aborted$2(algorithm);
   }
   return { n, maxIterations, tolerance, weights: options?.weighted === false ? null : void 0, dest };
 }
@@ -4382,13 +5435,13 @@ function finite(value, fallback, argument) {
 }
 function normalised(raw, dest, norm) {
   let acc = 0;
-  for (const v2 of raw) {
-    acc += norm === "sum" ? Math.abs(v2) : v2 * v2;
+  for (const v of raw) {
+    acc += norm === "sum" ? Math.abs(v) : v * v;
   }
   const scale = norm === "sum" ? acc : Math.sqrt(acc);
   const out = dest ?? raw;
-  for (let v2 = 0; v2 < raw.length; v2++) {
-    out[v2] = scale > 0 ? raw[v2] / scale : raw[v2];
+  for (let v = 0; v < raw.length; v++) {
+    out[v] = scale > 0 ? raw[v] / scale : raw[v];
   }
   return out;
 }
@@ -4433,76 +5486,1857 @@ async function eigenvectorCentrality(ctx, s, options) {
   });
   return scoresOf(run2, r.dest, "l2");
 }
-async function katzCentrality(ctx, s, options) {
-  const algorithm = "katzCentrality";
-  const alpha = finite(options?.alpha, 0.1, "alpha");
-  const beta = finite(options?.beta, 1, "beta");
-  const r = resolve(ctx, s, options, algorithm);
-  if (r.n === 0) {
-    return empty(r.dest, r.maxIterations, options?.onProgress);
+async function katzCentrality(ctx, s, options) {
+  const algorithm = "katzCentrality";
+  const alpha = finite(options?.alpha, 0.1, "alpha");
+  const beta = finite(options?.beta, 1, "beta");
+  const r = resolve(ctx, s, options, algorithm);
+  if (r.n === 0) {
+    return empty(r.dest, r.maxIterations, options?.onProgress);
+  }
+  const run2 = await runPowerIteration(ctx, r.n, {
+    normMode: 4,
+    adjacency: reverseOf(ctx, s),
+    alternate: null,
+    alpha,
+    beta,
+    uniformP: 1,
+    maxIterations: r.maxIterations,
+    tolerance: r.tolerance,
+    weights: r.weights,
+    label: algorithm,
+    signal: options?.signal,
+    onProgress: options?.onProgress
+  });
+  return scoresOf(run2, r.dest, "l2");
+}
+async function hits(ctx, s, options) {
+  const algorithm = "hits";
+  const r = resolve(ctx, s, options, algorithm);
+  const total = 2 * r.maxIterations;
+  if (r.n === 0) {
+    const { scores, iterations, converged, precision } = empty(r.dest, total, options?.onProgress);
+    return { hubs: scores, authorities: new Float32Array(0), iterations, converged, precision };
+  }
+  const onProgress = options?.onProgress;
+  const shared = {
+    normMode: 1,
+    alpha: 1,
+    beta: 0,
+    uniformP: 0,
+    maxIterations: r.maxIterations,
+    tolerance: r.tolerance,
+    weights: r.weights,
+    signal: options?.signal
+  };
+  const forward = coreOf(ctx, s, algorithm);
+  const reverse = reverseOf(ctx, s);
+  const hubSeeded = await runPowerIteration(ctx, r.n, {
+    ...shared,
+    adjacency: reverse,
+    alternate: forward,
+    label: `${algorithm}/hub-seeded`,
+    onProgress: onProgress === void 0 ? void 0 : (done) => {
+      onProgress(done, total);
+    }
+  });
+  const authoritySeeded = await runPowerIteration(ctx, r.n, {
+    ...shared,
+    adjacency: forward,
+    alternate: reverse,
+    label: `${algorithm}/authority-seeded`,
+    onProgress: onProgress === void 0 ? void 0 : (done) => {
+      onProgress(r.maxIterations + done, total);
+    }
+  });
+  return {
+    hubs: normalised(latestOfKind(hubSeeded, authoritySeeded), r.dest, "sum"),
+    authorities: normalised(latestOfKind(authoritySeeded, hubSeeded), null, "sum"),
+    iterations: Math.max(hubSeeded.iterations, authoritySeeded.iterations),
+    converged: hubSeeded.converged && authoritySeeded.converged,
+    precision: "f32"
+  };
+}
+async function prepareCompact(scope) {
+  const scatter = await scope.pipelines.kernel(kernelSpec("compact-scatter"));
+  const claim = await scope.pipelines.kernel(kernelSpec("dedupe-claim"));
+  const filter = await scope.pipelines.kernel(kernelSpec("dedupe-filter"));
+  const scan = await prepareScan(scope);
+  return new CompactPlannerImpl(scope, scatter, claim, filter, scan);
+}
+function checkCount(what, count) {
+  if (!Number.isSafeInteger(count) || count < 0 || count > U32_MAX$2) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${what}: count must be a non-negative integer below 2^32`, {
+      argument: "count",
+      value: count
+    });
+  }
+}
+function checkWords$1(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,
+      value: binding.size,
+      expected: 4 * words
+    });
+  }
+}
+function checkWordIndex(what, name, index, block) {
+  if (!Number.isSafeInteger(index) || index < 0 || 4 * (index + 1) > block.size) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${what}: ${name} ${index} is outside the block`, {
+      argument: name,
+      value: index,
+      expected: `0 <= ${name} < ${Math.floor(block.size / 4)}`
+    });
+  }
+}
+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);
+  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)));
+  checkWordIndex("dedupe", "outIndex", r.outIndex, r.outCount);
+  if (r.countIndex === U32_MAX$2) {
+    return;
+  }
+  checkWordIndex("dedupe", "countIndex", r.countIndex, r.counters);
+  if (r.countIndex === r.outIndex) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", "dedupe: countIndex must not be the output word outIndex", {
+      argument: "countIndex",
+      value: r.countIndex
+    });
+  }
+  if (r.counters.buffer !== r.outCount.buffer || r.counters.offset !== r.outCount.offset || r.counters.size !== r.outCount.size) {
+    throw new WebGpuGraphError(
+      "E_INVALID_ARGUMENT",
+      "dedupe: counters must be the same range as outCount when countIndex names a device word",
+      {
+        argument: "counters",
+        value: r.counters.size,
+        expected: r.outCount.size
+      }
+    );
+  }
+}
+class CompactPlannerImpl {
+  /**
+   * Wraps the resolved kernels; use prepareCompact().
+   * @param scope - the caller's scope
+   * @param scatter - the `compact-scatter` kernel
+   * @param claim - the `dedupe-claim` kernel
+   * @param filter - the `dedupe-filter` kernel
+   * @param scan - the scan planner of the same scope
+   */
+  constructor(scope, scatter, claim, filter, scan) {
+    this.dispatches = 0;
+    this.scope = scope;
+    this.scatter = scatter;
+    this.claim = claim;
+    this.filter = filter;
+    this.scan = scan;
+  }
+  /**
+   * Dispatches the last record*() issued.
+   * @returns the count
+   */
+  get lastDispatches() {
+    return this.dispatches;
+  }
+  /**
+   * Records the scan and the scatter (see the interface).
+   * @param pass - the compute pass
+   * @param r - the record
+   */
+  record(pass, r) {
+    checkCompactArguments(r);
+    if (r.count === 0) {
+      this.dispatches = 0;
+      return;
+    }
+    const size = 4 * r.count;
+    const offsets = { buffer: this.scope.scratch(size, "compact/offsets"), offset: 0, size, window: null };
+    this.scan.record(pass, r.flags, r.count, offsets);
+    const params = this.scope.params(COMPACT_PARAMS, {
+      count: r.count,
+      outIndex: r.outIndex,
+      countIndex: U32_MAX$2,
+      stride: 0
+    });
+    const bound = this.scatter.bind({
+      queue: r.queue,
+      flags: r.flags,
+      offsets,
+      out: r.out,
+      outCount: r.outCount,
+      P: params.binding
+    });
+    this.scatter.dispatch(pass, bound, plan1d(r.count, this.scope.workgroupSize, this.scope.caps), [params.offset]);
+    this.dispatches = this.scan.lastDispatches + 1;
+  }
+  /**
+   * Records the claim and the filter over plan1d(count) (see the interface).
+   * @param pass - the compute pass
+   * @param r - the record
+   */
+  recordDedupe(pass, r) {
+    checkDedupeArguments(r);
+    if (r.count === 0) {
+      this.dispatches = 0;
+      return;
+    }
+    const plan = planGridStride(r.count, this.scope.workgroupSize, this.scope.caps);
+    const bound = this.bindDedupe(r, plan.stride ?? this.scope.workgroupSize);
+    this.claim.dispatch(pass, bound.claim, plan, [bound.offset]);
+    this.filter.dispatch(pass, bound.filter, plan, [bound.offset]);
+    this.dispatches = 2;
+  }
+  /**
+   * One params record (both kernels read the same values) and the two bind groups.
+   * @param r - the record
+   * @param stride - the grid-stride plan's stride (entries per pass over the grid)
+   * @returns the bound kernels and the record's dynamic offset
+   */
+  bindDedupe(r, stride) {
+    const params = this.scope.params(COMPACT_PARAMS, {
+      count: r.count,
+      outIndex: r.outIndex,
+      countIndex: r.countIndex,
+      stride
+    });
+    return {
+      claim: this.claim.bind({ queue: r.queue, owner: r.owner, counters: r.counters, P: params.binding }),
+      filter: this.filter.bind({
+        queue: r.queue,
+        owner: r.owner,
+        out: r.out,
+        outCount: r.outCount,
+        P: params.binding
+      }),
+      offset: params.offset
+    };
+  }
+}
+const W = Object.freeze({
+  frontierCount: 0,
+  nextFrontierCount: 1,
+  frontierDegreeSum: 2,
+  prevFrontierCount: 3,
+  prevDegreeSum: 4,
+  unvisitedCount: 5,
+  unvisitedDegreeSum: 6,
+  unvisitedListLen: 7,
+  edgeCount: 8,
+  edgeCountUnclamped: 9,
+  overflowLevels: 10,
+  level: 11,
+  visitedCount: 12,
+  switches: 13,
+  direction: 14,
+  done: 15,
+  arcsScanned: 16,
+  fusedLevels: 17,
+  twoPhaseLevels: 18,
+  bottomUpLevels: 19,
+  farCount: 20,
+  nextFarCount: 21,
+  thresholdBits: 22,
+  deltaBits: 23,
+  path: 24
+});
+function definedWords(words) {
+  const out = {};
+  for (const [name, value] of Object.entries(words)) {
+    if (value !== void 0) {
+      out[name] = value;
+    }
+  }
+  return out;
+}
+const MAX_ROLE = 3;
+function assertCount(argument, value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `frontier: ${argument} must be a non-negative integer`, {
+      argument,
+      value,
+      expected: "a non-negative integer"
+    });
+  }
+}
+class Frontier {
+  /**
+   * Wraps the leased buffers; use prepareFrontier().
+   * @param vertices - the two vertex queues
+   * @param counters - the counters block
+   * @param edgeQueue - the edge queue
+   * @param edgeCapacity - the edge queue's entry count
+   * @param n - the vertex count
+   */
+  constructor(vertices, counters, edgeQueue, edgeCapacity, n) {
+    this.sideIndex = 0;
+    this.vertices = vertices;
+    this.counters = counters;
+    this.edgeQueue = edgeQueue;
+    this.edgeCapacity = edgeCapacity;
+    this.n = n;
+  }
+  /**
+   * Which vertex queue is the input of the current level (a host-side index between two cached bind-group sets).
+   * @returns 0 or 1
+   */
+  get side() {
+    return this.sideIndex;
+  }
+  /**
+   * The vertex queue the current level expands from.
+   * @returns `vertices[side]`
+   */
+  get input() {
+    return this.sideIndex === 0 ? this.vertices[0] : this.vertices[1];
+  }
+  /**
+   * The vertex queue the current level's claims append to.
+   * @returns `vertices[1 - side]`
+   */
+  get output() {
+    return this.sideIndex === 0 ? this.vertices[1] : this.vertices[0];
+  }
+  /** Flips the two vertex queues; the counts rotate inside the block, so nothing else moves. */
+  swap() {
+    this.sideIndex = this.sideIndex === 0 ? 1 : 0;
+  }
+  /**
+   * Seeds a traversal: one `queue.writeBuffer` of the whole 112-byte block (zero except the caller's words) and one of
+   * `vertices[0][0] = source`, both ordered before the submit that follows; the source is on side 0 afterwards.
+   * `frontierCount` is not a word to seed: the first boundary rotates word 1 into it (the BFS seed is
+   * `{ nextFrontierCount: 1, level: U32_MAX }`). A source outside `[0, n)`, an unknown word or a value that is not a
+   * u32 is E_INVALID_ARGUMENT before anything is written.
+   * @param queue - the device queue
+   * @param source - the source vertex
+   * @param seed - the words to seed
+   */
+  reset(queue, source, seed) {
+    if (!Number.isInteger(source) || source < 0 || source >= this.n) {
+      throw new WebGpuGraphError("E_INVALID_ARGUMENT", `frontier: source ${source} is outside [0, ${this.n})`, {
+        argument: "source",
+        value: source,
+        expected: `an integer in [0, ${this.n})`
+      });
+    }
+    const bytes = new ArrayBuffer(FRONTIER_COUNTERS.byteLength);
+    FRONTIER_COUNTERS.write(new DataView(bytes), definedWords(seed));
+    this.sideIndex = 0;
+    queue.writeBuffer(this.counters.buffer, this.counters.offset, bytes);
+    queue.writeBuffer(this.vertices[0].buffer, this.vertices[0].offset, Uint32Array.of(source));
+  }
+}
+async function prepareFrontier(scope, n, arcCount, edgeCapacity) {
+  assertCount("n", n);
+  assertCount("arcCount", arcCount);
+  const capacity = edgeCapacity ?? Math.max(1, Math.min(arcCount, Math.floor(scope.caps.limits.maxStorageBufferBindingSize / 4)));
+  if (!Number.isSafeInteger(capacity) || capacity < 1 || capacity > U32_MAX$2) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", "frontier: edgeCapacity must be an integer >= 1", {
+      argument: "edgeCapacity",
+      value: capacity,
+      expected: "an integer in [1, 2^32)"
+    });
+  }
+  const kernel = await scope.pipelines.kernel(kernelSpec("frontier-finalize"));
+  const queueBytes = 4 * Math.max(1, n);
+  const vertices = [
+    { buffer: scope.scratch(queueBytes, "frontier/vertices-0"), offset: 0, size: queueBytes, window: null },
+    { buffer: scope.scratch(queueBytes, "frontier/vertices-1"), offset: 0, size: queueBytes, window: null }
+  ];
+  const counters = {
+    buffer: scope.scratch(FRONTIER_COUNTERS.byteLength, "frontier/counters"),
+    offset: 0,
+    size: FRONTIER_COUNTERS.byteLength,
+    window: null
+  };
+  const edgeQueue = {
+    buffer: scope.scratch(4 * capacity, "frontier/edge-queue"),
+    offset: 0,
+    size: 4 * capacity,
+    window: null
+  };
+  const frontier = new Frontier(vertices, counters, edgeQueue, capacity, n);
+  return new FrontierPlannerImpl(scope, kernel, frontier);
+}
+class FrontierPlannerImpl {
+  /**
+   * Wraps the resolved kernel; use prepareFrontier().
+   * @param scope - the caller's scope
+   * @param kernel - the `frontier-finalize` kernel
+   * @param frontier - the leased queue
+   */
+  constructor(scope, kernel, frontier) {
+    this.scope = scope;
+    this.kernel = kernel;
+    this.frontier = frontier;
+  }
+  /**
+   * Records one selector dispatch (see the interface).
+   * @param pass - the compute pass
+   * @param role - the role
+   * @param level - the level inside the submit
+   * @param fields - the caller's fields
+   */
+  recordFinalize(pass, role, level, fields) {
+    if (!Number.isInteger(level) || level < 0 || level >= MAX_LEVELS_PER_SUBMIT) {
+      throw new WebGpuGraphError("E_INVALID_ARGUMENT", `frontier: level ${level} is outside the submit`, {
+        argument: "level",
+        value: level,
+        expected: `an integer in [0, ${MAX_LEVELS_PER_SUBMIT})`
+      });
+    }
+    if (!Number.isInteger(role) || role < 0 || role > MAX_ROLE) {
+      throw new WebGpuGraphError("E_INVALID_ARGUMENT", `frontier: role ${role} is not a finalize role`, {
+        argument: "role",
+        value: role,
+        expected: `an integer in [0, ${MAX_ROLE}]`
+      });
+    }
+    const { scope, frontier } = this;
+    const params = scope.params(FRONTIER_PARAMS, {
+      ...definedWords(fields),
+      role,
+      wg: scope.workgroupSize,
+      edgeCapacity: frontier.edgeCapacity,
+      n: frontier.n
+    });
+    const bound = this.kernel.bind({ counters: frontier.counters, P: params.binding });
+    this.kernel.dispatch(pass, bound, plan1d(1, scope.workgroupSize, scope.caps), [params.offset]);
+  }
+}
+async function prepareAdvance(scope, core) {
+  const kernel = await scope.pipelines.kernel(kernelSpec("advance-expand", graphOverrides(core, null)));
+  return new AdvancePlannerImpl(scope, core, kernel);
+}
+class AdvancePlannerImpl {
+  /**
+   * Wraps the resolved kernel; use prepareAdvance().
+   * @param scope - the caller's scope
+   * @param core - the core the kernel was compiled for
+   * @param kernel - the `advance-expand` kernel
+   */
+  constructor(scope, core, kernel) {
+    this.scope = scope;
+    this.kernel = kernel;
+    this.windows = coreWindows(core);
+    this.n = rowCountOf(core, "advance");
+  }
+  /**
+   * Records one direct expansion per window (see the interface).
+   * @param pass - the compute pass
+   * @param frontier - the queue to expand
+   */
+  record(pass, frontier) {
+    if (frontier.n !== this.n) {
+      throw new WebGpuGraphError(
+        "E_INVALID_ARGUMENT",
+        `advance: the frontier holds ${frontier.n} vertices, the core ${this.n} rows`,
+        {
+          argument: "frontier",
+          value: frontier.n,
+          expected: this.n
+        }
+      );
+    }
+    const { scope } = this;
+    const plan = planGridStride(frontier.n, scope.workgroupSize, scope.caps);
+    for (const w of this.windows) {
+      const params = scope.params(FRONTIER_PARAMS, {
+        wg: scope.workgroupSize,
+        edgeCapacity: frontier.edgeCapacity,
+        n: frontier.n,
+        arcBase: w.arcBase,
+        arcEnd: w.arcEnd,
+        stride: plan.stride ?? scope.workgroupSize
+      });
+      const bound = this.kernel.bind({
+        ...graphBindings(w.core, null),
+        frontierIn: frontier.input,
+        counters: frontier.counters,
+        edgeQueue: frontier.edgeQueue,
+        P: params.binding
+      });
+      this.kernel.dispatch(pass, bound, plan, [params.offset]);
+    }
+  }
+}
+const RADIX_DIGIT_BITS = 8;
+function radixHistBytes(count, wg) {
+  return 4 * RADIX_BINS * Math.ceil(count / wg);
+}
+async function prepareRadixSort(scope) {
+  const hist = await scope.pipelines.kernel(kernelSpec("radix-hist"));
+  const scatter = await scope.pipelines.kernel(kernelSpec("radix-scatter"));
+  const scan = await prepareScan(scope);
+  return new RadixSortPlannerImpl(scope, hist, scatter, scan);
+}
+function checkBinding(argument, binding, bytes) {
+  if (binding.size < bytes) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `radixSort: ${argument} is smaller than ${bytes} bytes`, {
+      argument,
+      value: binding.size,
+      expected: bytes
+    });
+  }
+}
+function checkRecordArguments(keys, vals, count, bits, scratch, wg) {
+  if (bits !== 8 && bits !== 16 && bits !== 24 && bits !== 32) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", "radixSort: bits must be 8, 16, 24 or 32", {
+      argument: "bits",
+      value: bits,
+      expected: [8, 16, 24, 32]
+    });
+  }
+  if (!Number.isSafeInteger(count) || count < 0 || count > U32_MAX$2) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", "radixSort: count must be a non-negative integer below 2^32", {
+      argument: "count",
+      value: count
+    });
+  }
+  const pairBytes = 4 * count;
+  checkBinding("keys", keys, pairBytes);
+  checkBinding("vals", vals, pairBytes);
+  checkBinding("scratch.keys", scratch.keys, pairBytes);
+  checkBinding("scratch.vals", scratch.vals, pairBytes);
+  const tableBytes = radixHistBytes(count, wg);
+  checkBinding("scratch.hist", scratch.hist, tableBytes);
+  checkBinding("scratch.offsets", scratch.offsets, tableBytes);
+}
+class RadixSortPlannerImpl {
+  /**
+   * Wraps the resolved kernels; use prepareRadixSort().
+   * @param scope - the caller's scope
+   * @param hist - the `radix-hist` kernel
+   * @param scatter - the `radix-scatter` kernel
+   * @param scan - the scan planner of the same scope
+   */
+  constructor(scope, hist, scatter, scan) {
+    this.dispatches = 0;
+    this.scope = scope;
+    this.hist = hist;
+    this.scatter = scatter;
+    this.scan = scan;
+  }
+  /**
+   * Dispatches the last record() issued.
+   * @returns the count
+   */
+  get lastDispatches() {
+    return this.dispatches;
+  }
+  /**
+   * Records the passes into the pass (see the interface).
+   * @param pass - the compute pass
+   * @param keys - the keys
+   * @param vals - the values
+   * @param count - the pair count
+   * @param bits - the key width
+   * @param scratch - the second pair, the histogram table and its scanned twin
+   * @returns the pair the result lives in
+   */
+  record(pass, keys, vals, count, bits, scratch) {
+    const wg = this.scope.workgroupSize;
+    checkRecordArguments(keys, vals, count, bits, scratch, wg);
+    if (count === 0) {
+      this.dispatches = 0;
+      return { keys, vals };
+    }
+    const groups = Math.ceil(count / wg);
+    const plan = plan1d(count, wg, this.scope.caps);
+    const tableWords = RADIX_BINS * groups;
+    const tableBytes = 4 * tableWords;
+    const histTable = { ...scratch.hist, size: tableBytes };
+    const offsets = { ...scratch.offsets, size: tableBytes };
+    let src = { keys, vals };
+    let dst = { keys: scratch.keys, vals: scratch.vals };
+    let dispatches = 0;
+    const passes = bits / RADIX_DIGIT_BITS;
+    for (let p = 0; p < passes; p++) {
+      const params = this.scope.params(RADIX_PARAMS, { count, shift: RADIX_DIGIT_BITS * p, groups, pad0: 0 });
+      const histBound = this.hist.bind({ keys: src.keys, hist: histTable, P: params.binding });
+      this.hist.dispatch(pass, histBound, plan, [params.offset]);
+      this.scan.record(pass, histTable, tableWords, offsets);
+      const scatterBound = this.scatter.bind({
+        keys: src.keys,
+        vals: src.vals,
+        offsets,
+        keysOut: dst.keys,
+        valsOut: dst.vals,
+        P: params.binding
+      });
+      this.scatter.dispatch(pass, scatterBound, plan, [params.offset]);
+      dispatches += 2 + this.scan.lastDispatches;
+      [src, dst] = [dst, src];
+    }
+    this.dispatches = dispatches;
+    return src;
+  }
+}
+const ALGORITHM$3 = "breadthFirstSearch";
+function bfsRingSlots(windows, levelsPerSubmit) {
+  return Math.max((5 + 4 * windows) * levelsPerSubmit + 16, RESULT_BATCH_SLOTS + windows);
+}
+const RESULT_BATCH_SLOTS = 2 + 4 * 8;
+function normaliseMaxDepth(maxDepth) {
+  if (maxDepth === void 0 || Number.isNaN(maxDepth) || maxDepth >= U32_MAX$2) {
+    return U32_MAX$2;
+  }
+  return Math.max(0, Math.ceil(maxDepth));
+}
+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$3}: 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 bindingOf$1(buffer, size) {
+  return { buffer, offset: 0, size, window: null };
+}
+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}`,
+      message: `the ${name} view has no ${name} binding`
+    });
+  }
+  return binding;
+}
+function aborted$1(batchId) {
+  return new WebGpuGraphError(
+    "E_ABORTED",
+    `${ALGORITHM$3}: 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`,
+      message: `the field ${name} did not decode to a number`
+    });
+  }
+  return value;
+}
+async function bfsWithTuning(ctx, s, source, options, tuning) {
+  ctx.assertReady();
+  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})`, {
+      argument: "source",
+      value: source,
+      expected: `an integer in [0, ${n})`
+    });
+  }
+  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$3}: levelsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
+      {
+        argument: "levelsPerSubmit",
+        value: levelsPerSubmit,
+        expected: `an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`
+      }
+    );
+  }
+  const dest = checkDest$1(options?.dest, n);
+  const maxDepth = normaliseMaxDepth(options?.maxDepth);
+  const predKind = tuning.predKind ?? 1;
+  if (options?.signal?.aborted) {
+    throw aborted$1();
+  }
+  const core = ctx.residency.core(s);
+  const forward = coreWindows(core);
+  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`,
+      {
+        needed: 4 * s.arcCount,
+        limit: ctx.caps.limits.maxStorageBufferBindingSize,
+        path: "windowed",
+        algorithm: ALGORITHM$3
+      }
+    );
+  }
+  const reverse = s.directed ? coreOfView(ctx.residency.view(s, "reverse"), s.arcCount) : core;
+  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));
+  tuning.onScope?.(scope);
+  try {
+    const bytes = 4 * n;
+    const wg = ctx.workgroupSize;
+    const depth = bindingOf$1(scope.scratch(bytes, "depth"), bytes);
+    const bitsBase = Math.ceil(n / 64) * 64;
+    const bitsWords = Math.ceil(n / 32);
+    const sweepBytes = 4 * (bitsBase + bitsWords);
+    const sweepIn = bindingOf$1(scope.scratch(sweepBytes, "sweep-in"), sweepBytes);
+    const unvisitedList = { buffer: sweepIn.buffer, offset: 0, size: bytes, window: null };
+    const frontierBits = {
+      buffer: sweepIn.buffer,
+      offset: 4 * bitsBase,
+      size: 4 * bitsWords,
+      window: null
+    };
+    const flags = bindingOf$1(scope.scratch(bytes, "unvisited-flags"), bytes);
+    const iota = bindingOf$1(scope.scratch(bytes, "iota"), bytes);
+    const compactCount = bindingOf$1(scope.scratch(4, "compact-count"), 4);
+    await ctx.allocator.check();
+    const planner = await prepareFrontier(scope, n, s.arcCount, tuning.edgeCapacity);
+    const advance = await prepareAdvance(scope, core);
+    const compact = await prepareCompact(scope);
+    const contract = await ctx.pipelines.kernel(kernelSpec("bfs-contract"));
+    const fused = await ctx.pipelines.kernel(kernelSpec("bfs-fused", graphOverrides(core, null)));
+    const bitset = await ctx.pipelines.kernel(kernelSpec("bfs-bitset-build"));
+    const bottomUp = await ctx.pipelines.kernel(kernelSpec("bfs-bottom-up", graphOverrides(reverse, null)));
+    const unvisited = await ctx.pipelines.kernel(kernelSpec("bfs-unvisited-flags"));
+    const pred = await ctx.pipelines.kernel(kernelSpec("sssp-pred", { ...graphOverrides(core, null), MODE: 1 }));
+    const fill = await ctx.pipelines.kernel(kernelSpec("fill"));
+    const sort = await prepareRadixSort(scope);
+    const { frontier } = planner;
+    const { counters } = frontier;
+    const { queue } = ctx.device;
+    const fillPlan = plan1d(n, wg, ctx.caps);
+    const levelPlan = planGridStride(Math.max(n, frontier.edgeCapacity), wg, ctx.caps);
+    const sweepPlan = planGridStride(n, wg, ctx.caps);
+    const fusedPlan = planGridStride(n * wg, wg, ctx.caps);
+    const bitsPlan = plan1d(bitsWords, wg, ctx.caps);
+    const recordFill = (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]);
+    };
+    const flagsPlan = planGridStride(n, wg, ctx.caps);
+    const recordRebuild = (pass2) => {
+      const params = scope.params(FRONTIER_PARAMS, { wg, n, stride: flagsPlan.stride ?? n });
+      const bound = unvisited.bind({ outDegree, inDegree, depth, flags, counters, P: params.binding });
+      unvisited.dispatch(pass2, bound, flagsPlan, [params.offset]);
+      compact.record(pass2, {
+        queue: iota,
+        flags,
+        count: n,
+        out: unvisitedList,
+        outCount: compactCount,
+        outIndex: 0
+      });
+    };
+    const submit = (batch) => {
+      scope.flush();
+      return batch.submit();
+    };
+    const setup = new CommandBatch(ctx, `${ALGORITHM$3}/setup`);
+    const setupPass = setup.pass("fill");
+    recordFill(setupPass, depth, INVALID_INDEX, 0);
+    recordFill(setupPass, iota, 0, 1);
+    setup.endPass();
+    await submit(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 });
+    const fields = {
+      mode: tuning.direction === "top-down" ? 1 : 0,
+      alpha: tuning.alpha ?? Math.max(1, Math.floor(s.arcCount / n)),
+      beta: tuning.beta ?? BEAMER_BETA,
+      fusedMax: tuning.fusedMax ?? FUSED_FRONTIER_MAX,
+      maxDepth
+    };
+    let levelsRecorded = 0;
+    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 pass2 = batch.pass("bfs");
+      recordRebuild(pass2);
+      const bitsParams = scope.params(FILL_PARAMS, { count: bitsWords, value: 0, mode: 0, pad0: 0 });
+      const boundBitsFill = fill.bind({ dst: frontierBits, P: bitsParams.binding });
+      for (let level2 = 0; level2 < levelsPerSubmit; level2++) {
+        planner.recordFinalize(pass2, 0, level2, { ...fields, firstOfSubmit: Math.min(level2, 2) });
+        advance.record(pass2, frontier);
+        planner.recordFinalize(pass2, 1, level2, fields);
+        const params = scope.params(FRONTIER_PARAMS, {
+          wg,
+          n,
+          edgeCapacity: frontier.edgeCapacity,
+          arcBase: 0,
+          arcEnd: s.arcCount,
+          bitsBase,
+          stride: levelPlan.stride ?? wg
+        });
+        const boundContract = contract.bind({
+          edgeQueue: frontier.edgeQueue,
+          counters,
+          depth,
+          frontierOut: frontier.output,
+          P: params.binding
+        });
+        contract.dispatch(pass2, boundContract, levelPlan, [params.offset]);
+        for (const w of forward) {
+          const fusedParams = scope.params(FRONTIER_PARAMS, {
+            wg,
+            n,
+            edgeCapacity: frontier.edgeCapacity,
+            arcBase: w.arcBase,
+            arcEnd: w.arcEnd,
+            stride: fusedPlan.x * fusedPlan.y
+          });
+          const boundFused = fused.bind({
+            ...graphBindings(w.core, null),
+            frontierIn: frontier.input,
+            counters,
+            depth,
+            frontierOut: frontier.output,
+            P: fusedParams.binding
+          });
+          fused.dispatch(pass2, boundFused, fusedPlan, [fusedParams.offset]);
+        }
+        fill.dispatch(pass2, boundBitsFill, bitsPlan, [bitsParams.offset]);
+        const boundBitset = bitset.bind({
+          frontierIn: frontier.input,
+          counters,
+          bits: sweepIn,
+          P: params.binding
+        });
+        bitset.dispatch(pass2, boundBitset, levelPlan, [params.offset]);
+        for (const w of backward) {
+          const sweepParams = scope.params(FRONTIER_PARAMS, {
+            wg,
+            n,
+            arcBase: w.arcBase,
+            arcEnd: w.arcEnd,
+            bitsBase,
+            stride: sweepPlan.stride ?? wg
+          });
+          const boundSweep = bottomUp.bind({
+            ...graphBindings(w.core, null),
+            sweepIn,
+            counters,
+            depth,
+            frontierOut: frontier.output,
+            P: sweepParams.binding
+          });
+          bottomUp.dispatch(pass2, boundSweep, sweepPlan, [sweepParams.offset]);
+        }
+        frontier.swap();
+      }
+      batch.endPass();
+      const doneRequest = batch.readback(counters.buffer, counters.offset + 4 * W.done, 4);
+      const inspect = tuning.onLevel === void 0 ? null : {
+        block: batch.readback(counters.buffer, counters.offset, FRONTIER_COUNTERS.byteLength),
+        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 back2 = await submitted.readback;
+      levelsRecorded += levelsPerSubmit;
+      submits += 1;
+      ctx.assertReady();
+      if (options?.signal?.aborted) {
+        throw aborted$1(submitted.id);
+      }
+      options?.onProgress?.(Math.min(levelsRecorded, n), n);
+      if (inspect !== null && tuning.onLevel !== void 0) {
+        const block2 = FRONTIER_COUNTERS.read(new DataView(back2), inspect.block.offset);
+        const claimed = new Uint32Array(back2, inspect.frontier.offset, wordOf$1(block2, "nextFrontierCount"));
+        const rebuilt = new Uint32Array(back2, inspect.count.offset, 1)[0];
+        tuning.onLevel(levelsRecorded - 1, block2, claimed.slice(), rebuilt);
+      }
+      if (new Uint32Array(back2, doneRequest.offset, 1)[0] !== 0) {
+        break;
+      }
+      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` }
+        );
+      }
+    }
+    const keys = bindingOf$1(scope.scratch(bytes, "order/keys"), bytes);
+    const vals = bindingOf$1(scope.scratch(bytes, "order/vals"), bytes);
+    const histBytes = radixHistBytes(n, wg);
+    const scratch = {
+      keys: bindingOf$1(scope.scratch(bytes, "order/keys-scratch"), bytes),
+      vals: bindingOf$1(scope.scratch(bytes, "order/vals-scratch"), bytes),
+      hist: bindingOf$1(scope.scratch(histBytes, "order/hist"), histBytes),
+      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`);
+    result.copy(depth, keys, bytes);
+    const pass = result.pass("result");
+    recordFill(pass, vals, 0, 1);
+    const sorted = sort.record(pass, keys, vals, n, 32, scratch);
+    recordFill(pass, parent, INVALID_INDEX, 0);
+    const predPlan = planGridStride(n, wg, ctx.caps);
+    for (const w of forward) {
+      const predParams = scope.params(FRONTIER_PARAMS, {
+        wg,
+        n,
+        arcBase: w.arcBase,
+        arcEnd: w.arcEnd,
+        predKind,
+        source,
+        stride: predPlan.stride ?? n
+      });
+      const predBound = pred.bind({
+        ...graphBindings(w.core, null),
+        dist: depth,
+        pred: parent,
+        P: predParams.binding
+      });
+      pred.dispatch(pass, predBound, predPlan, [predParams.offset]);
+    }
+    result.endPass();
+    const depthRequest = result.readback(depth.buffer, depth.offset, bytes);
+    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;
+    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)`,
+        {
+          label: `${ALGORITHM$3}/visitedCount`,
+          message: `the device counted ${visitedCount} visits of ${n} vertices`
+        }
+      );
+    }
+    const level = wordOf$1(block, "level");
+    const levels = wordOf$1(block, "frontierCount") === 0 ? level : level + 1;
+    const depthOut = dest ?? new Uint32Array(n);
+    depthOut.set(new Uint32Array(back, depthRequest.offset, n));
+    return {
+      depth: depthOut,
+      parent: new Uint32Array(back, parentRequest.offset, n).slice(),
+      order: new Uint32Array(back, orderRequest.offset, visitedCount).slice(),
+      visitedCount,
+      levels,
+      switches: wordOf$1(block, "switches")
+    };
+  } finally {
+    scope.dispose();
+  }
+}
+function breadthFirstSearch(ctx, s, source, options) {
+  return bfsWithTuning(ctx, s, source, options, {});
+}
+const ALGORITHM$2 = "sssp";
+const HALF_ALIGN = 64;
+const RING_SLOTS$2 = 4 * MAX_LEVELS_PER_SUBMIT + 40;
+function bitsOf(value) {
+  return new Uint32Array(Float32Array.of(value).buffer)[0];
+}
+function bindingOf(buffer, size) {
+  return { buffer, offset: 0, size, window: null };
+}
+function aborted(algorithm, batchId) {
+  return new WebGpuGraphError(
+    "E_ABORTED",
+    `${algorithm}: the signal was aborted`,
+    batchId === void 0 ? {} : { batchId }
+  );
+}
+function assertSource(algorithm, source, n) {
+  if (!Number.isInteger(source) || source < 0 || source >= n) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${algorithm}: source ${source} is outside [0, ${n})`, {
+      argument: "source",
+      value: source,
+      expected: `an integer in [0, ${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`,
+      message: `the field ${name} did not decode to a number`
+    });
+  }
+  return value;
+}
+function checkDest(algorithm, dest, n) {
+  if (dest === void 0) {
+    return null;
+  }
+  if (dest instanceof Float32Array && dest.length === n && dest.buffer instanceof ArrayBuffer) {
+    return dest;
+  }
+  throw new WebGpuGraphError(
+    "E_INVALID_ARGUMENT",
+    `${algorithm}: dest must be a Float32Array of length ${n} over an ArrayBuffer`,
+    {
+      argument: "dest",
+      value: `${dest.constructor.name}(${dest.length})`,
+      expected: `Float32Array(${n}) over an ArrayBuffer`
+    }
+  );
+}
+function normaliseCutoff(algorithm, cutoff) {
+  if (cutoff === void 0) {
+    return Infinity;
+  }
+  if (Number.isNaN(cutoff)) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${algorithm}: cutoff must not be NaN`, {
+      argument: "cutoff",
+      value: cutoff,
+      expected: "a number (the CPU port and the kernel would disagree on NaN)"
+    });
+  }
+  return cutoff;
+}
+function resolveWeights$1(algorithm, s, weights) {
+  if (weights === void 0) {
+    if (s.weights === null) {
+      return null;
+    }
+    let sum2 = 0;
+    for (const w of s.weights) {
+      sum2 += w;
+    }
+    return {
+      values: s.weights,
+      override: null,
+      allOne: s.flags.allWeightsOne,
+      nonNegative: s.flags.nonNegativeWeights,
+      finite: s.flags.finiteWeights,
+      sum: sum2
+    };
+  }
+  if (weights.length !== s.arcCount) {
+    throw new WebGpuGraphError(
+      "E_INVALID_ARGUMENT",
+      `${algorithm}: weights has ${weights.length} entries, the snapshot ${s.arcCount} arcs`,
+      { argument: "weights", value: weights.length, expected: s.arcCount }
+    );
+  }
+  const values = weights instanceof Float32Array ? weights : Float32Array.from(weights);
+  let allOne = true;
+  let nonNegative = true;
+  let finite2 = true;
+  let sum = 0;
+  for (const w of values) {
+    if (w !== 1) {
+      allOne = false;
+    }
+    if (w < 0) {
+      nonNegative = false;
+    }
+    if (!Number.isFinite(w)) {
+      finite2 = false;
+    }
+    sum += w;
+  }
+  return { values, override: values, allOne, nonNegative, finite: finite2, sum };
+}
+async function unitWeightRoute(ctx, s, source, cutoff, dest, options) {
+  const maxDepth = cutoff === Infinity ? void 0 : Math.floor(cutoff);
+  const bfs = await bfsWithTuning(
+    ctx,
+    s,
+    source,
+    { maxDepth, signal: options?.signal, onProgress: options?.onProgress },
+    { predKind: 0 }
+  );
+  const dist = dest ?? new Float32Array(s.nodeCount);
+  for (let v = 0; v < s.nodeCount; v++) {
+    const d = bfs.depth[v];
+    dist[v] = d === INVALID_INDEX ? Infinity : d;
+  }
+  return { dist, predArc: bfs.parent, reachedCount: bfs.visitedCount };
+}
+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 wg = ctx.workgroupSize;
+  const { queue } = ctx.device;
+  const bytes = 4 * n;
+  const hb = Math.ceil(n / 64) * 64;
+  const predArcs = { buffer: pred.buffer, offset: pred.offset, size: bytes, window: null };
+  queue.writeBuffer(pred.buffer, pred.offset + 4 * (hb + source), Uint32Array.of(0));
+  queue.writeBuffer(pred.buffer, pred.offset + 4 * 2 * hb, new Uint32Array(2));
+  const predPlan = planGridStride(n, wg, ctx.caps);
+  const predFields = {
+    wg,
+    n,
+    arcBase: 0,
+    arcEnd: arcCount,
+    predKind: 0,
+    source,
+    stride: predPlan.stride ?? n,
+    mode
+  };
+  const maxBatches = Math.ceil((n + 1) / MAX_LEVELS_PER_SUBMIT) + 1;
+  let batches = 0;
+  for (; ; ) {
+    const batch = new CommandBatch(ctx, `${algorithm}/pred`);
+    const pass = batch.pass("pred");
+    const recordRole = (role, iteration) => {
+      const params = scope.params(FRONTIER_PARAMS, { ...predFields, role, iteration });
+      const bound = predKernel.bind({ ...graph, dist, pred, P: params.binding });
+      predKernel.dispatch(pass, bound, predPlan, [params.offset]);
+    };
+    if (batches === 0 && mode === 0) {
+      recordRole(0, 0);
+    }
+    for (let iteration = 0; iteration < MAX_LEVELS_PER_SUBMIT; iteration++) {
+      recordRole(1, iteration);
+    }
+    recordFill(pass, predArcs, n, INVALID_INDEX);
+    recordRole(2, 0);
+    batch.endPass();
+    const distRequest = batch.readback(dist.buffer, dist.offset, bytes);
+    const predRequest = batch.readback(pred.buffer, pred.offset, bytes);
+    const flagsRequest = batch.readback(pred.buffer, pred.offset + 4 * 2 * hb, 8);
+    scope.flush();
+    const back = await batch.submit().readback;
+    ctx.assertReady();
+    batches += 1;
+    const [changed, orphans] = new Uint32Array(back, flagsRequest.offset, 2);
+    if (changed < MAX_LEVELS_PER_SUBMIT) {
+      return {
+        dist: new Float32Array(back, distRequest.offset, n),
+        predArc: new Uint32Array(back, predRequest.offset, n).slice(),
+        orphans
+      };
+    }
+    if (batches > maxBatches) {
+      throw new WebGpuGraphError(
+        "E_VALIDATION",
+        `${algorithm}: the hop passes still changed something after ${batches} batches (a hop count is at most ${n})`,
+        { label: `${algorithm}/pred`, message: `the hop passes did not converge in ${batches} batches` }
+      );
+    }
+    queue.writeBuffer(pred.buffer, pred.offset + 4 * 2 * hb, new Uint32Array(2));
+  }
+}
+async function ssspWithTuning(ctx, s, source, options, tuning) {
+  ctx.assertReady();
+  await assertDeviceComputes(ctx);
+  const n = s.nodeCount;
+  assertSource(ALGORITHM$2, 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}]`,
+      {
+        argument: "roundsPerSubmit",
+        value: roundsPerSubmit,
+        expected: `an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`
+      }
+    );
+  }
+  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`, {
+      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);
+  if (options?.signal?.aborted) {
+    throw aborted(ALGORITHM$2);
+  }
+  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`, {
+      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`, {
+      feature: "sssp.nonFiniteWeights"
+    });
+  }
+  const { arcCount } = s;
+  const core = ctx.residency.core(s);
+  const limit = ctx.caps.limits.maxStorageBufferBindingSize;
+  assertWholeCore(core, arcCount, limit, ALGORITHM$2);
+  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 }
+    );
+  }
+  const delta = Math.fround(
+    tuning.delta ?? (vector2.sum === 0 ? 1 : SSSP_DELTA_FACTOR * (vector2.sum / arcCount) / (arcCount / n))
+  );
+  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);
+  try {
+    const wg = ctx.workgroupSize;
+    const bytes = 4 * n;
+    const dist = bindingOf(scope.scratch(bytes, "dist"), bytes);
+    const owner = bindingOf(scope.scratch(bytes, "owner"), bytes);
+    const queueOut = bindingOf(scope.scratch(8 * cap, "queue-out"), 8 * cap);
+    const nearHalf = { buffer: queueOut.buffer, offset: 0, size: 4 * cap, window: null };
+    const farHalf = { buffer: queueOut.buffer, offset: 4 * cap, size: 4 * cap, window: null };
+    const predWords = predBufferWords(n);
+    const pred = bindingOf(scope.scratch(4 * predWords, "pred"), 4 * predWords);
+    const { queue } = ctx.device;
+    let weightsBinding;
+    if (vector2.override !== null) {
+      const uploaded = scope.scratch(4 * arcCount, "weights");
+      queue.writeBuffer(uploaded, 0, vector2.override);
+      weightsBinding = bindingOf(uploaded, 4 * arcCount);
+    }
+    await ctx.allocator.check();
+    const planner = await prepareFrontier(scope, n, arcCount, cap);
+    const compact = await prepareCompact(scope);
+    const overrides = graphOverrides(core, null, weightsBinding);
+    const relax = await ctx.pipelines.kernel(kernelSpec("sssp-relax", overrides));
+    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 { frontier } = planner;
+    const { counters } = frontier;
+    const nearIn = frontier.vertices[0];
+    const farIn = frontier.vertices[1];
+    const recordFill = (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) => {
+      scope.flush();
+      return batch.submit();
+    };
+    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);
+    setup.endPass();
+    await submit(setup).readback;
+    ctx.assertReady();
+    queue.writeBuffer(dist.buffer, dist.offset + 4 * source, Uint32Array.of(0));
+    frontier.reset(queue, source, { nextFrontierCount: 1, thresholdBits: deltaBits, deltaBits });
+    queue.writeBuffer(queueOut.buffer, queueOut.offset, Uint32Array.of(source));
+    const nearDedupe = {
+      queue: nearHalf,
+      count: cap,
+      countIndex: W.edgeCount,
+      // role 2 writes the raw near count here when it chooses a near round, 0 otherwise
+      counters,
+      owner,
+      out: nearIn,
+      outCount: counters,
+      outIndex: W.frontierCount
+    };
+    const farDedupe = {
+      queue: farHalf,
+      count: cap,
+      countIndex: W.edgeCountUnclamped,
+      // and the raw far count here on a far round
+      counters,
+      owner,
+      out: farIn,
+      outCount: counters,
+      outIndex: W.farCount
+    };
+    const relaxPlan = planGridStride(n, wg, ctx.caps);
+    const relaxFields = {
+      wg,
+      n,
+      edgeCapacity: cap,
+      arcBase: 0,
+      arcEnd: arcCount,
+      cutoffBits: bitsOf(cutoff),
+      source,
+      stride: relaxPlan.stride ?? wg
+    };
+    let roundsRecorded = 0;
+    let submits = 0;
+    for (; ; ) {
+      const batch = new CommandBatch(ctx, `${ALGORITHM$2}/rounds`);
+      const pass = batch.pass("sssp");
+      const near = scope.params(FRONTIER_PARAMS, { ...relaxFields, role: 0 });
+      const far = scope.params(FRONTIER_PARAMS, { ...relaxFields, role: 1 });
+      const boundNear = relax.bind({ ...graph, dist, counters, queueIn: nearIn, queueOut, P: near.binding });
+      const boundFar = relax.bind({ ...graph, dist, counters, queueIn: farIn, queueOut, P: far.binding });
+      for (let round = 0; round < roundsPerSubmit; round++) {
+        planner.recordFinalize(pass, 2, round, {});
+        compact.recordDedupe(pass, nearDedupe);
+        compact.recordDedupe(pass, farDedupe);
+        planner.recordFinalize(pass, 3, round, {});
+        relax.dispatch(pass, boundNear, relaxPlan, [near.offset]);
+        relax.dispatch(pass, boundFar, relaxPlan, [far.offset]);
+      }
+      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 back = await submitted.readback;
+      roundsRecorded += roundsPerSubmit;
+      submits += 1;
+      ctx.assertReady();
+      if (options?.signal?.aborted) {
+        throw aborted(ALGORITHM$2, submitted.id);
+      }
+      options?.onProgress?.(Math.min(roundsRecorded, maxRounds), maxRounds);
+      if (inspect !== null && tuning.onRound !== void 0) {
+        tuning.onRound(roundsRecorded - 1, FRONTIER_COUNTERS.read(new DataView(back), inspect.offset));
+      }
+      const done = new Uint32Array(back, doneRequest.offset, 1)[0];
+      if (done === 1) {
+        break;
+      }
+      if (done !== 0) {
+        const block = FRONTIER_COUNTERS.read(
+          new DataView(
+            await ctx.readback.read(
+              counters.buffer,
+              FRONTIER_COUNTERS.byteLength,
+              void 0,
+              counters.offset
+            )
+          )
+        );
+        if (done === 2) {
+          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 }
+          );
+        }
+        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`,
+          { 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` }
+        );
+      }
+    }
+    const passed = await predecessorPass({
+      algorithm: ALGORITHM$2,
+      ctx,
+      scope,
+      predKernel,
+      recordFill,
+      graph,
+      dist,
+      pred,
+      n,
+      arcCount,
+      source,
+      mode: 0
+    });
+    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` }
+      );
+    }
+    const distOut = dest ?? new Float32Array(n);
+    distOut.set(passed.dist);
+    let reachedCount = 0;
+    for (const d of distOut) {
+      if (d !== Infinity) {
+        reachedCount += 1;
+      }
+    }
+    return { dist: distOut, predArc: passed.predArc, reachedCount };
+  } finally {
+    scope.dispose();
+  }
+}
+function sssp(ctx, s, source, options) {
+  return ssspWithTuning(ctx, s, source, options, {});
+}
+const ALGORITHM$1 = "bellmanFord";
+const ROUNDS_PER_BATCH = 8;
+const MAX_RETRIES = 16;
+const RING_SLOTS$1 = MAX_LEVELS_PER_SUBMIT + 16;
+function assertSymmetric(s, vector2) {
+  const { arcToEdge, edgeToArc } = s;
+  for (let a = 0; a < s.arcCount; a++) {
+    const forward = edgeToArc[arcToEdge[a]];
+    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`,
+        { feature: "bellmanFord.asymmetricUndirectedWeights", hint: "use a directed snapshot" }
+      );
+    }
+  }
+}
+async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
+  ctx.assertReady();
+  await assertDeviceComputes(ctx);
+  const n = s.nodeCount;
+  assertSource(ALGORITHM$1, 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`, {
+      argument: "maxRetries",
+      value: maxRetries,
+      expected: "an integer >= 1"
+    });
+  }
+  const roundsPerBatch = tuning.roundsPerBatch ?? ROUNDS_PER_BATCH;
+  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}]`,
+      {
+        argument: "roundsPerBatch",
+        value: roundsPerBatch,
+        expected: `an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`
+      }
+    );
+  }
+  const dest = checkDest(ALGORITHM$1, options?.dest, n);
+  const vector2 = resolveWeights$1(ALGORITHM$1, s, options?.weights);
+  const cutoff = normaliseCutoff(ALGORITHM$1, options?.cutoff);
+  if (options?.signal?.aborted) {
+    throw aborted(ALGORITHM$1);
+  }
+  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`, {
+      feature: "bellmanFord.nonFiniteWeights"
+    });
+  }
+  if (!s.directed && vector2.override !== null) {
+    assertSymmetric(s, vector2.override);
+  }
+  const { arcCount } = s;
+  const core = ctx.residency.core(s, ["rowPtr", "colIdx", "weights", "edgeToArc"]);
+  assertWholeCore(core, arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$1);
+  const edges = ctx.residency.view(s, "edgeList");
+  const edgeCount = edges.scalars.edgeCount[0];
+  const scope = algorithmScope(ctx, ALGORITHM$1, RING_SLOTS$1);
+  try {
+    const wg = ctx.workgroupSize;
+    const bytes = 4 * n;
+    const dist = bindingOf(scope.scratch(bytes, "dist"), bytes);
+    const predWords = predBufferWords(n);
+    const pred = bindingOf(scope.scratch(4 * predWords, "pred"), 4 * predWords);
+    const flags = bindingOf(scope.scratch(BF_FLAGS.byteLength, "flags"), BF_FLAGS.byteLength);
+    let iota = null;
+    let { edgeToArc } = core;
+    if (edgeToArc === null) {
+      iota = bindingOf(scope.scratch(4 * edgeCount, "iota"), 4 * edgeCount);
+      edgeToArc = iota;
+    }
+    const { queue } = ctx.device;
+    let weightsBinding;
+    if (vector2.override !== null) {
+      const uploaded = scope.scratch(4 * arcCount, "weights");
+      queue.writeBuffer(uploaded, 0, vector2.override);
+      weightsBinding = bindingOf(uploaded, 4 * arcCount);
+    }
+    await ctx.allocator.check();
+    const overrides = graphOverrides(core, null, weightsBinding);
+    const relax = await ctx.pipelines.kernel(kernelSpec("bf-relax", { UNDIRECTED: !s.directed }));
+    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 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) => {
+      scope.flush();
+      return batch.submit();
+    };
+    const setup = new CommandBatch(ctx, `${ALGORITHM$1}/setup`);
+    const setupPass = setup.pass("fill");
+    recordFill(setupPass, dist, n, F32_INF_BITS);
+    recordFill(setupPass, pred, predWords, INVALID_INDEX);
+    if (iota !== null) {
+      recordFill(setupPass, iota, edgeCount, 0, 1);
+    }
+    setup.endPass();
+    await submit(setup).readback;
+    ctx.assertReady();
+    queue.writeBuffer(dist.buffer, dist.offset + 4 * source, Uint32Array.of(0));
+    const edgePlan = planGridStride(edgeCount, wg, ctx.caps);
+    const relaxBindings = {
+      edgeSrc: edges.bindings.src,
+      edgeDst: edges.bindings.dst,
+      edgeToArc,
+      weights: graph.weights,
+      dist,
+      flags
+    };
+    const relaxFields = {
+      edgeCount,
+      stride: edgePlan.stride ?? edgeCount,
+      maxRetries,
+      cutoffBits: bitsOf(cutoff)
+    };
+    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 pass = batch.pass("relax");
+      const params = scope.params(BF_PARAMS, relaxFields);
+      const bound = relax.bind({ ...relaxBindings, P: params.binding });
+      for (let round = 0; round < count; round++) {
+        relax.dispatch(pass, bound, edgePlan, [params.offset]);
+      }
+      batch.endPass();
+      const request = batch.readback(flags.buffer, flags.offset, BF_FLAGS.byteLength);
+      const submitted = submit(batch);
+      const back = await submitted.readback;
+      ctx.assertReady();
+      const block = BF_FLAGS.read(new DataView(back), request.offset);
+      return { changed: Number(block.changed), retryExhausted: Number(block.retryExhausted), id: submitted.id };
+    };
+    let rounds = 0;
+    let retryExhaustedRounds = 0;
+    let hasNegativeCycle = false;
+    for (; ; ) {
+      const remaining = n - 1 - rounds;
+      if (remaining <= 0) {
+        const decision = await runRounds(1, "decision");
+        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`,
+            {
+              label: `${ALGORITHM$1}/retry`,
+              message: "retryExhausted in the decision round",
+              batchId: decision.id
+            }
+          );
+        }
+        hasNegativeCycle = decision.changed !== 0;
+        break;
+      }
+      const count = Math.min(roundsPerBatch, remaining);
+      const batch = await runRounds(count, "rounds");
+      rounds += count;
+      if (batch.retryExhausted !== 0) {
+        retryExhaustedRounds += 1;
+      }
+      if (options?.signal?.aborted) {
+        throw aborted(ALGORITHM$1, batch.id);
+      }
+      options?.onProgress?.(rounds, n);
+      if (batch.changed === 0 && batch.retryExhausted === 0) {
+        break;
+      }
+    }
+    const passed = await predecessorPass({
+      algorithm: ALGORITHM$1,
+      ctx,
+      scope,
+      predKernel,
+      recordFill,
+      graph,
+      dist,
+      pred,
+      n,
+      arcCount,
+      source,
+      mode: 1
+    });
+    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)`,
+        {
+          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"
+        }
+      );
+    }
+    const distOut = dest ?? new Float32Array(n);
+    distOut.set(passed.dist);
+    let reachedCount = 0;
+    for (const d of distOut) {
+      if (d !== Infinity) {
+        reachedCount += 1;
+      }
+    }
+    return {
+      result: { dist: distOut, predArc: passed.predArc, reachedCount, hasNegativeCycle },
+      rounds,
+      retryExhaustedRounds
+    };
+  } finally {
+    scope.dispose();
+  }
+}
+async function bellmanFord(ctx, s, source, options) {
+  return (await bellmanFordWithTuning(ctx, s, source, options, {})).result;
+}
+const ALGORITHM = "closenessCentrality";
+const SOURCES_PER_BATCH = 32;
+const PER_SOURCE_WORDS = 4 * SOURCES_PER_BATCH;
+const RING_SLOTS = 8 * MAX_LEVELS_PER_SUBMIT + 16;
+function reusingScratch(scope) {
+  const held = /* @__PURE__ */ new Map();
+  return {
+    ...scope,
+    scratch: (byteLength, label) => {
+      const key = `${label}/${byteLength}`;
+      let buffer = held.get(key);
+      if (buffer === void 0) {
+        buffer = scope.scratch(byteLength, label);
+        held.set(key, buffer);
+      }
+      return buffer;
+    }
+  };
+}
+async function weightedRoute(ctx, s, scores, options) {
+  const n = s.nodeCount;
+  for (let source = 0; source < n; source++) {
+    if (options?.signal?.aborted) {
+      throw aborted(ALGORITHM);
+    }
+    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;
+      }
+    }
+    scores[source] = sum === 0 ? 0 : 1 / sum;
+    options?.onProgress?.(source + 1, n);
+  }
+  return { scores, iterations: n, converged: true, precision: "f32" };
+}
+async function sweepRoute(ctx, s, scores, levelsPerSubmit, options, tuning) {
+  const n = s.nodeCount;
+  if (n === 0) {
+    return { scores, iterations: 0, converged: true, precision: "f32" };
+  }
+  const core = ctx.residency.core(s);
+  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM);
+  const scope = algorithmScope(ctx, ALGORITHM, RING_SLOTS);
+  try {
+    const wg = ctx.workgroupSize;
+    const bytes = 4 * n;
+    const bitsBase = Math.ceil(n / 64) * 64;
+    const regionBytes = 4 * bitsBase;
+    const bits = bindingOf(scope.scratch(4 * regionBytes, "bits"), 4 * regionBytes);
+    const region = (index) => ({
+      buffer: bits.buffer,
+      offset: index * regionBytes,
+      size: regionBytes,
+      window: null
+    });
+    const flags = region(3);
+    const frontierList = bindingOf(scope.scratch(bytes, "frontier-list"), bytes);
+    const iota = bindingOf(scope.scratch(bytes, "iota"), bytes);
+    const counters = bindingOf(
+      scope.scratch(FRONTIER_COUNTERS.byteLength, "counters"),
+      FRONTIER_COUNTERS.byteLength
+    );
+    const perSourceBytes = 4 * PER_SOURCE_WORDS;
+    const perSource = bindingOf(scope.scratch(perSourceBytes, "per-source"), perSourceBytes);
+    await ctx.allocator.check();
+    const compact = await prepareCompact(reusingScratch(scope));
+    const sweep = await ctx.pipelines.kernel(kernelSpec("closeness-sweep", graphOverrides(core, null)));
+    const reduce = await ctx.pipelines.kernel(kernelSpec("closeness-reduce"));
+    const fill = await ctx.pipelines.kernel(kernelSpec("fill"));
+    const graph = graphBindings(core, null);
+    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 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) => {
+      scope.flush();
+      return batch.submit();
+    };
+    const setup = new CommandBatch(ctx, `${ALGORITHM}/setup`);
+    recordFill(setup.pass("fill"), iota, n, 1);
+    setup.endPass();
+    await submit(setup).readback;
+    ctx.assertReady();
+    let batches = 0;
+    for (let batchStart = 0; batchStart < n; 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 });
+          reduce.dispatch(pass, reduce.bind({ counters, perSource, bits, P: seed.binding }), onePlan, [
+            seed.offset
+          ]);
+        }
+        const boundary = scope.params(FRONTIER_PARAMS, { role: 0, n, bitsBase });
+        const boundBoundary = reduce.bind({ counters, perSource, bits, P: boundary.binding });
+        const clear = scope.params(FILL_PARAMS, { count: bitsBase, value: 0, mode: 0, pad0: 0 });
+        const boundClearNext = [region(2), region(1)].map((dst) => fill.bind({ dst, P: clear.binding }));
+        const boundClearFlags = fill.bind({ dst: flags, P: clear.binding });
+        const boundSweep = [0, 1].map((mode) => {
+          const params = scope.params(FRONTIER_PARAMS, {
+            wg,
+            n,
+            bitsBase,
+            arcBase: 0,
+            arcEnd: s.arcCount,
+            mode,
+            stride: sweepPlan.stride ?? wg
+          });
+          return {
+            bound: sweep.bind({ ...graph, frontierList, counters, bits, perSource, P: params.binding }),
+            offset: params.offset
+          };
+        });
+        for (let k = 0; k < levelsPerSubmit; k++, level++) {
+          const parity = level % 2;
+          reduce.dispatch(pass, boundBoundary, onePlan, [boundary.offset]);
+          compact.record(pass, {
+            queue: iota,
+            flags,
+            count: n,
+            out: frontierList,
+            outCount: counters,
+            outIndex: W.frontierCount
+          });
+          fill.dispatch(pass, boundClearNext[parity], regionPlan, [clear.offset]);
+          fill.dispatch(pass, boundClearFlags, regionPlan, [clear.offset]);
+          sweep.dispatch(pass, boundSweep[parity].bound, sweepPlan, [boundSweep[parity].offset]);
+        }
+        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 back = await submitted.readback;
+        ctx.assertReady();
+        if (options?.signal?.aborted) {
+          throw aborted(ALGORITHM, 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;
+          }
+          tuning.onBatch?.(batchStart, block.slice());
+          break;
+        }
+        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` }
+          );
+        }
+      }
+      batches += 1;
+      options?.onProgress?.(Math.min(batchStart + SOURCES_PER_BATCH, n), n);
+    }
+    return { scores, iterations: batches, converged: true, precision: "f32" };
+  } finally {
+    scope.dispose();
   }
-  const run2 = await runPowerIteration(ctx, r.n, {
-    normMode: 4,
-    adjacency: reverseOf(ctx, s),
-    alternate: null,
-    alpha,
-    beta,
-    uniformP: 1,
-    maxIterations: r.maxIterations,
-    tolerance: r.tolerance,
-    weights: r.weights,
-    label: algorithm,
-    signal: options?.signal,
-    onProgress: options?.onProgress
-  });
-  return scoresOf(run2, r.dest, "l2");
 }
-async function hits(ctx, s, options) {
-  const algorithm = "hits";
-  const r = resolve(ctx, s, options, algorithm);
-  const total = 2 * r.maxIterations;
-  if (r.n === 0) {
-    const { scores, iterations, converged, precision } = empty(r.dest, total, options?.onProgress);
-    return { hubs: scores, authorities: new Float32Array(0), iterations, converged, precision };
+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`, {
+        option: key,
+        hint: "closeness is an exact traversal; the option has no meaning here"
+      });
+    }
   }
-  const onProgress = options?.onProgress;
-  const shared = {
-    normMode: 1,
-    alpha: 1,
-    beta: 0,
-    uniformP: 0,
-    maxIterations: r.maxIterations,
-    tolerance: r.tolerance,
-    weights: r.weights,
-    signal: options?.signal
-  };
-  const forward = coreOf(ctx, s, algorithm);
-  const reverse = reverseOf(ctx, s);
-  const hubSeeded = await runPowerIteration(ctx, r.n, {
-    ...shared,
-    adjacency: reverse,
-    alternate: forward,
-    label: `${algorithm}/hub-seeded`,
-    onProgress: onProgress === void 0 ? void 0 : (done) => {
-      onProgress(done, total);
+  const n = s.nodeCount;
+  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}]`,
+      {
+        argument: "levelsPerSubmit",
+        value: levelsPerSubmit,
+        expected: `an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`
+      }
+    );
+  }
+  const scores = checkDest(ALGORITHM, options?.dest, n) ?? new Float32Array(n);
+  const weighted = options?.weighted ?? s.flags.weighted;
+  if (options?.signal?.aborted) {
+    throw aborted(ALGORITHM);
+  }
+  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`,
+        {
+          feature: "closenessCentrality.negativeWeights",
+          hint: "pass weighted: false to ignore the column"
+        }
+      );
     }
-  });
-  const authoritySeeded = await runPowerIteration(ctx, r.n, {
-    ...shared,
-    adjacency: forward,
-    alternate: reverse,
-    label: `${algorithm}/authority-seeded`,
-    onProgress: onProgress === void 0 ? void 0 : (done) => {
-      onProgress(r.maxIterations + done, total);
+    if (!s.flags.finiteWeights) {
+      throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM}: a NaN or infinite weight has no shortest path`, {
+        feature: "closenessCentrality.nonFiniteWeights"
+      });
     }
-  });
-  return {
-    hubs: normalised(latestOfKind(hubSeeded, authoritySeeded), r.dest, "sum"),
-    authorities: normalised(latestOfKind(authoritySeeded, hubSeeded), null, "sum"),
-    iterations: Math.max(hubSeeded.iterations, authoritySeeded.iterations),
-    converged: hubSeeded.converged && authoritySeeded.converged,
-    precision: "f32"
-  };
+    return weightedRoute(ctx, s, scores, options);
+  }
+  return sweepRoute(ctx, s, scores, levelsPerSubmit, options, tuning);
+}
+function closenessCentrality(ctx, s, options) {
+  return closenessWithTuning(ctx, s, options, {});
 }
 const U32_MAX = 4294967295;
 async function prepareHistogram(scope) {
@@ -4646,128 +7480,16 @@ class CountingSortPlannerImpl {
     this.dispatches += 1;
   }
 }
-const RADIX_DIGIT_BITS = 8;
-function radixHistBytes(count, wg) {
-  return 4 * RADIX_BINS * Math.ceil(count / wg);
-}
-async function prepareRadixSort(scope) {
-  const hist = await scope.pipelines.kernel(kernelSpec("radix-hist"));
-  const scatter = await scope.pipelines.kernel(kernelSpec("radix-scatter"));
-  const scan = await prepareScan(scope);
-  return new RadixSortPlannerImpl(scope, hist, scatter, scan);
-}
-function checkBinding(argument, binding, bytes) {
-  if (binding.size < bytes) {
-    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `radixSort: ${argument} is smaller than ${bytes} bytes`, {
-      argument,
-      value: binding.size,
-      expected: bytes
-    });
-  }
-}
-function checkRecordArguments(keys, vals, count, bits, scratch, wg) {
-  if (bits !== 8 && bits !== 16 && bits !== 24 && bits !== 32) {
-    throw new WebGpuGraphError("E_INVALID_ARGUMENT", "radixSort: bits must be 8, 16, 24 or 32", {
-      argument: "bits",
-      value: bits,
-      expected: [8, 16, 24, 32]
-    });
-  }
-  if (!Number.isSafeInteger(count) || count < 0 || count > U32_MAX$2) {
-    throw new WebGpuGraphError("E_INVALID_ARGUMENT", "radixSort: count must be a non-negative integer below 2^32", {
-      argument: "count",
-      value: count
-    });
-  }
-  const pairBytes = 4 * count;
-  checkBinding("keys", keys, pairBytes);
-  checkBinding("vals", vals, pairBytes);
-  checkBinding("scratch.keys", scratch.keys, pairBytes);
-  checkBinding("scratch.vals", scratch.vals, pairBytes);
-  const tableBytes = radixHistBytes(count, wg);
-  checkBinding("scratch.hist", scratch.hist, tableBytes);
-  checkBinding("scratch.offsets", scratch.offsets, tableBytes);
-}
-class RadixSortPlannerImpl {
-  /**
-   * Wraps the resolved kernels; use prepareRadixSort().
-   * @param scope - the caller's scope
-   * @param hist - the `radix-hist` kernel
-   * @param scatter - the `radix-scatter` kernel
-   * @param scan - the scan planner of the same scope
-   */
-  constructor(scope, hist, scatter, scan) {
-    this.dispatches = 0;
-    this.scope = scope;
-    this.hist = hist;
-    this.scatter = scatter;
-    this.scan = scan;
-  }
-  /**
-   * Dispatches the last record() issued.
-   * @returns the count
-   */
-  get lastDispatches() {
-    return this.dispatches;
-  }
-  /**
-   * Records the passes into the pass (see the interface).
-   * @param pass - the compute pass
-   * @param keys - the keys
-   * @param vals - the values
-   * @param count - the pair count
-   * @param bits - the key width
-   * @param scratch - the second pair, the histogram table and its scanned twin
-   * @returns the pair the result lives in
-   */
-  record(pass, keys, vals, count, bits, scratch) {
-    const wg = this.scope.workgroupSize;
-    checkRecordArguments(keys, vals, count, bits, scratch, wg);
-    if (count === 0) {
-      this.dispatches = 0;
-      return { keys, vals };
-    }
-    const groups = Math.ceil(count / wg);
-    const plan = plan1d(count, wg, this.scope.caps);
-    const tableWords = RADIX_BINS * groups;
-    const tableBytes = 4 * tableWords;
-    const histTable = { ...scratch.hist, size: tableBytes };
-    const offsets = { ...scratch.offsets, size: tableBytes };
-    let src = { keys, vals };
-    let dst = { keys: scratch.keys, vals: scratch.vals };
-    let dispatches = 0;
-    const passes = bits / RADIX_DIGIT_BITS;
-    for (let p = 0; p < passes; p++) {
-      const params = this.scope.params(RADIX_PARAMS, { count, shift: RADIX_DIGIT_BITS * p, groups, pad0: 0 });
-      const histBound = this.hist.bind({ keys: src.keys, hist: histTable, P: params.binding });
-      this.hist.dispatch(pass, histBound, plan, [params.offset]);
-      this.scan.record(pass, histTable, tableWords, offsets);
-      const scatterBound = this.scatter.bind({
-        keys: src.keys,
-        vals: src.vals,
-        offsets,
-        keysOut: dst.keys,
-        valsOut: dst.vals,
-        P: params.binding
-      });
-      this.scatter.dispatch(pass, scatterBound, plan, [params.offset]);
-      dispatches += 2 + this.scan.lastDispatches;
-      [src, dst] = [dst, src];
-    }
-    this.dispatches = dispatches;
-    return src;
-  }
-}
-function nextPow2(x2) {
+function nextPow2(x) {
   let p = 1;
-  while (p < x2) {
+  while (p < x) {
     p *= 2;
   }
   return p;
 }
-function floorPow2$1(x2) {
+function floorPow2$1(x) {
   let p = 1;
-  while (p * 2 <= x2) {
+  while (p * 2 <= x) {
     p *= 2;
   }
   return p;
@@ -4951,15 +7673,15 @@ function resolveCenter(center) {
     return out;
   }
   for (let axis = 0; axis < 3 && axis < center.length; axis++) {
-    const v2 = center[axis];
-    if (!Number.isFinite(v2)) {
+    const v = center[axis];
+    if (!Number.isFinite(v)) {
       throw new WebGpuGraphError("E_INVALID_ARGUMENT", `center[${axis}] is not finite`, {
         argument: "center",
-        value: v2,
+        value: v,
         expected: "finite components"
       });
     }
-    out[axis] = v2;
+    out[axis] = v;
   }
   return out;
 }
@@ -4998,13 +7720,13 @@ function seedPositions(s, positions, seed, dim, scale, center, range) {
   for (let i = 0; i < n; i++) {
     let finite2 = true;
     for (let axis = 0; axis < dim; axis++) {
-      const v2 = positions[3 * i + axis];
-      if (Number.isFinite(v2)) {
-        if (v2 < lo[axis]) {
-          lo[axis] = v2;
+      const v = positions[3 * i + axis];
+      if (Number.isFinite(v)) {
+        if (v < lo[axis]) {
+          lo[axis] = v;
         }
-        if (v2 > hi[axis]) {
-          hi[axis] = v2;
+        if (v > hi[axis]) {
+          hi[axis] = v;
         }
       } else {
         finite2 = false;
@@ -5046,8 +7768,8 @@ function seedPositions(s, positions, seed, dim, scale, center, range) {
       const at = 3 * i + axis;
       if (!Number.isFinite(positions[at])) {
         const u = rng.next();
-        const v2 = boxLo[axis] + u * (boxHi[axis] - boxLo[axis]);
-        positions[at] = v2 * scale + c[axis];
+        const v = boxLo[axis] + u * (boxHi[axis] - boxLo[axis]);
+        positions[at] = v * scale + c[axis];
       }
     }
     if (dim === 2) {
@@ -5188,11 +7910,11 @@ function centerOf(options) {
     return out;
   }
   for (let axis = 0; axis < 3 && axis < center.length; axis++) {
-    const v2 = center[axis];
-    if (!Number.isFinite(v2)) {
-      throw invalidArgument("center", v2, "finite components", `center[${axis}] is not finite`);
+    const v = center[axis];
+    if (!Number.isFinite(v)) {
+      throw invalidArgument("center", v, "finite components", `center[${axis}] is not finite`);
     }
-    out[axis] = v2;
+    out[axis] = v;
   }
   return out;
 }
@@ -5840,12 +8562,12 @@ class ForceSimulation {
       );
     }
     let unpinned = false;
-    for (let w2 = 0; w2 < words && !unpinned; w2++) {
-      if (this.fixedWords[w2] === mask[w2]) {
+    for (let w = 0; w < words && !unpinned; w++) {
+      if (this.fixedWords[w] === mask[w]) {
         continue;
       }
-      const last = Math.min(n, w2 * 32 + 32);
-      for (let i = w2 * 32; i < last; i++) {
+      const last = Math.min(n, w * 32 + 32);
+      for (let i = w * 32; i < last; i++) {
         if (maskTest(this.fixedWords, i) && !maskTest(mask, i)) {
           unpinned = true;
           break;
@@ -5867,7 +8589,7 @@ class ForceSimulation {
    * @param y - scene y
    * @param z - scene z (ignored on the device in 2D)
    */
-  setPosition(index, x2, y2, z) {
+  setPosition(index, x, y, z) {
     this.assertLoaded();
     const { n } = this;
     if (!Number.isInteger(index) || index < 0 || index >= n) {
@@ -5878,10 +8600,10 @@ class ForceSimulation {
         `setPosition(${index}): index out of range`
       );
     }
-    if (!Number.isFinite(x2) || !Number.isFinite(y2) || !Number.isFinite(z)) {
+    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) {
       throw invalidArgument(
         "position",
-        [x2, y2, z],
+        [x, y, z],
         "finite coordinates",
         "setPosition: coordinates must be finite"
       );
@@ -5890,13 +8612,13 @@ class ForceSimulation {
     if (owner === null || buffers === null) {
       throw new WebGpuGraphError("E_NOT_LOADED", `${this.label}: load() first`, { state: this.stateValue });
     }
-    owner[3 * index] = x2;
-    owner[3 * index + 1] = y2;
+    owner[3 * index] = x;
+    owner[3 * index + 1] = y;
     owner[3 * index + 2] = z;
     const [cx, cy, cz] = this.center;
     const layout = new Float32Array([
-      (x2 - cx) / this.scale,
-      (y2 - cy) / this.scale,
+      (x - cx) / this.scale,
+      (y - cy) / this.scale,
       this.dimValue === 2 ? 0 : (z - cz) / this.scale
     ]);
     this.ctx.device.queue.writeBuffer(buffers.positions, 16 * index, layout);
@@ -6517,17 +9239,17 @@ class ForceSimulation {
     const lo = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
     const hi = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
     for (let i = 0; i < n; i++) {
-      const x2 = packed[4 * i];
-      const y2 = packed[4 * i + 1];
+      const x = packed[4 * i];
+      const y = packed[4 * i + 1];
       const z = packed[4 * i + 2];
-      sx += x2;
-      sy += y2;
+      sx += x;
+      sy += y;
       sz += z;
-      lo[0] = Math.min(lo[0], x2);
-      lo[1] = Math.min(lo[1], y2);
+      lo[0] = Math.min(lo[0], x);
+      lo[1] = Math.min(lo[1], y);
       lo[2] = Math.min(lo[2], z);
-      hi[0] = Math.max(hi[0], x2);
-      hi[1] = Math.max(hi[1], y2);
+      hi[0] = Math.max(hi[0], x);
+      hi[1] = Math.max(hi[1], y);
       hi[2] = Math.max(hi[2], z);
     }
     const mx = sx / n;
@@ -6788,14 +9510,14 @@ function invalid$1(argument, value, expected, message) {
 }
 function checkMass(mass, source) {
   for (let i = 0; i < mass.length; i++) {
-    const v2 = mass[i];
-    if (!Number.isFinite(v2) || v2 <= 0) {
+    const v = mass[i];
+    if (!Number.isFinite(v) || v <= 0) {
       throw new WebGpuGraphError(
         "E_INVALID_ARGUMENT",
-        `${source}: mass[${i}] = ${v2} is not a finite number > 0`,
+        `${source}: mass[${i}] = ${v} is not a finite number > 0`,
         {
           argument: "nodeMass",
-          value: v2,
+          value: v,
           index: i,
           expected: "finite masses > 0"
         }
@@ -7061,13 +9783,13 @@ function pickCenter(given, fallback) {
   if (length !== 2 && length !== 3) {
     throw invalid("center", given, expected);
   }
-  const x2 = given[0];
-  const y2 = given[1];
+  const x = given[0];
+  const y = given[1];
   const z = length === 3 ? given[2] : 0;
-  if (typeof x2 !== "number" || typeof y2 !== "number" || typeof z !== "number" || !Number.isFinite(x2) || !Number.isFinite(y2) || !Number.isFinite(z)) {
+  if (typeof x !== "number" || typeof y !== "number" || typeof z !== "number" || !Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) {
     throw invalid("center", given, expected);
   }
-  return [x2, y2, z];
+  return [x, y, z];
 }
 function pickSeed(given, fallback) {
   if (given === void 0) {
@@ -7669,9 +10391,9 @@ function resolveForceAtlas2Options(options, previous) {
   }
   const resolved = {
     maxIter: pickNumber("maxIter", o.maxIter, base.maxIter, isPositiveInteger, "an integer >= 1"),
-    jitterTolerance: pickNumber("jitterTolerance", o.jitterTolerance, base.jitterTolerance, (v2) => v2 > 0, "> 0"),
-    scalingRatio: pickNumber("scalingRatio", o.scalingRatio, base.scalingRatio, (v2) => v2 > 0, "> 0"),
-    gravity: pickNumber("gravity", o.gravity, base.gravity, (v2) => v2 >= 0, ">= 0"),
+    jitterTolerance: pickNumber("jitterTolerance", o.jitterTolerance, base.jitterTolerance, (v) => v > 0, "> 0"),
+    scalingRatio: pickNumber("scalingRatio", o.scalingRatio, base.scalingRatio, (v) => v > 0, "> 0"),
+    gravity: pickNumber("gravity", o.gravity, base.gravity, (v) => v >= 0, ">= 0"),
     strongGravity: pickBoolean("strongGravity", o.strongGravity, base.strongGravity),
     distributedAction: pickBoolean("distributedAction", o.distributedAction, base.distributedAction),
     linlog: pickBoolean("linlog", o.linlog, base.linlog),
@@ -7680,10 +10402,10 @@ function resolveForceAtlas2Options(options, previous) {
     weight: o.weight === void 0 ? base.weight : o.weight,
     dissuadeHubs: pickBoolean("dissuadeHubs", o.dissuadeHubs, base.dissuadeHubs),
     dim: pickDim(o.dim, base.dim),
-    scale: pickNumber("scale", o.scale, base.scale, (v2) => v2 > 0, "> 0"),
+    scale: pickNumber("scale", o.scale, base.scale, (v) => v > 0, "> 0"),
     center: pickCenter(o.center, base.center),
     seed: pickSeed(o.seed, base.seed),
-    settleThreshold: pickNumber("settleThreshold", o.settleThreshold, base.settleThreshold, (v2) => v2 >= 0, ">= 0"),
+    settleThreshold: pickNumber("settleThreshold", o.settleThreshold, base.settleThreshold, (v) => v >= 0, ">= 0"),
     settleWindow: pickNumber(
       "settleWindow",
       o.settleWindow,
@@ -7695,7 +10417,7 @@ function resolveForceAtlas2Options(options, previous) {
       "iterationsPerStep",
       o.iterationsPerStep,
       base.iterationsPerStep,
-      (v2) => isPositiveInteger(v2) && v2 <= MAX_ITERATIONS_PER_STEP,
+      (v) => isPositiveInteger(v) && v <= MAX_ITERATIONS_PER_STEP,
       `an integer in [1, ${MAX_ITERATIONS_PER_STEP}]`
     ),
     maxInFlight: pickNumber("maxInFlight", o.maxInFlight, base.maxInFlight, isPositiveInteger, "an integer >= 1")
@@ -7725,7 +10447,7 @@ function resolveLayoutTuning(tuning) {
       "nearMax",
       t.nearMax,
       LAYOUT_TUNING_DEFAULTS.nearMax,
-      (v2) => isPositiveInteger(v2) && v2 >= 2,
+      (v) => isPositiveInteger(v) && v >= 2,
       "an integer >= 2"
     ),
     deterministic: pickBoolean("deterministic", t.deterministic, LAYOUT_TUNING_DEFAULTS.deterministic),
@@ -7747,7 +10469,7 @@ function resolveLayoutTuning(tuning) {
       "extentFactor",
       t.extentFactor,
       LAYOUT_TUNING_DEFAULTS.extentFactor,
-      (v2) => v2 > 0,
+      (v) => v > 0,
       "> 0"
     ),
     compat
@@ -8374,7 +11096,7 @@ function resolveK(given, fallback) {
   if (given === null || given === 0 || Number.isNaN(given)) {
     return null;
   }
-  return pickNumber("k", given, 1, (v2) => v2 > 0, "> 0 or null");
+  return pickNumber("k", given, 1, (v) => v > 0, "> 0 or null");
 }
 function pickCooling(given, fallback) {
   if (given === void 0) {
@@ -8407,16 +11129,16 @@ function resolveFruchtermanReingoldOptions(options, previous) {
       "iterations",
       o.iterations,
       iterationsFallback,
-      (v2) => Number.isInteger(v2) && v2 >= 0,
+      (v) => Number.isInteger(v) && v >= 0,
       "an integer >= 0"
     ),
     cooling,
     fixed,
     dim: pickDim(o.dim, base.dim),
-    scale: pickNumber("scale", o.scale, base.scale, (v2) => v2 > 0, "> 0"),
+    scale: pickNumber("scale", o.scale, base.scale, (v) => v > 0, "> 0"),
     center: pickCenter(o.center, base.center),
     seed: pickSeed(o.seed, base.seed),
-    settleThreshold: pickNumber("settleThreshold", o.settleThreshold, base.settleThreshold, (v2) => v2 >= 0, ">= 0"),
+    settleThreshold: pickNumber("settleThreshold", o.settleThreshold, base.settleThreshold, (v) => v >= 0, ">= 0"),
     settleWindow: pickNumber(
       "settleWindow",
       o.settleWindow,
@@ -8428,7 +11150,7 @@ function resolveFruchtermanReingoldOptions(options, previous) {
       "iterationsPerStep",
       o.iterationsPerStep,
       base.iterationsPerStep,
-      (v2) => isPositiveInteger(v2) && v2 <= MAX_ITERATIONS_PER_STEP,
+      (v) => isPositiveInteger(v) && v <= MAX_ITERATIONS_PER_STEP,
       `an integer in [1, ${MAX_ITERATIONS_PER_STEP}]`
     ),
     maxInFlight: pickNumber("maxInFlight", o.maxInFlight, base.maxInFlight, isPositiveInteger, "an integer >= 1")
@@ -9058,22 +11780,22 @@ function resolveSpringElectricalOptions(options, previous) {
     );
   }
   const resolved = {
-    springLength: pickNumber("springLength", o.springLength, base.springLength, (v2) => v2 > 0, "> 0"),
+    springLength: pickNumber("springLength", o.springLength, base.springLength, (v) => v > 0, "> 0"),
     springCoefficient: pickNullable(
       "springCoefficient",
       o.springCoefficient,
       base.springCoefficient,
-      (v2) => v2 > 0,
+      (v) => v > 0,
       "> 0"
     ),
     gravity: pickNullable("gravity", o.gravity, base.gravity, () => true, "a finite number (negative repels)"),
-    dragCoefficient: pickNumber("dragCoefficient", o.dragCoefficient, base.dragCoefficient, (v2) => v2 >= 0, ">= 0"),
-    timeStep: pickNumber("timeStep", o.timeStep, base.timeStep, (v2) => v2 > 0, "> 0"),
+    dragCoefficient: pickNumber("dragCoefficient", o.dragCoefficient, base.dragCoefficient, (v) => v >= 0, ">= 0"),
+    timeStep: pickNumber("timeStep", o.timeStep, base.timeStep, (v) => v > 0, "> 0"),
     dim: pickDim(o.dim, base.dim),
-    scale: pickNumber("scale", o.scale, base.scale, (v2) => v2 > 0, "> 0"),
+    scale: pickNumber("scale", o.scale, base.scale, (v) => v > 0, "> 0"),
     center: pickCenter(o.center, base.center),
     seed: pickSeed(o.seed, base.seed),
-    settleThreshold: pickNumber("settleThreshold", o.settleThreshold, base.settleThreshold, (v2) => v2 >= 0, ">= 0"),
+    settleThreshold: pickNumber("settleThreshold", o.settleThreshold, base.settleThreshold, (v) => v >= 0, ">= 0"),
     settleWindow: pickNumber(
       "settleWindow",
       o.settleWindow,
@@ -9085,7 +11807,7 @@ function resolveSpringElectricalOptions(options, previous) {
       "iterationsPerStep",
       o.iterationsPerStep,
       base.iterationsPerStep,
-      (v2) => isPositiveInteger(v2) && v2 <= MAX_ITERATIONS_PER_STEP,
+      (v) => isPositiveInteger(v) && v <= MAX_ITERATIONS_PER_STEP,
       `an integer in [1, ${MAX_ITERATIONS_PER_STEP}]`
     ),
     maxInFlight: pickNumber("maxInFlight", o.maxInFlight, base.maxInFlight, isPositiveInteger, "an integer >= 1")
@@ -9718,6 +12440,51 @@ function createAccelerator(ctx, options) {
       ctx.assertReady();
       return await connectedComponents(ctx, gs, o);
     },
+    /**
+     * Breadth-first search on the device (spec 8.4; P8-T13). The result is bitwise reproducible (P8 PD-14).
+     * @param gs - the snapshot
+     * @param source - the source node index
+     * @param o - the seam's `BfsOptions` (`maxDepth`)
+     * @returns depth, parent, the level-grouped order, visitedCount, levels and switches (spec 3.3 line 830)
+     */
+    async breadthFirstSearch(gs, source, o) {
+      ctx.assertReady();
+      return await breadthFirstSearch(ctx, gs, source, o);
+    },
+    /**
+     * Single-source shortest paths on the device (spec 8.4; P8-T13): the near-far queue over f32 distances, or the
+     * breadth-first route when every weight is one.
+     * @param gs - the snapshot
+     * @param source - the source node index
+     * @param o - the seam's `SsspOptions` (`cutoff`, `weights`)
+     * @returns dist, predArc and reachedCount (spec 3.3 line 831)
+     */
+    async sssp(gs, source, o) {
+      ctx.assertReady();
+      return await sssp(ctx, gs, source, o);
+    },
+    /**
+     * Bellman-Ford on the device with negative-cycle detection (spec 8.4; P8-T13).
+     * @param gs - the snapshot
+     * @param source - the source node index
+     * @param o - the seam's `SsspOptions` (`cutoff`, `weights`)
+     * @returns dist, predArc, reachedCount and hasNegativeCycle (spec 3.3 line 832)
+     */
+    async bellmanFord(gs, source, o) {
+      ctx.assertReady();
+      return await bellmanFord(ctx, gs, source, o);
+    },
+    /**
+     * 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)
+     */
+    async closenessCentrality(gs, o) {
+      ctx.assertReady();
+      return await closenessCentrality(ctx, gs, o);
+    },
     /**
      * Destroys every device buffer recorded for the snapshot (spec 4.5); delegates to ctx.release.
      * @param s - the snapshot the app is done with
@@ -9835,12 +12602,15 @@ export {
   LAYOUT_TUNING_DEFAULTS,
   MAX_1D_ITEMS,
   MAX_WORKGROUPS_PER_DIM,
-  v as PASSTHROUGH_FORMAT_CODES,
+  C as PASSTHROUGH_FORMAT_CODES,
   SE_DEFAULTS,
-  w as STORAGE_ALIGN,
-  x as WORKGROUP_SIZE,
+  D as STORAGE_ALIGN,
+  H as WORKGROUP_SIZE,
   WebGpuGraphError,
+  bellmanFord,
+  breadthFirstSearch,
   calibrateLayout,
+  closenessCentrality,
   connectedComponents,
   createAccelerator,
   createForceAtlas2,
@@ -9850,12 +12620,13 @@ export {
   eigenvectorCentrality,
   hasErrorCode,
   hits,
-  y as isSoftwareAdapter,
+  J as isSoftwareAdapter,
   isWebGpuGraphError,
   katzCentrality,
   pageRank,
   personalizedPageRank,
   seedPositions,
+  sssp,
   verifyDevice
 };
 //# sourceMappingURL=webgpu-graph-algorithms.js.map