@graphty/webgpu-graph-algorithms 0.6.14 → 0.6.16

package/dist/src/types/all-pairs.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The all-pairs shortest-path result and option records (design 3.3 lines 813 and 835, 8.7, 9.7). The result is the
+ * design's shape verbatim; every sentinel is spelled on its field, because a consumer who reads a `0` off the diagonal
+ * or an `Infinity` off the matrix and guesses what it means is the failure this file prevents. Types only: this file
+ * imports nothing at runtime.
+ */
+import type { F32 } from "@graphty/graph-format";
+/**
+ * Design 3.3 line 835: what `allPairsShortestPath` returns. Satisfies the seam's `ApspResultLike` (`dist:
+ * NumericVector` admits `F32`).
+ * @public
+ */
+export interface GpuApspResult {
+    /**
+     * The `n * n` distances, row-major: `dist[i * n + j]` is the shortest distance FROM `i` TO `j` (the i-to-j
+     * direction on a directed snapshot). `+Infinity` when `j` is unreachable from `i`. The diagonal is `0` even when
+     * a self-loop carries a weight. f32 throughout; hop counts are exact integers.
+     */
+    readonly dist: F32;
+    /** The node count; `dist.length === n * n`. */
+    readonly n: number;
+}
+/**
+ * The options of `allPairsShortestPath` beyond `GpuRunOptions`. Nothing else: a cutoff would change the meaning of
+ * `+Infinity`, and the design asks for none.
+ * @public
+ */
+export interface ApspOptions {
+    /**
+     * Use the snapshot's weight column. Default: true when the snapshot has weights. `false` on a weighted snapshot
+     * computes HOP COUNTS (every arc costs 1), not distances.
+     */
+    readonly weighted?: boolean | undefined;
+}
+//# sourceMappingURL=all-pairs.d.ts.map

package/dist/src/types/all-pairs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"all-pairs.d.ts","sourceRoot":"","sources":["../../../src/types/all-pairs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAC;AAEjD;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;IACnB,+CAA+C;IAC/C,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IACxB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC3C"}

package/dist/src/types/all-pairs.js

@@ -0,0 +1,8 @@
+/**
+ * The all-pairs shortest-path result and option records (design 3.3 lines 813 and 835, 8.7, 9.7). The result is the
+ * design's shape verbatim; every sentinel is spelled on its field, because a consumer who reads a `0` off the diagonal
+ * or an `Infinity` off the matrix and guesses what it means is the failure this file prevents. Types only: this file
+ * imports nothing at runtime.
+ */
+export {};
+//# sourceMappingURL=all-pairs.js.map

package/dist/src/types/all-pairs.js.map

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

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/types/community.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The option record of label propagation (design 3.3 line 807, 8.6). Types only.
+ */
+/**
+ * Label propagation's options. Ties between neighbour labels are broken by the LOWEST label, never at random, so
+ * the result is bitwise reproducible on one device; that is also why there is no `randomSeed`.
+ * @public
+ */
+export interface LabelPropagationOptions {
+    /** The largest number of passes (default 100, as in `@graphty/algorithms`); a non-negative integer. */
+    readonly maxIterations?: number | undefined;
+    /**
+     * Sum the weights of the edges to each neighbour label (default true; an unweighted snapshot's edges weigh 1
+     * each, so a parallel edge counts once per copy); false counts every distinct neighbour once.
+     */
+    readonly weighted?: boolean | undefined;
+}
+//# sourceMappingURL=community.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"community.d.ts","sourceRoot":"","sources":["../../../src/types/community.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACpC,uGAAuG;IACvG,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC3C"}

package/dist/src/types/community.js

@@ -0,0 +1,5 @@
+/**
+ * The option record of label propagation (design 3.3 line 807, 8.6). Types only.
+ */
+export {};
+//# sourceMappingURL=community.js.map

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

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

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

@@ -0,0 +1,27 @@
+/**
+ * The result record of triangle counting (design 3.3 line 828, 8.5; design 17 line 5067). Design 3.3 declares
+ * `{ perNode, total }`; this package also returns the clustering coefficient and the transitivity, because they are
+ * an epilogue over the counts and degrees the call already holds and nothing else in the monorepo computes them.
+ * Types only.
+ */
+import type { F32, U32 } from "@graphty/graph-format";
+/**
+ * Triangle counting over the simple undirected graph underlying the snapshot: arc directions are ignored, parallel
+ * edges count once and self-loops not at all, so a directed snapshot and its undirected twin give the same answer.
+ * @public
+ */
+export interface GpuTriangleResult {
+    /** The triangles each node lies in. */
+    readonly perNode: U32;
+    /** The triangles of the graph (each counted once). */
+    readonly total: number;
+    /**
+     * The local clustering coefficient of every node, `2 T(v) / (d(v) (d(v) - 1))` with `d` the node's number of
+     * distinct neighbours. It is 0 -- a defined value, not a missing one -- for a node with fewer than two
+     * neighbours, so a star graph returns all zeros.
+     */
+    readonly coefficient: F32;
+    /** The graph's transitivity, `3 x triangles / connected triples`; 0 when the graph has no connected triple. */
+    readonly transitivity: number;
+}
+//# sourceMappingURL=structure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"structure.d.ts","sourceRoot":"","sources":["../../../src/types/structure.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAC;AAEtD;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAC9B,uCAAuC;IACvC,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC;IACtB,sDAAsD;IACtD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC;IAC1B,+GAA+G;IAC/G,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CACjC"}

package/dist/src/types/structure.js

@@ -0,0 +1,8 @@
+/**
+ * The result record of triangle counting (design 3.3 line 828, 8.5; design 17 line 5067). Design 3.3 declares
+ * `{ perNode, total }`; this package also returns the clustering coefficient and the transitivity, because they are
+ * an epilogue over the counts and degrees the call already holds and nothing else in the monorepo computes them.
+ * Types only.
+ */
+export {};
+//# sourceMappingURL=structure.js.map

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

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

package/dist/src/wgsl/apsp-fw.wgsl.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The `apsp-fw` kernel body (design 8.7): one phase of one round of blocked Floyd-Warshall over `APSP_TILE x
+ * APSP_TILE` blocks of the row-major `n x n` matrix `dist`. Round `r` (`P.round`) runs three dispatches in order,
+ * the `PHASE` override choosing which:
+ *
+ * - PHASE 0, one workgroup: the pivot block `(r, r)`, staged in `tileA` and updated in place.
+ * - PHASE 1, `2 (B - 1)` workgroups (`B` = `P.blocks`): every other block of block row `r` (the first `B - 1`
+ *   workgroups) and of block column `r` (the rest). The pivot block is staged in `tileA`, the block itself in
+ *   `tileB`, updated in place.
+ * - PHASE 2, `(B - 1)^2` workgroups: every block `(i, j)` off the pivot row and column. Its two operands are the
+ *   pivot-COLUMN block `(i, r)` in `tileA` and the pivot-ROW block `(r, j)` in `tileB`; its own cells are read,
+ *   minimised over the 32 steps and written by one lane each, never shared, so they stay in registers.
+ *
+ * In-place updates are race-free because a cell is written only when the candidate is STRICTLY smaller: the cells
+ * every lane reads in step `k` (column `k` and row `k` of the tile) would be updated with `d + d[k][k]`, and the
+ * diagonal is `0` (weights are non-negative, which the driver checks) or `+Infinity` outside the matrix, so they are
+ * never written in step `k`. Every barrier is reached in uniform control flow: the early return keys on the workgroup
+ * id and uniforms only, the per-lane loops hold no barrier, and the lanes of an edge tile load `+Infinity` for a cell
+ * outside `n x n` (it offers no path; read from `P.infBits` because Tint refuses `+Infinity` as a constant) and
+ * store nothing there -- the matrix is exactly `n * n`, never padded, so the
+ * ceiling is `floor(sqrt(maxStorageBufferBindingSize / 4))`. 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 apspFwWgsl = "\nvar<workgroup> tileA: array<f32, APSP_TILE * APSP_TILE>;\nvar<workgroup> tileB: array<f32, APSP_TILE * APSP_TILE>;\n\nfn tile_row(block: vec2<u32>, c: u32) -> u32 { return block.x * APSP_TILE + c / APSP_TILE; }\nfn tile_col(block: vec2<u32>, c: u32) -> u32 { return block.y * APSP_TILE + c % APSP_TILE; }\n\nfn load_cell(block: vec2<u32>, c: u32) -> f32 {\n    let i = tile_row(block, c);\n    let j = tile_col(block, c);\n    if (i < P.n && j < P.n) { return dist[i * P.n + j]; }\n    return bitcast<f32>(P.infBits);                                   // outside the matrix: no path through it\n}\n\nfn store_cell(block: vec2<u32>, c: u32, v: f32) {\n    let i = tile_row(block, c);\n    let j = tile_col(block, c);\n    if (i >= P.n || j >= P.n) { return; }                            // an edge tile stores nothing outside n x n\n    dist[i * P.n + j] = v;\n}\n\n@compute @workgroup_size(WG)\nfn apsp_fw(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let g = group_id(wid);\n    let r = P.round;\n    let others = max(P.blocks, 2u) - 1u;                             // the blocks of a strip, the pivot excluded\n    let cells = APSP_TILE * APSP_TILE;\n    var count = 1u;\n    var own = vec2<u32>(r, r);                                        // the block this workgroup updates\n    var a = vec2<u32>(r, r);                                          // staged in tileA\n    var b = vec2<u32>(r, r);                                          // staged in tileB\n    if (PHASE == 1u) {\n        count = 2u * others;\n        let s = g % others;\n        let o = select(s, s + 1u, s >= r);                            // a strip skips the pivot block\n        own = select(vec2<u32>(o, r), vec2<u32>(r, o), g < others);   // block row r first, then block column r\n        b = own;\n    }\n    if (PHASE == 2u) {\n        count = others * others;\n        let i = g / others;\n        let j = g % others;\n        own = vec2<u32>(select(i, i + 1u, i >= r), select(j, j + 1u, j >= r));\n        a = vec2<u32>(own.x, r);                                      // the pivot-column block (i, r)\n        b = vec2<u32>(r, own.y);                                      // the pivot-row block (r, j)\n    }\n    if (g >= count) { return; }                                       // uniform: the workgroup id and uniforms only\n\n    for (var c = lid.x; c < cells; c = c + WG) {\n        tileA[c] = load_cell(a, c);\n        if (PHASE != 0u) { tileB[c] = load_cell(b, c); }\n    }\n    workgroupBarrier();                                               // every staged cell is visible\n\n    if (PHASE == 2u) {\n        for (var c = lid.x; c < cells; c = c + WG) {\n            let x = c / APSP_TILE;\n            let y = c % APSP_TILE;\n            var v = load_cell(own, c);\n            for (var kr = 0u; kr < APSP_TILE; kr = kr + 1u) {\n                v = min(v, tileA[x * APSP_TILE + kr] + tileB[kr * APSP_TILE + y]);\n            }\n            store_cell(own, c, v);\n        }\n        return;\n    }\n\n    let pivotRow = PHASE == 1u && own.x == r;                          // block row r reads d[x][k] from the pivot\n    for (var k = 0u; k < APSP_TILE; k = k + 1u) {\n        for (var c = lid.x; c < cells; c = c + WG) {\n            let x = c / APSP_TILE;\n            let y = c % APSP_TILE;\n            if (PHASE == 0u) {\n                let via = tileA[x * APSP_TILE + k] + tileA[k * APSP_TILE + y];\n                if (via < tileA[c]) { tileA[c] = via; }\n            } else {\n                let left = select(tileB[x * APSP_TILE + k], tileA[x * APSP_TILE + k], pivotRow);\n                let right = select(tileA[k * APSP_TILE + y], tileB[k * APSP_TILE + y], pivotRow);\n                let via = left + right;\n                if (via < tileB[c]) { tileB[c] = via; }\n            }\n        }\n        workgroupBarrier();                                           // step k is complete before step k + 1 reads\n    }\n    for (var c = lid.x; c < cells; c = c + WG) {\n        store_cell(own, c, select(tileB[c], tileA[c], PHASE == 0u));\n    }\n}\n";
+//# sourceMappingURL=apsp-fw.wgsl.d.ts.map

package/dist/src/wgsl/apsp-fw.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apsp-fw.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/apsp-fw.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,UAAU,4gIAwFtB,CAAC"}

package/dist/src/wgsl/apsp-fw.wgsl.js

@@ -0,0 +1,113 @@
+/**
+ * The `apsp-fw` kernel body (design 8.7): one phase of one round of blocked Floyd-Warshall over `APSP_TILE x
+ * APSP_TILE` blocks of the row-major `n x n` matrix `dist`. Round `r` (`P.round`) runs three dispatches in order,
+ * the `PHASE` override choosing which:
+ *
+ * - PHASE 0, one workgroup: the pivot block `(r, r)`, staged in `tileA` and updated in place.
+ * - PHASE 1, `2 (B - 1)` workgroups (`B` = `P.blocks`): every other block of block row `r` (the first `B - 1`
+ *   workgroups) and of block column `r` (the rest). The pivot block is staged in `tileA`, the block itself in
+ *   `tileB`, updated in place.
+ * - PHASE 2, `(B - 1)^2` workgroups: every block `(i, j)` off the pivot row and column. Its two operands are the
+ *   pivot-COLUMN block `(i, r)` in `tileA` and the pivot-ROW block `(r, j)` in `tileB`; its own cells are read,
+ *   minimised over the 32 steps and written by one lane each, never shared, so they stay in registers.
+ *
+ * In-place updates are race-free because a cell is written only when the candidate is STRICTLY smaller: the cells
+ * every lane reads in step `k` (column `k` and row `k` of the tile) would be updated with `d + d[k][k]`, and the
+ * diagonal is `0` (weights are non-negative, which the driver checks) or `+Infinity` outside the matrix, so they are
+ * never written in step `k`. Every barrier is reached in uniform control flow: the early return keys on the workgroup
+ * id and uniforms only, the per-lane loops hold no barrier, and the lanes of an edge tile load `+Infinity` for a cell
+ * outside `n x n` (it offers no path; read from `P.infBits` because Tint refuses `+Infinity` as a constant) and
+ * store nothing there -- the matrix is exactly `n * n`, never padded, so the
+ * ceiling is `floor(sqrt(maxStorageBufferBindingSize / 4))`. Body only (spec 3.5, D9); the text is normative: the
+ * sabotage rows of test/helpers/sabotage.ts are textual edits of it.
+ */
+export const apspFwWgsl = /* wgsl */ `
+var<workgroup> tileA: array<f32, APSP_TILE * APSP_TILE>;
+var<workgroup> tileB: array<f32, APSP_TILE * APSP_TILE>;
+
+fn tile_row(block: vec2<u32>, c: u32) -> u32 { return block.x * APSP_TILE + c / APSP_TILE; }
+fn tile_col(block: vec2<u32>, c: u32) -> u32 { return block.y * APSP_TILE + c % APSP_TILE; }
+
+fn load_cell(block: vec2<u32>, c: u32) -> f32 {
+    let i = tile_row(block, c);
+    let j = tile_col(block, c);
+    if (i < P.n && j < P.n) { return dist[i * P.n + j]; }
+    return bitcast<f32>(P.infBits);                                   // outside the matrix: no path through it
+}
+
+fn store_cell(block: vec2<u32>, c: u32, v: f32) {
+    let i = tile_row(block, c);
+    let j = tile_col(block, c);
+    if (i >= P.n || j >= P.n) { return; }                            // an edge tile stores nothing outside n x n
+    dist[i * P.n + j] = v;
+}
+
+@compute @workgroup_size(WG)
+fn apsp_fw(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let g = group_id(wid);
+    let r = P.round;
+    let others = max(P.blocks, 2u) - 1u;                             // the blocks of a strip, the pivot excluded
+    let cells = APSP_TILE * APSP_TILE;
+    var count = 1u;
+    var own = vec2<u32>(r, r);                                        // the block this workgroup updates
+    var a = vec2<u32>(r, r);                                          // staged in tileA
+    var b = vec2<u32>(r, r);                                          // staged in tileB
+    if (PHASE == 1u) {
+        count = 2u * others;
+        let s = g % others;
+        let o = select(s, s + 1u, s >= r);                            // a strip skips the pivot block
+        own = select(vec2<u32>(o, r), vec2<u32>(r, o), g < others);   // block row r first, then block column r
+        b = own;
+    }
+    if (PHASE == 2u) {
+        count = others * others;
+        let i = g / others;
+        let j = g % others;
+        own = vec2<u32>(select(i, i + 1u, i >= r), select(j, j + 1u, j >= r));
+        a = vec2<u32>(own.x, r);                                      // the pivot-column block (i, r)
+        b = vec2<u32>(r, own.y);                                      // the pivot-row block (r, j)
+    }
+    if (g >= count) { return; }                                       // uniform: the workgroup id and uniforms only
+
+    for (var c = lid.x; c < cells; c = c + WG) {
+        tileA[c] = load_cell(a, c);
+        if (PHASE != 0u) { tileB[c] = load_cell(b, c); }
+    }
+    workgroupBarrier();                                               // every staged cell is visible
+
+    if (PHASE == 2u) {
+        for (var c = lid.x; c < cells; c = c + WG) {
+            let x = c / APSP_TILE;
+            let y = c % APSP_TILE;
+            var v = load_cell(own, c);
+            for (var kr = 0u; kr < APSP_TILE; kr = kr + 1u) {
+                v = min(v, tileA[x * APSP_TILE + kr] + tileB[kr * APSP_TILE + y]);
+            }
+            store_cell(own, c, v);
+        }
+        return;
+    }
+
+    let pivotRow = PHASE == 1u && own.x == r;                          // block row r reads d[x][k] from the pivot
+    for (var k = 0u; k < APSP_TILE; k = k + 1u) {
+        for (var c = lid.x; c < cells; c = c + WG) {
+            let x = c / APSP_TILE;
+            let y = c % APSP_TILE;
+            if (PHASE == 0u) {
+                let via = tileA[x * APSP_TILE + k] + tileA[k * APSP_TILE + y];
+                if (via < tileA[c]) { tileA[c] = via; }
+            } else {
+                let left = select(tileB[x * APSP_TILE + k], tileA[x * APSP_TILE + k], pivotRow);
+                let right = select(tileA[k * APSP_TILE + y], tileB[k * APSP_TILE + y], pivotRow);
+                let via = left + right;
+                if (via < tileB[c]) { tileB[c] = via; }
+            }
+        }
+        workgroupBarrier();                                           // step k is complete before step k + 1 reads
+    }
+    for (var c = lid.x; c < cells; c = c + WG) {
+        store_cell(own, c, select(tileB[c], tileA[c], PHASE == 0u));
+    }
+}
+`;
+//# sourceMappingURL=apsp-fw.wgsl.js.map

package/dist/src/wgsl/apsp-fw.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apsp-fw.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/apsp-fw.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwFpC,CAAC"}

package/dist/src/wgsl/apsp-init.wgsl.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The `apsp-init` kernel body (design 8.7): writes the arcs into the `n x n` distance matrix after `fill` has set
+ * every entry to `+Infinity`. One lane per ROW `u`: it walks `u`'s arcs and keeps the cheapest weight per target
+ * (`min`), so parallel arcs collapse to the cheapest one, then writes the diagonal zero LAST, so a self-loop never
+ * displaces it. Every arc of row `u` lands in row `u` of the matrix and only this lane writes that row, so there is
+ * no race and no atomic. Unweighted (`HAS_WEIGHTS` false) every arc costs 1. A directed snapshot writes its one
+ * direction; an undirected one stores both arcs of every edge, so both halves are written. The driver refuses
+ * negative and non-finite weights before any dispatch. 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 apspInitWgsl = "\n@compute @workgroup_size(WG)\nfn apsp_init(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let u = linear_id(wid, lid.x);\n    if (u >= P.n) { return; }\n    let rowBase = u * P.n;\n    let end = rowPtr[u + 1u];\n    for (var a = rowPtr[u]; a < end; a = a + 1u) {\n        let v = colIdx[a];\n        let w = select(1.0, weights[a], HAS_WEIGHTS);\n        dist[rowBase + v] = min(dist[rowBase + v], w);               // parallel arcs collapse to the cheapest\n    }\n    dist[rowBase + u] = 0.0;                                          // last: a self-loop never displaces the zero\n}\n";
+//# sourceMappingURL=apsp-init.wgsl.d.ts.map

package/dist/src/wgsl/apsp-init.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apsp-init.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/apsp-init.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,8nBAcxB,CAAC"}

package/dist/src/wgsl/apsp-init.wgsl.js

@@ -0,0 +1,26 @@
+/**
+ * The `apsp-init` kernel body (design 8.7): writes the arcs into the `n x n` distance matrix after `fill` has set
+ * every entry to `+Infinity`. One lane per ROW `u`: it walks `u`'s arcs and keeps the cheapest weight per target
+ * (`min`), so parallel arcs collapse to the cheapest one, then writes the diagonal zero LAST, so a self-loop never
+ * displaces it. Every arc of row `u` lands in row `u` of the matrix and only this lane writes that row, so there is
+ * no race and no atomic. Unweighted (`HAS_WEIGHTS` false) every arc costs 1. A directed snapshot writes its one
+ * direction; an undirected one stores both arcs of every edge, so both halves are written. The driver refuses
+ * negative and non-finite weights before any dispatch. Body only (spec 3.5, D9); the text is normative: the
+ * sabotage rows of test/helpers/sabotage.ts are textual edits of it.
+ */
+export const apspInitWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn apsp_init(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let u = linear_id(wid, lid.x);
+    if (u >= P.n) { return; }
+    let rowBase = u * P.n;
+    let end = rowPtr[u + 1u];
+    for (var a = rowPtr[u]; a < end; a = a + 1u) {
+        let v = colIdx[a];
+        let w = select(1.0, weights[a], HAS_WEIGHTS);
+        dist[rowBase + v] = min(dist[rowBase + v], w);               // parallel arcs collapse to the cheapest
+    }
+    dist[rowBase + u] = 0.0;                                          // last: a self-loop never displaces the zero
+}
+`;
+//# sourceMappingURL=apsp-init.wgsl.js.map

package/dist/src/wgsl/apsp-init.wgsl.js.map

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

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"}