@graphty/webgpu-graph-algorithms 0.6.13 → 0.6.15

package/src/algorithms/closeness.ts

@@ -23,6 +23,11 @@
  * seam's placeholder keys and an exact traversal has neither, so a defined value is REFUSED before any device work
  * (`E_UNSUPPORTED { option }`, the package's rule for an option it does not implement, PD-25); `undefined` is legal.
  * `iterations` reports the source batches run (the sources, on the weighted route), `converged` is always true.
+ * A SAMPLED run (`sources`, issue #426; undirected snapshots only) seeds its batches from the listed sources (the
+ * reduce's role 2 reads the list the host wrote after the per-node sums in `perSource`), and the sweep also adds each
+ * claim's distance into a per-node sum (`perNode`), read back with every submit and folded on the host in f64 into
+ * `1 / sum` per NODE, where the exact run folds per SOURCE: on an undirected graph the distance from a source to a node
+ * is the distance from the node to the source, which is what the CPU port's sampled closeness sums.
  *
  * Cost, stated so nobody is surprised: closeness is O(n x m) on any device -- at 1M nodes it is 31,250 batches of a
  * full multi-source traversal, minutes on the card, and no target in design 10.4 asks for less. `compact.record`
@@ -54,8 +59,8 @@ import { assertWholeCore } from "../primitives/core-shape.js";
 import { W } from "../primitives/frontier.js";
 import { type ReduceScope } from "../primitives/reduce.js";
 import { assertDeviceComputes } from "../primitives/verify.js";
-import { type HitsOptionsLike } from "../types/accelerator.js";
-import { type GpuScoresResult } from "../types/algorithms.js";
+import { type ClosenessAcceleratorOptions, type HitsOptionsLike } from "../types/accelerator.js";
+import { type GpuClosenessResult } from "../types/algorithms.js";
 import { type Binding } from "../types/memory.js";
 import { type GpuRunOptions } from "../types/run.js";
 import { algorithmScope } from "./scope.js";
@@ -116,10 +121,12 @@ function reusingScratch(scope: ReduceScope): ReduceScope {
 }
 
 /**
- * The weighted route: one `sssp` per source, the sums reduced on the host.
+ * The weighted route: one `sssp` per source, the sums reduced on the host. With `sources` (a sampled run on an
+ * undirected snapshot) each search adds its distances into the sums of the nodes it reaches instead of its own.
  * @param ctx - the context
  * @param s - the snapshot
  * @param scores - the destination
+ * @param sources - a sampled run's sources, or null for every node
  * @param options - the run options
  * @returns the result
  */
@@ -127,25 +134,40 @@ async function weightedRoute(
     ctx: GpuContext,
     s: GraphSnapshot,
     scores: F32,
+    sources: readonly number[] | null,
     options: GpuRunOptions | undefined,
-): Promise<GpuScoresResult> {
+): Promise<GpuClosenessResult> {
     const n = s.nodeCount;
-    for (let source = 0; source < n; source++) {
+    const count = sources?.length ?? n;
+    const totals = sources === null ? null : new Float64Array(n);
+    for (let i = 0; i < count; i++) {
         if (options?.signal?.aborted) {
             throw aborted(ALGORITHM);
         }
+        const source = sources === null ? i : sources[i];
         const { dist } = await sssp(ctx, s, source, { signal: options?.signal });
         let sum = 0;
         for (let v = 0; v < n; v++) {
             const d = dist[v];
             if (v !== source && d !== Infinity) {
-                sum += d;
+                if (totals === null) {
+                    sum += d;
+                } else {
+                    totals[v] += d;
+                }
             }
         }
-        scores[source] = sum === 0 ? 0 : 1 / sum;
-        options?.onProgress?.(source + 1, n);
+        if (totals === null) {
+            scores[source] = sum === 0 ? 0 : 1 / sum;
+        }
+        options?.onProgress?.(i + 1, count);
+    }
+    if (totals !== null) {
+        totals.forEach((sum, v) => {
+            scores[v] = sum === 0 ? 0 : 1 / sum;
+        });
     }
-    return { scores, iterations: n, converged: true, precision: "f32" };
+    return { scores, iterations: count, converged: true, precision: "f32", sourcesUsed: count };
 }
 
 /**
@@ -153,6 +175,7 @@ async function weightedRoute(
  * @param ctx - the context
  * @param s - the snapshot
  * @param scores - the destination
+ * @param sources - a sampled run's sources, or null for every node
  * @param levelsPerSubmit - the submit cadence
  * @param options - the run options
  * @param tuning - the knobs
@@ -162,13 +185,15 @@ async function sweepRoute(
     ctx: GpuContext,
     s: GraphSnapshot,
     scores: F32,
+    sources: readonly number[] | null,
     levelsPerSubmit: number,
     options: GpuRunOptions | undefined,
     tuning: ClosenessTuning,
-): Promise<GpuScoresResult> {
+): Promise<GpuClosenessResult> {
     const n = s.nodeCount;
-    if (n === 0) {
-        return { scores, iterations: 0, converged: true, precision: "f32" };
+    const seedCount = sources?.length ?? n;
+    if (seedCount === 0) {
+        return { scores, iterations: 0, converged: true, precision: "f32", sourcesUsed: 0 };
     }
     const core = ctx.residency.core(s);
     assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM);
@@ -195,7 +220,18 @@ async function sweepRoute(
             FRONTIER_COUNTERS.byteLength,
         );
         const perSourceBytes = 4 * PER_SOURCE_WORDS;
-        const perSource = bindingOf(scope.scratch(perSourceBytes, "per-source"), perSourceBytes);
+        // a sampled run appends the per-node distance sums (bitsBase words) and then its source list
+        const zeroedWords = PER_SOURCE_WORDS + (sources === null ? 0 : bitsBase);
+        const perSourceAll = 4 * (zeroedWords + (sources === null ? 0 : sources.length));
+        const perSource = bindingOf(scope.scratch(perSourceAll, "per-source"), perSourceAll);
+        if (sources !== null) {
+            ctx.device.queue.writeBuffer(
+                perSource.buffer,
+                perSource.offset + 4 * zeroedWords,
+                Uint32Array.from(sources),
+            );
+        }
+        const totals = sources === null ? null : new Float64Array(n);
         await ctx.allocator.check();
         const compact = await prepareCompact(reusingScratch(scope));
         const sweep = await ctx.pipelines.kernel(kernelSpec("closeness-sweep", graphOverrides(core, null)));
@@ -222,7 +258,7 @@ async function sweepRoute(
         ctx.assertReady();
 
         let batches = 0;
-        for (let batchStart = 0; batchStart < n; batchStart += SOURCES_PER_BATCH) {
+        for (let batchStart = 0; batchStart < seedCount; batchStart += SOURCES_PER_BATCH) {
             let level = 0;
             for (let first = true; ; first = false) {
                 const batch = new CommandBatch(ctx, `${ALGORITHM}/levels`);
@@ -231,8 +267,13 @@ async function sweepRoute(
                     // the batch's seed: the four regions and the block zeroed, then role 1 (the sources' bits, their
                     // flags, counters[0] = k, level = U32_MAX)
                     recordFill(pass, bits, 4 * bitsBase, 0);
-                    recordFill(pass, perSource, PER_SOURCE_WORDS, 0);
-                    const seed = scope.params(FRONTIER_PARAMS, { role: 1, n, bitsBase, source: batchStart });
+                    recordFill(pass, perSource, zeroedWords, 0);
+                    const seed = scope.params(FRONTIER_PARAMS, {
+                        role: sources === null ? 1 : 2,
+                        n: seedCount,
+                        bitsBase,
+                        source: batchStart,
+                    });
                     reduce.dispatch(pass, reduce.bind({ counters, perSource, bits, P: seed.binding }), onePlan, [
                         seed.offset,
                     ]);
@@ -253,6 +294,7 @@ async function sweepRoute(
                         arcEnd: s.arcCount,
                         mode,
                         stride: sweepPlan.stride ?? wg,
+                        perNode: sources === null ? 0 : 1,
                     });
                     return {
                         bound: sweep.bind({ ...graph, frontierList, counters, bits, perSource, P: params.binding }),
@@ -277,6 +319,8 @@ async function sweepRoute(
                 batch.endPass();
                 const doneRequest = batch.readback(counters.buffer, counters.offset + 4 * W.done, 4);
                 const blockRequest = batch.readback(perSource.buffer, perSource.offset, perSourceBytes);
+                const nodeRequest =
+                    totals === null ? null : batch.readback(perSource.buffer, perSource.offset + perSourceBytes, 4 * n);
                 const submitted = submit(batch);
                 const back = await submitted.readback;
                 ctx.assertReady();
@@ -285,10 +329,18 @@ async function sweepRoute(
                 }
                 if (new Uint32Array(back, doneRequest.offset, 1)[0] !== 0) {
                     const block = new Uint32Array(back, blockRequest.offset, PER_SOURCE_WORDS);
-                    const count = Math.min(SOURCES_PER_BATCH, n - batchStart);
-                    for (let i = 0; i < count; i++) {
-                        const sum = block[3 * SOURCES_PER_BATCH + i] * 2 ** 32 + block[2 * SOURCES_PER_BATCH + i];
-                        scores[batchStart + i] = sum === 0 ? 0 : 1 / sum;
+                    if (totals === null || nodeRequest === null) {
+                        const count = Math.min(SOURCES_PER_BATCH, n - batchStart);
+                        for (let i = 0; i < count; i++) {
+                            const sum = block[3 * SOURCES_PER_BATCH + i] * 2 ** 32 + block[2 * SOURCES_PER_BATCH + i];
+                            scores[batchStart + i] = sum === 0 ? 0 : 1 / sum;
+                        }
+                    } else {
+                        // at most 32 (n - 1) per node per batch, so a u32 word never wraps below 134M nodes
+                        const sums = new Uint32Array(back, nodeRequest.offset, n);
+                        for (let v = 0; v < n; v++) {
+                            totals[v] += sums[v];
+                        }
                     }
                     tuning.onBatch?.(batchStart, block.slice());
                     break;
@@ -303,29 +355,63 @@ async function sweepRoute(
                 }
             }
             batches += 1;
-            options?.onProgress?.(Math.min(batchStart + SOURCES_PER_BATCH, n), n);
+            options?.onProgress?.(Math.min(batchStart + SOURCES_PER_BATCH, seedCount), seedCount);
         }
-        return { scores, iterations: batches, converged: true, precision: "f32" };
+        totals?.forEach((sum, v) => {
+            scores[v] = sum === 0 ? 0 : 1 / sum;
+        });
+        return { scores, iterations: batches, converged: true, precision: "f32", sourcesUsed: seedCount };
     } finally {
         scope.dispose();
     }
 }
 
+/**
+ * A sampled run's sources, checked: node indices of `s`, on an undirected snapshot only.
+ * @param s - the snapshot
+ * @param sources - the caller's list, or undefined for every node
+ * @returns the list, or null for every node
+ * @throws WebGpuGraphError E_INVALID_ARGUMENT for an index outside the snapshot, E_UNSUPPORTED on a directed snapshot
+ */
+function checkSources(s: GraphSnapshot, sources: readonly number[] | undefined): readonly number[] | null {
+    if (sources === undefined) {
+        return null;
+    }
+    if (s.directed) {
+        // a search FROM a source measures distance to the nodes it reaches, which is the distance FROM them to the
+        // source only when every edge runs both ways
+        throw new WebGpuGraphError("E_UNSUPPORTED", `${ALGORITHM}: sampled sources need an undirected snapshot`, {
+            feature: "closenessCentrality.directedSources",
+            hint: "run the CPU port, which searches the in-arcs",
+        });
+    }
+    for (const v of sources) {
+        if (!Number.isInteger(v) || v < 0 || v >= s.nodeCount) {
+            throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM}: a source is not a node index`, {
+                argument: "sources",
+                value: v,
+                expected: `an integer in [0, ${s.nodeCount})`,
+            });
+        }
+    }
+    return sources;
+}
+
 /**
  * Closeness with the test knobs of PD-26's shape; `closenessCentrality` is this with an empty tuning.
  * @internal
  * @param ctx - the context whose device runs the kernels
  * @param s - the snapshot (uploaded through ctx.residency, or found there)
- * @param options - the seam's `HitsOptionsLike` (`weighted` honoured, the other two refused when defined), plus dest / signal / onProgress
+ * @param options - `weighted` and a sampled run's `sources` honoured, the placeholder `maxIterations` / `tolerance` refused when defined, plus dest / signal / onProgress
  * @param tuning - the knobs
- * @returns the scores, the batches run, `converged: true` and `precision: "f32"`
+ * @returns the scores, the batches run, `converged: true`, `precision: "f32"` and `sourcesUsed`
  */
 export async function closenessWithTuning(
     ctx: GpuContext,
     s: GraphSnapshot,
-    options: (HitsOptionsLike & GpuRunOptions) | undefined,
+    options: (ClosenessAcceleratorOptions & HitsOptionsLike & GpuRunOptions) | undefined,
     tuning: ClosenessTuning,
-): Promise<GpuScoresResult> {
+): Promise<GpuClosenessResult> {
     ctx.assertReady();
     await assertDeviceComputes(ctx);
     for (const key of ["maxIterations", "tolerance"] as const) {
@@ -337,6 +423,7 @@ export async function closenessWithTuning(
         }
     }
     const n = s.nodeCount;
+    const sources = checkSources(s, options?.sources);
     const levelsPerSubmit = tuning.levelsPerSubmit ?? MAX_LEVELS_PER_SUBMIT;
     if (!Number.isInteger(levelsPerSubmit) || levelsPerSubmit < 1 || levelsPerSubmit > MAX_LEVELS_PER_SUBMIT) {
         throw new WebGpuGraphError(
@@ -370,9 +457,9 @@ export async function closenessWithTuning(
                 feature: "closenessCentrality.nonFiniteWeights",
             });
         }
-        return weightedRoute(ctx, s, scores, options);
+        return weightedRoute(ctx, s, scores, sources, options);
     }
-    return sweepRoute(ctx, s, scores, levelsPerSubmit, options, tuning);
+    return sweepRoute(ctx, s, scores, sources, levelsPerSubmit, options, tuning);
 }
 
 /**
@@ -381,15 +468,20 @@ export async function closenessWithTuning(
  * `closenessCentrality`, unweighted by one bit-parallel multi-source search per 32 sources, weighted by one `sssp`
  * per source; `weighted` defaults to the snapshot's flag, `maxIterations` / `tolerance` are refused when defined
  * (PD-25). `iterations` is the source batches run and `converged` is always true.
+ *
+ * SAMPLED (`sources`, node indices, duplicates run twice; undirected snapshots only, E_UNSUPPORTED
+ * `closenessCentrality.directedSources` otherwise): the batches seed the listed sources instead of every node, and
+ * each node's score is `1 / sum` of its distances to the sources that reach it (itself excluded), `0` when none does:
+ * the sampled score of the CPU port, unscaled. `sourcesUsed` is the list's length (`n` exact).
  * @param ctx - the context whose device runs the kernels
  * @param s - the snapshot (uploaded through ctx.residency, or found there)
- * @param options - the seam's `HitsOptionsLike`, plus dest (a Float32Array of length n for `scores`) / signal / onProgress
- * @returns the scores, the batches run, `converged: true` and `precision: "f32"`
+ * @param options - `weighted`, `sources`, plus dest (a Float32Array of length n for `scores`) / signal / onProgress
+ * @returns the scores, the batches run, `converged: true`, `precision: "f32"` and `sourcesUsed`
  */
 export function closenessCentrality(
     ctx: GpuContext,
     s: GraphSnapshot,
-    options?: HitsOptionsLike & GpuRunOptions,
-): Promise<GpuScoresResult> {
+    options?: ClosenessAcceleratorOptions & HitsOptionsLike & GpuRunOptions,
+): Promise<GpuClosenessResult> {
     return closenessWithTuning(ctx, s, options, {});
 }

package/src/constants.ts

@@ -259,3 +259,11 @@ export const BEAMER_BETA = 24;
 export const SSSP_DELTA_FACTOR = 32;
 /** The bit pattern of +Infinity, the unreached sentinel of `dist` (P8 PD-9); interpolated into the prelude as `F32_INF_BITS` so no body types the literal. */
 export const F32_INF_BITS = 0x7f800000;
+/** Design 8.4 "k planned from maxBufferSize and a 25% budget": the share of `maxBufferSize` one betweenness source batch may hold. WebGPU exposes no device memory size, so this is a fraction of the largest buffer, not a memory measurement. */
+export const BC_BATCH_BUDGET_FRACTION = 0.25;
+/** Design 10.1's betweenness column: the most sources one betweenness batch runs together. */
+export const BC_MAX_BATCH = 64;
+/** Design 8.4 (McLaughlin-Bader): a betweenness batch runs the edge-parallel forward pass when the previous batch's level count is below `BC_EDGE_PARALLEL_GAMMA * log2(n)`. The design names the rule and no value; 2 is unmeasured and a benchmark run re-fixes it. */
+export const BC_EDGE_PARALLEL_GAMMA = 2;
+/** Backward-pass levels recorded per submit: each level is one dispatch with its own parameter record, so this bounds the uniform ring. */
+export const BC_BACKWARD_LEVELS_PER_SUBMIT = 64;

package/src/index.ts

@@ -57,6 +57,7 @@ export { eigenvectorCentrality, hits, katzCentrality } from "./algorithms/spectr
 
 // ==================== algorithms (P8: the frontier family, spec 3.3 lines 807-810, 8.4; the seam's option types in)
 export { bellmanFord } from "./algorithms/bellman-ford.js";
+export { betweennessCentrality, edgeBetweennessCentrality } from "./algorithms/betweenness.js";
 export { breadthFirstSearch } from "./algorithms/bfs.js";
 export { closenessCentrality } from "./algorithms/closeness.js";
 export { sssp } from "./algorithms/sssp.js";
@@ -79,6 +80,8 @@ export type {
     BetweennessAcceleratorOptions,
     BfsOptions,
     BfsResultLike,
+    ClosenessAcceleratorOptions,
+    ClosenessResultLike,
     CommunityResultLike,
     CorenessResultLike,
     EdgeScoresResultLike,
@@ -99,10 +102,15 @@ export type {
 // BfsOptions / SsspOptions / HitsOptionsLike above (P8 PD-19)
 export type { GpuBellmanFordResult, GpuBfsResult, GpuSsspResult } from "./types/traversal.js";
 
+// ==================== types: the betweenness results (spec 3.3 lines 833-834); the option type is the seam's
+// BetweennessAcceleratorOptions above
+export type { GpuBetweennessResult, GpuEdgeScoresResult } from "./types/betweenness.js";
+
 // ==================== types: the P7 algorithm results and option records (spec 3.3 lines 815-828, 9.7)
 export type {
     ComponentsOptions,
     EigenvectorOptions,
+    GpuClosenessResult,
     GpuHitsResult,
     GpuLabelResult,
     GpuPageRankResult,

package/src/kernels.ts

@@ -12,7 +12,8 @@
  * dedupe-claim and dedupe-filter; P8-T4 adds frontier-finalize with the FrontierCounters and FrontierParams blocks;
  * P8-T5 adds advance-expand; P8-T6 adds bfs-contract and sssp-pred; P8-T7 adds bfs-fused; P8-T8 adds bfs-bottom-up,
  * bfs-bitset-build and bfs-unvisited-flags; P8-T9 adds sssp-relax; P8-T10 adds bf-relax with the BfParams and BfFlags
- * blocks; P8-T11 adds closeness-sweep and closeness-reduce. This file is the only importer of src/wgsl/** (spec 3.2;
+ * blocks; P8-T11 adds closeness-sweep and closeness-reduce; P9 (betweenness) adds bc-finalize, bc-forward,
+ * bc-backward, bc-gather, bc-edge-gather and bc-forward-edge with the BcParams block. This file is the only importer of src/wgsl/** (spec 3.2;
  * test/layers.test.ts).
  */
 
@@ -23,6 +24,12 @@ import { type BindingDecl, type OverrideDecl, type WgslModuleSpec } from "./kern
 import { type CoreBinding } from "./memory/residency.js";
 import { type Binding } from "./types/memory.js";
 import { advanceExpandWgsl } from "./wgsl/advance-expand.wgsl.js";
+import { bcBackwardWgsl } from "./wgsl/bc-backward.wgsl.js";
+import { bcEdgeGatherWgsl } from "./wgsl/bc-edge-gather.wgsl.js";
+import { bcFinalizeWgsl } from "./wgsl/bc-finalize.wgsl.js";
+import { bcForwardWgsl } from "./wgsl/bc-forward.wgsl.js";
+import { bcForwardEdgeWgsl } from "./wgsl/bc-forward-edge.wgsl.js";
+import { bcGatherWgsl } from "./wgsl/bc-gather.wgsl.js";
 import { bfRelaxWgsl } from "./wgsl/bf-relax.wgsl.js";
 import { bfsBitsetBuildWgsl } from "./wgsl/bfs-bitset-build.wgsl.js";
 import { bfsBottomUpWgsl } from "./wgsl/bfs-bottom-up.wgsl.js";
@@ -69,7 +76,7 @@ import { wccLinkEdgesWgsl } from "./wgsl/wcc-link-edges.wgsl.js";
 import { wccLinkSampleWgsl } from "./wgsl/wcc-link-sample.wgsl.js";
 import { wccSampleWgsl } from "./wgsl/wcc-sample.wgsl.js";
 
-/** Every module id of P1-P4, P7 and P8 (later ids are appended, never renamed). */
+/** Every module id of P1-P4, P7, P8 and P9 (later ids are appended, never renamed). */
 export type KernelId =
     | "degree"
     | "reduce"
@@ -116,7 +123,13 @@ export type KernelId =
     | "sssp-relax"
     | "bf-relax"
     | "closeness-sweep"
-    | "closeness-reduce";
+    | "closeness-reduce"
+    | "bc-finalize"
+    | "bc-forward"
+    | "bc-backward"
+    | "bc-gather"
+    | "bc-edge-gather"
+    | "bc-forward-edge";
 
 /** One registry entry: everything of a WgslModuleSpec except the per-variant overrides and snippets. */
 export interface KernelEntry {
@@ -131,7 +144,7 @@ export interface KernelEntry {
     /** The snippet marker names the body carries (segmented-reduce: ["VALUE"]). */
     readonly snippetSlots: readonly string[];
     /** The phase the entry landed in (documentation and the compile-matrix filter). */
-    readonly phase: "P1" | "P2" | "P3" | "P4" | "P7" | "P8";
+    readonly phase: "P1" | "P2" | "P3" | "P4" | "P7" | "P8" | "P9";
 }
 
 // ---- the generated blocks (spec 5.3; contract 3.10.2): field order = byte order, offsets in the JSDoc
@@ -392,7 +405,9 @@ export const COMPACT_PARAMS: UniformBlock = UniformBlock.define("CompactParams",
  * one; every level kernel is a direct dispatch that reads it first -- G8-F5), `nextDegreeSum` @100 (issue #391: the
  * out-degree sum of the vertices the level claimed, accumulated by `bfs-next-degree` at the end of every level and
  * read, subtracted and zeroed by the next boundary -- Beamer's m_f measured on the frontier the boundary decides
- * for, not on the one it has just expanded). The words nothing writes before P8-T8 / P8-T9 are declared now because
+ * for, not on the one it has just expanded); `stackTop` @104 (betweenness: the append cursor of the claim log, which
+ * `bc-finalize` also writes into `ends` at every level boundary) and `sigmaOverflow` @108 (betweenness: 1 once a u32
+ * path count wrapped) are APPENDED so every earlier word keeps its byte offset. The words nothing writes before P8-T8 / P8-T9 are declared now because
  * the byte layout is what the single result copy decodes.
  */
 export const FRONTIER_COUNTERS: UniformBlock = UniformBlock.define(
@@ -424,6 +439,8 @@ export const FRONTIER_COUNTERS: UniformBlock = UniformBlock.define(
         ["deltaBits", "u32"],
         ["path", "u32"],
         ["nextDegreeSum", "u32"],
+        ["stackTop", "u32"],
+        ["sigmaOverflow", "u32"],
     ],
     { layout: "storage" },
 );
@@ -436,7 +453,8 @@ export const FRONTIER_COUNTERS: UniformBlock = UniformBlock.define(
  * `arcEnd` @44 (the bound arc window), `predKind` @48 (0 arc, 1 node), `bitsBase` @52, `source` @56, `stride` @60
  * (a grid-stride plan's stride), `firstOfSubmit` @64 (the boundary's index inside its submit, clamped to 1: both
  * the unvisited-count and the unvisited-degree-sum subtraction run at >= 1, issue #391), `iteration` @68 (an
- * `sssp-pred` hop pass, P8-T9), `pad1` @72, `pad2` @76. The `slotBase` field that once addressed the selector's indirect slots went with
+ * `sssp-pred` hop pass, P8-T9), `perNode` @72 (`closeness-sweep`: 1 also folds every claim into the per-node
+ * distance sums of a sampled run), `pad2` @76. The `slotBase` field that once addressed the selector's indirect slots went with
  * the slots (2026-09-25); `pad2` keeps the block an explicit 80 bytes, the way every block here is padded.
  */
 export const FRONTIER_PARAMS: UniformBlock = UniformBlock.define("FrontierParams", [
@@ -458,10 +476,22 @@ export const FRONTIER_PARAMS: UniformBlock = UniformBlock.define("FrontierParams
     ["stride", "u32"],
     ["firstOfSubmit", "u32"],
     ["iteration", "u32"],
-    ["pad1", "u32"],
+    ["perNode", "u32"],
     ["pad2", "u32"],
 ]);
 
+/** `BcParams` (uniform, 32 B; betweenness): `n` @0, `k` @4 (the batch's sources), `start` @8 (the first log index of a backward level), `count` @12 (a backward level's entries, or the edge count of `bc-forward-edge`), `stride` @16 (a grid-stride plan's stride), `role` @20 (`bc-finalize`: 0 the level boundary, 1 the seed), `pad0` @24, `pad1` @28. */
+export const BC_PARAMS: UniformBlock = UniformBlock.define("BcParams", [
+    ["n", "u32"],
+    ["k", "u32"],
+    ["start", "u32"],
+    ["count", "u32"],
+    ["stride", "u32"],
+    ["role", "u32"],
+    ["pad0", "u32"],
+    ["pad1", "u32"],
+]);
+
 /** `BfParams` (uniform, 16 B; P8-T10): `edgeCount` @0 (the logical edges of the `edgeList` view), `stride` @4 (the grid-stride plan's stride), `maxRetries` @8 (PD-12's compare-exchange bound), `cutoffBits` @12 (the f32 bit pattern of the CPU port's `cutoff`, `+Inf` when absent). */
 export const BF_PARAMS: UniformBlock = UniformBlock.define("BfParams", [
     ["edgeCount", "u32"],
@@ -1345,7 +1375,7 @@ const CLOSENESS_SWEEP: KernelEntry = {
     phase: "P8",
 };
 
-/** `closeness-reduce` (design 8.4, 9.7; P8-T11, PD-13): the one-lane bookkeeping of the sweep -- role 0 the level boundary (`done` from the previous level's compacted count, `newCount` folded into `reached` and the 64-bit `sum` at `level + 1` with the 16-bit split product and the carry, `level` advanced), role 1 the seed of a batch (the sources' bits into `visited` and the level-0 frontier region, their flags, `counters[0] = k`, `level = U32_MAX`); 3 storage bindings (`counters` and `perSource` as `array<atomic<u32>>`, `bits` plain: one lane writes the seed). */
+/** `closeness-reduce` (design 8.4, 9.7; P8-T11, PD-13): the one-lane bookkeeping of the sweep -- role 0 the level boundary (`done` from the previous level's compacted count, `newCount` folded into `reached` and the 64-bit `sum` at `level + 1` with the 16-bit split product and the carry, `level` advanced), role 1 the seed of a batch (the sources' bits into `visited` and the level-0 frontier region, their flags, `counters[0] = k`, `level = U32_MAX`), role 2 the same seed from a sampled run's source list; 3 storage bindings (`counters` and `perSource` as `array<atomic<u32>>`, `bits` plain: one lane writes the seed). */
 const CLOSENESS_REDUCE: KernelEntry = {
     id: "closeness-reduce",
     body: closenessReduceWgsl,
@@ -1363,6 +1393,129 @@ const CLOSENESS_REDUCE: KernelEntry = {
     phase: "P8",
 };
 
+/** `bc-finalize` (design 8.4, 5.4): the one-lane bookkeeping of a betweenness batch -- role 1 seeds it (depth 0 and one path for the k seed entries of the claim log, `stackTop = k`, `level = U32_MAX`), role 0 is the level boundary (`ends[level + 1] = stackTop`, `frontierCount`, `done` on an empty level); 5 storage bindings (the counters block as `array<atomic<u32>>`, `ends`, `S` read-only, `depthK` and `sigmaK` plain: one lane writes the seed). The design's finalize row has 2; `ends` is the third (the level boundary), and the seed's `S`, `depthK` and `sigmaK` make it five. */
+const BC_FINALIZE: KernelEntry = {
+    id: "bc-finalize",
+    body: bcFinalizeWgsl,
+    entryPoint: "bc_finalize",
+    bindings: [
+        decl(1, 0, "counters", "storage", "array<atomic<u32>>"),
+        decl(1, 1, "ends", "storage", "array<u32>"),
+        decl(1, 2, "S", "storage-ro", "array<u32>"),
+        decl(1, 3, "depthK", "storage", "array<u32>"),
+        decl(1, 4, "sigmaK", "storage", "array<u32>"),
+        decl(2, 0, "P", "uniform", "BcParams"),
+    ],
+    overrideDecls: [],
+    uniforms: [BC_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P9",
+};
+
+/** `bc-forward` (design 8.4, 8.10 "BC forward (tagged)", 16.1): one level of the tagged multi-source BFS -- the block-mapped strip over the level's range of the claim log with the claim, the path count and the overflow report inline, the winners appended to the log; 7 storage bindings (`rowPtr`, `colIdx`, `S` read-write -- the level being read and the appends are ranges of ONE binding --, `ends` read-only, the counters block, `depthK` and `sigmaK` as `array<atomic<u32>>`); the inlined Hillis-Steele scan, so `needs: []`. */
+const BC_FORWARD: KernelEntry = {
+    id: "bc-forward",
+    body: bcForwardWgsl,
+    entryPoint: "bc_forward",
+    bindings: [
+        decl(1, 0, "rowPtr", "storage-ro", "array<u32>"),
+        decl(1, 1, "colIdx", "storage-ro", "array<u32>"),
+        decl(1, 2, "S", "storage", "array<u32>"),
+        decl(1, 3, "ends", "storage-ro", "array<u32>"),
+        decl(1, 4, "counters", "storage", "array<atomic<u32>>"),
+        decl(1, 5, "depthK", "storage", "array<atomic<u32>>"),
+        decl(1, 6, "sigmaK", "storage", "array<atomic<u32>>"),
+        decl(2, 0, "P", "uniform", "BcParams"),
+    ],
+    overrideDecls: [],
+    uniforms: [BC_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P9",
+};
+
+/** `bc-backward` (design 8.4, 8.10 "BC backward (successor pull)"): one level of the dependency accumulation, one invocation per log entry of a host-planned range, each pulling over its successors and writing its delta once; 6 storage bindings (`rowPtr`, `colIdx`, `S`, `depthK`, `sigmaK` read-only, `deltaK`). */
+const BC_BACKWARD: KernelEntry = {
+    id: "bc-backward",
+    body: bcBackwardWgsl,
+    entryPoint: "bc_backward",
+    bindings: [
+        decl(1, 0, "rowPtr", "storage-ro", "array<u32>"),
+        decl(1, 1, "colIdx", "storage-ro", "array<u32>"),
+        decl(1, 2, "S", "storage-ro", "array<u32>"),
+        decl(1, 3, "depthK", "storage-ro", "array<u32>"),
+        decl(1, 4, "sigmaK", "storage-ro", "array<u32>"),
+        decl(1, 5, "deltaK", "storage", "array<f32>"),
+        decl(2, 0, "P", "uniform", "BcParams"),
+    ],
+    overrideDecls: [],
+    uniforms: [BC_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P9",
+};
+
+/** `bc-gather` (design 8.4, 8.10 "BC gather"): `bc[w] += sum over s of delta[s][w]`, one invocation per vertex, no atomic; 2 storage bindings (`deltaK` read-only, `bc`). */
+const BC_GATHER: KernelEntry = {
+    id: "bc-gather",
+    body: bcGatherWgsl,
+    entryPoint: "bc_gather",
+    bindings: [
+        decl(1, 0, "deltaK", "storage-ro", "array<f32>"),
+        decl(1, 1, "bc", "storage", "array<f32>"),
+        decl(2, 0, "P", "uniform", "BcParams"),
+    ],
+    overrideDecls: [],
+    uniforms: [BC_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P9",
+};
+
+/** `bc-edge-gather` (design 8.4 "edge BC accumulates per arc from the same n x k deltas"): the per-arc twin of `bc-gather`, one invocation per arc (its row found by an upper-bound search over `rowPtr`) adding the arc's term over the batch's sources; 6 storage bindings (`rowPtr`, `colIdx`, `depthK`, `sigmaK`, `deltaK` read-only, `arcScores`). */
+const BC_EDGE_GATHER: KernelEntry = {
+    id: "bc-edge-gather",
+    body: bcEdgeGatherWgsl,
+    entryPoint: "bc_edge_gather",
+    bindings: [
+        decl(1, 0, "rowPtr", "storage-ro", "array<u32>"),
+        decl(1, 1, "colIdx", "storage-ro", "array<u32>"),
+        decl(1, 2, "depthK", "storage-ro", "array<u32>"),
+        decl(1, 3, "sigmaK", "storage-ro", "array<u32>"),
+        decl(1, 4, "deltaK", "storage-ro", "array<f32>"),
+        decl(1, 5, "arcScores", "storage", "array<f32>"),
+        decl(2, 0, "P", "uniform", "BcParams"),
+    ],
+    overrideDecls: [],
+    uniforms: [BC_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P9",
+};
+
+/** `bc-forward-edge` (design 8.4 "the edge-parallel form", 8.8 row 7): one forward level edge-parallel over the `edgeList` view for every source of the batch, with `bc-forward`'s claim, count and overflow report, appending to the same claim log; `UNDIRECTED` relaxes both directions of every edge; 7 storage bindings (`edgeSrc`, `edgeDst`, `S` read-write, `ends` read-only, the counters block, `depthK` and `sigmaK` as `array<atomic<u32>>`). */
+const BC_FORWARD_EDGE: KernelEntry = {
+    id: "bc-forward-edge",
+    body: bcForwardEdgeWgsl,
+    entryPoint: "bc_forward_edge",
+    bindings: [
+        decl(1, 0, "edgeSrc", "storage-ro", "array<u32>"),
+        decl(1, 1, "edgeDst", "storage-ro", "array<u32>"),
+        decl(1, 2, "S", "storage", "array<u32>"),
+        decl(1, 3, "ends", "storage-ro", "array<u32>"),
+        decl(1, 4, "counters", "storage", "array<atomic<u32>>"),
+        decl(1, 5, "depthK", "storage", "array<atomic<u32>>"),
+        decl(1, 6, "sigmaK", "storage", "array<atomic<u32>>"),
+        decl(2, 0, "P", "uniform", "BcParams"),
+    ],
+    overrideDecls: [{ name: "UNDIRECTED", type: "bool", default: false }],
+    uniforms: [BC_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P9",
+};
+
 /**
  * The entries by id, in dispatch order. PLAN DECISION: `KernelId` is declared in full (contract 3.10) while the
  * entries landed phase by phase, so the table is built as a Partial record and exported below through the
@@ -1372,8 +1525,8 @@ const CLOSENESS_REDUCE: KernelEntry = {
  * and `"fa2-to-scene"`; M8b-T3 landed the seven P7 entries and P4 its thirteen; P8-T3 landed the three compact /
  * dedupe entries, P8-T4 `"frontier-finalize"`, P8-T5 `"advance-expand"`, P8-T6 `"bfs-contract"` and `"sssp-pred"` and
  * P8-T7 `"bfs-fused"`, P8-T8 `"bfs-bottom-up"`, `"bfs-bitset-build"` and `"bfs-unvisited-flags"`, P8-T9
- * `"sssp-relax"`, P8-T10 `"bf-relax"` and P8-T11 `"closeness-sweep"` and `"closeness-reduce"`, so every member of
- * `KernelId` is present and the assertion is exact.
+ * `"sssp-relax"`, P8-T10 `"bf-relax"` and P8-T11 `"closeness-sweep"` and `"closeness-reduce"`, and betweenness the
+ * six `"bc-*"` entries, so every member of `KernelId` is present and the assertion is exact.
  */
 const REGISTRY: Readonly<Partial<Record<KernelId, KernelEntry>>> = Object.freeze({
     degree: DEGREE,
@@ -1422,6 +1575,12 @@ const REGISTRY: Readonly<Partial<Record<KernelId, KernelEntry>>> = Object.freeze
     "bf-relax": BF_RELAX,
     "closeness-sweep": CLOSENESS_SWEEP,
     "closeness-reduce": CLOSENESS_REDUCE,
+    "bc-finalize": BC_FINALIZE,
+    "bc-forward": BC_FORWARD,
+    "bc-backward": BC_BACKWARD,
+    "bc-gather": BC_GATHER,
+    "bc-edge-gather": BC_EDGE_GATHER,
+    "bc-forward-edge": BC_FORWARD_EDGE,
 });
 
 /** THE registry (spec 3.5): every entry, keyed by id. */

package/src/primitives/frontier.ts

@@ -72,6 +72,8 @@ export const W: Readonly<{
     deltaBits: 23;
     path: 24;
     nextDegreeSum: 25;
+    stackTop: 26;
+    sigmaOverflow: 27;
 }> = Object.freeze({
     frontierCount: 0,
     nextFrontierCount: 1,
@@ -99,6 +101,8 @@ export const W: Readonly<{
     deltaBits: 23,
     path: 24,
     nextDegreeSum: 25,
+    stackTop: 26,
+    sigmaOverflow: 27,
 });
 
 /** The words a `reset` seeds (every other word is zeroed). */