@graphty/webgpu-graph-algorithms 0.6.13 → 0.6.15

package/dist/src/types/betweenness.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The betweenness result records (spec 3.3 lines 833-834). Types only: this file imports nothing at runtime. The
+ * options are the CPU seam's own `BetweennessAcceleratorOptions` (`normalized`, `endpoints`, `sources`, `k`), as the
+ * traversals take the seam's option types.
+ */
+import type { F32 } from "@graphty/graph-format";
+import type { GpuScoresResult } from "./algorithms.js";
+/**
+ * Vertex betweenness (spec 3.3 line 833). A SAMPLED run (`sources` or `k`) returns the UNSCALED sum over the sources
+ * actually run -- never extrapolated by `n / k` -- and `sourcesUsed` says how many that was; a caller who wants the
+ * estimator of the full sum multiplies by `n / sourcesUsed`.
+ * @public
+ */
+export interface GpuBetweennessResult extends GpuScoresResult {
+    /** How many sources the scores sum over: `n` for an exact run, the sample size for a sampled one. */
+    readonly sourcesUsed: number;
+    /**
+     * True when some pair of vertices is joined by more than 2^32 shortest paths: the u32 path counts wrapped and the
+     * scores are WRONG, not approximate. Never clamped, never silent.
+     */
+    readonly sigmaOverflow: boolean;
+}
+/**
+ * Edge betweenness (spec 3.3 line 834): one score per logical edge (`edgeCount`), the per-arc scores folded with
+ * `foldArcs(s, perArc, "sum")` and halved on an undirected snapshot (the two arcs carry the pairs crossing the edge
+ * in each direction). `sourcesUsed` and `sigmaOverflow` mean what they mean on `GpuBetweennessResult`.
+ * @public
+ */
+export interface GpuEdgeScoresResult {
+    readonly scores: F32;
+    readonly precision: "f32";
+    readonly sourcesUsed: number;
+    readonly sigmaOverflow: boolean;
+}
+//# sourceMappingURL=betweenness.d.ts.map

package/dist/src/types/betweenness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"betweenness.d.ts","sourceRoot":"","sources":["../../../src/types/betweenness.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAC;AAEjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,WAAW,oBAAqB,SAAQ,eAAe;IACzD,qGAAqG;IACrG,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAChC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;IACrB,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACnC"}

package/dist/src/types/betweenness.js

@@ -0,0 +1,7 @@
+/**
+ * The betweenness result records (spec 3.3 lines 833-834). Types only: this file imports nothing at runtime. The
+ * options are the CPU seam's own `BetweennessAcceleratorOptions` (`normalized`, `endpoints`, `sources`, `k`), as the
+ * traversals take the seam's option types.
+ */
+export {};
+//# sourceMappingURL=betweenness.js.map

package/dist/src/types/betweenness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"betweenness.js","sourceRoot":"","sources":["../../../src/types/betweenness.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/src/wgsl/bc-backward.wgsl.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The `bc-backward` kernel body (design 8.4 "each (w, s) PULLS over its successors", 8.10 "BC backward (successor
+ * pull)"): one level of a betweenness batch's dependency accumulation, one invocation per log entry `(w, s)` of the
+ * level's range `S[P.start .. P.start + P.count)`, which the host planned from the `ends` it read back. Each entry
+ * walks the out-arcs of `w` -- the rows the forward pass expanded -- and sums `sigma[s][w] / sigma[s][v] * (1 +
+ * delta[s][v])` over the successors `v` (`depth[s][v] == depth[s][w] + 1`), whose dependencies the previous (deeper)
+ * dispatch wrote, then writes `delta[s][w]` ONCE. No float is ever accumulated through an atomic, so the result is
+ * bitwise reproducible. The sources (depth 0) are never dispatched: their dependency stays 0, which is what keeps a
+ * source's own dependency out of its score. Grid-stride loop (`P.stride`). ponytail: one lane walks one row, so a
+ * vertex of degree above 65,535 exceeds llvmpipe's per-invocation loop cap (CLAUDE.md, Verified Platform Facts) and
+ * would need a workgroup-per-row form there; hardware adapters have no such cap. Body only; the sabotage rows of
+ * test/helpers/sabotage.ts are textual edits of it.
+ */
+export declare const bcBackwardWgsl = "\n@compute @workgroup_size(WG)\nfn bc_backward(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    for (var i = linear_id(wid, lid.x); i < P.count; i = i + P.stride) {\n        let t = S[P.start + i];                                      // s * n + w\n        let w = t % P.n;\n        let base = t - w;                                            // s * n\n        let succ = depthK[t] + 1u;\n        let sw = f32(sigmaK[t]);\n        var acc = 0.0;\n        for (var a = rowPtr[w]; a < rowPtr[w + 1u]; a = a + 1u) {\n            let v = base + colIdx[a];\n            if (depthK[v] == succ) {                                 // v is a successor of w for source s\n                acc = acc + (sw / f32(sigmaK[v])) * (1.0 + deltaK[v]);\n            }\n        }\n        deltaK[t] = acc;                                             // written once per (w, s)\n    }\n}\n";
+//# sourceMappingURL=bc-backward.wgsl.d.ts.map

package/dist/src/wgsl/bc-backward.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc-backward.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/bc-backward.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,m5BAmB1B,CAAC"}

package/dist/src/wgsl/bc-backward.wgsl.js

@@ -0,0 +1,34 @@
+/**
+ * The `bc-backward` kernel body (design 8.4 "each (w, s) PULLS over its successors", 8.10 "BC backward (successor
+ * pull)"): one level of a betweenness batch's dependency accumulation, one invocation per log entry `(w, s)` of the
+ * level's range `S[P.start .. P.start + P.count)`, which the host planned from the `ends` it read back. Each entry
+ * walks the out-arcs of `w` -- the rows the forward pass expanded -- and sums `sigma[s][w] / sigma[s][v] * (1 +
+ * delta[s][v])` over the successors `v` (`depth[s][v] == depth[s][w] + 1`), whose dependencies the previous (deeper)
+ * dispatch wrote, then writes `delta[s][w]` ONCE. No float is ever accumulated through an atomic, so the result is
+ * bitwise reproducible. The sources (depth 0) are never dispatched: their dependency stays 0, which is what keeps a
+ * source's own dependency out of its score. Grid-stride loop (`P.stride`). ponytail: one lane walks one row, so a
+ * vertex of degree above 65,535 exceeds llvmpipe's per-invocation loop cap (CLAUDE.md, Verified Platform Facts) and
+ * would need a workgroup-per-row form there; hardware adapters have no such cap. Body only; the sabotage rows of
+ * test/helpers/sabotage.ts are textual edits of it.
+ */
+export const bcBackwardWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn bc_backward(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    for (var i = linear_id(wid, lid.x); i < P.count; i = i + P.stride) {
+        let t = S[P.start + i];                                      // s * n + w
+        let w = t % P.n;
+        let base = t - w;                                            // s * n
+        let succ = depthK[t] + 1u;
+        let sw = f32(sigmaK[t]);
+        var acc = 0.0;
+        for (var a = rowPtr[w]; a < rowPtr[w + 1u]; a = a + 1u) {
+            let v = base + colIdx[a];
+            if (depthK[v] == succ) {                                 // v is a successor of w for source s
+                acc = acc + (sw / f32(sigmaK[v])) * (1.0 + deltaK[v]);
+            }
+        }
+        deltaK[t] = acc;                                             // written once per (w, s)
+    }
+}
+`;
+//# sourceMappingURL=bc-backward.wgsl.js.map

package/dist/src/wgsl/bc-backward.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc-backward.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/bc-backward.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;CAmBxC,CAAC"}

package/dist/src/wgsl/bc-edge-gather.wgsl.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The `bc-edge-gather` kernel body (design 8.4 "edge BC accumulates per arc from the same n x k deltas"): the per-arc
+ * twin of `bc-gather`, run once per batch after the backward sweep. One invocation per ARC (`P.count` arcs,
+ * grid-stride): it finds the row `w` that owns the arc by an upper-bound search over `rowPtr`, then adds over the
+ * batch's sources in order the term the backward pass summed -- `sigma[s][w] / sigma[s][v] * (1 + delta[s][v])`
+ * whenever `w` was reached and `depth[s][v] == depth[s][w] + 1` -- into `arcScores[arc]`. Each arc is written by one
+ * invocation: no atomic, a fixed order. Arc-parallel rather than row-parallel so a hub row is not one lane's loop
+ * (llvmpipe caps a shader loop at 65,535 iterations, and a 1,000-arc hub times 64 sources passed it). Body only;
+ * the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
+ */
+export declare const bcEdgeGatherWgsl = "\n@compute @workgroup_size(WG)\nfn bc_edge_gather(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    for (var a = linear_id(wid, lid.x); a < P.count; a = a + P.stride) {\n        var lo = 0u;                                                 // the row w with rowPtr[w] <= a < rowPtr[w + 1]\n        var hi = P.n;\n        loop {\n            if (lo >= hi) { break; }\n            let mid = (lo + hi) / 2u;\n            if (rowPtr[mid + 1u] <= a) { lo = mid + 1u; } else { hi = mid; }\n        }\n        let w = lo;\n        let nbr = colIdx[a];\n        var acc = arcScores[a];\n        for (var s = 0u; s < P.k; s = s + 1u) {\n            let base = s * P.n;\n            let dw = depthK[base + w];\n            if (dw != INVALID_INDEX && depthK[base + nbr] == dw + 1u) {   // (w, nbr) is on a shortest path from s\n                acc = acc + (f32(sigmaK[base + w]) / f32(sigmaK[base + nbr])) * (1.0 + deltaK[base + nbr]);\n            }\n        }\n        arcScores[a] = acc;\n    }\n}\n";
+//# sourceMappingURL=bc-edge-gather.wgsl.d.ts.map

package/dist/src/wgsl/bc-edge-gather.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc-edge-gather.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/bc-edge-gather.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,6gCAwB5B,CAAC"}

package/dist/src/wgsl/bc-edge-gather.wgsl.js

@@ -0,0 +1,36 @@
+/**
+ * The `bc-edge-gather` kernel body (design 8.4 "edge BC accumulates per arc from the same n x k deltas"): the per-arc
+ * twin of `bc-gather`, run once per batch after the backward sweep. One invocation per ARC (`P.count` arcs,
+ * grid-stride): it finds the row `w` that owns the arc by an upper-bound search over `rowPtr`, then adds over the
+ * batch's sources in order the term the backward pass summed -- `sigma[s][w] / sigma[s][v] * (1 + delta[s][v])`
+ * whenever `w` was reached and `depth[s][v] == depth[s][w] + 1` -- into `arcScores[arc]`. Each arc is written by one
+ * invocation: no atomic, a fixed order. Arc-parallel rather than row-parallel so a hub row is not one lane's loop
+ * (llvmpipe caps a shader loop at 65,535 iterations, and a 1,000-arc hub times 64 sources passed it). Body only;
+ * the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
+ */
+export const bcEdgeGatherWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn bc_edge_gather(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    for (var a = linear_id(wid, lid.x); a < P.count; a = a + P.stride) {
+        var lo = 0u;                                                 // the row w with rowPtr[w] <= a < rowPtr[w + 1]
+        var hi = P.n;
+        loop {
+            if (lo >= hi) { break; }
+            let mid = (lo + hi) / 2u;
+            if (rowPtr[mid + 1u] <= a) { lo = mid + 1u; } else { hi = mid; }
+        }
+        let w = lo;
+        let nbr = colIdx[a];
+        var acc = arcScores[a];
+        for (var s = 0u; s < P.k; s = s + 1u) {
+            let base = s * P.n;
+            let dw = depthK[base + w];
+            if (dw != INVALID_INDEX && depthK[base + nbr] == dw + 1u) {   // (w, nbr) is on a shortest path from s
+                acc = acc + (f32(sigmaK[base + w]) / f32(sigmaK[base + nbr])) * (1.0 + deltaK[base + nbr]);
+            }
+        }
+        arcScores[a] = acc;
+    }
+}
+`;
+//# sourceMappingURL=bc-edge-gather.wgsl.js.map

package/dist/src/wgsl/bc-edge-gather.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc-edge-gather.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/bc-edge-gather.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwB1C,CAAC"}

package/dist/src/wgsl/bc-finalize.wgsl.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The `bc-finalize` kernel body (design 8.4, 5.4): the one-lane bookkeeping of a betweenness source batch, two roles
+ * by `P.role`. The batch keeps ONE append-only claim log `S` -- every `(vertex, source)` pair the forward pass
+ * claims, packed as the index `s * n + v` into the `n x k` arrays -- and `ends`, the level boundaries into it: the
+ * entries at depth `L` are `S[ends[L] .. ends[L + 1])`. That log is Brandes' stack, so the backward pass walks the
+ * same ranges from the deepest level up and nothing is ever copied between levels.
+ *
+ * Role 1 seeds the batch: the k seed entries the host wrote into `S[0 .. k)` get depth 0 and one shortest path,
+ * `ends[0] = 0`, the append cursor `stackTop` (counters word 26) starts at k, the overflow flag (word 27) is cleared,
+ * `level` (word 11) is U32_MAX so the first boundary lands on 0, and `done` (word 15) is cleared.
+ *
+ * Role 0 is the level boundary, recorded before every forward level: it advances `level`, closes the level just
+ * claimed by writing `ends[level + 1] = stackTop`, publishes the new level's size in `frontierCount` (word 0) and sets
+ * `done` when that level is empty. A boundary that finds `done` set moves nothing, so the levels the host records
+ * past the end are no-ops. The forward kernels dispatch directly and read their range from `ends` (no indirect
+ * dispatch: design/decisions/2026-09-25-frontier-kernels-dispatch-directly.md). One lane; no barrier follows the
+ * early return of the others (spec 3.5 rule 1). Body only; the sabotage rows of test/helpers/sabotage.ts are
+ * textual edits of it.
+ */
+export declare const bcFinalizeWgsl = "\n@compute @workgroup_size(WG)\nfn bc_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {\n    if (lid.x != 0u) { return; }                                     // one lane; no barrier follows (3.5 rule 1)\n    if (P.role == 1u) {                                              // the seed of a batch\n        for (var i = 0u; i < P.k; i = i + 1u) {\n            let t = S[i];\n            depthK[t] = 0u;                                          // the source is at depth 0\n            sigmaK[t] = 1u;                                          // with one shortest path, itself\n        }\n        ends[0] = 0u;\n        atomicStore(&counters[26], P.k);                             // stackTop: the seeds are the log's first k entries\n        atomicStore(&counters[27], 0u);                              // sigmaOverflow\n        atomicStore(&counters[11], U32_MAX);                         // level: the first boundary brings it to 0\n        atomicStore(&counters[15], 0u);                              // done\n        return;\n    }\n    if (atomicLoad(&counters[15]) != 0u) { return; }                 // done: a no-op level the host recorded past the end\n    let level = atomicLoad(&counters[11]) + 1u;\n    let top = atomicLoad(&counters[26]);\n    ends[level + 1u] = top;                                          // the level's entries end where the log ends now\n    let count = top - ends[level];\n    atomicStore(&counters[0], count);                                // frontierCount (the inspect seam reads it)\n    atomicStore(&counters[11], level);\n    atomicStore(&counters[15], select(0u, 1u, count == 0u));         // an empty level ends the batch\n}\n";
+//# sourceMappingURL=bc-finalize.wgsl.d.ts.map

package/dist/src/wgsl/bc-finalize.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc-finalize.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/bc-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,+oDA0B1B,CAAC"}

package/dist/src/wgsl/bc-finalize.wgsl.js

@@ -0,0 +1,47 @@
+/**
+ * The `bc-finalize` kernel body (design 8.4, 5.4): the one-lane bookkeeping of a betweenness source batch, two roles
+ * by `P.role`. The batch keeps ONE append-only claim log `S` -- every `(vertex, source)` pair the forward pass
+ * claims, packed as the index `s * n + v` into the `n x k` arrays -- and `ends`, the level boundaries into it: the
+ * entries at depth `L` are `S[ends[L] .. ends[L + 1])`. That log is Brandes' stack, so the backward pass walks the
+ * same ranges from the deepest level up and nothing is ever copied between levels.
+ *
+ * Role 1 seeds the batch: the k seed entries the host wrote into `S[0 .. k)` get depth 0 and one shortest path,
+ * `ends[0] = 0`, the append cursor `stackTop` (counters word 26) starts at k, the overflow flag (word 27) is cleared,
+ * `level` (word 11) is U32_MAX so the first boundary lands on 0, and `done` (word 15) is cleared.
+ *
+ * Role 0 is the level boundary, recorded before every forward level: it advances `level`, closes the level just
+ * claimed by writing `ends[level + 1] = stackTop`, publishes the new level's size in `frontierCount` (word 0) and sets
+ * `done` when that level is empty. A boundary that finds `done` set moves nothing, so the levels the host records
+ * past the end are no-ops. The forward kernels dispatch directly and read their range from `ends` (no indirect
+ * dispatch: design/decisions/2026-09-25-frontier-kernels-dispatch-directly.md). One lane; no barrier follows the
+ * early return of the others (spec 3.5 rule 1). Body only; the sabotage rows of test/helpers/sabotage.ts are
+ * textual edits of it.
+ */
+export const bcFinalizeWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn bc_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
+    if (lid.x != 0u) { return; }                                     // one lane; no barrier follows (3.5 rule 1)
+    if (P.role == 1u) {                                              // the seed of a batch
+        for (var i = 0u; i < P.k; i = i + 1u) {
+            let t = S[i];
+            depthK[t] = 0u;                                          // the source is at depth 0
+            sigmaK[t] = 1u;                                          // with one shortest path, itself
+        }
+        ends[0] = 0u;
+        atomicStore(&counters[26], P.k);                             // stackTop: the seeds are the log's first k entries
+        atomicStore(&counters[27], 0u);                              // sigmaOverflow
+        atomicStore(&counters[11], U32_MAX);                         // level: the first boundary brings it to 0
+        atomicStore(&counters[15], 0u);                              // done
+        return;
+    }
+    if (atomicLoad(&counters[15]) != 0u) { return; }                 // done: a no-op level the host recorded past the end
+    let level = atomicLoad(&counters[11]) + 1u;
+    let top = atomicLoad(&counters[26]);
+    ends[level + 1u] = top;                                          // the level's entries end where the log ends now
+    let count = top - ends[level];
+    atomicStore(&counters[0], count);                                // frontierCount (the inspect seam reads it)
+    atomicStore(&counters[11], level);
+    atomicStore(&counters[15], select(0u, 1u, count == 0u));         // an empty level ends the batch
+}
+`;
+//# sourceMappingURL=bc-finalize.wgsl.js.map

package/dist/src/wgsl/bc-finalize.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc-finalize.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/bc-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BxC,CAAC"}

package/dist/src/wgsl/bc-forward-edge.wgsl.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The `bc-forward-edge` kernel body (design 8.4 "the McLaughlin-Bader online switch to the edge-parallel form", 8.8
+ * row 7): one level of a betweenness batch's forward pass, edge-parallel -- every logical edge of the `edgeList` view
+ * for every source of the batch, grid-striding over the edges inside a loop over the k sources. For the edge `(u, x)`
+ * and source `s`, when `depth[s][u]` is the level the edge is relaxed toward `x` with EXACTLY the claim and the count
+ * of `bc-forward` (the pre-check, `atomicMin`, the winner appends `s * n + x` to the same claim log, every arc on a
+ * shortest path adds `sigma[s][u]`, a u32 wrap raises word 27); `UNDIRECTED` relaxes the other direction too, the
+ * edge list holding each undirected edge once. So the two forward bodies are interchangeable level by level and the
+ * backward pass cannot tell which ran. A workgroup does nothing when the level is empty (the done boundary). The
+ * winners of a strip are packed into the log with one global `atomicAdd` per strip; every barrier is in uniform
+ * control flow (the loop bounds are uniforms and the workgroup id). Body only; the sabotage rows of
+ * test/helpers/sabotage.ts are textual edits of it.
+ */
+export declare const bcForwardEdgeWgsl = "\nvar<workgroup> wlive: u32;                        // 1 when the level has entries\nvar<workgroup> wwon: atomic<u32>;                 // the strip's winners\nvar<workgroup> wbase: u32;                        // where the strip's winners go in the log\n\nfn claim(x: u32, next: u32) -> bool {\n    if (atomicLoad(&depthK[x]) != INVALID_INDEX) { return false; }   // the pre-check of design 16.1\n    return atomicMin(&depthK[x], next) == INVALID_INDEX;\n}\n\nfn count_paths(origin: u32, x: u32, next: u32) {\n    if (atomicLoad(&depthK[x]) == next) {                            // every arc on a shortest path adds\n        let add = atomicLoad(&sigmaK[origin]);\n        let old = atomicAdd(&sigmaK[x], add);\n        if (old + add < old) { atomicOr(&counters[27], 1u); }        // the u32 wrap, reported\n    }\n}\n\n@compute @workgroup_size(WG)\nfn bc_forward_edge(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let level = atomicLoad(&counters[11]);\n    if (lid.x == 0u) { wlive = select(0u, 1u, ends[level + 1u] > ends[level]); }\n    if (workgroupUniformLoad(&wlive) == 0u) { return; }              // uniform: nothing below runs on an empty level\n    let next = level + 1u;\n    for (var s = 0u; s < P.k; s = s + 1u) {\n        let base = s * P.n;\n        for (var e0 = group_id(wid) * WG; e0 < P.count; e0 = e0 + P.stride) {   // grid-stride over the edges\n            let e = e0 + lid.x;\n            var a = INVALID_INDEX;                                   // the claims this lane won\n            var b = INVALID_INDEX;\n            if (e < P.count) {\n                let u = base + edgeSrc[e];\n                let x = base + edgeDst[e];\n                if (atomicLoad(&depthK[u]) == level) {\n                    if (claim(x, next)) { a = x; }\n                    count_paths(u, x, next);\n                }\n                if (UNDIRECTED) {                                    // the other direction of an undirected edge\n                    if (atomicLoad(&depthK[x]) == level) {\n                        if (claim(u, next)) { b = u; }\n                        count_paths(x, u, next);\n                    }\n                }\n            }\n            let mine = select(0u, 1u, a != INVALID_INDEX) + select(0u, 1u, b != INVALID_INDEX);\n            var slot = 0u;\n            if (mine != 0u) { slot = atomicAdd(&wwon, mine); }\n            workgroupBarrier();\n            if (lid.x == 0u) {\n                wbase = atomicAdd(&counters[26], atomicLoad(&wwon));   // stackTop: one global atomic per strip\n                atomicStore(&wwon, 0u);\n            }\n            workgroupBarrier();\n            if (a != INVALID_INDEX) {\n                S[wbase + slot] = a;\n                slot = slot + 1u;\n            }\n            if (b != INVALID_INDEX) { S[wbase + slot] = b; }\n        }\n    }\n}\n";
+//# sourceMappingURL=bc-forward-edge.wgsl.d.ts.map

package/dist/src/wgsl/bc-forward-edge.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc-forward-edge.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/bc-forward-edge.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,m0FA6D7B,CAAC"}

package/dist/src/wgsl/bc-forward-edge.wgsl.js

@@ -0,0 +1,76 @@
+/**
+ * The `bc-forward-edge` kernel body (design 8.4 "the McLaughlin-Bader online switch to the edge-parallel form", 8.8
+ * row 7): one level of a betweenness batch's forward pass, edge-parallel -- every logical edge of the `edgeList` view
+ * for every source of the batch, grid-striding over the edges inside a loop over the k sources. For the edge `(u, x)`
+ * and source `s`, when `depth[s][u]` is the level the edge is relaxed toward `x` with EXACTLY the claim and the count
+ * of `bc-forward` (the pre-check, `atomicMin`, the winner appends `s * n + x` to the same claim log, every arc on a
+ * shortest path adds `sigma[s][u]`, a u32 wrap raises word 27); `UNDIRECTED` relaxes the other direction too, the
+ * edge list holding each undirected edge once. So the two forward bodies are interchangeable level by level and the
+ * backward pass cannot tell which ran. A workgroup does nothing when the level is empty (the done boundary). The
+ * winners of a strip are packed into the log with one global `atomicAdd` per strip; every barrier is in uniform
+ * control flow (the loop bounds are uniforms and the workgroup id). Body only; the sabotage rows of
+ * test/helpers/sabotage.ts are textual edits of it.
+ */
+export const bcForwardEdgeWgsl = /* wgsl */ `
+var<workgroup> wlive: u32;                        // 1 when the level has entries
+var<workgroup> wwon: atomic<u32>;                 // the strip's winners
+var<workgroup> wbase: u32;                        // where the strip's winners go in the log
+
+fn claim(x: u32, next: u32) -> bool {
+    if (atomicLoad(&depthK[x]) != INVALID_INDEX) { return false; }   // the pre-check of design 16.1
+    return atomicMin(&depthK[x], next) == INVALID_INDEX;
+}
+
+fn count_paths(origin: u32, x: u32, next: u32) {
+    if (atomicLoad(&depthK[x]) == next) {                            // every arc on a shortest path adds
+        let add = atomicLoad(&sigmaK[origin]);
+        let old = atomicAdd(&sigmaK[x], add);
+        if (old + add < old) { atomicOr(&counters[27], 1u); }        // the u32 wrap, reported
+    }
+}
+
+@compute @workgroup_size(WG)
+fn bc_forward_edge(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let level = atomicLoad(&counters[11]);
+    if (lid.x == 0u) { wlive = select(0u, 1u, ends[level + 1u] > ends[level]); }
+    if (workgroupUniformLoad(&wlive) == 0u) { return; }              // uniform: nothing below runs on an empty level
+    let next = level + 1u;
+    for (var s = 0u; s < P.k; s = s + 1u) {
+        let base = s * P.n;
+        for (var e0 = group_id(wid) * WG; e0 < P.count; e0 = e0 + P.stride) {   // grid-stride over the edges
+            let e = e0 + lid.x;
+            var a = INVALID_INDEX;                                   // the claims this lane won
+            var b = INVALID_INDEX;
+            if (e < P.count) {
+                let u = base + edgeSrc[e];
+                let x = base + edgeDst[e];
+                if (atomicLoad(&depthK[u]) == level) {
+                    if (claim(x, next)) { a = x; }
+                    count_paths(u, x, next);
+                }
+                if (UNDIRECTED) {                                    // the other direction of an undirected edge
+                    if (atomicLoad(&depthK[x]) == level) {
+                        if (claim(u, next)) { b = u; }
+                        count_paths(x, u, next);
+                    }
+                }
+            }
+            let mine = select(0u, 1u, a != INVALID_INDEX) + select(0u, 1u, b != INVALID_INDEX);
+            var slot = 0u;
+            if (mine != 0u) { slot = atomicAdd(&wwon, mine); }
+            workgroupBarrier();
+            if (lid.x == 0u) {
+                wbase = atomicAdd(&counters[26], atomicLoad(&wwon));   // stackTop: one global atomic per strip
+                atomicStore(&wwon, 0u);
+            }
+            workgroupBarrier();
+            if (a != INVALID_INDEX) {
+                S[wbase + slot] = a;
+                slot = slot + 1u;
+            }
+            if (b != INVALID_INDEX) { S[wbase + slot] = b; }
+        }
+    }
+}
+`;
+//# sourceMappingURL=bc-forward-edge.wgsl.js.map

package/dist/src/wgsl/bc-forward-edge.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc-forward-edge.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/bc-forward-edge.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6D3C,CAAC"}

package/dist/src/wgsl/bc-forward.wgsl.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The `bc-forward` kernel body (design 8.4 "forward pass = BFS with sigma as array<atomic<u32>>", 8.10 "BC forward
+ * (tagged)", 16.1): one level of the tagged multi-source breadth-first search of a betweenness batch. The level's
+ * frontier is the range `S[ends[level] .. ends[level + 1])` of the claim log, every entry a packed `s * n + u`; the
+ * expansion is `closeness-sweep`'s block-mapped strip (each workgroup loads up to `WG` entries, scans their degrees
+ * in workgroup memory, and every lane strips the aggregate by an upper-bound binary search), fused with the claim, so
+ * no edge queue exists.
+ *
+ * For the arc `(u, x)` of the entry `(u, s)`, with `t = s * n + x`: the CLAIM -- a relaxed pre-check that skips the
+ * atomic when `t` is already claimed (design 16.1: a stale "unclaimed" costs one redundant atomic, a stale "claimed"
+ * cannot happen because a claim is never revoked), then `atomicMin(&depthK[t], level + 1)`, the invocation that
+ * observes INVALID_INDEX the unique winner, which appends `t` to the log; and, as a SEPARATE condition, the COUNT:
+ * every arc that reaches `t` at `level + 1` adds `sigma[s][u]` into `sigma[s][x]`, winner or not, which is what makes
+ * sigma the number of shortest paths rather than of claims. The add detects a u32 wrap from `atomicAdd`'s return
+ * value (`old + add < old`) and raises `sigmaOverflow` (counters word 27); the count is never clamped. The winners of
+ * a strip are packed into the log with one workgroup-memory counter and ONE global `atomicAdd` on `stackTop` (word
+ * 26) per strip. Uniformity (spec 3.5 rule 1): the range and the aggregate are `workgroupUniformLoad`s and the strip
+ * loop steps a uniform `p0`, so every barrier is in uniform control flow. The order of the log inside a level is
+ * not deterministic; nothing downstream depends on it (the counts are integers and every dependency is written by
+ * index). Body only; the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
+ */
+export declare const bcForwardWgsl = "\nvar<workgroup> sh: array<u32, WG>;                // the block's degrees, then their inclusive scan\nvar<workgroup> rowStart: array<u32, WG>;          // the first arc of each entry's row\nvar<workgroup> entryOf: array<u32, WG>;           // each entry, s * n + u\nvar<workgroup> wstart: u32;                       // the level's first log index\nvar<workgroup> wcount: u32;                       // the level's entry count\nvar<workgroup> wwon: atomic<u32>;                 // the strip's winners\nvar<workgroup> wbase: u32;                        // where the strip's winners go in the log\n\n@compute @workgroup_size(WG)\nfn bc_forward(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let level = atomicLoad(&counters[11]);\n    if (lid.x == 0u) {\n        let lo = ends[level];\n        wstart = lo;\n        wcount = ends[level + 1u] - lo;\n    }\n    let start = workgroupUniformLoad(&wstart);\n    let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers\n    let next = level + 1u;\n    for (var b0 = group_id(wid) * WG; b0 < count; b0 = b0 + P.stride) {   // grid-stride over blocks of WG entries\n        let i = b0 + lid.x;\n        var deg = 0u;\n        var first = 0u;\n        var entry = 0u;\n        if (i < count) {                                             // guarded loads into locals (3.5 rule 1)\n            entry = S[start + i];\n            let u = entry % P.n;\n            first = rowPtr[u];\n            deg = rowPtr[u + 1u] - first;\n        }\n        sh[lid.x] = deg;\n        rowStart[lid.x] = first;\n        entryOf[lid.x] = entry;\n        workgroupBarrier();\n        for (var s = 1u; s < WG; s = s * 2u) {                       // Hillis-Steele inclusive scan of the degrees\n            var t = 0u;\n            if (lid.x >= s) { t = sh[lid.x - s]; }\n            workgroupBarrier();\n            sh[lid.x] = sh[lid.x] + t;\n            workgroupBarrier();\n        }\n        let aggregate = workgroupUniformLoad(&sh[WG - 1u]);          // uniform; includes a barrier\n        for (var p0 = 0u; p0 < aggregate; p0 = p0 + WG) {            // strip [0, aggregate) WG arcs at a time\n            let p = p0 + lid.x;\n            var won = false;\n            var claimed = 0u;\n            if (p < aggregate) {\n                var lo = 0u;                                         // upper_bound: the first k with sh[k] > p owns arc p\n                var hi = WG;\n                loop {\n                    if (lo >= hi) { break; }\n                    let mid = (lo + hi) / 2u;\n                    if (sh[mid] > p) { hi = mid; } else { lo = mid + 1u; }\n                }\n                let k = lo;\n                var exclusive = 0u;\n                if (k > 0u) { exclusive = sh[k - 1u]; }\n                let origin = entryOf[k];                             // s * n + u\n                let x = (origin - (origin % P.n)) + colIdx[rowStart[k] + (p - exclusive)];   // s * n + x\n                if (atomicLoad(&depthK[x]) == INVALID_INDEX) {       // the pre-check of design 16.1\n                    won = atomicMin(&depthK[x], next) == INVALID_INDEX;   // the claim: the one winner appends\n                }\n                if (atomicLoad(&depthK[x]) == next) {                // the count: EVERY arc on a shortest path adds\n                    let add = atomicLoad(&sigmaK[origin]);\n                    let old = atomicAdd(&sigmaK[x], add);\n                    if (old + add < old) { atomicOr(&counters[27], 1u); }   // the u32 wrap, reported\n                }\n                claimed = x;\n            }\n            var slot = 0u;\n            if (won) { slot = atomicAdd(&wwon, 1u); }\n            workgroupBarrier();\n            if (lid.x == 0u) {\n                wbase = atomicAdd(&counters[26], atomicLoad(&wwon));   // stackTop: one global atomic per strip\n                atomicStore(&wwon, 0u);\n            }\n            workgroupBarrier();\n            if (won) { S[wbase + slot] = claimed; }\n        }\n        workgroupBarrier();                                          // sh, rowStart and entryOf are reused by the next block\n    }\n}\n";
+//# sourceMappingURL=bc-forward.wgsl.d.ts.map

package/dist/src/wgsl/bc-forward.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc-forward.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/bc-forward.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa,+nIAmFzB,CAAC"}

package/dist/src/wgsl/bc-forward.wgsl.js

@@ -0,0 +1,106 @@
+/**
+ * The `bc-forward` kernel body (design 8.4 "forward pass = BFS with sigma as array<atomic<u32>>", 8.10 "BC forward
+ * (tagged)", 16.1): one level of the tagged multi-source breadth-first search of a betweenness batch. The level's
+ * frontier is the range `S[ends[level] .. ends[level + 1])` of the claim log, every entry a packed `s * n + u`; the
+ * expansion is `closeness-sweep`'s block-mapped strip (each workgroup loads up to `WG` entries, scans their degrees
+ * in workgroup memory, and every lane strips the aggregate by an upper-bound binary search), fused with the claim, so
+ * no edge queue exists.
+ *
+ * For the arc `(u, x)` of the entry `(u, s)`, with `t = s * n + x`: the CLAIM -- a relaxed pre-check that skips the
+ * atomic when `t` is already claimed (design 16.1: a stale "unclaimed" costs one redundant atomic, a stale "claimed"
+ * cannot happen because a claim is never revoked), then `atomicMin(&depthK[t], level + 1)`, the invocation that
+ * observes INVALID_INDEX the unique winner, which appends `t` to the log; and, as a SEPARATE condition, the COUNT:
+ * every arc that reaches `t` at `level + 1` adds `sigma[s][u]` into `sigma[s][x]`, winner or not, which is what makes
+ * sigma the number of shortest paths rather than of claims. The add detects a u32 wrap from `atomicAdd`'s return
+ * value (`old + add < old`) and raises `sigmaOverflow` (counters word 27); the count is never clamped. The winners of
+ * a strip are packed into the log with one workgroup-memory counter and ONE global `atomicAdd` on `stackTop` (word
+ * 26) per strip. Uniformity (spec 3.5 rule 1): the range and the aggregate are `workgroupUniformLoad`s and the strip
+ * loop steps a uniform `p0`, so every barrier is in uniform control flow. The order of the log inside a level is
+ * not deterministic; nothing downstream depends on it (the counts are integers and every dependency is written by
+ * index). Body only; the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
+ */
+export const bcForwardWgsl = /* wgsl */ `
+var<workgroup> sh: array<u32, WG>;                // the block's degrees, then their inclusive scan
+var<workgroup> rowStart: array<u32, WG>;          // the first arc of each entry's row
+var<workgroup> entryOf: array<u32, WG>;           // each entry, s * n + u
+var<workgroup> wstart: u32;                       // the level's first log index
+var<workgroup> wcount: u32;                       // the level's entry count
+var<workgroup> wwon: atomic<u32>;                 // the strip's winners
+var<workgroup> wbase: u32;                        // where the strip's winners go in the log
+
+@compute @workgroup_size(WG)
+fn bc_forward(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let level = atomicLoad(&counters[11]);
+    if (lid.x == 0u) {
+        let lo = ends[level];
+        wstart = lo;
+        wcount = ends[level + 1u] - lo;
+    }
+    let start = workgroupUniformLoad(&wstart);
+    let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers
+    let next = level + 1u;
+    for (var b0 = group_id(wid) * WG; b0 < count; b0 = b0 + P.stride) {   // grid-stride over blocks of WG entries
+        let i = b0 + lid.x;
+        var deg = 0u;
+        var first = 0u;
+        var entry = 0u;
+        if (i < count) {                                             // guarded loads into locals (3.5 rule 1)
+            entry = S[start + i];
+            let u = entry % P.n;
+            first = rowPtr[u];
+            deg = rowPtr[u + 1u] - first;
+        }
+        sh[lid.x] = deg;
+        rowStart[lid.x] = first;
+        entryOf[lid.x] = entry;
+        workgroupBarrier();
+        for (var s = 1u; s < WG; s = s * 2u) {                       // Hillis-Steele inclusive scan of the degrees
+            var t = 0u;
+            if (lid.x >= s) { t = sh[lid.x - s]; }
+            workgroupBarrier();
+            sh[lid.x] = sh[lid.x] + t;
+            workgroupBarrier();
+        }
+        let aggregate = workgroupUniformLoad(&sh[WG - 1u]);          // uniform; includes a barrier
+        for (var p0 = 0u; p0 < aggregate; p0 = p0 + WG) {            // strip [0, aggregate) WG arcs at a time
+            let p = p0 + lid.x;
+            var won = false;
+            var claimed = 0u;
+            if (p < aggregate) {
+                var lo = 0u;                                         // upper_bound: the first k with sh[k] > p owns arc p
+                var hi = WG;
+                loop {
+                    if (lo >= hi) { break; }
+                    let mid = (lo + hi) / 2u;
+                    if (sh[mid] > p) { hi = mid; } else { lo = mid + 1u; }
+                }
+                let k = lo;
+                var exclusive = 0u;
+                if (k > 0u) { exclusive = sh[k - 1u]; }
+                let origin = entryOf[k];                             // s * n + u
+                let x = (origin - (origin % P.n)) + colIdx[rowStart[k] + (p - exclusive)];   // s * n + x
+                if (atomicLoad(&depthK[x]) == INVALID_INDEX) {       // the pre-check of design 16.1
+                    won = atomicMin(&depthK[x], next) == INVALID_INDEX;   // the claim: the one winner appends
+                }
+                if (atomicLoad(&depthK[x]) == next) {                // the count: EVERY arc on a shortest path adds
+                    let add = atomicLoad(&sigmaK[origin]);
+                    let old = atomicAdd(&sigmaK[x], add);
+                    if (old + add < old) { atomicOr(&counters[27], 1u); }   // the u32 wrap, reported
+                }
+                claimed = x;
+            }
+            var slot = 0u;
+            if (won) { slot = atomicAdd(&wwon, 1u); }
+            workgroupBarrier();
+            if (lid.x == 0u) {
+                wbase = atomicAdd(&counters[26], atomicLoad(&wwon));   // stackTop: one global atomic per strip
+                atomicStore(&wwon, 0u);
+            }
+            workgroupBarrier();
+            if (won) { S[wbase + slot] = claimed; }
+        }
+        workgroupBarrier();                                          // sh, rowStart and entryOf are reused by the next block
+    }
+}
+`;
+//# sourceMappingURL=bc-forward.wgsl.js.map

package/dist/src/wgsl/bc-forward.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc-forward.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/bc-forward.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFvC,CAAC"}

package/dist/src/wgsl/bc-gather.wgsl.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The `bc-gather` kernel body (design 8.4 "one gather kernel after the batch's last backward level", 8.10 "BC
+ * gather"): one invocation per vertex `w`, `bc[w] += delta[0][w] + ... + delta[k - 1][w]` in source order -- k reads,
+ * one write, no atomic, a fixed summation order, so the scores are bitwise reproducible across runs and adapters.
+ * A source's own dependency is 0 (the backward pass never visits depth 0), so nothing is skipped here. Grid-stride
+ * loop (`P.stride`). Body only; the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
+ */
+export declare const bcGatherWgsl = "\n@compute @workgroup_size(WG)\nfn bc_gather(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    for (var w = linear_id(wid, lid.x); w < P.n; w = w + P.stride) {\n        var acc = bc[w];\n        for (var s = 0u; s < P.k; s = s + 1u) {\n            acc = acc + deltaK[s * P.n + w];\n        }\n        bc[w] = acc;\n    }\n}\n";
+//# sourceMappingURL=bc-gather.wgsl.d.ts.map

package/dist/src/wgsl/bc-gather.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc-gather.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/bc-gather.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,oXAWxB,CAAC"}

package/dist/src/wgsl/bc-gather.wgsl.js

@@ -0,0 +1,20 @@
+/**
+ * The `bc-gather` kernel body (design 8.4 "one gather kernel after the batch's last backward level", 8.10 "BC
+ * gather"): one invocation per vertex `w`, `bc[w] += delta[0][w] + ... + delta[k - 1][w]` in source order -- k reads,
+ * one write, no atomic, a fixed summation order, so the scores are bitwise reproducible across runs and adapters.
+ * A source's own dependency is 0 (the backward pass never visits depth 0), so nothing is skipped here. Grid-stride
+ * loop (`P.stride`). Body only; the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
+ */
+export const bcGatherWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn bc_gather(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    for (var w = linear_id(wid, lid.x); w < P.n; w = w + P.stride) {
+        var acc = bc[w];
+        for (var s = 0u; s < P.k; s = s + 1u) {
+            acc = acc + deltaK[s * P.n + w];
+        }
+        bc[w] = acc;
+    }
+}
+`;
+//# sourceMappingURL=bc-gather.wgsl.js.map

package/dist/src/wgsl/bc-gather.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bc-gather.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/bc-gather.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC;;;;;;;;;;;CAWtC,CAAC"}

package/dist/src/wgsl/closeness-reduce.wgsl.d.ts

@@ -10,8 +10,11 @@
  * level 0's parity is 0), `flags[source_s] = 1` (level 0's `compact` turns the flags into the list; a seeded list
  * would be overwritten by a compaction of all-zero flags), `counters[0] = k` (not done) and `level = U32_MAX` (so
  * level 0's boundary accumulates nothing and brings the word to 0, and level 1's counts the distance-1 claims at 1).
+ * Role 2 is role 1 for a sampled run: source `s` of the batch is word `P.source + s` of the source list the host
+ * wrote after the per-node sums (`perSource[128 + P.bitsBase + ...]`), `P.n` is the list's length, and a node listed
+ * twice in one batch carries both bits (the seed ORs, so a duplicate runs twice).
  * No barrier follows the early return of the other lanes (3.5 rule 1). Body only (spec 3.5, D9); the text is
  * normative: the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
  */
-export declare const closenessReduceWgsl = "\n@compute @workgroup_size(WG)\nfn closeness_reduce(@builtin(local_invocation_id) lid: vec3<u32>) {\n    if (lid.x != 0u) { return; }                                     // one lane; no barrier follows (3.5 rule 1)\n    if (P.role == 1u) {                                              // the seed of a batch: P.source is its first source\n        let k = min(32u, P.n - P.source);\n        for (var s = 0u; s < k; s = s + 1u) {\n            let v = P.source + s;\n            let bit = 1u << s;\n            bits[v] = bit;                                           // visited\n            bits[P.bitsBase + v] = bit;                              // the frontier level 0 reads (region 1: level 0's parity is 0)\n            bits[3u * P.bitsBase + v] = 1u;                          // flags: level 0's compact turns them into the list\n        }\n        atomicStore(&counters[0], k);                                // not done\n        atomicStore(&counters[11], U32_MAX);                         // level: the first boundary brings it to 0\n        atomicStore(&counters[15], 0u);                              // done\n        return;\n    }\n    // role 0: the level boundary -- done from the previous level's compacted count, then the accumulation\n    let count = atomicLoad(&counters[0]);\n    atomicStore(&counters[15], select(0u, 1u, count == 0u));\n    let level = atomicLoad(&counters[11]);\n    let d = level + 1u;                                              // the distance of the claims the level just run made\n    for (var s = 0u; s < 32u; s = s + 1u) {\n        let c = atomicLoad(&perSource[s]);                           // newCount[s]\n        atomicStore(&perSource[32u + s], atomicLoad(&perSource[32u + s]) + c);   // reached[s]\n        // sum[s] += c x d in 64 bits: the 16-bit split product (pLo, pHi), then the add with its carry\n        let cLo = c & 0xFFFFu;\n        let cHi = c >> 16u;\n        let dLo = d & 0xFFFFu;\n        let dHi = d >> 16u;\n        let ll = cLo * dLo;\n        let lh = cLo * dHi;\n        let hl = cHi * dLo;\n        let mid = (ll >> 16u) + (lh & 0xFFFFu) + (hl & 0xFFFFu);\n        let pLo = (ll & 0xFFFFu) | ((mid & 0xFFFFu) << 16u);\n        let pHi = (cHi * dHi) + (lh >> 16u) + (hl >> 16u) + (mid >> 16u);\n        var lo = atomicLoad(&perSource[64u + s]);                    // sumLo[s]\n        var hi = atomicLoad(&perSource[96u + s]);                    // sumHi[s]\n        let before = lo;\n        lo = lo + pLo;\n        hi = hi + pHi + select(0u, 1u, lo < before);\n        atomicStore(&perSource[64u + s], lo);\n        atomicStore(&perSource[96u + s], hi);\n        atomicStore(&perSource[s], 0u);\n    }\n    atomicStore(&counters[11], level + 1u);\n}\n";
+export declare const closenessReduceWgsl = "\n@compute @workgroup_size(WG)\nfn closeness_reduce(@builtin(local_invocation_id) lid: vec3<u32>) {\n    if (lid.x != 0u) { return; }                                     // one lane; no barrier follows (3.5 rule 1)\n    if (P.role != 0u) {                                              // the seed of a batch: P.source is its first source\n        let k = min(32u, P.n - P.source);\n        for (var s = 0u; s < k; s = s + 1u) {\n            var v = P.source + s;\n            if (P.role == 2u) { v = atomicLoad(&perSource[128u + P.bitsBase + P.source + s]); }   // a sampled run's list\n            let bit = 1u << s;\n            bits[v] = bits[v] | bit;                                 // visited\n            bits[P.bitsBase + v] = bits[P.bitsBase + v] | bit;       // the frontier level 0 reads (region 1: level 0's parity is 0)\n            bits[3u * P.bitsBase + v] = 1u;                          // flags: level 0's compact turns them into the list\n        }\n        atomicStore(&counters[0], k);                                // not done\n        atomicStore(&counters[11], U32_MAX);                         // level: the first boundary brings it to 0\n        atomicStore(&counters[15], 0u);                              // done\n        return;\n    }\n    // role 0: the level boundary -- done from the previous level's compacted count, then the accumulation\n    let count = atomicLoad(&counters[0]);\n    atomicStore(&counters[15], select(0u, 1u, count == 0u));\n    let level = atomicLoad(&counters[11]);\n    let d = level + 1u;                                              // the distance of the claims the level just run made\n    for (var s = 0u; s < 32u; s = s + 1u) {\n        let c = atomicLoad(&perSource[s]);                           // newCount[s]\n        atomicStore(&perSource[32u + s], atomicLoad(&perSource[32u + s]) + c);   // reached[s]\n        // sum[s] += c x d in 64 bits: the 16-bit split product (pLo, pHi), then the add with its carry\n        let cLo = c & 0xFFFFu;\n        let cHi = c >> 16u;\n        let dLo = d & 0xFFFFu;\n        let dHi = d >> 16u;\n        let ll = cLo * dLo;\n        let lh = cLo * dHi;\n        let hl = cHi * dLo;\n        let mid = (ll >> 16u) + (lh & 0xFFFFu) + (hl & 0xFFFFu);\n        let pLo = (ll & 0xFFFFu) | ((mid & 0xFFFFu) << 16u);\n        let pHi = (cHi * dHi) + (lh >> 16u) + (hl >> 16u) + (mid >> 16u);\n        var lo = atomicLoad(&perSource[64u + s]);                    // sumLo[s]\n        var hi = atomicLoad(&perSource[96u + s]);                    // sumHi[s]\n        let before = lo;\n        lo = lo + pLo;\n        hi = hi + pHi + select(0u, 1u, lo < before);\n        atomicStore(&perSource[64u + s], lo);\n        atomicStore(&perSource[96u + s], hi);\n        atomicStore(&perSource[s], 0u);\n    }\n    atomicStore(&counters[11], level + 1u);\n}\n";
 //# sourceMappingURL=closeness-reduce.wgsl.d.ts.map

package/dist/src/wgsl/closeness-reduce.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"closeness-reduce.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/closeness-reduce.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,0qFAgD/B,CAAC"}
+{"version":3,"file":"closeness-reduce.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/closeness-reduce.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB,qyFAiD/B,CAAC"}

package/dist/src/wgsl/closeness-reduce.wgsl.js

@@ -10,6 +10,9 @@
  * level 0's parity is 0), `flags[source_s] = 1` (level 0's `compact` turns the flags into the list; a seeded list
  * would be overwritten by a compaction of all-zero flags), `counters[0] = k` (not done) and `level = U32_MAX` (so
  * level 0's boundary accumulates nothing and brings the word to 0, and level 1's counts the distance-1 claims at 1).
+ * Role 2 is role 1 for a sampled run: source `s` of the batch is word `P.source + s` of the source list the host
+ * wrote after the per-node sums (`perSource[128 + P.bitsBase + ...]`), `P.n` is the list's length, and a node listed
+ * twice in one batch carries both bits (the seed ORs, so a duplicate runs twice).
  * No barrier follows the early return of the other lanes (3.5 rule 1). Body only (spec 3.5, D9); the text is
  * normative: the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
  */
@@ -17,13 +20,14 @@ export 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
+    if (P.role != 0u) {                                              // the seed of a batch: P.source is its first source
         let k = min(32u, P.n - P.source);
         for (var s = 0u; s < k; s = s + 1u) {
-            let v = P.source + s;
+            var v = P.source + s;
+            if (P.role == 2u) { v = atomicLoad(&perSource[128u + P.bitsBase + P.source + s]); }   // a sampled run's list
             let bit = 1u << s;
-            bits[v] = bit;                                           // visited
-            bits[P.bitsBase + v] = bit;                              // the frontier level 0 reads (region 1: level 0's parity is 0)
+            bits[v] = bits[v] | bit;                                 // visited
+            bits[P.bitsBase + v] = bits[P.bitsBase + v] | bit;       // the frontier level 0 reads (region 1: level 0's parity is 0)
             bits[3u * P.bitsBase + v] = 1u;                          // flags: level 0's compact turns them into the list
         }
         atomicStore(&counters[0], k);                                // not done