@graphty/webgpu-graph-algorithms 0.6.14 → 0.6.16

package/dist/src/kernels.js

@@ -12,13 +12,26 @@
  * 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; all-pairs shortest paths
+ * (design 8.7) adds apsp-init and apsp-fw with the ApspParams block. P11 (the structure and community phase, plan
+ * design/webgpu/plans/2026-09-23-webgpu-p11-structure-and-community.md) adds the graph build on the device (coo-emit,
+ * run-flags, coo-scatter), the per-row group-by-key (group-by-key-row), label propagation's step (lpa-step) and
+ * triangle counting (orient-flags, tri-intersect). This file is the only importer of src/wgsl/** (spec 3.2;
  * test/layers.test.ts).
  */
 import { STATE_HEADER_BYTES } from "./constants.js";
 import { WebGpuGraphError } from "./errors.js";
 import { UniformBlock } from "./kernel/struct-block.js";
 import { advanceExpandWgsl } from "./wgsl/advance-expand.wgsl.js";
+import { apspFwWgsl } from "./wgsl/apsp-fw.wgsl.js";
+import { apspInitWgsl } from "./wgsl/apsp-init.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";
@@ -29,6 +42,8 @@ import { bfsUnvisitedFlagsWgsl } from "./wgsl/bfs-unvisited-flags.wgsl.js";
 import { closenessReduceWgsl } from "./wgsl/closeness-reduce.wgsl.js";
 import { closenessSweepWgsl } from "./wgsl/closeness-sweep.wgsl.js";
 import { compactScatterWgsl } from "./wgsl/compact-scatter.wgsl.js";
+import { cooEmitWgsl } from "./wgsl/coo-emit.wgsl.js";
+import { cooScatterWgsl } from "./wgsl/coo-scatter.wgsl.js";
 import { countingScatterWgsl } from "./wgsl/counting-scatter.wgsl.js";
 import { dedupeClaimWgsl } from "./wgsl/dedupe-claim.wgsl.js";
 import { dedupeFilterWgsl } from "./wgsl/dedupe-filter.wgsl.js";
@@ -47,19 +62,24 @@ import { gridCentroidHubWgsl } from "./wgsl/grid-centroid-hub.wgsl.js";
 import { gridDownsampleWgsl } from "./wgsl/grid-downsample.wgsl.js";
 import { gridFarFieldWgsl } from "./wgsl/grid-far-field.wgsl.js";
 import { gridNearFieldWgsl } from "./wgsl/grid-near-field.wgsl.js";
+import { groupByKeyRowWgsl } from "./wgsl/group-by-key-row.wgsl.js";
 import { histogramWgsl } from "./wgsl/histogram.wgsl.js";
 import { indirectFinalizeWgsl } from "./wgsl/indirect-finalize.wgsl.js";
+import { lpaStepWgsl } from "./wgsl/lpa-step.wgsl.js";
+import { orientFlagsWgsl } from "./wgsl/orient-flags.wgsl.js";
 import { prFinalizeWgsl } from "./wgsl/pr-finalize.wgsl.js";
 import { prScaleWgsl } from "./wgsl/pr-scale.wgsl.js";
 import { radixHistWgsl } from "./wgsl/radix-hist.wgsl.js";
 import { radixScatterWgsl } from "./wgsl/radix-scatter.wgsl.js";
 import { reduceWgsl } from "./wgsl/reduce.wgsl.js";
+import { runFlagsWgsl } from "./wgsl/run-flags.wgsl.js";
 import { scanAddWgsl } from "./wgsl/scan-add.wgsl.js";
 import { scanBlockWgsl } from "./wgsl/scan-block.wgsl.js";
 import { segmentedReduceWgsl } from "./wgsl/segmented-reduce.wgsl.js";
 import { spmvPullWgsl } from "./wgsl/spmv-pull.wgsl.js";
 import { ssspPredWgsl } from "./wgsl/sssp-pred.wgsl.js";
 import { ssspRelaxWgsl } from "./wgsl/sssp-relax.wgsl.js";
+import { triIntersectWgsl } from "./wgsl/tri-intersect.wgsl.js";
 import { wccCompressWgsl } from "./wgsl/wcc-compress.wgsl.js";
 import { wccLinkEdgesWgsl } from "./wgsl/wcc-link-edges.wgsl.js";
 import { wccLinkSampleWgsl } from "./wgsl/wcc-link-sample.wgsl.js";
@@ -288,7 +308,9 @@ export const COMPACT_PARAMS = 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.define("FrontierCounters", [
@@ -318,6 +340,8 @@ export const FRONTIER_COUNTERS = UniformBlock.define("FrontierCounters", [
     ["deltaBits", "u32"],
     ["path", "u32"],
     ["nextDegreeSum", "u32"],
+    ["stackTop", "u32"],
+    ["sigmaOverflow", "u32"],
 ], { layout: "storage" });
 /**
  * `FrontierParams` (uniform, 80 B; P8-T4): the params block every P8 kernel except the three compact / dedupe
@@ -327,7 +351,8 @@ export const FRONTIER_COUNTERS = UniformBlock.define("FrontierCounters", [
  * `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.define("FrontierParams", [
@@ -349,9 +374,20 @@ export const FRONTIER_PARAMS = 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.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.define("BfParams", [
     ["edgeCount", "u32"],
@@ -366,6 +402,34 @@ export const BF_FLAGS = UniformBlock.define("BfFlags", [
     ["pad0", "u32"],
     ["pad1", "u32"],
 ], { layout: "storage" });
+/** `ApspParams` (uniform, 16 B; design 8.7): `n` @0 (the node count, the matrix side), `round` @4 (the pivot block index of the blocked Floyd-Warshall round), `blocks` @8 (`ceil(n / APSP_TILE)`), `infBits` @12 (`F32_INF_BITS`: a kernel reads `+Infinity` from a uniform because Tint refuses it as a constant expression). */
+export const APSP_PARAMS = UniformBlock.define("ApspParams", [
+    ["n", "u32"],
+    ["round", "u32"],
+    ["blocks", "u32"],
+    ["infBits", "u32"],
+]);
+/** `CooParams` (uniform, 16 B; P11): `count` @0 (the arcs or positions of the dispatch), `pad0` @4, `pad1` @8, `pad2` @12. The one params block of `coo-emit`, `run-flags`, `coo-scatter`, `orient-flags` and `tri-intersect`. */
+export const COO_PARAMS = UniformBlock.define("CooParams", [
+    ["count", "u32"],
+    ["pad0", "u32"],
+    ["pad1", "u32"],
+    ["pad2", "u32"],
+]);
+/** `GroupParams` (uniform, 16 B; P11): `rowsBase` @0 (the word of `rows` where the dispatch's row list starts), `basesBase` @4 (the word where the workgroup tier's region offsets start), `count` @8 (the rows of the dispatch), `pad0` @12. */
+export const GROUP_PARAMS = UniformBlock.define("GroupParams", [
+    ["rowsBase", "u32"],
+    ["basesBase", "u32"],
+    ["count", "u32"],
+    ["pad0", "u32"],
+]);
+/** `LpaParams` (uniform, 16 B; P11): `n` @0, `direction` @4 (0: a pass that moves labels down only, 1: up only), `counterIndex` @8 (the word of `counters` that receives the pass's move count), `pad0` @12. */
+export const LPA_PARAMS = UniformBlock.define("LpaParams", [
+    ["n", "u32"],
+    ["direction", "u32"],
+    ["counterIndex", "u32"],
+    ["pad0", "u32"],
+]);
 // ---- the entries (contract 3.10.1; group 0 = graph, 1 = state, 2 = params, 3 = cold)
 /**
  * One binding declaration of contract 3.9, so the tables below read like the rows of 3.10.1.
@@ -1129,7 +1193,7 @@ const CLOSENESS_SWEEP = {
     snippetSlots: [],
     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 = {
     id: "closeness-reduce",
     body: closenessReduceWgsl,
@@ -1146,6 +1210,291 @@ const CLOSENESS_REDUCE = {
     snippetSlots: [],
     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 = {
+    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 = {
+    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 = {
+    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 = {
+    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 = {
+    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 = {
+    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",
+};
+/** `apsp-init` (design 8.7): one lane per row writes that row's arcs into the `+Infinity`-filled `n x n` matrix, the cheapest of parallel arcs, then the diagonal zero; 5 storage bindings (the four graph slots -- `perm` bound to its dummy, the rows are never permuted -- and `dist`). */
+const APSP_INIT = {
+    id: "apsp-init",
+    body: apspInitWgsl,
+    entryPoint: "apsp_init",
+    bindings: GRAPH_SLOTS.concat(decl(1, 0, "dist", "storage", "array<f32>"), decl(2, 0, "P", "uniform", "ApspParams")),
+    overrideDecls: [],
+    uniforms: [APSP_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P9",
+};
+/** `apsp-fw` (design 8.7): one phase of one blocked Floyd-Warshall round over 32 x 32 tiles in workgroup memory -- `PHASE` 0 the pivot block, 1 the pivot row and column, 2 every other block; 1 storage binding (`dist`, read-write). */
+const APSP_FW = {
+    id: "apsp-fw",
+    body: apspFwWgsl,
+    entryPoint: "apsp_fw",
+    bindings: [decl(1, 0, "dist", "storage", "array<f32>"), decl(2, 0, "P", "uniform", "ApspParams")],
+    overrideDecls: [{ name: "PHASE", type: "u32", default: 0 }],
+    uniforms: [APSP_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P9",
+};
+/** `coo-emit` (design 6 row 10; P11): position i takes arc i, or `order[i]` under INDEXED, and writes its source, target and weight -- arc 2e is edge e as declared, 2e + 1 its reverse; a self-loop's two arcs become `INVALID_INDEX`; 7 storage bindings. */
+const COO_EMIT = {
+    id: "coo-emit",
+    body: cooEmitWgsl,
+    entryPoint: "coo_emit",
+    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, "order", "storage-ro", "array<u32>"),
+        decl(1, 4, "outSrc", "storage", "array<u32>"),
+        decl(1, 5, "outDst", "storage", "array<u32>"),
+        decl(1, 6, "outWeight", "storage", "array<f32>"),
+        decl(2, 0, "P", "uniform", "CooParams"),
+    ],
+    overrideDecls: [
+        { name: "INDEXED", type: "bool", default: false },
+        { name: "WEIGHTED", type: "bool", default: false },
+    ],
+    uniforms: [COO_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P11",
+};
+/** `run-flags` (design 6 row 10; P11): 1 where an arc opens a run of equal (keysA, keysB) pairs and is not dropped; 3 storage bindings. */
+const RUN_FLAGS = {
+    id: "run-flags",
+    body: runFlagsWgsl,
+    entryPoint: "run_flags",
+    bindings: [
+        decl(1, 0, "keysA", "storage-ro", "array<u32>"),
+        decl(1, 1, "keysB", "storage-ro", "array<u32>"),
+        decl(1, 2, "flags", "storage", "array<u32>"),
+        decl(2, 0, "P", "uniform", "CooParams"),
+    ],
+    overrideDecls: [],
+    uniforms: [COO_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P11",
+};
+/** `coo-scatter` (design 6 row 10; P11): the scatter of `cooToCsr` -- the cursor mode, or under SORTED_INPUT the order-preserving mode whose precondition flag is `cursors[0]`; 7 storage bindings. */
+const COO_SCATTER = {
+    id: "coo-scatter",
+    body: cooScatterWgsl,
+    entryPoint: "coo_scatter",
+    bindings: [
+        decl(1, 0, "src", "storage-ro", "array<u32>"),
+        decl(1, 1, "dst", "storage-ro", "array<u32>"),
+        decl(1, 2, "weight", "storage-ro", "array<f32>"),
+        decl(1, 3, "rowPtr", "storage-ro", "array<u32>"),
+        decl(1, 4, "cursors", "storage", "array<atomic<u32>>"),
+        decl(1, 5, "colIdx", "storage", "array<u32>"),
+        decl(1, 6, "outWeight", "storage", "array<f32>"),
+        decl(2, 0, "P", "uniform", "CooParams"),
+    ],
+    overrideDecls: [
+        { name: "SORTED_INPUT", type: "bool", default: false },
+        { name: "WEIGHTED", type: "bool", default: false },
+    ],
+    uniforms: [COO_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P11",
+};
+/** `orient-flags` (design 8.5; P11): 1 where arc (u, v) points up the (degree, id) order, one arc per undirected edge; 4 storage bindings. */
+const ORIENT_FLAGS = {
+    id: "orient-flags",
+    body: orientFlagsWgsl,
+    entryPoint: "orient_flags",
+    bindings: [
+        decl(1, 0, "rowPtr", "storage-ro", "array<u32>"),
+        decl(1, 1, "colIdx", "storage-ro", "array<u32>"),
+        decl(1, 2, "src", "storage-ro", "array<u32>"),
+        decl(1, 3, "flags", "storage", "array<u32>"),
+        decl(2, 0, "P", "uniform", "CooParams"),
+    ],
+    overrideDecls: [],
+    uniforms: [COO_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P11",
+};
+/** `tri-intersect` (design 8.5, 8.10 "Triangle intersection"; P11): one oriented arc per invocation, merge or binary-search intersection (SEARCH 0 chooses, 1 merge, 2 search), u32 atomic per-node counts; 4 storage bindings. */
+const TRI_INTERSECT = {
+    id: "tri-intersect",
+    body: triIntersectWgsl,
+    entryPoint: "tri_intersect",
+    bindings: [
+        decl(1, 0, "rowPtr", "storage-ro", "array<u32>"),
+        decl(1, 1, "colIdx", "storage-ro", "array<u32>"),
+        decl(1, 2, "src", "storage-ro", "array<u32>"),
+        decl(1, 3, "counts", "storage", "array<atomic<u32>>"),
+        decl(2, 0, "P", "uniform", "CooParams"),
+    ],
+    overrideDecls: [{ name: "SEARCH", type: "u32", default: 0 }],
+    uniforms: [COO_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P11",
+};
+/** `group-by-key-row` (design 8.6; P11): per listed row, the target key with the largest summed weight (lowest key on a tie), TIER 0 a thread per row, else a workgroup per row over a global hash region; 8 storage bindings. */
+const GROUP_BY_KEY_ROW = {
+    id: "group-by-key-row",
+    body: groupByKeyRowWgsl,
+    entryPoint: "group_by_key_row",
+    bindings: [
+        decl(1, 0, "rowPtr", "storage-ro", "array<u32>"),
+        decl(1, 1, "colIdx", "storage-ro", "array<u32>"),
+        decl(1, 2, "weights", "storage-ro", "array<f32>"),
+        decl(1, 3, "keyIn", "storage-ro", "array<u32>"),
+        decl(1, 4, "rows", "storage-ro", "array<u32>"),
+        decl(1, 5, "hashRegion", "storage", "array<atomic<u32>>"),
+        decl(1, 6, "bestKey", "storage", "array<u32>"),
+        decl(1, 7, "bestScore", "storage", "array<f32>"),
+        decl(2, 0, "P", "uniform", "GroupParams"),
+    ],
+    overrideDecls: [
+        { name: "TIER", type: "u32", default: 0 },
+        { name: "WEIGHTED", type: "bool", default: false },
+    ],
+    uniforms: [GROUP_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P11",
+};
+/** `lpa-step` (design 8.6, 8.10 "Label propagation"; P11): a vertex adopts its best neighbour label when the move goes the pass's direction; one atomic per workgroup adds the moves to `counters[P.counterIndex]`; 4 storage bindings. */
+const LPA_STEP = {
+    id: "lpa-step",
+    body: lpaStepWgsl,
+    entryPoint: "lpa_step",
+    bindings: [
+        decl(1, 0, "labelsIn", "storage-ro", "array<u32>"),
+        decl(1, 1, "bestKey", "storage-ro", "array<u32>"),
+        decl(1, 2, "labelsOut", "storage", "array<u32>"),
+        decl(1, 3, "counters", "storage", "array<atomic<u32>>"),
+        decl(2, 0, "P", "uniform", "LpaParams"),
+    ],
+    overrideDecls: [],
+    uniforms: [LPA_PARAMS],
+    needs: [],
+    snippetSlots: [],
+    phase: "P11",
+};
 /**
  * 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
@@ -1155,8 +1504,10 @@ const CLOSENESS_REDUCE = {
  * 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"`, betweenness the
+ * six `"bc-*"` entries, all-pairs shortest paths `"apsp-init"` and `"apsp-fw"`, and P11 its seven (the graph
+ * build, the group-by-key, label propagation's step and triangle counting), so every member of `KernelId`
+ * is present and the assertion is exact.
  */
 const REGISTRY = Object.freeze({
     degree: DEGREE,
@@ -1205,6 +1556,21 @@ const REGISTRY = 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,
+    "apsp-init": APSP_INIT,
+    "apsp-fw": APSP_FW,
+    "coo-emit": COO_EMIT,
+    "run-flags": RUN_FLAGS,
+    "coo-scatter": COO_SCATTER,
+    "orient-flags": ORIENT_FLAGS,
+    "tri-intersect": TRI_INTERSECT,
+    "group-by-key-row": GROUP_BY_KEY_ROW,
+    "lpa-step": LPA_STEP,
 });
 /** THE registry (spec 3.5): every entry, keyed by id. */
 export const KERNELS = REGISTRY;