@graphty/webgpu-graph-algorithms 0.6.21 → 0.6.23

package/dist/webgpu-graph-algorithms.js

@@ -1,5 +1,5 @@
-import { W as WebGpuGraphError, U as UNIFORM_SLOT_BYTES, B as BufferUsage, M as MAX_WORKGROUPS_PER_DIM, a as WGSL_RESERVED_WORDS, S as STATE_HEADER_BYTES, d as deviceLostError, i as isWebGpuGraphError, b as U32_MAX$2, c as MAX_LEVELS_PER_SUBMIT, R as RADIX_BINS, F as FUSED_FRONTIER_MAX, e as BEAMER_BETA, f as SSSP_DELTA_FACTOR, g as F32_INF_BITS, h as BC_EDGE_PARALLEL_GAMMA, j as BC_BATCH_BUDGET_FRACTION, k as BC_MAX_BATCH, l as BC_BACKWARD_LEVELS_PER_SUBMIT, A as APSP_MAX_DISPATCHES_PER_SUBMIT, m as APSP_TILE, n as GROUP_ROW_THREAD_MAX, o as GROUP_ROW_THREAD_LIMIT, p as GROUP_HASH_LOAD_FACTOR, P as PARALLEL_MERGE_LIMIT, L as LABEL_PROP_PASSES_PER_SUBMIT, q as GRID_COARSEST_SIDE, r as GRID_MIN_SIDE, s as GRID_SORT_BITS, t as FA2_DEFAULTS, u as MAX_ITERATIONS_PER_STEP, v as MAX_1D_ITEMS, w as hasErrorCode, x as FA2_FLAG_FIRST, y as PARTIAL_BYTES, E as EXACT_TILES_PER_PASS, I as INDIRECT_ARGS_STRIDE, z as GRID_HUB_CELL, C as LAYOUT_TUNING_DEFAULTS, D as EXACT_MAX_NODES, H as SETTLE_FLOOR_UNBOUNDED, T as TRACE_RECORD_BYTES, J as GRID_BBOX_MARGIN, K as GRID_EXTENT_FLOOR, N as FR_ADAPTIVE_MAX_ITERATIONS, O as FR_START_TEMPERATURE, Q as FA2_FLAG_ADAPTIVE, V as SETTLE_FLOOR_FRACTION, X as FR_REHEAT_FRACTION, Y as FR_DEFAULTS, Z as SE_DEFAULTS, _ as SETTLE_FLOOR_REFERENCE_NODES, $ as SE_SCALE_REFERENCE_NODES } from "./chunks/context-VIvatQOo.js";
-import { a0, G, a1, a2, a3, a4 } from "./chunks/context-VIvatQOo.js";
+import { W as WebGpuGraphError, U as UNIFORM_SLOT_BYTES, B as BufferUsage, M as MAX_WORKGROUPS_PER_DIM, a as WGSL_RESERVED_WORDS, S as STATE_HEADER_BYTES, d as deviceLostError, i as isWebGpuGraphError, b as U32_MAX$2, c as MAX_LEVELS_PER_SUBMIT, R as RADIX_BINS, F as FUSED_FRONTIER_MAX, e as BEAMER_BETA, f as SSSP_DELTA_FACTOR, g as F32_INF_BITS, h as BC_EDGE_PARALLEL_GAMMA, j as BC_BATCH_BUDGET_FRACTION, k as BC_MAX_BATCH, l as BC_BACKWARD_LEVELS_PER_SUBMIT, A as APSP_MAX_DISPATCHES_PER_SUBMIT, m as APSP_TILE, n as GROUP_ROW_THREAD_MAX, o as GROUP_ROW_THREAD_LIMIT, p as GROUP_HASH_LOAD_FACTOR, P as PARALLEL_MERGE_LIMIT, L as LABEL_PROP_PASSES_PER_SUBMIT, q as BORUVKA_ROUNDS_PER_SUBMIT, r as GRID_COARSEST_SIDE, s as GRID_MIN_SIDE, t as GRID_SORT_BITS, u as FA2_DEFAULTS, v as MAX_ITERATIONS_PER_STEP, w as MAX_1D_ITEMS, x as hasErrorCode, y as FA2_FLAG_FIRST, z as PARTIAL_BYTES, E as EXACT_TILES_PER_PASS, I as INDIRECT_ARGS_STRIDE, C as GRID_HUB_CELL, D as LAYOUT_TUNING_DEFAULTS, H as EXACT_MAX_NODES, J as SETTLE_FLOOR_UNBOUNDED, T as TRACE_RECORD_BYTES, K as GRID_BBOX_MARGIN, N as GRID_EXTENT_FLOOR, O as FR_ADAPTIVE_MAX_ITERATIONS, Q as FR_START_TEMPERATURE, V as FA2_FLAG_ADAPTIVE, X as SETTLE_FLOOR_FRACTION, Y as FR_REHEAT_FRACTION, Z as FR_DEFAULTS, _ as SE_DEFAULTS, $ as SETTLE_FLOOR_REFERENCE_NODES, a0 as SE_SCALE_REFERENCE_NODES } from "./chunks/context-B40Z6lV_.js";
+import { a1, G, a2, a3, a4, a5 } from "./chunks/context-B40Z6lV_.js";
 import { renumberPartition, INVALID_INDEX, foldArcs, makeMask, maskTest, expandEdges, fromEdgeArrays } from "@graphty/graph-format";
 class UniformRing {
   /**
@@ -2539,6 +2539,58 @@ fn lpa_step(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id)
 }
 `
 );
+const mstBestWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn mst_best(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let e = linear_id(wid, lid.x);
+    if (e >= P.count) { return; }
+    let cu = comp[edgeSrc[e]];
+    let cv = comp[edgeDst[e]];
+    if (cu == cv) { return; }                                     // inside one component, or a self-loop
+    var w = 1.0;
+    if (WEIGHTED) { w = edgeWeight[e]; }
+    let k = order_key(w);
+    if (PASS == 0u) {
+        atomicMin(&bestKey[cu], k);
+        atomicMin(&bestKey[cv], k);
+    } else {
+        if (k == atomicLoad(&bestKey[cu])) { atomicMin(&bestEdge[cu], e); }
+        if (k == atomicLoad(&bestKey[cv])) { atomicMin(&bestEdge[cv], e); }
+    }
+}
+`
+);
+const mstLinkWgsl = (
+  /* wgsl */
+  `
+var<workgroup> added: atomic<u32>;
+
+@compute @workgroup_size(WG)
+fn mst_link(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    if (lid.x == 0u) { atomicStore(&added, 0u); }
+    workgroupBarrier();
+    let c = linear_id(wid, lid.x);
+    if (c < P.count) {
+        let e = bestEdge[c];
+        if (e != INVALID_INDEX) {
+            let a = atomicLoad(&comp[edgeSrc[e]]);
+            let b = atomicLoad(&comp[edgeDst[e]]);
+            let other = select(a, b, a == c);
+            let keep = bestEdge[other] == e && c <= other;           // the lower root of a two-cycle stays
+            if (!keep) { atomicStore(&comp[c], other); }
+            if (!keep) { treeEdge[c] = e; atomicAdd(&added, 1u); }
+        }
+    }
+    workgroupBarrier();                                            // every lane, unconditionally
+    if (lid.x == 0u) {
+        let k = atomicLoad(&added);
+        if (k > 0u) { atomicAdd(&counters[P.counterIndex], k); }  // one atomic per workgroup
+    }
+}
+`
+);
 const orientFlagsWgsl = (
   /* wgsl */
   `
@@ -3544,6 +3596,12 @@ const LPA_PARAMS = UniformBlock.define("LpaParams", [
   ["counterIndex", "u32"],
   ["pad0", "u32"]
 ]);
+const MST_PARAMS = UniformBlock.define("MstParams", [
+  ["count", "u32"],
+  ["counterIndex", "u32"],
+  ["pad0", "u32"],
+  ["pad1", "u32"]
+]);
 function decl(group, binding, name, kind, wgslType) {
   return { group, binding, name, kind, wgslType };
 }
@@ -4583,6 +4641,47 @@ const LPA_STEP = {
   snippetSlots: [],
   phase: "P11"
 };
+const MST_BEST = {
+  id: "mst-best",
+  body: mstBestWgsl,
+  entryPoint: "mst_best",
+  bindings: [
+    decl(1, 0, "edgeSrc", "storage-ro", "array<u32>"),
+    decl(1, 1, "edgeDst", "storage-ro", "array<u32>"),
+    decl(1, 2, "edgeWeight", "storage-ro", "array<f32>"),
+    decl(1, 3, "comp", "storage-ro", "array<u32>"),
+    decl(1, 4, "bestKey", "storage", "array<atomic<u32>>"),
+    decl(1, 5, "bestEdge", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "MstParams")
+  ],
+  overrideDecls: [
+    { name: "PASS", type: "u32", default: 0 },
+    { name: "WEIGHTED", type: "bool", default: false }
+  ],
+  uniforms: [MST_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P11"
+};
+const MST_LINK = {
+  id: "mst-link",
+  body: mstLinkWgsl,
+  entryPoint: "mst_link",
+  bindings: [
+    decl(1, 0, "edgeSrc", "storage-ro", "array<u32>"),
+    decl(1, 1, "edgeDst", "storage-ro", "array<u32>"),
+    decl(1, 2, "bestEdge", "storage-ro", "array<u32>"),
+    decl(1, 3, "comp", "storage", "array<atomic<u32>>"),
+    decl(1, 4, "treeEdge", "storage", "array<u32>"),
+    decl(1, 5, "counters", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "MstParams")
+  ],
+  overrideDecls: [],
+  uniforms: [MST_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P11"
+};
 const REGISTRY = Object.freeze({
   degree: DEGREE,
   reduce: REDUCE,
@@ -4644,7 +4743,9 @@ const REGISTRY = Object.freeze({
   "orient-flags": ORIENT_FLAGS,
   "tri-intersect": TRI_INTERSECT,
   "group-by-key-row": GROUP_BY_KEY_ROW,
-  "lpa-step": LPA_STEP
+  "lpa-step": LPA_STEP,
+  "mst-best": MST_BEST,
+  "mst-link": MST_LINK
 });
 const bodyOverrides = /* @__PURE__ */ new Map();
 function entryOf(id) {
@@ -4803,7 +4904,7 @@ class ScanPlannerImpl {
 }
 const POISON = 3735928559;
 const CHECK_BLOCKS = 32;
-const RING_SLOTS$9 = 8;
+const RING_SLOTS$a = 8;
 const checked = /* @__PURE__ */ new WeakMap();
 function inputAt(i) {
   return i + 1;
@@ -4831,7 +4932,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$9, "device-check/ring");
+  const ring = new UniformRing(ctx.device, ctx.allocator, RING_SLOTS$a, "device-check/ring");
   try {
     const scope = {
       device: ctx.device,
@@ -5498,12 +5599,12 @@ function algorithmScope(ctx, label, slots) {
     ringOverruns: () => ring.overruns
   };
 }
-const ALGORITHM$8 = "connectedComponents";
+const ALGORITHM$9 = "connectedComponents";
 const ROUNDS_PER_BATCH$1 = 4;
 const MAX_WCC_ROUNDS = 64;
 const SAMPLE_SIZE = 1024;
 const MAX_STEPS = 1024;
-const RING_SLOTS$8 = 2 * ROUNDS_PER_BATCH$1;
+const RING_SLOTS$9 = 2 * ROUNDS_PER_BATCH$1;
 function checkDest$6(dest, n) {
   if (dest === void 0) {
     return null;
@@ -5513,7 +5614,7 @@ function checkDest$6(dest, n) {
   }
   throw new WebGpuGraphError(
     "E_INVALID_ARGUMENT",
-    `${ALGORITHM$8}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
+    `${ALGORITHM$9}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
     {
       argument: "dest",
       value: `${dest.constructor.name}(${dest.length})`,
@@ -5523,7 +5624,7 @@ function checkDest$6(dest, n) {
 }
 function coreOf$2(ctx, s) {
   const core = ctx.residency.core(s);
-  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$8);
+  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$9);
   return core;
 }
 function bindingOf$3(buffer, size) {
@@ -5582,8 +5683,8 @@ function checkLabels(raw) {
   for (let v = 0; v < n; v++) {
     const label = raw[v];
     if (label >= n) {
-      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$8}: labels[${v}] = ${label} is not a node index`, {
-        label: `${ALGORITHM$8}/labels`,
+      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$9}: labels[${v}] = ${label} is not a node index`, {
+        label: `${ALGORITHM$9}/labels`,
         message: `the device produced a label outside [0, ${n})`
       });
     }
@@ -5601,7 +5702,7 @@ async function connectedComponents(ctx, s, options) {
   const renumber = options?.renumber !== false;
   const dest = checkDest$6(options?.dest, n);
   if (options?.signal?.aborted) {
-    throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$8}: the signal was aborted before any work started`, {});
+    throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$9}: the signal was aborted before any work started`, {});
   }
   if (n === 0) {
     options?.onProgress?.(1, 1);
@@ -5618,7 +5719,7 @@ async function connectedComponents(ctx, s, options) {
   }
   const edges = ctx.residency.view(s, "edgeList");
   const edgeCount = edges.scalars.edgeCount[0];
-  const scope = algorithmScope(ctx, ALGORITHM$8, RING_SLOTS$8);
+  const scope = algorithmScope(ctx, ALGORITHM$9, RING_SLOTS$9);
   try {
     const compBytes = 4 * (n + 1);
     const comp = scope.scratch(compBytes, "comp");
@@ -5647,7 +5748,7 @@ async function connectedComponents(ctx, s, options) {
       return batch.submit();
     };
     queue.writeBuffer(comp, 4 * flagIndex, zero);
-    const setup = new CommandBatch(ctx, `${ALGORITHM$8}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$9}/setup`);
     let pass = setup.pass("sample-rounds");
     const fillParams = scope.params(FILL_PARAMS, { count: n, value: 0, mode: 1, pad0: 0 });
     fill.dispatch(
@@ -5666,7 +5767,7 @@ async function connectedComponents(ctx, s, options) {
     setup.endPass();
     await submit2(setup).readback;
     ctx.assertReady();
-    const sampler = new CommandBatch(ctx, `${ALGORITHM$8}/sample`);
+    const sampler = new CommandBatch(ctx, `${ALGORITHM$9}/sample`);
     pass = sampler.pass("sample");
     const sampleParams = wccParams({ items, stride: 0, r: 0, giant: U32_MAX$2 });
     sample.dispatch(
@@ -5684,7 +5785,7 @@ async function connectedComponents(ctx, s, options) {
     let rounds = 0;
     for (; ; ) {
       queue.writeBuffer(comp, 4 * flagIndex, zero);
-      const batch = new CommandBatch(ctx, `${ALGORITHM$8}/rounds`);
+      const batch = new CommandBatch(ctx, `${ALGORITHM$9}/rounds`);
       pass = batch.pass("edge-rounds");
       for (let i = 0; i < ROUNDS_PER_BATCH$1; i++) {
         const params = wccParams({ items: edgeCount, stride: edgePlan.stride ?? edgeCount, r: 0, giant });
@@ -5699,7 +5800,7 @@ async function connectedComponents(ctx, s, options) {
       rounds += ROUNDS_PER_BATCH$1;
       ctx.assertReady();
       if (options?.signal?.aborted) {
-        throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$8}: the signal was aborted`, {
+        throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$9}: the signal was aborted`, {
           batchId: submitted.id
         });
       }
@@ -5709,12 +5810,12 @@ async function connectedComponents(ctx, s, options) {
       if (rounds >= MAX_WCC_ROUNDS) {
         throw new WebGpuGraphError(
           "E_VALIDATION",
-          `${ALGORITHM$8}: the changed flag never settled in ${MAX_WCC_ROUNDS} rounds`,
-          { label: ALGORITHM$8, message: `the changed flag never settled in ${MAX_WCC_ROUNDS} rounds` }
+          `${ALGORITHM$9}: the changed flag never settled in ${MAX_WCC_ROUNDS} rounds`,
+          { label: ALGORITHM$9, message: `the changed flag never settled in ${MAX_WCC_ROUNDS} rounds` }
         );
       }
     }
-    const final = new CommandBatch(ctx, `${ALGORITHM$8}/final`);
+    const final = new CommandBatch(ctx, `${ALGORITHM$9}/final`);
     recordCompress(final.pass("compress"));
     final.endPass();
     await submit2(final).readback;
@@ -6092,7 +6193,7 @@ async function prepareSpmvPull(scope, rev, options) {
   return new SpmvPullPlannerImpl(scope, compiled, perm, options.weights);
 }
 const PR_BATCH = 8;
-const RING_SLOTS$7 = 2 * PR_BATCH + 2;
+const RING_SLOTS$8 = 2 * PR_BATCH + 2;
 function checkDest$5(dest, n, algorithm) {
   if (dest === void 0) {
     return null;
@@ -6170,7 +6271,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$7);
+  const scope = algorithmScope(ctx, algorithm, RING_SLOTS$8);
   let uploaded = null;
   try {
     const bytes = 4 * n;
@@ -6333,7 +6434,7 @@ async function personalizedPageRank(ctx, s, personalization, options) {
   return run(ctx, s, normalised2, options, "personalizedPageRank");
 }
 const BATCH = 8;
-const RING_SLOTS$6 = 4 * BATCH + 8;
+const RING_SLOTS$7 = 4 * BATCH + 8;
 function checkDest$4(dest, n, algorithm) {
   if (dest === void 0) {
     return null;
@@ -6373,7 +6474,7 @@ function whole(buffer, size) {
 }
 async function runPowerIteration(ctx, n, config) {
   await assertDeviceComputes(ctx);
-  const scope = algorithmScope(ctx, config.label, RING_SLOTS$6);
+  const scope = algorithmScope(ctx, config.label, RING_SLOTS$7);
   try {
     const bytes = 4 * n;
     const ring = (config.alternate === null ? ["rankA", "rankB"] : ["rankA", "rankB", "rankC"]).map(
@@ -7153,7 +7254,7 @@ class RadixSortPlannerImpl {
     return src;
   }
 }
-const ALGORITHM$7 = "breadthFirstSearch";
+const ALGORITHM$8 = "breadthFirstSearch";
 const NEXT_DEGREE_MAX_GROUPS = 128;
 function bfsRingSlots(windows, levelsPerSubmit) {
   return Math.max((5 + 4 * windows) * levelsPerSubmit + 16, RESULT_BATCH_SLOTS + windows);
@@ -7174,7 +7275,7 @@ function checkDest$3(dest, n) {
   }
   throw new WebGpuGraphError(
     "E_INVALID_ARGUMENT",
-    `${ALGORITHM$7}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
+    `${ALGORITHM$8}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
     {
       argument: "dest",
       value: `${dest.constructor.name}(${dest.length})`,
@@ -7189,8 +7290,8 @@ function degreeView(ctx, s, name) {
   const { bindings } = ctx.residency.view(s, name);
   const { [name]: binding } = bindings;
   if (binding === void 0) {
-    throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$7}: the ${name} view has no ${name} binding`, {
-      label: `${ALGORITHM$7}/${name}`,
+    throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$8}: the ${name} view has no ${name} binding`, {
+      label: `${ALGORITHM$8}/${name}`,
       message: `the ${name} view has no ${name} binding`
     });
   }
@@ -7199,15 +7300,15 @@ function degreeView(ctx, s, name) {
 function aborted$1(batchId) {
   return new WebGpuGraphError(
     "E_ABORTED",
-    `${ALGORITHM$7}: the signal was aborted`,
+    `${ALGORITHM$8}: 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$7}: counters.${name} did not decode to a number`, {
-      label: `${ALGORITHM$7}/counters`,
+    throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$8}: counters.${name} did not decode to a number`, {
+      label: `${ALGORITHM$8}/counters`,
       message: `the field ${name} did not decode to a number`
     });
   }
@@ -7218,7 +7319,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
   await assertDeviceComputes(ctx);
   const n = s.nodeCount;
   if (!Number.isInteger(source) || source < 0 || source >= n) {
-    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$7}: source ${source} is outside [0, ${n})`, {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$8}: source ${source} is outside [0, ${n})`, {
       argument: "source",
       value: source,
       expected: `an integer in [0, ${n})`
@@ -7228,7 +7329,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
   if (!Number.isInteger(levelsPerSubmit) || levelsPerSubmit < 1 || levelsPerSubmit > MAX_LEVELS_PER_SUBMIT) {
     throw new WebGpuGraphError(
       "E_INVALID_ARGUMENT",
-      `${ALGORITHM$7}: levelsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
+      `${ALGORITHM$8}: levelsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
       {
         argument: "levelsPerSubmit",
         value: levelsPerSubmit,
@@ -7247,12 +7348,12 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
   if (s.directed && 4 * s.arcCount > ctx.caps.limits.maxStorageBufferBindingSize) {
     throw new WebGpuGraphError(
       "E_TOO_LARGE",
-      `${ALGORITHM$7}: the reverse adjacency of a directed snapshot (${4 * s.arcCount} bytes) needs arc windows, which no view executes (spec 4.3); the bottom-up sweep binds it whole`,
+      `${ALGORITHM$8}: 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$7
+        algorithm: ALGORITHM$8
       }
     );
   }
@@ -7260,7 +7361,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
   const backward = coreWindows(reverse);
   const outDegree = degreeView(ctx, s, "outDegree");
   const inDegree = degreeView(ctx, s, "inDegree");
-  const scope = algorithmScope(ctx, ALGORITHM$7, bfsRingSlots(forward.length, levelsPerSubmit));
+  const scope = algorithmScope(ctx, ALGORITHM$8, bfsRingSlots(forward.length, levelsPerSubmit));
   tuning.onScope?.(scope);
   try {
     const bytes = 4 * n;
@@ -7324,7 +7425,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
       scope.flush();
       return batch.submit();
     };
-    const setup = new CommandBatch(ctx, `${ALGORITHM$7}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$8}/setup`);
     const setupPass = setup.pass("fill");
     recordFill2(setupPass, depth, INVALID_INDEX, 0);
     recordFill2(setupPass, iota, 0, 1);
@@ -7344,7 +7445,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
     let submits = 0;
     for (; ; ) {
       queue.writeBuffer(counters.buffer, counters.offset + 4 * W.unvisitedCount, new Uint32Array(3));
-      const batch = new CommandBatch(ctx, `${ALGORITHM$7}/levels`);
+      const batch = new CommandBatch(ctx, `${ALGORITHM$8}/levels`);
       const pass2 = batch.pass("bfs");
       recordRebuild(pass2);
       const bitsParams = scope.params(FILL_PARAMS, { count: bitsWords, value: 0, mode: 0, pad0: 0 });
@@ -7454,8 +7555,8 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
       if (submits > n + 1) {
         throw new WebGpuGraphError(
           "E_VALIDATION",
-          `${ALGORITHM$7}: the done flag never rose in ${submits} submits (a traversal has at most ${n} levels)`,
-          { label: ALGORITHM$7, message: `the done flag never rose in ${submits} submits` }
+          `${ALGORITHM$8}: the done flag never rose in ${submits} submits (a traversal has at most ${n} levels)`,
+          { label: ALGORITHM$8, message: `the done flag never rose in ${submits} submits` }
         );
       }
     }
@@ -7469,7 +7570,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
       offsets: bindingOf$1(scope.scratch(histBytes, "order/offsets"), histBytes)
     };
     const parent = bindingOf$1(scope.scratch(bytes, "parent"), bytes);
-    const result = new CommandBatch(ctx, `${ALGORITHM$7}/result`);
+    const result = new CommandBatch(ctx, `${ALGORITHM$8}/result`);
     result.copy(depth, keys, bytes);
     const pass = result.pass("result");
     recordFill2(pass, vals, 0, 1);
@@ -7506,9 +7607,9 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
     if (visitedCount > n) {
       throw new WebGpuGraphError(
         "E_VALIDATION",
-        `${ALGORITHM$7}: visitedCount ${visitedCount} exceeds the ${n} vertices (a duplicate claim)`,
+        `${ALGORITHM$8}: visitedCount ${visitedCount} exceeds the ${n} vertices (a duplicate claim)`,
         {
-          label: `${ALGORITHM$7}/visitedCount`,
+          label: `${ALGORITHM$8}/visitedCount`,
           message: `the device counted ${visitedCount} visits of ${n} vertices`
         }
       );
@@ -7532,9 +7633,9 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
 function breadthFirstSearch(ctx, s, source, options) {
   return bfsWithTuning(ctx, s, source, options, {});
 }
-const ALGORITHM$6 = "sssp";
+const ALGORITHM$7 = "sssp";
 const HALF_ALIGN = 64;
-const RING_SLOTS$5 = 4 * MAX_LEVELS_PER_SUBMIT + 40;
+const RING_SLOTS$6 = 4 * MAX_LEVELS_PER_SUBMIT + 40;
 function bitsOf(value) {
   return new Uint32Array(Float32Array.of(value).buffer)[0];
 }
@@ -7560,8 +7661,8 @@ function assertSource(algorithm, source, n) {
 function wordOf(block, name) {
   const value = block[name];
   if (typeof value !== "number") {
-    throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$6}: counters.${name} did not decode to a number`, {
-      label: `${ALGORITHM$6}/counters`,
+    throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$7}: counters.${name} did not decode to a number`, {
+      label: `${ALGORITHM$7}/counters`,
       message: `the field ${name} did not decode to a number`
     });
   }
@@ -7728,12 +7829,12 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
   ctx.assertReady();
   await assertDeviceComputes(ctx);
   const n = s.nodeCount;
-  assertSource(ALGORITHM$6, source, n);
+  assertSource(ALGORITHM$7, 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$6}: roundsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
+      `${ALGORITHM$7}: roundsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
       {
         argument: "roundsPerSubmit",
         value: roundsPerSubmit,
@@ -7742,42 +7843,42 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
     );
   }
   if (tuning.delta !== void 0 && !(Number.isFinite(tuning.delta) && tuning.delta > 0)) {
-    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$6}: delta must be a finite positive number`, {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$7}: delta must be a finite positive number`, {
       argument: "delta",
       value: tuning.delta,
       expected: "a finite positive number"
     });
   }
-  const dest = checkDest$2(ALGORITHM$6, options?.dest, n);
-  const vector2 = resolveWeights$1(ALGORITHM$6, s, options?.weights);
-  const cutoff = normaliseCutoff(ALGORITHM$6, options?.cutoff);
+  const dest = checkDest$2(ALGORITHM$7, options?.dest, n);
+  const vector2 = resolveWeights$1(ALGORITHM$7, s, options?.weights);
+  const cutoff = normaliseCutoff(ALGORITHM$7, options?.cutoff);
   if (options?.signal?.aborted) {
-    throw aborted(ALGORITHM$6);
+    throw aborted(ALGORITHM$7);
   }
   if (vector2 === null || vector2.allOne) {
     return unitWeightRoute(ctx, s, source, cutoff, dest, options);
   }
   if (!vector2.nonNegative) {
-    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$6}: a negative weight has no shortest path here`, {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$7}: a negative weight has no shortest path here`, {
       feature: "sssp.negativeWeights",
       hint: "use bellmanFord"
     });
   }
   if (!vector2.finite) {
-    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$6}: a NaN or infinite weight has no bit-pattern order`, {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$7}: 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$6);
+  assertWholeCore(core, arcCount, limit, ALGORITHM$7);
   const cap = Math.ceil(Math.max(1, arcCount) / HALF_ALIGN) * HALF_ALIGN;
   if (8 * cap > limit) {
     throw new WebGpuGraphError(
       "E_TOO_LARGE",
-      `${ALGORITHM$6}: the near-far queue of ${cap} entries per half needs ${8 * cap} bytes, above the ${limit}-byte binding limit (the relax is never windowed)`,
-      { needed: 8 * cap, limit, path: "sssp.queue", algorithm: ALGORITHM$6 }
+      `${ALGORITHM$7}: 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$7 }
     );
   }
   const delta = Math.fround(
@@ -7786,7 +7887,7 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
   const deltaBits = bitsOf(delta);
   const maxRounds = n + Math.ceil(vector2.sum / delta) + 1;
   const maxSubmits = Math.ceil((maxRounds + 1) / roundsPerSubmit) + 1;
-  const scope = algorithmScope(ctx, ALGORITHM$6, RING_SLOTS$5);
+  const scope = algorithmScope(ctx, ALGORITHM$7, RING_SLOTS$6);
   try {
     const wg = ctx.workgroupSize;
     const bytes = 4 * n;
@@ -7824,7 +7925,7 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
       scope.flush();
       return batch.submit();
     };
-    const setup = new CommandBatch(ctx, `${ALGORITHM$6}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$7}/setup`);
     const setupPass = setup.pass("fill");
     recordFill2(setupPass, dist, n, F32_INF_BITS);
     recordFill2(setupPass, pred, predWords, INVALID_INDEX);
@@ -7870,7 +7971,7 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
     let roundsRecorded = 0;
     let submits = 0;
     for (; ; ) {
-      const batch = new CommandBatch(ctx, `${ALGORITHM$6}/rounds`);
+      const batch = new CommandBatch(ctx, `${ALGORITHM$7}/rounds`);
       const pass = batch.pass("sssp");
       const near = scope.params(FRONTIER_PARAMS, { ...relaxFields, role: 0 });
       const far = scope.params(FRONTIER_PARAMS, { ...relaxFields, role: 1 });
@@ -7893,7 +7994,7 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
       submits += 1;
       ctx.assertReady();
       if (options?.signal?.aborted) {
-        throw aborted(ALGORITHM$6, submitted.id);
+        throw aborted(ALGORITHM$7, submitted.id);
       }
       options?.onProgress?.(Math.min(roundsRecorded, maxRounds), maxRounds);
       if (inspect !== null && tuning.onRound !== void 0) {
@@ -7918,26 +8019,26 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
           const needed = Math.max(wordOf(block, "nextFrontierCount"), wordOf(block, "nextFarCount"));
           throw new WebGpuGraphError(
             "E_TOO_LARGE",
-            `${ALGORITHM$6}: a raw pile of ${needed} entries overflowed its ${cap}-entry half`,
-            { needed, limit: cap, path: "sssp.pile", algorithm: ALGORITHM$6 }
+            `${ALGORITHM$7}: a raw pile of ${needed} entries overflowed its ${cap}-entry half`,
+            { needed, limit: cap, path: "sssp.pile", algorithm: ALGORITHM$7 }
           );
         }
         throw new WebGpuGraphError(
           "E_UNSUPPORTED",
-          `${ALGORITHM$6}: the f32 threshold ${wordOf(block, "thresholdBits")} absorbed the delta ${deltaBits} (as bit patterns); the far pile can no longer be bucketed`,
+          `${ALGORITHM$7}: 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$6}: the done flag never rose in ${submits} submits (at most ${maxRounds} rounds)`,
-          { label: `${ALGORITHM$6}/rounds`, message: `the done flag never rose in ${submits} submits` }
+          `${ALGORITHM$7}: the done flag never rose in ${submits} submits (at most ${maxRounds} rounds)`,
+          { label: `${ALGORITHM$7}/rounds`, message: `the done flag never rose in ${submits} submits` }
         );
       }
     }
     const passed = await predecessorPass({
-      algorithm: ALGORITHM$6,
+      algorithm: ALGORITHM$7,
       ctx,
       scope,
       predKernel,
@@ -7953,8 +8054,8 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
     if (passed.orphans !== 0) {
       throw new WebGpuGraphError(
         "E_VALIDATION",
-        `${ALGORITHM$6}: ${passed.orphans} reached node(s) the predecessor key never reached (a kernel bug)`,
-        { label: `${ALGORITHM$6}/pred`, message: `${passed.orphans} orphan(s) in the predecessor pass` }
+        `${ALGORITHM$7}: ${passed.orphans} reached node(s) the predecessor key never reached (a kernel bug)`,
+        { label: `${ALGORITHM$7}/pred`, message: `${passed.orphans} orphan(s) in the predecessor pass` }
       );
     }
     const distOut = dest ?? new Float32Array(n);
@@ -7973,10 +8074,10 @@ async function ssspWithTuning(ctx, s, source, options, tuning) {
 function sssp(ctx, s, source, options) {
   return ssspWithTuning(ctx, s, source, options, {});
 }
-const ALGORITHM$5 = "bellmanFord";
+const ALGORITHM$6 = "bellmanFord";
 const ROUNDS_PER_BATCH = 8;
 const MAX_RETRIES = 16;
-const RING_SLOTS$4 = MAX_LEVELS_PER_SUBMIT + 16;
+const RING_SLOTS$5 = MAX_LEVELS_PER_SUBMIT + 16;
 function assertSymmetric(s, vector2) {
   const { arcToEdge, edgeToArc } = s;
   for (let a = 0; a < s.arcCount; a++) {
@@ -7984,7 +8085,7 @@ function assertSymmetric(s, vector2) {
     if (vector2[a] !== vector2[forward]) {
       throw new WebGpuGraphError(
         "E_UNSUPPORTED",
-        `${ALGORITHM$5}: weights[${a}] = ${vector2[a]} differs from weights[${forward}] = ${vector2[forward]}, the forward arc of the same undirected edge; the kernel reads one weight per edge`,
+        `${ALGORITHM$6}: 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" }
       );
     }
@@ -7994,10 +8095,10 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
   ctx.assertReady();
   await assertDeviceComputes(ctx);
   const n = s.nodeCount;
-  assertSource(ALGORITHM$5, source, n);
+  assertSource(ALGORITHM$6, source, n);
   const maxRetries = tuning.maxRetries ?? MAX_RETRIES;
   if (!Number.isInteger(maxRetries) || maxRetries < 1) {
-    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$5}: maxRetries must be an integer >= 1`, {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$6}: maxRetries must be an integer >= 1`, {
       argument: "maxRetries",
       value: maxRetries,
       expected: "an integer >= 1"
@@ -8007,7 +8108,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
   if (!Number.isInteger(roundsPerBatch) || roundsPerBatch < 1 || roundsPerBatch > MAX_LEVELS_PER_SUBMIT) {
     throw new WebGpuGraphError(
       "E_INVALID_ARGUMENT",
-      `${ALGORITHM$5}: roundsPerBatch must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
+      `${ALGORITHM$6}: roundsPerBatch must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
       {
         argument: "roundsPerBatch",
         value: roundsPerBatch,
@@ -8015,18 +8116,18 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
       }
     );
   }
-  const dest = checkDest$2(ALGORITHM$5, options?.dest, n);
-  const vector2 = resolveWeights$1(ALGORITHM$5, s, options?.weights);
-  const cutoff = normaliseCutoff(ALGORITHM$5, options?.cutoff);
+  const dest = checkDest$2(ALGORITHM$6, options?.dest, n);
+  const vector2 = resolveWeights$1(ALGORITHM$6, s, options?.weights);
+  const cutoff = normaliseCutoff(ALGORITHM$6, options?.cutoff);
   if (options?.signal?.aborted) {
-    throw aborted(ALGORITHM$5);
+    throw aborted(ALGORITHM$6);
   }
   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$5}: a NaN or infinite weight has no shortest path`, {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$6}: a NaN or infinite weight has no shortest path`, {
       feature: "bellmanFord.nonFiniteWeights"
     });
   }
@@ -8035,10 +8136,10 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
   }
   const { arcCount } = s;
   const core = ctx.residency.core(s, ["rowPtr", "colIdx", "weights", "edgeToArc"]);
-  assertWholeCore(core, arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$5);
+  assertWholeCore(core, arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$6);
   const edges = ctx.residency.view(s, "edgeList");
   const edgeCount = edges.scalars.edgeCount[0];
-  const scope = algorithmScope(ctx, ALGORITHM$5, RING_SLOTS$4);
+  const scope = algorithmScope(ctx, ALGORITHM$6, RING_SLOTS$5);
   try {
     const wg = ctx.workgroupSize;
     const bytes = 4 * n;
@@ -8073,7 +8174,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
       scope.flush();
       return batch.submit();
     };
-    const setup = new CommandBatch(ctx, `${ALGORITHM$5}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$6}/setup`);
     const setupPass = setup.pass("fill");
     recordFill2(setupPass, dist, n, F32_INF_BITS);
     recordFill2(setupPass, pred, predWords, INVALID_INDEX);
@@ -8102,7 +8203,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
     const zero = new Uint32Array(BF_FLAGS.byteLength / 4);
     const runRounds = async (count, label) => {
       queue.writeBuffer(flags.buffer, flags.offset, zero);
-      const batch = new CommandBatch(ctx, `${ALGORITHM$5}/${label}`);
+      const batch = new CommandBatch(ctx, `${ALGORITHM$6}/${label}`);
       const pass = batch.pass("relax");
       const params = scope.params(BF_PARAMS, relaxFields);
       const bound = relax.bind({ ...relaxBindings, P: params.binding });
@@ -8127,9 +8228,9 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
         if (decision.retryExhausted !== 0) {
           throw new WebGpuGraphError(
             "E_VALIDATION",
-            `${ALGORITHM$5}: a lane exhausted the ${maxRetries}-retry compare-exchange bound in the decision round, so its change is not a verdict`,
+            `${ALGORITHM$6}: a lane exhausted the ${maxRetries}-retry compare-exchange bound in the decision round, so its change is not a verdict`,
             {
-              label: `${ALGORITHM$5}/retry`,
+              label: `${ALGORITHM$6}/retry`,
               message: "retryExhausted in the decision round",
               batchId: decision.id
             }
@@ -8145,7 +8246,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
         retryExhaustedRounds += 1;
       }
       if (options?.signal?.aborted) {
-        throw aborted(ALGORITHM$5, batch.id);
+        throw aborted(ALGORITHM$6, batch.id);
       }
       options?.onProgress?.(rounds, n);
       if (batch.changed === 0 && batch.retryExhausted === 0) {
@@ -8153,7 +8254,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
       }
     }
     const passed = await predecessorPass({
-      algorithm: ALGORITHM$5,
+      algorithm: ALGORITHM$6,
       ctx,
       scope,
       predKernel,
@@ -8169,7 +8270,7 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
     if (passed.orphans !== 0 && !hasNegativeCycle) {
       throw new WebGpuGraphError(
         "E_UNSUPPORTED",
-        `${ALGORITHM$5}: ${passed.orphans} reached node(s) the tight subgraph never reaches (a cycle of weights below one f32 ulp relaxed once)`,
+        `${ALGORITHM$6}: ${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"
@@ -8196,17 +8297,17 @@ async function bellmanFordWithTuning(ctx, s, source, options, tuning) {
 async function bellmanFord(ctx, s, source, options) {
   return (await bellmanFordWithTuning(ctx, s, source, options, {})).result;
 }
-const ALGORITHM$4 = "betweennessCentrality";
+const ALGORITHM$5 = "betweennessCentrality";
 const BYTES_PER_NODE_SOURCE = 16;
 const SAMPLE_SEED = 2654435769;
-const RING_SLOTS$3 = BC_BACKWARD_LEVELS_PER_SUBMIT + 16;
+const RING_SLOTS$4 = BC_BACKWARD_LEVELS_PER_SUBMIT + 16;
 function planBatchSize(n, remaining, limits) {
   const needed = 4 * (n + 2);
   if (needed > limits.maxStorageBufferBindingSize) {
     throw new WebGpuGraphError(
       "E_TOO_LARGE",
-      `${ALGORITHM$4}: one source needs ${needed} bytes in its largest binding at n = ${n}, above maxStorageBufferBindingSize = ${limits.maxStorageBufferBindingSize}; a limit of at least ${needed} admits one source per batch`,
-      { needed, limit: limits.maxStorageBufferBindingSize, path: "binding", algorithm: ALGORITHM$4 }
+      `${ALGORITHM$5}: one source needs ${needed} bytes in its largest binding at n = ${n}, above maxStorageBufferBindingSize = ${limits.maxStorageBufferBindingSize}; a limit of at least ${needed} admits one source per batch`,
+      { needed, limit: limits.maxStorageBufferBindingSize, path: "binding", algorithm: ALGORITHM$5 }
     );
   }
   const kByBinding = Math.floor(limits.maxStorageBufferBindingSize / (4 * n));
@@ -8227,7 +8328,7 @@ function drawSources(n, k) {
   return pool.slice(0, k);
 }
 function badArgument(argument, value, expected) {
-  return new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$4}: ${argument} must be ${expected}`, {
+  return new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$5}: ${argument} must be ${expected}`, {
     argument,
     value,
     expected
@@ -8279,7 +8380,7 @@ async function submit(state, batch, signal) {
   const back = await submitted.readback;
   state.ctx.assertReady();
   if (signal?.aborted) {
-    throw aborted(ALGORITHM$4, submitted.id);
+    throw aborted(ALGORITHM$5, submitted.id);
   }
   return back;
 }
@@ -8296,7 +8397,7 @@ async function runBatch(state, sources, form, levelsPerSubmit, tuning, signal) {
   let overflow = false;
   let endsWords = null;
   for (let first = true; endsWords === null; first = false) {
-    const batch = new CommandBatch(ctx, `${ALGORITHM$4}/forward`);
+    const batch = new CommandBatch(ctx, `${ALGORITHM$5}/forward`);
     const pass = batch.pass("forward");
     if (first) {
       recordFill(state, pass, depthK, words, 4294967295);
@@ -8338,8 +8439,8 @@ async function runBatch(state, sources, form, levelsPerSubmit, tuning, signal) {
       overflow = words32[W.sigmaOverflow] !== 0;
       endsWords = new Uint32Array(back, endsRequest.offset, endsCount).slice(0, levels + 1);
     } else if (recorded > n + 2) {
-      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$4}: the done flag never rose in ${recorded} levels`, {
-        label: ALGORITHM$4,
+      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$5}: the done flag never rose in ${recorded} levels`, {
+        label: ALGORITHM$5,
         message: `the done flag never rose in ${recorded} levels`
       });
     }
@@ -8352,7 +8453,7 @@ async function runBatch(state, sources, form, levelsPerSubmit, tuning, signal) {
   for (let i = 0; ; i += BC_BACKWARD_LEVELS_PER_SUBMIT) {
     const chunk = backwardLevels.slice(i, i + BC_BACKWARD_LEVELS_PER_SUBMIT);
     const last = i + BC_BACKWARD_LEVELS_PER_SUBMIT >= backwardLevels.length;
-    const batch = new CommandBatch(ctx, `${ALGORITHM$4}/backward`);
+    const batch = new CommandBatch(ctx, `${ALGORITHM$5}/backward`);
     const pass = batch.pass("backward");
     for (const level of chunk) {
       const start = endsWords[level];
@@ -8416,11 +8517,11 @@ async function runRaw(ctx, s, sources, withEdges, tuning, options) {
   const limits = tuning.limits ?? ctx.caps.limits;
   const kMax = planBatchSize(n, sources.length, limits);
   const core = ctx.residency.core(s);
-  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$4);
+  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$5);
   const { edgeCount } = s;
   const mayRunEdge = pinned === "edge" || pinned === "auto" && sources.length > kMax;
   const edgeView = mayRunEdge && edgeCount > 0 ? ctx.residency.view(s, "edgeList") : null;
-  const scope = algorithmScope(ctx, ALGORITHM$4, RING_SLOTS$3);
+  const scope = algorithmScope(ctx, ALGORITHM$5, RING_SLOTS$4);
   try {
     const arrayBytes = 4 * n * kMax;
     const lease = (bytes, label) => bindingOf(scope.scratch(bytes, label), bytes);
@@ -8460,7 +8561,7 @@ async function runRaw(ctx, s, sources, withEdges, tuning, options) {
       bound: /* @__PURE__ */ new Map()
     };
     await ctx.allocator.check();
-    const setup = new CommandBatch(ctx, `${ALGORITHM$4}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$5}/setup`);
     const setupPass = setup.pass("setup");
     recordFill(state, setupPass, state.bc, n, 0);
     if (state.arcScores !== null) {
@@ -8488,7 +8589,7 @@ async function runRaw(ctx, s, sources, withEdges, tuning, options) {
       batches += 1;
       options?.onProgress?.(start, sources.length);
     }
-    const result = new CommandBatch(ctx, `${ALGORITHM$4}/result`);
+    const result = new CommandBatch(ctx, `${ALGORITHM$5}/result`);
     const vertexRequest = result.readback(state.bc.buffer, state.bc.offset, 4 * n);
     const arcRequest = state.arcScores === null ? null : result.readback(state.arcScores.buffer, state.arcScores.offset, 4 * s.arcCount);
     const back = await submit(state, result, options?.signal);
@@ -8512,7 +8613,7 @@ async function precheck(ctx, options) {
   ctx.assertReady();
   await assertDeviceComputes(ctx);
   if (options?.endpoints === true) {
-    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$4}: endpoints: true is not supported`, {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$5}: endpoints: true is not supported`, {
       feature: "betweenness.endpoints",
       hint: "the CPU endpoints branch in algorithms/src/algorithms/centrality/betweenness.ts (predecessors.length === 0 && w !== source) never fires, so there is no convention to match"
     });
@@ -8521,10 +8622,10 @@ async function precheck(ctx, options) {
 async function betweennessWithTuning(ctx, s, options, tuning) {
   await precheck(ctx, options);
   const n = s.nodeCount;
-  const scores = checkDest$2(ALGORITHM$4, options?.dest, n) ?? new Float32Array(n);
+  const scores = checkDest$2(ALGORITHM$5, options?.dest, n) ?? new Float32Array(n);
   const sources = resolveSources(options, n);
   if (options?.signal?.aborted) {
-    throw aborted(ALGORITHM$4);
+    throw aborted(ALGORITHM$5);
   }
   if (n === 0 || sources.length === 0) {
     scores.fill(0);
@@ -8550,7 +8651,7 @@ async function edgeBetweennessWithTuning(ctx, s, options, tuning, onArcs) {
   const scores = checkDest$2("edgeBetweennessCentrality", options?.dest, s.edgeCount) ?? new Float32Array(s.edgeCount);
   const sources = resolveSources(options, n);
   if (options?.signal?.aborted) {
-    throw aborted(ALGORITHM$4);
+    throw aborted(ALGORITHM$5);
   }
   if (n === 0 || sources.length === 0 || s.arcCount === 0) {
     scores.fill(0);
@@ -8571,10 +8672,10 @@ function betweennessCentrality(ctx, s, options) {
 function edgeBetweennessCentrality(ctx, s, options) {
   return edgeBetweennessWithTuning(ctx, s, options, {});
 }
-const ALGORITHM$3 = "closenessCentrality";
+const ALGORITHM$4 = "closenessCentrality";
 const SOURCES_PER_BATCH = 32;
 const PER_SOURCE_WORDS = 4 * SOURCES_PER_BATCH;
-const RING_SLOTS$2 = 8 * MAX_LEVELS_PER_SUBMIT + 16;
+const RING_SLOTS$3 = 8 * MAX_LEVELS_PER_SUBMIT + 16;
 function reusingScratch(scope) {
   const held = /* @__PURE__ */ new Map();
   return {
@@ -8596,7 +8697,7 @@ async function weightedRoute(ctx, s, scores, sources, options) {
   const totals = sources === null ? null : new Float64Array(n);
   for (let i = 0; i < count; i++) {
     if (options?.signal?.aborted) {
-      throw aborted(ALGORITHM$3);
+      throw aborted(ALGORITHM$4);
     }
     const source = sources === null ? i : sources[i];
     const { dist } = await sssp(ctx, s, source, { signal: options?.signal });
@@ -8630,8 +8731,8 @@ async function sweepRoute(ctx, s, scores, sources, levelsPerSubmit, options, tun
     return { scores, iterations: 0, converged: true, precision: "f32", sourcesUsed: 0 };
   }
   const core = ctx.residency.core(s);
-  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$3);
-  const scope = algorithmScope(ctx, ALGORITHM$3, RING_SLOTS$2);
+  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$4);
+  const scope = algorithmScope(ctx, ALGORITHM$4, RING_SLOTS$3);
   try {
     const wg = ctx.workgroupSize;
     const bytes = 4 * n;
@@ -8680,7 +8781,7 @@ async function sweepRoute(ctx, s, scores, sources, levelsPerSubmit, options, tun
       scope.flush();
       return batch.submit();
     };
-    const setup = new CommandBatch(ctx, `${ALGORITHM$3}/setup`);
+    const setup = new CommandBatch(ctx, `${ALGORITHM$4}/setup`);
     recordFill2(setup.pass("fill"), iota, n, 1);
     setup.endPass();
     await submit2(setup).readback;
@@ -8689,7 +8790,7 @@ async function sweepRoute(ctx, s, scores, sources, levelsPerSubmit, options, tun
     for (let batchStart = 0; batchStart < seedCount; batchStart += SOURCES_PER_BATCH) {
       let level = 0;
       for (let first = true; ; first = false) {
-        const batch = new CommandBatch(ctx, `${ALGORITHM$3}/levels`);
+        const batch = new CommandBatch(ctx, `${ALGORITHM$4}/levels`);
         const pass = batch.pass("closeness");
         if (first) {
           recordFill2(pass, bits, 4 * bitsBase, 0);
@@ -8748,7 +8849,7 @@ async function sweepRoute(ctx, s, scores, sources, levelsPerSubmit, options, tun
         const back = await submitted.readback;
         ctx.assertReady();
         if (options?.signal?.aborted) {
-          throw aborted(ALGORITHM$3, submitted.id);
+          throw aborted(ALGORITHM$4, submitted.id);
         }
         if (new Uint32Array(back, doneRequest.offset, 1)[0] !== 0) {
           const block = new Uint32Array(back, blockRequest.offset, PER_SOURCE_WORDS);
@@ -8770,8 +8871,8 @@ async function sweepRoute(ctx, s, scores, sources, levelsPerSubmit, options, tun
         if (level > n + 3) {
           throw new WebGpuGraphError(
             "E_VALIDATION",
-            `${ALGORITHM$3}: the done flag never rose in ${level} levels of the batch at ${batchStart}`,
-            { label: ALGORITHM$3, message: `the done flag never rose in ${level} levels` }
+            `${ALGORITHM$4}: the done flag never rose in ${level} levels of the batch at ${batchStart}`,
+            { label: ALGORITHM$4, message: `the done flag never rose in ${level} levels` }
           );
         }
       }
@@ -8791,14 +8892,14 @@ function checkSources(s, sources) {
     return null;
   }
   if (s.directed) {
-    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$3}: sampled sources need an undirected snapshot`, {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$4}: sampled sources need an undirected snapshot`, {
       feature: "closenessCentrality.directedSources",
       hint: "run the CPU port, which searches the in-arcs"
     });
   }
   for (const v of sources) {
     if (!Number.isInteger(v) || v < 0 || v >= s.nodeCount) {
-      throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$3}: a source is not a node index`, {
+      throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$4}: a source is not a node index`, {
         argument: "sources",
         value: v,
         expected: `an integer in [0, ${s.nodeCount})`
@@ -8812,7 +8913,7 @@ async function closenessWithTuning(ctx, s, options, tuning) {
   await assertDeviceComputes(ctx);
   for (const key of ["maxIterations", "tolerance"]) {
     if (options?.[key] !== void 0) {
-      throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$3}: ${key} has no meaning for an exact traversal`, {
+      throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$4}: ${key} has no meaning for an exact traversal`, {
         option: key,
         hint: "closeness is an exact traversal; the option has no meaning here"
       });
@@ -8824,7 +8925,7 @@ async function closenessWithTuning(ctx, s, options, tuning) {
   if (!Number.isInteger(levelsPerSubmit) || levelsPerSubmit < 1 || levelsPerSubmit > MAX_LEVELS_PER_SUBMIT) {
     throw new WebGpuGraphError(
       "E_INVALID_ARGUMENT",
-      `${ALGORITHM$3}: levelsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
+      `${ALGORITHM$4}: levelsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
       {
         argument: "levelsPerSubmit",
         value: levelsPerSubmit,
@@ -8832,16 +8933,16 @@ async function closenessWithTuning(ctx, s, options, tuning) {
       }
     );
   }
-  const scores = checkDest$2(ALGORITHM$3, options?.dest, n) ?? new Float32Array(n);
+  const scores = checkDest$2(ALGORITHM$4, options?.dest, n) ?? new Float32Array(n);
   const weighted = options?.weighted ?? s.flags.weighted;
   if (options?.signal?.aborted) {
-    throw aborted(ALGORITHM$3);
+    throw aborted(ALGORITHM$4);
   }
   if (weighted && s.weights !== null && !s.flags.allWeightsOne) {
     if (!s.flags.nonNegativeWeights) {
       throw new WebGpuGraphError(
         "E_UNSUPPORTED",
-        `${ALGORITHM$3}: a negative weight has no shortest-path distance to sum`,
+        `${ALGORITHM$4}: a negative weight has no shortest-path distance to sum`,
         {
           feature: "closenessCentrality.negativeWeights",
           hint: "pass weighted: false to ignore the column"
@@ -8849,7 +8950,7 @@ async function closenessWithTuning(ctx, s, options, tuning) {
       );
     }
     if (!s.flags.finiteWeights) {
-      throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$3}: a NaN or infinite weight has no shortest path`, {
+      throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$4}: a NaN or infinite weight has no shortest path`, {
         feature: "closenessCentrality.nonFiniteWeights"
       });
     }
@@ -8860,7 +8961,7 @@ async function closenessWithTuning(ctx, s, options, tuning) {
 function closenessCentrality(ctx, s, options) {
   return closenessWithTuning(ctx, s, options, {});
 }
-const ALGORITHM$2 = "allPairsShortestPath";
+const ALGORITHM$3 = "allPairsShortestPath";
 const DEFAULT_ROUNDS_PER_SUBMIT = Math.floor(APSP_MAX_DISPATCHES_PER_SUBMIT / 3);
 function allPairsCeiling(limits) {
   const binding = limits.maxStorageBufferBindingSize;
@@ -8883,7 +8984,7 @@ async function allPairsWithTuning(ctx, s, options, tuning) {
   if (!Number.isInteger(roundsPerSubmit) || roundsPerSubmit < 1 || roundsPerSubmit > DEFAULT_ROUNDS_PER_SUBMIT) {
     throw new WebGpuGraphError(
       "E_INVALID_ARGUMENT",
-      `${ALGORITHM$2}: roundsPerSubmit must be an integer in [1, ${DEFAULT_ROUNDS_PER_SUBMIT}]`,
+      `${ALGORITHM$3}: roundsPerSubmit must be an integer in [1, ${DEFAULT_ROUNDS_PER_SUBMIT}]`,
       {
         argument: "roundsPerSubmit",
         value: roundsPerSubmit,
@@ -8895,12 +8996,12 @@ async function allPairsWithTuning(ctx, s, options, tuning) {
   if (n > maxNodes) {
     throw new WebGpuGraphError(
       "E_TOO_LARGE",
-      `${ALGORITHM$2}: ${n} nodes need a ${4 * n * n}-byte distance matrix in one storage binding; this device's ${limitName} of ${limit} bytes holds at most ${maxNodes} nodes -- raise it through GpuContextOptions.limits`,
+      `${ALGORITHM$3}: ${n} nodes need a ${4 * n * n}-byte distance matrix in one storage binding; this device's ${limitName} of ${limit} bytes holds at most ${maxNodes} nodes -- raise it through GpuContextOptions.limits`,
       {
         needed: 4 * n * n,
         limit,
         path: "allPairs.matrix",
-        algorithm: ALGORITHM$2,
+        algorithm: ALGORITHM$3,
         nodes: n,
         maxNodes,
         limitName,
@@ -8908,30 +9009,30 @@ async function allPairsWithTuning(ctx, s, options, tuning) {
       }
     );
   }
-  const dist = checkDest$2(ALGORITHM$2, options?.dest, n * n) ?? new Float32Array(n * n);
+  const dist = checkDest$2(ALGORITHM$3, options?.dest, n * n) ?? new Float32Array(n * n);
   const weighted = (options?.weighted ?? s.weights !== null) && s.weights !== null && !s.flags.allWeightsOne;
   if (weighted && !s.flags.nonNegativeWeights) {
-    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$2}: a negative weight is not supported`, {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$3}: a negative weight is not supported`, {
       feature: "allPairs.negativeWeights",
       hint: "the blocked Floyd-Warshall sweep needs non-negative weights; pass weighted: false for hop counts"
     });
   }
   if (weighted && !s.flags.finiteWeights) {
-    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$2}: a NaN or infinite weight has no shortest path`, {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$3}: a NaN or infinite weight has no shortest path`, {
       feature: "allPairs.nonFiniteWeights"
     });
   }
   if (options?.signal?.aborted) {
-    throw aborted(ALGORITHM$2);
+    throw aborted(ALGORITHM$3);
   }
   if (n === 0) {
     return { dist, n };
   }
   await assertDeviceComputes(ctx);
   const core = ctx.residency.core(s);
-  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$2);
+  assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM$3);
   const blocks = Math.ceil(n / APSP_TILE);
-  const scope = algorithmScope(ctx, ALGORITHM$2, Math.min(roundsPerSubmit, blocks) + 2);
+  const scope = algorithmScope(ctx, ALGORITHM$3, Math.min(roundsPerSubmit, blocks) + 2);
   try {
     const wg = ctx.workgroupSize;
     const bytes = 4 * n * n;
@@ -8947,7 +9048,7 @@ async function allPairsWithTuning(ctx, s, options, tuning) {
     const others = blocks - 1;
     const phasePlans = [plan2d(1, ctx.caps), plan2d(2 * others, ctx.caps), plan2d(others * others, ctx.caps)];
     for (let first = 0; first < blocks; first += roundsPerSubmit) {
-      const batch = new CommandBatch(ctx, `${ALGORITHM$2}/sweep`);
+      const batch = new CommandBatch(ctx, `${ALGORITHM$3}/sweep`);
       const pass = batch.pass("apsp");
       if (first === 0) {
         const fillParams = scope.params(FILL_PARAMS, { count: n * n, value: F32_INF_BITS, mode: 0, pad0: 0 });
@@ -8979,7 +9080,7 @@ async function allPairsWithTuning(ctx, s, options, tuning) {
       ctx.assertReady();
       options?.onProgress?.(last, blocks);
       if (options?.signal?.aborted) {
-        throw aborted(ALGORITHM$2, submitted.id);
+        throw aborted(ALGORITHM$3, submitted.id);
       }
     }
     await ctx.readback.read(matrix.buffer, bytes, dist);
@@ -9631,9 +9732,9 @@ function runCore(runStart, runs, sortedDst, sortedW, valid) {
     hasWeights: true
   };
 }
-const ALGORITHM$1 = "labelPropagation";
+const ALGORITHM$2 = "labelPropagation";
 const DEFAULT_MAX_ITERATIONS = 100;
-const RING_SLOTS$1 = 1024;
+const RING_SLOTS$2 = 1024;
 function checkDest$1(dest, n) {
   if (dest === void 0) {
     return null;
@@ -9643,7 +9744,7 @@ function checkDest$1(dest, n) {
   }
   throw new WebGpuGraphError(
     "E_INVALID_ARGUMENT",
-    `${ALGORITHM$1}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
+    `${ALGORITHM$2}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
     {
       argument: "dest",
       value: `${dest.constructor.name}(${dest.length})`,
@@ -9656,7 +9757,7 @@ function maxIterationsOf(value) {
     return DEFAULT_MAX_ITERATIONS;
   }
   if (!Number.isSafeInteger(value) || value < 0) {
-    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$1}: maxIterations must be a non-negative integer`, {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM$2}: maxIterations must be a non-negative integer`, {
       argument: "maxIterations",
       value,
       expected: "a non-negative integer"
@@ -9676,12 +9777,12 @@ function neighbourBound(s) {
   }
   return bound;
 }
-function resultOf(raw, dest) {
+function resultOf$1(raw, dest) {
   const n = raw.length;
   for (let v = 0; v < n; v++) {
     if (raw[v] >= n) {
-      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$1}: labels[${v}] = ${raw[v]} is not a node index`, {
-        label: `${ALGORITHM$1}/labels`,
+      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$2}: labels[${v}] = ${raw[v]} is not a node index`, {
+        label: `${ALGORITHM$2}/labels`,
         message: `the device produced a label outside [0, ${n})`
       });
     }
@@ -9704,23 +9805,23 @@ async function labelPropagation(ctx, s, options) {
   const maxIterations = maxIterationsOf(options?.maxIterations);
   const weighted = options?.weighted !== false;
   if (options?.signal?.aborted) {
-    throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$1}: the signal was aborted before any work started`, {});
+    throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$2}: the signal was aborted before any work started`, {});
   }
   if (n === 0 || s.edgeCount === 0 || maxIterations === 0) {
     options?.onProgress?.(1, 1);
     return identityResult(n, dest);
   }
   const plan = planGroupRows(neighbourBound(s));
-  assertBindable(ctx, 4 * plan.regionWords, "the group-by hash region", ALGORITHM$1);
-  const scope = algorithmScope(ctx, ALGORITHM$1, RING_SLOTS$1);
+  assertBindable(ctx, 4 * plan.regionWords, "the group-by hash region", ALGORITHM$2);
+  const scope = algorithmScope(ctx, ALGORITHM$2, RING_SLOTS$2);
   try {
-    const build = await buildSimpleSymmetric(ctx, s, scope, weighted, ALGORITHM$1);
+    const build = await buildSimpleSymmetric(ctx, s, scope, weighted, ALGORITHM$2);
     const { graph } = build;
     if (graph.colIdx === null) {
       scope.flush();
       const bytes = await build.batch.submit().readback;
       ctx.assertReady();
-      assertBuildSorted(bytes, build, ALGORITHM$1);
+      assertBuildSorted(bytes, build, ALGORITHM$2);
       options?.onProgress?.(1, 1);
       return identityResult(n, dest);
     }
@@ -9792,12 +9893,12 @@ async function labelPropagation(ctx, s, options) {
       const bytes = await submitted.readback;
       ctx.assertReady();
       if (first) {
-        assertBuildSorted(bytes, build, ALGORITHM$1);
+        assertBuildSorted(bytes, build, ALGORITHM$2);
         first = false;
       }
       if (new Uint32Array(bytes, exhaustedRequest.offset, 1)[0] !== 0) {
-        throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$1}: a hash probe exhausted its bound`, {
-          label: `${ALGORITHM$1}/group-by-key`,
+        throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$2}: a hash probe exhausted its bound`, {
+          label: `${ALGORITHM$2}/group-by-key`,
           message: "a compare-exchange loop of the workgroup tier ran out of steps"
         });
       }
@@ -9806,7 +9907,7 @@ async function labelPropagation(ctx, s, options) {
       const lastTwo = k >= 2 ? moves[k - 2] + moves[k - 1] : previousLast + moves[0];
       previousLast = moves[k - 1];
       if (options?.signal?.aborted) {
-        throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$1}: the signal was aborted`, {
+        throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$2}: the signal was aborted`, {
           batchId: submitted.id
         });
       }
@@ -9814,12 +9915,203 @@ async function labelPropagation(ctx, s, options) {
       if (lastTwo === 0 || done >= maxIterations) {
         break;
       }
-      batch = new CommandBatch(ctx, `${ALGORITHM$1}/passes`);
+      batch = new CommandBatch(ctx, `${ALGORITHM$2}/passes`);
     }
     const raw = new Uint32Array(n);
     await ctx.readback.read(cur.buffer, 4 * n, raw);
     ctx.assertReady();
-    return resultOf(raw, dest);
+    return resultOf$1(raw, dest);
+  } finally {
+    scope.dispose();
+  }
+}
+const ALGORITHM$1 = "minimumSpanningTree";
+const COMPRESS_STEPS = 1024;
+const MAX_ROUNDS = 64;
+const RING_SLOTS$1 = 5 + BORUVKA_ROUNDS_PER_SUBMIT;
+function compressPasses(n) {
+  let passes = 1;
+  for (let reach = COMPRESS_STEPS; reach < n; reach *= COMPRESS_STEPS) {
+    passes++;
+  }
+  return passes;
+}
+function resultOf(s, treeEdge, expected) {
+  const edges = new Uint32Array(expected);
+  const { weights } = s.edgeList();
+  let taken = 0;
+  let totalWeight = 0;
+  for (const e of treeEdge) {
+    if (e === INVALID_INDEX) {
+      continue;
+    }
+    if (e >= s.edgeCount || taken === expected) {
+      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$1}: the device recorded an edge it did not count`, {
+        label: `${ALGORITHM$1}/treeEdge`,
+        message: `edge ${e} at forest position ${taken} of ${expected}`
+      });
+    }
+    edges[taken++] = e;
+    totalWeight += weights === null ? 1 : weights[e];
+  }
+  if (taken !== expected) {
+    throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$1}: ${taken} recorded edges, ${expected} counted`, {
+      label: `${ALGORITHM$1}/treeEdge`,
+      message: "the per-round counts disagree with the recorded forest"
+    });
+  }
+  return { edges, totalWeight };
+}
+async function minimumSpanningTree(ctx, s, options) {
+  ctx.assertReady();
+  await assertDeviceComputes(ctx);
+  if (options?.dest !== void 0) {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM$1}: dest is not supported`, {
+      option: "dest",
+      hint: "the forest's edge count is known only after the run"
+    });
+  }
+  if (options?.signal?.aborted) {
+    throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$1}: the signal was aborted before any work started`, {});
+  }
+  const n = s.nodeCount;
+  const m = s.edgeCount;
+  if (n === 0 || m === 0) {
+    options?.onProgress?.(1, 1);
+    return { edges: new Uint32Array(0), totalWeight: 0 };
+  }
+  ctx.residency.core(s, ["rowPtr"]);
+  const edges = ctx.residency.view(s, "edgeList");
+  const edgeWeight = edges.bindings.weights ?? null;
+  const scope = algorithmScope(ctx, ALGORITHM$1, RING_SLOTS$1);
+  try {
+    const wg = ctx.workgroupSize;
+    const words = (count, label) => {
+      const size = 4 * Math.max(1, count);
+      return { buffer: scope.scratch(size, label), offset: 0, size, window: null };
+    };
+    const comp = words(n, "comp");
+    const bestKey = words(n, "bestKey");
+    const bestEdge = words(n, "bestEdge");
+    const treeEdge = words(n, "treeEdge");
+    const counters = words(BORUVKA_ROUNDS_PER_SUBMIT, "counters");
+    await ctx.allocator.check();
+    const fill = await ctx.pipelines.kernel(kernelSpec("fill"));
+    const weighted = edgeWeight !== null;
+    const minKey = await ctx.pipelines.kernel(kernelSpec("mst-best", { PASS: 0, WEIGHTED: weighted }));
+    const minEdge = await ctx.pipelines.kernel(kernelSpec("mst-best", { PASS: 1, WEIGHTED: weighted }));
+    const link = await ctx.pipelines.kernel(kernelSpec("mst-link"));
+    const compress = await ctx.pipelines.kernel(kernelSpec("wcc-compress"));
+    const nodePlan = plan1d(n, wg, ctx.caps);
+    const edgePlan = plan1d(m, wg, ctx.caps);
+    const compressPlan = planGridStride(n, wg, ctx.caps);
+    const passes = compressPasses(n);
+    const { queue } = ctx.device;
+    let batch = new CommandBatch(ctx, `${ALGORITHM$1}/rounds`);
+    let first = true;
+    let rounds = 0;
+    let recorded = 0;
+    for (; ; ) {
+      queue.writeBuffer(counters.buffer, 0, new Uint32Array(BORUVKA_ROUNDS_PER_SUBMIT));
+      const pass = batch.pass("rounds");
+      const fillFor = (value, mode) => scope.params(FILL_PARAMS, { count: n, value, mode, pad0: 0 });
+      if (first) {
+        const iota = fillFor(0, 1);
+        fill.dispatch(pass, fill.bind({ dst: comp, P: iota.binding }), nodePlan, [iota.offset]);
+        const none = fillFor(INVALID_INDEX, 0);
+        fill.dispatch(pass, fill.bind({ dst: treeEdge, P: none.binding }), nodePlan, [none.offset]);
+      }
+      const reset = fillFor(U32_MAX$2, 0);
+      const edgeParams = scope.params(MST_PARAMS, { count: m, counterIndex: 0, pad0: 0, pad1: 0 });
+      const compressParams = scope.params(WCC_PARAMS, {
+        n,
+        items: n,
+        stride: compressPlan.stride ?? n,
+        r: 0,
+        flagIndex: 0,
+        giant: U32_MAX$2,
+        maxSteps: COMPRESS_STEPS,
+        pad0: 0
+      });
+      const graph = {
+        edgeSrc: edges.bindings.src,
+        edgeDst: edges.bindings.dst,
+        edgeWeight: edgeWeight ?? edges.bindings.src
+      };
+      for (let i = 0; i < BORUVKA_ROUNDS_PER_SUBMIT; i++) {
+        for (const dst of [bestKey, bestEdge]) {
+          fill.dispatch(pass, fill.bind({ dst, P: reset.binding }), nodePlan, [reset.offset]);
+        }
+        for (const kernel of [minKey, minEdge]) {
+          kernel.dispatch(
+            pass,
+            kernel.bind({ ...graph, comp, bestKey, bestEdge, P: edgeParams.binding }),
+            edgePlan,
+            [edgeParams.offset]
+          );
+        }
+        const linkParams = scope.params(MST_PARAMS, { count: n, counterIndex: i, pad0: 0, pad1: 0 });
+        link.dispatch(
+          pass,
+          link.bind({
+            edgeSrc: graph.edgeSrc,
+            edgeDst: graph.edgeDst,
+            bestEdge,
+            comp,
+            treeEdge,
+            counters,
+            P: linkParams.binding
+          }),
+          nodePlan,
+          [linkParams.offset]
+        );
+        for (let j = 0; j < passes; j++) {
+          compress.dispatch(pass, compress.bind({ comp, P: compressParams.binding }), compressPlan, [
+            compressParams.offset
+          ]);
+        }
+      }
+      batch.endPass();
+      const countsRequest = batch.readback(counters.buffer, 0, 4 * BORUVKA_ROUNDS_PER_SUBMIT);
+      scope.flush();
+      const submitted = batch.submit();
+      const bytes = await submitted.readback;
+      ctx.assertReady();
+      first = false;
+      if (options?.signal?.aborted) {
+        throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM$1}: the signal was aborted`, {
+          batchId: submitted.id
+        });
+      }
+      const counts = new Uint32Array(bytes, countsRequest.offset, BORUVKA_ROUNDS_PER_SUBMIT);
+      let settled2 = false;
+      for (const count of counts) {
+        recorded += count;
+        settled2 ||= count === 0;
+      }
+      rounds += BORUVKA_ROUNDS_PER_SUBMIT;
+      if (recorded > n - 1) {
+        throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$1}: ${recorded} forest edges on ${n} nodes`, {
+          label: `${ALGORITHM$1}/counters`,
+          message: "a spanning forest has at most n - 1 edges"
+        });
+      }
+      if (settled2) {
+        break;
+      }
+      if (rounds >= MAX_ROUNDS) {
+        throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM$1}: still merging after ${rounds} rounds`, {
+          label: `${ALGORITHM$1}/rounds`,
+          message: "Boruvka halves the components every round; the device did not"
+        });
+      }
+      batch = new CommandBatch(ctx, `${ALGORITHM$1}/rounds`);
+    }
+    const raw = new Uint32Array(n);
+    await ctx.readback.read(treeEdge.buffer, 4 * n, raw);
+    ctx.assertReady();
+    options?.onProgress?.(1, 1);
+    return resultOf(s, raw, recorded);
   } finally {
     scope.dispose();
   }
@@ -15089,6 +15381,24 @@ function createAccelerator(ctx, options) {
       }
       return await labelPropagation(ctx, gs, { maxIterations: o?.maxIterations, weighted: o?.weighted });
     },
+    /**
+     * Boruvka's minimum spanning forest (design 8.5; P11-T4): the forest of the total edge order (weight, then
+     * edge index), which is the one `kruskalMST` accepts. The seam's per-arc `weights` override is refused when
+     * defined: the forest runs over the snapshot's own edge weights.
+     * @param gs - the snapshot
+     * @param o - the seam's `MstOptions`; `weights` refused when defined
+     * @returns the forest's logical edge indices and its f64 total weight
+     */
+    async minimumSpanningTree(gs, o) {
+      ctx.assertReady();
+      if (o?.weights !== void 0) {
+        throw new WebGpuGraphError("E_UNSUPPORTED", "minimumSpanningTree: weights is not supported", {
+          option: "weights",
+          hint: "the spanning forest runs over the snapshot's own edge weights"
+        });
+      }
+      return await minimumSpanningTree(ctx, gs);
+    },
     /**
      * Destroys every device buffer recorded for the snapshot (spec 4.5); delegates to ctx.release.
      * @param s - the snapshot the app is done with
@@ -15198,7 +15508,7 @@ async function calibrateLayout(ctx, options) {
   };
 }
 export {
-  a0 as ARC_WINDOW_ALIGN,
+  a1 as ARC_WINDOW_ALIGN,
   EXACT_MAX_NODES,
   FA2_DEFAULTS,
   FR_DEFAULTS,
@@ -15206,10 +15516,10 @@ export {
   LAYOUT_TUNING_DEFAULTS,
   MAX_1D_ITEMS,
   MAX_WORKGROUPS_PER_DIM,
-  a1 as PASSTHROUGH_FORMAT_CODES,
+  a2 as PASSTHROUGH_FORMAT_CODES,
   SE_DEFAULTS,
-  a2 as STORAGE_ALIGN,
-  a3 as WORKGROUP_SIZE,
+  a3 as STORAGE_ALIGN,
+  a4 as WORKGROUP_SIZE,
   WebGpuGraphError,
   allPairsShortestPath,
   bellmanFord,
@@ -15227,10 +15537,11 @@ export {
   eigenvectorCentrality,
   hasErrorCode,
   hits,
-  a4 as isSoftwareAdapter,
+  a5 as isSoftwareAdapter,
   isWebGpuGraphError,
   katzCentrality,
   labelPropagation,
+  minimumSpanningTree,
   pageRank,
   personalizedPageRank,
   seedPositions,