@graphty/webgpu-graph-algorithms 0.6.2 → 0.6.4

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

@@ -0,0 +1,17 @@
+/**
+ * The `closeness-reduce` kernel body (design 8.4, 9.7 "integer distances before division"; P8-T11, the P8 plan's
+ * PD-13): the one-lane bookkeeping of the bit-parallel sweep, two roles by `P.role`. Role 0 is the level boundary,
+ * recorded BEFORE the level's `compact` and sweep: `done` is whether the previous level's compacted count is 0 (so the
+ * traversal ends one level after the last claim, one empty sweep and no wrong sum), then for every source `s` the
+ * claims the level just run made (`newCount[s]`) are folded into `reached[s]` and into the 64-bit `sum[s]` at the
+ * distance `level + 1` -- the product as a 16-bit split into a low and a high word, then the add with its carry --
+ * `newCount[s]` is zeroed and `level` advances. Role 1 is the seed of a batch: for the batch's `k = min(32, n -
+ * P.source)` sources, bit `s` into `visited[source_s]` and into the frontier region level 0 reads (region 1, since
+ * level 0's parity is 0), `flags[source_s] = 1` (level 0's `compact` turns the flags into the list; a seeded list
+ * would be overwritten by a compaction of all-zero flags), `counters[0] = k` (not done) and `level = U32_MAX` (so
+ * level 0's boundary accumulates nothing and brings the word to 0, and level 1's counts the distance-1 claims at 1).
+ * No barrier follows the early return of the other lanes (3.5 rule 1). Body only (spec 3.5, D9); the text is
+ * normative: the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
+ */
+export declare const closenessReduceWgsl = "\n@compute @workgroup_size(WG)\nfn closeness_reduce(@builtin(local_invocation_id) lid: vec3<u32>) {\n    if (lid.x != 0u) { return; }                                     // one lane; no barrier follows (3.5 rule 1)\n    if (P.role == 1u) {                                              // the seed of a batch: P.source is its first source\n        let k = min(32u, P.n - P.source);\n        for (var s = 0u; s < k; s = s + 1u) {\n            let v = P.source + s;\n            let bit = 1u << s;\n            bits[v] = bit;                                           // visited\n            bits[P.bitsBase + v] = bit;                              // the frontier level 0 reads (region 1: level 0's parity is 0)\n            bits[3u * P.bitsBase + v] = 1u;                          // flags: level 0's compact turns them into the list\n        }\n        atomicStore(&counters[0], k);                                // not done\n        atomicStore(&counters[11], U32_MAX);                         // level: the first boundary brings it to 0\n        atomicStore(&counters[15], 0u);                              // done\n        return;\n    }\n    // role 0: the level boundary -- done from the previous level's compacted count, then the accumulation\n    let count = atomicLoad(&counters[0]);\n    atomicStore(&counters[15], select(0u, 1u, count == 0u));\n    let level = atomicLoad(&counters[11]);\n    let d = level + 1u;                                              // the distance of the claims the level just run made\n    for (var s = 0u; s < 32u; s = s + 1u) {\n        let c = atomicLoad(&perSource[s]);                           // newCount[s]\n        atomicStore(&perSource[32u + s], atomicLoad(&perSource[32u + s]) + c);   // reached[s]\n        // sum[s] += c x d in 64 bits: the 16-bit split product (pLo, pHi), then the add with its carry\n        let cLo = c & 0xFFFFu;\n        let cHi = c >> 16u;\n        let dLo = d & 0xFFFFu;\n        let dHi = d >> 16u;\n        let ll = cLo * dLo;\n        let lh = cLo * dHi;\n        let hl = cHi * dLo;\n        let mid = (ll >> 16u) + (lh & 0xFFFFu) + (hl & 0xFFFFu);\n        let pLo = (ll & 0xFFFFu) | ((mid & 0xFFFFu) << 16u);\n        let pHi = (cHi * dHi) + (lh >> 16u) + (hl >> 16u) + (mid >> 16u);\n        var lo = atomicLoad(&perSource[64u + s]);                    // sumLo[s]\n        var hi = atomicLoad(&perSource[96u + s]);                    // sumHi[s]\n        let before = lo;\n        lo = lo + pLo;\n        hi = hi + pHi + select(0u, 1u, lo < before);\n        atomicStore(&perSource[64u + s], lo);\n        atomicStore(&perSource[96u + s], hi);\n        atomicStore(&perSource[s], 0u);\n    }\n    atomicStore(&counters[11], level + 1u);\n}\n";
+//# sourceMappingURL=closeness-reduce.wgsl.d.ts.map

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

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

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

@@ -0,0 +1,65 @@
+/**
+ * The `closeness-reduce` kernel body (design 8.4, 9.7 "integer distances before division"; P8-T11, the P8 plan's
+ * PD-13): the one-lane bookkeeping of the bit-parallel sweep, two roles by `P.role`. Role 0 is the level boundary,
+ * recorded BEFORE the level's `compact` and sweep: `done` is whether the previous level's compacted count is 0 (so the
+ * traversal ends one level after the last claim, one empty sweep and no wrong sum), then for every source `s` the
+ * claims the level just run made (`newCount[s]`) are folded into `reached[s]` and into the 64-bit `sum[s]` at the
+ * distance `level + 1` -- the product as a 16-bit split into a low and a high word, then the add with its carry --
+ * `newCount[s]` is zeroed and `level` advances. Role 1 is the seed of a batch: for the batch's `k = min(32, n -
+ * P.source)` sources, bit `s` into `visited[source_s]` and into the frontier region level 0 reads (region 1, since
+ * level 0's parity is 0), `flags[source_s] = 1` (level 0's `compact` turns the flags into the list; a seeded list
+ * would be overwritten by a compaction of all-zero flags), `counters[0] = k` (not done) and `level = U32_MAX` (so
+ * level 0's boundary accumulates nothing and brings the word to 0, and level 1's counts the distance-1 claims at 1).
+ * No barrier follows the early return of the other lanes (3.5 rule 1). Body only (spec 3.5, D9); the text is
+ * normative: the sabotage rows of test/helpers/sabotage.ts are textual edits of it.
+ */
+export const closenessReduceWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn closeness_reduce(@builtin(local_invocation_id) lid: vec3<u32>) {
+    if (lid.x != 0u) { return; }                                     // one lane; no barrier follows (3.5 rule 1)
+    if (P.role == 1u) {                                              // the seed of a batch: P.source is its first source
+        let k = min(32u, P.n - P.source);
+        for (var s = 0u; s < k; s = s + 1u) {
+            let v = P.source + s;
+            let bit = 1u << s;
+            bits[v] = bit;                                           // visited
+            bits[P.bitsBase + v] = bit;                              // the frontier level 0 reads (region 1: level 0's parity is 0)
+            bits[3u * P.bitsBase + v] = 1u;                          // flags: level 0's compact turns them into the list
+        }
+        atomicStore(&counters[0], k);                                // not done
+        atomicStore(&counters[11], U32_MAX);                         // level: the first boundary brings it to 0
+        atomicStore(&counters[15], 0u);                              // done
+        return;
+    }
+    // role 0: the level boundary -- done from the previous level's compacted count, then the accumulation
+    let count = atomicLoad(&counters[0]);
+    atomicStore(&counters[15], select(0u, 1u, count == 0u));
+    let level = atomicLoad(&counters[11]);
+    let d = level + 1u;                                              // the distance of the claims the level just run made
+    for (var s = 0u; s < 32u; s = s + 1u) {
+        let c = atomicLoad(&perSource[s]);                           // newCount[s]
+        atomicStore(&perSource[32u + s], atomicLoad(&perSource[32u + s]) + c);   // reached[s]
+        // sum[s] += c x d in 64 bits: the 16-bit split product (pLo, pHi), then the add with its carry
+        let cLo = c & 0xFFFFu;
+        let cHi = c >> 16u;
+        let dLo = d & 0xFFFFu;
+        let dHi = d >> 16u;
+        let ll = cLo * dLo;
+        let lh = cLo * dHi;
+        let hl = cHi * dLo;
+        let mid = (ll >> 16u) + (lh & 0xFFFFu) + (hl & 0xFFFFu);
+        let pLo = (ll & 0xFFFFu) | ((mid & 0xFFFFu) << 16u);
+        let pHi = (cHi * dHi) + (lh >> 16u) + (hl >> 16u) + (mid >> 16u);
+        var lo = atomicLoad(&perSource[64u + s]);                    // sumLo[s]
+        var hi = atomicLoad(&perSource[96u + s]);                    // sumHi[s]
+        let before = lo;
+        lo = lo + pLo;
+        hi = hi + pHi + select(0u, 1u, lo < before);
+        atomicStore(&perSource[64u + s], lo);
+        atomicStore(&perSource[96u + s], hi);
+        atomicStore(&perSource[s], 0u);
+    }
+    atomicStore(&counters[11], level + 1u);
+}
+`;
+//# sourceMappingURL=closeness-reduce.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"closeness-reduce.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/closeness-reduce.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgD7C,CAAC"}

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

@@ -0,0 +1,20 @@
+/**
+ * The `closeness-sweep` kernel body (design 8.4 "32 sources per u32 word"; P8-T11, the P8 plan's PD-13 / DEP-P8-E):
+ * one level of the bit-parallel multi-source breadth-first search. The batch's state is one `bits` buffer of four
+ * regions of `P.bitsBase` words each -- `visited` at 0, the two frontier regions at `P.bitsBase` and `2 x P.bitsBase`
+ * (which one is the frontier and which the next swaps by the level's parity, `P.mode`, so nothing is copied between
+ * levels), `flags` at `3 x P.bitsBase` -- with bit `s` of word `v` meaning "source `s` has reached / is at / is next
+ * at `v`". The expansion is `advance-expand`'s block-mapped strip (P8-T5): each workgroup loads up to `WG` entries of
+ * the frontier LIST (the vertices any source is at, compacted from the flags by the host's `compact`), scans their
+ * degrees with the inlined Hillis-Steele scan of `bfs-contract` (this is not a twin kernel: `needs: []`), and every
+ * invocation strips the aggregate by binary search. The claim is inline: for the arc `(u, x)` the mask is the sources
+ * at `u` that have not reached `x`; `atomicOr` on `visited[x]` returns the bits this lane won (`fresh`), which go into
+ * the next region, set `flags[x]` (the flags region is part of the one atomic binding, so a plain store is a compile
+ * error), and are tallied per source in WORKGROUP memory -- one global `atomicAdd` per source per workgroup after the
+ * strip loop, never one per arc. Uniformity (spec 3.5 rule 1): the guarded loads write locals, the scan and the
+ * `workgroupUniformLoad` sit unconditionally after the guard, the strip loop is bounded by the uniform aggregate, and
+ * the flush's barrier follows it in uniform control flow. 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 closenessSweepWgsl = "\nvar<workgroup> sh: array<u32, WG>;                // the block's degrees, then their inclusive scan\nvar<workgroup> rowStart: array<u32, WG>;          // the first bound arc of each entry's row\nvar<workgroup> rowOf: array<u32, WG>;             // the frontier vertex of each entry (the source end of its arcs)\nvar<workgroup> local: array<atomic<u32>, 32>;     // this workgroup's fresh claims per source\nvar<workgroup> wcount: u32;                       // the frontier list's length\n\n@compute @workgroup_size(WG)\nfn closeness_sweep(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    if (lid.x == 0u) { wcount = atomicLoad(&counters[0]); }          // the frontier list's length (compact's total)\n    let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers\n    let nextBase = select(2u * P.bitsBase, P.bitsBase, P.mode == 1u);   // the region that is next this level\n    let frontierBase = 3u * P.bitsBase - nextBase;                   // the other one: the region that is the frontier\n    for (var b0 = group_id(wid) * WG; b0 < count; b0 = b0 + P.stride) {   // grid-stride over blocks of WG entries\n        let i = b0 + lid.x;                                          // this lane's frontier entry\n        var deg = 0u;\n        var start = 0u;\n        var u = 0u;\n        if (i < count) {                                                 // guarded loads into locals (3.5 rule 1)\n            u = frontierList[i];\n            let lo = max(rowPtr[u], P.arcBase);\n            let hi = min(rowPtr[u + 1u], P.arcEnd);\n            start = lo;\n            deg = select(0u, hi - lo, hi > lo);\n        }\n        if (lid.x < 32u) { atomicStore(&local[lid.x], 0u); }            // zeroed before the strip loop (WebGPU zero-initialises workgroup memory; said anyway)\n        sh[lid.x] = deg;\n        rowStart[lid.x] = start;\n        rowOf[lid.x] = u;\n        workgroupBarrier();\n        for (var s = 1u; s < WG; s = s * 2u) {                           // Hillis-Steele inclusive scan of the degrees (bfs-contract's, inlined)\n            var t = 0u;\n            if (lid.x >= s) { t = sh[lid.x - s]; }\n            workgroupBarrier();\n            sh[lid.x] = sh[lid.x] + t;\n            workgroupBarrier();\n        }\n        let aggregate = workgroupUniformLoad(&sh[WG - 1u]);              // uniform; includes a barrier\n        for (var p = lid.x; p < aggregate; p = p + WG) {                 // strip [0, aggregate): lane j takes j, j + WG, ...\n            var lo = 0u;                                                 // upper_bound: the first k with sh[k] > p owns arc p\n            var hi = WG;\n            loop {\n                if (lo >= hi) { break; }\n                let mid = (lo + hi) / 2u;\n                if (sh[mid] > p) { hi = mid; } else { lo = mid + 1u; }\n            }\n            let k = lo;\n            var exclusive = 0u;\n            if (k > 0u) { exclusive = sh[k - 1u]; }\n            let arc = rowStart[k] + (p - exclusive);\n            let x = colIdx[arc - P.arcBase];\n            let mask = atomicLoad(&bits[frontierBase + rowOf[k]]) & ~atomicLoad(&bits[x]);   // the sources at u that have not reached x\n            if (mask != 0u) {\n                let old = atomicOr(&bits[x], mask);                      // visited: the claim, one read-modify-write\n                let fresh = mask & ~old;                                 // the sources whose claim this lane won\n                if (fresh != 0u) {\n                    atomicOr(&bits[nextBase + x], fresh);\n                    atomicStore(&bits[3u * P.bitsBase + x], 1u);         // flags: x is in the next frontier list (compact reads it)\n                    var b = fresh;\n                    loop {                                               // one tally per set bit of fresh\n                        if (b == 0u) { break; }\n                        let s = firstTrailingBit(b);\n                        atomicAdd(&local[s], 1u);\n                        b = b & (b - 1u);\n                    }\n                }\n            }\n        }\n        workgroupBarrier();                                              // uniform: the loop's bound is the uniform aggregate\n        if (lid.x < 32u) {                                               // ONE global atomic per source per workgroup\n            let c = atomicLoad(&local[lid.x]);\n            if (c != 0u) { atomicAdd(&perSource[lid.x], c); }            // newCount[s]\n        }\n        workgroupBarrier();                                              // sh, rowStart, rowOf and local are reused by the next block\n    }\n}\n";
+//# sourceMappingURL=closeness-sweep.wgsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"closeness-sweep.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/closeness-sweep.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,ymJA4E9B,CAAC"}

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

@@ -0,0 +1,96 @@
+/**
+ * The `closeness-sweep` kernel body (design 8.4 "32 sources per u32 word"; P8-T11, the P8 plan's PD-13 / DEP-P8-E):
+ * one level of the bit-parallel multi-source breadth-first search. The batch's state is one `bits` buffer of four
+ * regions of `P.bitsBase` words each -- `visited` at 0, the two frontier regions at `P.bitsBase` and `2 x P.bitsBase`
+ * (which one is the frontier and which the next swaps by the level's parity, `P.mode`, so nothing is copied between
+ * levels), `flags` at `3 x P.bitsBase` -- with bit `s` of word `v` meaning "source `s` has reached / is at / is next
+ * at `v`". The expansion is `advance-expand`'s block-mapped strip (P8-T5): each workgroup loads up to `WG` entries of
+ * the frontier LIST (the vertices any source is at, compacted from the flags by the host's `compact`), scans their
+ * degrees with the inlined Hillis-Steele scan of `bfs-contract` (this is not a twin kernel: `needs: []`), and every
+ * invocation strips the aggregate by binary search. The claim is inline: for the arc `(u, x)` the mask is the sources
+ * at `u` that have not reached `x`; `atomicOr` on `visited[x]` returns the bits this lane won (`fresh`), which go into
+ * the next region, set `flags[x]` (the flags region is part of the one atomic binding, so a plain store is a compile
+ * error), and are tallied per source in WORKGROUP memory -- one global `atomicAdd` per source per workgroup after the
+ * strip loop, never one per arc. Uniformity (spec 3.5 rule 1): the guarded loads write locals, the scan and the
+ * `workgroupUniformLoad` sit unconditionally after the guard, the strip loop is bounded by the uniform aggregate, and
+ * the flush's barrier follows it in uniform control flow. 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 closenessSweepWgsl = /* wgsl */ `
+var<workgroup> sh: array<u32, WG>;                // the block's degrees, then their inclusive scan
+var<workgroup> rowStart: array<u32, WG>;          // the first bound arc of each entry's row
+var<workgroup> rowOf: array<u32, WG>;             // the frontier vertex of each entry (the source end of its arcs)
+var<workgroup> local: array<atomic<u32>, 32>;     // this workgroup's fresh claims per source
+var<workgroup> wcount: u32;                       // the frontier list's length
+
+@compute @workgroup_size(WG)
+fn closeness_sweep(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    if (lid.x == 0u) { wcount = atomicLoad(&counters[0]); }          // the frontier list's length (compact's total)
+    let count = workgroupUniformLoad(&wcount);                       // uniform: the block loop below holds barriers
+    let nextBase = select(2u * P.bitsBase, P.bitsBase, P.mode == 1u);   // the region that is next this level
+    let frontierBase = 3u * P.bitsBase - nextBase;                   // the other one: the region that is the frontier
+    for (var b0 = group_id(wid) * WG; b0 < count; b0 = b0 + P.stride) {   // grid-stride over blocks of WG entries
+        let i = b0 + lid.x;                                          // this lane's frontier entry
+        var deg = 0u;
+        var start = 0u;
+        var u = 0u;
+        if (i < count) {                                                 // guarded loads into locals (3.5 rule 1)
+            u = frontierList[i];
+            let lo = max(rowPtr[u], P.arcBase);
+            let hi = min(rowPtr[u + 1u], P.arcEnd);
+            start = lo;
+            deg = select(0u, hi - lo, hi > lo);
+        }
+        if (lid.x < 32u) { atomicStore(&local[lid.x], 0u); }            // zeroed before the strip loop (WebGPU zero-initialises workgroup memory; said anyway)
+        sh[lid.x] = deg;
+        rowStart[lid.x] = start;
+        rowOf[lid.x] = u;
+        workgroupBarrier();
+        for (var s = 1u; s < WG; s = s * 2u) {                           // Hillis-Steele inclusive scan of the degrees (bfs-contract's, inlined)
+            var t = 0u;
+            if (lid.x >= s) { t = sh[lid.x - s]; }
+            workgroupBarrier();
+            sh[lid.x] = sh[lid.x] + t;
+            workgroupBarrier();
+        }
+        let aggregate = workgroupUniformLoad(&sh[WG - 1u]);              // uniform; includes a barrier
+        for (var p = lid.x; p < aggregate; p = p + WG) {                 // strip [0, aggregate): lane j takes j, j + WG, ...
+            var lo = 0u;                                                 // upper_bound: the first k with sh[k] > p owns arc p
+            var hi = WG;
+            loop {
+                if (lo >= hi) { break; }
+                let mid = (lo + hi) / 2u;
+                if (sh[mid] > p) { hi = mid; } else { lo = mid + 1u; }
+            }
+            let k = lo;
+            var exclusive = 0u;
+            if (k > 0u) { exclusive = sh[k - 1u]; }
+            let arc = rowStart[k] + (p - exclusive);
+            let x = colIdx[arc - P.arcBase];
+            let mask = atomicLoad(&bits[frontierBase + rowOf[k]]) & ~atomicLoad(&bits[x]);   // the sources at u that have not reached x
+            if (mask != 0u) {
+                let old = atomicOr(&bits[x], mask);                      // visited: the claim, one read-modify-write
+                let fresh = mask & ~old;                                 // the sources whose claim this lane won
+                if (fresh != 0u) {
+                    atomicOr(&bits[nextBase + x], fresh);
+                    atomicStore(&bits[3u * P.bitsBase + x], 1u);         // flags: x is in the next frontier list (compact reads it)
+                    var b = fresh;
+                    loop {                                               // one tally per set bit of fresh
+                        if (b == 0u) { break; }
+                        let s = firstTrailingBit(b);
+                        atomicAdd(&local[s], 1u);
+                        b = b & (b - 1u);
+                    }
+                }
+            }
+        }
+        workgroupBarrier();                                              // uniform: the loop's bound is the uniform aggregate
+        if (lid.x < 32u) {                                               // ONE global atomic per source per workgroup
+            let c = atomicLoad(&local[lid.x]);
+            if (c != 0u) { atomicAdd(&perSource[lid.x], c); }            // newCount[s]
+        }
+        workgroupBarrier();                                              // sh, rowStart, rowOf and local are reused by the next block
+    }
+}
+`;
+//# sourceMappingURL=closeness-sweep.wgsl.js.map

package/dist/src/wgsl/closeness-sweep.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"closeness-sweep.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/closeness-sweep.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4E5C,CAAC"}

package/dist/src/wgsl/compact-scatter.wgsl.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The `compact-scatter` kernel body (spec 6 row 4; P8-T3): the scatter step of `compact`, after the caller's flags
+ * have been exclusive-scanned into `offsets`. Every flagged entry lands at its offset, in queue order, so the output
+ * is bitwise reproducible; lane 0 writes the total -- the last offset plus the last flag -- into `outCount[P.outIndex]`
+ * (the block is bound whole and indexed because a four-byte word is never 256-aligned). The planner never dispatches
+ * this body for count 0, so `P.count - 1u` never wraps. Body only (spec 3.5, D9); normative text.
+ */
+export declare const compactScatterWgsl = "\n@compute @workgroup_size(WG)\nfn compact_scatter(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let i = linear_id(wid, lid.x);\n    if (i == 0u) { outCount[P.outIndex] = offsets[P.count - 1u] + flags[P.count - 1u]; }   // the exclusive scan's total; the planner never dispatches for count 0\n    if (i >= P.count) { return; }                                                          // no barrier follows\n    if (flags[i] != 0u) { out[offsets[i]] = queue[i]; }\n}\n";
+//# sourceMappingURL=compact-scatter.wgsl.d.ts.map

package/dist/src/wgsl/compact-scatter.wgsl.d.ts.map

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

package/dist/src/wgsl/compact-scatter.wgsl.js

@@ -0,0 +1,17 @@
+/**
+ * The `compact-scatter` kernel body (spec 6 row 4; P8-T3): the scatter step of `compact`, after the caller's flags
+ * have been exclusive-scanned into `offsets`. Every flagged entry lands at its offset, in queue order, so the output
+ * is bitwise reproducible; lane 0 writes the total -- the last offset plus the last flag -- into `outCount[P.outIndex]`
+ * (the block is bound whole and indexed because a four-byte word is never 256-aligned). The planner never dispatches
+ * this body for count 0, so `P.count - 1u` never wraps. Body only (spec 3.5, D9); normative text.
+ */
+export const compactScatterWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn compact_scatter(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let i = linear_id(wid, lid.x);
+    if (i == 0u) { outCount[P.outIndex] = offsets[P.count - 1u] + flags[P.count - 1u]; }   // the exclusive scan's total; the planner never dispatches for count 0
+    if (i >= P.count) { return; }                                                          // no barrier follows
+    if (flags[i] != 0u) { out[offsets[i]] = queue[i]; }
+}
+`;
+//# sourceMappingURL=compact-scatter.wgsl.js.map

package/dist/src/wgsl/compact-scatter.wgsl.js.map

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

package/dist/src/wgsl/dedupe-claim.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `dedupe-claim` kernel body (spec 6 row 4; P8-T3): the first of `dedupe`'s two dispatches. Every entry stores
+ * its own index into `owner[queue[i]]` (relaxed atomics: between two dispatches last-writer-wins is well defined, so
+ * exactly one index per distinct vertex is the owner). The entry count is `P.count`, or the device word
+ * `counters[P.countIndex]` clamped to `P.count` when `P.countIndex` is not `U32_MAX` (the SSSP piles only know their
+ * count on the device). `owner` needs no reset between calls: a stale or garbage word is only ever read by an entry
+ * whose vertex a current entry has just overwritten. Body only (spec 3.5, D9); normative text.
+ */
+export declare const dedupeClaimWgsl = "\n@compute @workgroup_size(WG)\nfn dedupe_claim(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    var count = P.count;\n    if (P.countIndex != U32_MAX) { count = min(atomicLoad(&counters[P.countIndex]), P.count); }   // a device-side count, clamped to the capacity\n    for (var i = linear_id(wid, lid.x); i < count; i = i + P.stride) {   // grid-stride; no barrier anywhere\n        atomicStore(&owner[queue[i]], i);\n    }\n}\n";
+//# sourceMappingURL=dedupe-claim.wgsl.d.ts.map

package/dist/src/wgsl/dedupe-claim.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedupe-claim.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/dedupe-claim.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,6dAS3B,CAAC"}

package/dist/src/wgsl/dedupe-claim.wgsl.js

@@ -0,0 +1,19 @@
+/**
+ * The `dedupe-claim` kernel body (spec 6 row 4; P8-T3): the first of `dedupe`'s two dispatches. Every entry stores
+ * its own index into `owner[queue[i]]` (relaxed atomics: between two dispatches last-writer-wins is well defined, so
+ * exactly one index per distinct vertex is the owner). The entry count is `P.count`, or the device word
+ * `counters[P.countIndex]` clamped to `P.count` when `P.countIndex` is not `U32_MAX` (the SSSP piles only know their
+ * count on the device). `owner` needs no reset between calls: a stale or garbage word is only ever read by an entry
+ * whose vertex a current entry has just overwritten. Body only (spec 3.5, D9); normative text.
+ */
+export const dedupeClaimWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn dedupe_claim(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    var count = P.count;
+    if (P.countIndex != U32_MAX) { count = min(atomicLoad(&counters[P.countIndex]), P.count); }   // a device-side count, clamped to the capacity
+    for (var i = linear_id(wid, lid.x); i < count; i = i + P.stride) {   // grid-stride; no barrier anywhere
+        atomicStore(&owner[queue[i]], i);
+    }
+}
+`;
+//# sourceMappingURL=dedupe-claim.wgsl.js.map

package/dist/src/wgsl/dedupe-claim.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedupe-claim.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/dedupe-claim.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;CASzC,CAAC"}

package/dist/src/wgsl/dedupe-filter.wgsl.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The `dedupe-filter` kernel body (spec 6 row 4; P8-T3): the second of `dedupe`'s two dispatches, a SEPARATE
+ * dispatch because a plain store read back in the same one is a data race (WGSL 6.5.7). An entry survives iff
+ * `owner[queue[i]]` still holds its own index; the survivors are packed by a Hillis-Steele inclusive scan of the keep
+ * bits in workgroup memory (scan-block's rounds and barrier placement, verbatim) and ONE `atomicAdd` per workgroup on
+ * `outCount[P.outIndex]` for the block's aggregate, so the output is set-deterministic: the surviving SET is fixed,
+ * the order inside `out` follows the schedule. The entry count is `P.count` or the device word
+ * `outCount[P.countIndex]` clamped to it -- the same block and the same word `dedupe-claim` read. Every lane reaches
+ * every barrier: the guarded work goes into locals (spec 3.5 rule 1). Body only (spec 3.5, D9); normative text.
+ */
+export declare const dedupeFilterWgsl = "\nvar<workgroup> sh: array<u32, WG>;\nvar<workgroup> base: u32;\nvar<workgroup> wcount: u32;\n\n@compute @workgroup_size(WG)\nfn dedupe_filter(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    if (lid.x == 0u) {\n        var count = P.count;\n        if (P.countIndex != U32_MAX) { count = min(atomicLoad(&outCount[P.countIndex]), P.count); }   // the same count source as the claim\n        wcount = count;\n    }\n    let count = workgroupUniformLoad(&wcount);                                            // uniform: the block loop below holds barriers\n    for (var b0 = group_id(wid) * WG; b0 < count; b0 = b0 + P.stride) {                  // grid-stride over blocks of WG entries\n        let i = b0 + lid.x;\n        var keep = 0u;\n        var v = 0u;\n        if (i < count) { v = queue[i]; keep = select(0u, 1u, atomicLoad(&owner[v]) == i); }   // guarded work into locals\n        sh[lid.x] = keep;\n        workgroupBarrier();                                                                   // every lane, unconditionally (3.5 rule 1)\n        for (var s = 1u; s < WG; s = s * 2u) {                                                // Hillis-Steele inclusive scan of keep\n            var t = 0u;\n            if (lid.x >= s) { t = sh[lid.x - s]; }\n            workgroupBarrier();\n            sh[lid.x] = sh[lid.x] + t;\n            workgroupBarrier();\n        }\n        let inclusive = sh[lid.x];\n        if (lid.x == WG - 1u) { base = atomicAdd(&outCount[P.outIndex], inclusive); }         // ONE atomic per workgroup: the block's aggregate\n        workgroupBarrier();\n        if (keep == 1u) { out[base + inclusive - 1u] = v; }\n        workgroupBarrier();                                                                   // sh and base are reused by the next block\n    }\n}\n";
+//# sourceMappingURL=dedupe-filter.wgsl.d.ts.map

package/dist/src/wgsl/dedupe-filter.wgsl.d.ts.map

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

package/dist/src/wgsl/dedupe-filter.wgsl.js

@@ -0,0 +1,46 @@
+/**
+ * The `dedupe-filter` kernel body (spec 6 row 4; P8-T3): the second of `dedupe`'s two dispatches, a SEPARATE
+ * dispatch because a plain store read back in the same one is a data race (WGSL 6.5.7). An entry survives iff
+ * `owner[queue[i]]` still holds its own index; the survivors are packed by a Hillis-Steele inclusive scan of the keep
+ * bits in workgroup memory (scan-block's rounds and barrier placement, verbatim) and ONE `atomicAdd` per workgroup on
+ * `outCount[P.outIndex]` for the block's aggregate, so the output is set-deterministic: the surviving SET is fixed,
+ * the order inside `out` follows the schedule. The entry count is `P.count` or the device word
+ * `outCount[P.countIndex]` clamped to it -- the same block and the same word `dedupe-claim` read. Every lane reaches
+ * every barrier: the guarded work goes into locals (spec 3.5 rule 1). Body only (spec 3.5, D9); normative text.
+ */
+export const dedupeFilterWgsl = /* wgsl */ `
+var<workgroup> sh: array<u32, WG>;
+var<workgroup> base: u32;
+var<workgroup> wcount: u32;
+
+@compute @workgroup_size(WG)
+fn dedupe_filter(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    if (lid.x == 0u) {
+        var count = P.count;
+        if (P.countIndex != U32_MAX) { count = min(atomicLoad(&outCount[P.countIndex]), P.count); }   // the same count source as the claim
+        wcount = count;
+    }
+    let count = workgroupUniformLoad(&wcount);                                            // uniform: the block loop below holds barriers
+    for (var b0 = group_id(wid) * WG; b0 < count; b0 = b0 + P.stride) {                  // grid-stride over blocks of WG entries
+        let i = b0 + lid.x;
+        var keep = 0u;
+        var v = 0u;
+        if (i < count) { v = queue[i]; keep = select(0u, 1u, atomicLoad(&owner[v]) == i); }   // guarded work into locals
+        sh[lid.x] = keep;
+        workgroupBarrier();                                                                   // every lane, unconditionally (3.5 rule 1)
+        for (var s = 1u; s < WG; s = s * 2u) {                                                // Hillis-Steele inclusive scan of keep
+            var t = 0u;
+            if (lid.x >= s) { t = sh[lid.x - s]; }
+            workgroupBarrier();
+            sh[lid.x] = sh[lid.x] + t;
+            workgroupBarrier();
+        }
+        let inclusive = sh[lid.x];
+        if (lid.x == WG - 1u) { base = atomicAdd(&outCount[P.outIndex], inclusive); }         // ONE atomic per workgroup: the block's aggregate
+        workgroupBarrier();
+        if (keep == 1u) { out[base + inclusive - 1u] = v; }
+        workgroupBarrier();                                                                   // sh and base are reused by the next block
+    }
+}
+`;
+//# sourceMappingURL=dedupe-filter.wgsl.js.map

package/dist/src/wgsl/dedupe-filter.wgsl.js.map

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

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

@@ -0,0 +1,59 @@
+/**
+ * The `frontier-finalize` kernel body (design 5.4, 6 row 7; P8-T4, the P8 plan's PD-3 / PD-23 / DEP-P8-C): the
+ * device-side selector of the frontier family. One workgroup, one lane, no barrier after the early return (spec 3.5
+ * rule 1). It is recorded TWICE per level, in two roles chosen by `P.role`, because a level's dispatch sizes become
+ * known at two moments: role 0 runs at the START of a level -- rotates `nextFrontierCount` into `frontierCount`,
+ * advances `level`, decides `done` (an empty frontier, or `level >= P.maxDepth`), chooses the path and writes this
+ * level's seven 16-byte slots at `P.slotBase`; role 1 runs once the edge queue is filled -- clamps `edgeCount` to
+ * `P.edgeCapacity`, sizes the contract slot, or, when `edgeCountUnclamped` exceeds the capacity, zeroes it and sizes
+ * the fused-retry slot from `frontierCount` instead (PD-23). Two rules: a boundary that finds `done` set zeroes its
+ * slots and moves no counter word (the host records levels past the end); role 1 counts a two-phase level only when
+ * role 0 chose one, which it reads from slot 0's `x` (a storage write of one dispatch is visible to the next of the
+ * same pass). The `(x, y)` arithmetic is `indirect-finalize`'s verbatim (P4), so a count above 2^32 - wg cannot wrap
+ * and a group count above MAX_WORKGROUPS_PER_DIM splits in 2D; slots 2 and 6 are sized one WORKGROUP per entry for
+ * `bfs-fused`; slots 3, 4 and 5 (the bits fill over `ceil(n / 32)` words, the bitset build over the frontier, the sweep
+ * over the unvisited list) are the bottom-up level's.
+ *
+ * Roles 2 and 3 are the SSSP round boundary of the near-far loop (P8-T9, PD-20), over the same block read in its
+ * SSSP sense (word 1 the raw near half's appends, 21 the raw far half's, 0 and 20 the deduped pile counts, 22 the
+ * threshold, 23 the delta, 4 the previous threshold, 14 the round's mode) and the same seven slots: role 2 finds a
+ * non-empty raw near half and sizes the near dedupe (slots 0 and 1, count word 1, output word 0) in mode 0; finds it
+ * empty and the far half not, raises the threshold by the delta (one f32 add; an add that returns the threshold
+ * unchanged sets `done 3`, the host's E_UNSUPPORTED), remembers the previous threshold in word 4 and sizes the far
+ * dedupe (slots 3 and 4, count word 21, output word 20) in mode 1; finds both empty and sets `done 1`; and finds a
+ * raw half above the capacity and sets `done 2` (the host's E_TOO_LARGE). It counts a round in `level` when it
+ * picks a mode and NOT at the done boundary, so `level` at the end is the number of relax rounds dispatched; a
+ * boundary that finds `done` set obeys rule 1. Role 3 runs once the dedupe has landed: mode 0 sizes slot 2 (the
+ * relax over nearIn) from word 0 and restarts the raw near half (word 1 to 0); mode 1 sizes slot 5 (the pass-through
+ * over farIn) from word 20 and restarts the raw far half (word 21 to 0).
+ *
+ * Beamer's test (P8-T8, PD-21), evaluated at every boundary BEFORE the `done` branch (so a switch can be counted at
+ * the done boundary too, which the host model of the tests mirrors): top-down switches to bottom-up when
+ * `frontierDegreeSum > unvisitedDegreeSum / alpha` (u32 division; alpha the host's `max(1, floor(arcCount / n))`
+ * unless tuned) and the frontier is growing (`next > frontierCount`); bottom-up switches back when
+ * `next * beta < unvisitedCount` (a u32 product, wrapping only above 178M vertices, which no admitted device
+ * reaches) and the frontier is shrinking; `P.mode == 1` (the driver's `"top-down"`) pins the direction at 0. Every
+ * change is counted in `switches`, the previous direction is word 14. The two unvisited words the test reads are
+ * rebuilt exactly once per submit by `bfs-unvisited-flags` (PD-18) and maintained here by subtraction: the count is
+ * subtracted from the SECOND boundary of a submit on and the degree sum from the THIRD on, because a boundary may
+ * only subtract what the submit's rebuild counted, and the frontier whose degree sum the second boundary holds was
+ * claimed before the rebuild ran (the rebuild counts the vertices unclaimed when it runs; the frontier rotated in at
+ * boundary 0 was claimed by the previous submit's last contract, so it was never in the sum; boundary b subtracts
+ * `next = |F_b|`, inside the sum iff b >= 1, and `degSum = deg(F_{b-1})`, inside it iff b >= 2). The degree sum is
+ * the "unvisited degree estimate" of the design rather than an exact count for two reasons: it is one level stale
+ * (a frontier's degree sum is only known once it has been expanded), and a bottom-up level expands nothing, so the
+ * word stops falling while bottom-up runs and overstates the set afterwards. The bias is one-directional -- an
+ * overstated m_u makes the switch INTO bottom-up harder, never easier -- and the next submit's rebuild makes it
+ * exact again. Body only (spec 3.5, D9); the text is normative: the sabotage rows of test/helpers/sabotage.ts are
+ * textual edits of it.
+ *
+ * Since 2026-09-25 nothing dispatches FROM the slots (G8-F5: Dawn's validation of an indirect dispatch cost about
+ * 0.4 ms of device time each, whether or not it dispatched anything, and the seven slots of thirty-two recorded
+ * levels were 97 % of a traversal's wall time). Every level kernel is a direct grid-stride dispatch that reads the
+ * `path` word (24) this kernel writes -- 0 nothing (done, or a level past the end), 1 two-phase, 2 fused, 3
+ * bottom-up, 4 the fused retry (role 1), 5 a near SSSP round, 6 a far one (role 2) -- and the SSSP dedupes read
+ * their counts from words 8 and 9, which role 2 writes. The slots stay as the selector's recorded decision, read
+ * back by the frontier tests; deleting them with those tests is the follow-up.
+ */
+export declare const frontierFinalizeWgsl = "\nfn write_slot_groups(slot: u32, groups: u32, count: u32) {           // groups workgroups, split in 2D above the per-dim limit\n    var x = groups;\n    var y = 1u;\n    if (groups > MAX_WORKGROUPS_PER_DIM) {\n        x = MAX_WORKGROUPS_PER_DIM;\n        y = (groups + MAX_WORKGROUPS_PER_DIM - 1u) / MAX_WORKGROUPS_PER_DIM;\n    }\n    let base = 4u * (P.slotBase + slot);                               // 16-byte slots: (x, y, 1, count)\n    args[base] = x; args[base + 1u] = y; args[base + 2u] = 1u; args[base + 3u] = count;\n}\nfn write_slot(slot: u32, count: u32) {                                // one INVOCATION per entry: ceil(count / wg) workgroups\n    let groups = count / P.wg + select(0u, 1u, count % P.wg != 0u);   // ceil(count / wg) without the u32 wrap (indirect-finalize's rule)\n    write_slot_groups(slot, groups, count);\n}\nfn zero_slot(slot: u32) {\n    let base = 4u * (P.slotBase + slot);\n    args[base] = 0u; args[base + 1u] = 0u; args[base + 2u] = 1u; args[base + 3u] = 0u;\n}\n\n@compute @workgroup_size(WG)\nfn frontier_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 == 0u) {                                                // the level boundary\n        if (atomicLoad(&counters[15]) != 0u) {                         // done already: a no-op level the host recorded past the end\n            for (var s = 0u; s < 7u; s = s + 1u) { zero_slot(s); }     // this slotBase holds the previous submit's args\n            return;                                                    // no counter word moves (P8-T6's levels formula reads them)\n        }\n        let finished = atomicLoad(&counters[0]);\n        let next = atomicLoad(&counters[1]);\n        let degSum = atomicLoad(&counters[2]);\n        atomicStore(&counters[3], finished);                           // prevFrontierCount\n        atomicStore(&counters[4], degSum);                             // prevDegreeSum\n        atomicStore(&counters[0], next);                               // the rotation\n        atomicStore(&counters[1], 0u);\n        atomicStore(&counters[2], 0u);\n        atomicStore(&counters[8], 0u);                                 // edgeCount\n        atomicStore(&counters[9], 0u);                                 // edgeCountUnclamped\n        atomicStore(&counters[12], atomicLoad(&counters[12]) + next);  // visitedCount\n        if (P.firstOfSubmit >= 1u) {                                   // b = the boundary's index inside its submit, clamped to 2 (P8-T8, PD-18)\n            atomicStore(&counters[5], atomicLoad(&counters[5]) - next);    // unvisitedCount (exact): F_b was inside the submit's rebuilt sum iff b >= 1\n        }\n        if (P.firstOfSubmit >= 2u) {\n            atomicStore(&counters[6], atomicLoad(&counters[6]) - degSum);  // unvisitedDegreeSum (one level stale): F_{b-1} was inside it iff b >= 2\n        }\n        let level = atomicLoad(&counters[11]) + 1u;                    // the seed is U32_MAX, so the first boundary lands on 0\n        atomicStore(&counters[11], level);\n        let done = (next == 0u) || (level >= P.maxDepth);\n        atomicStore(&counters[15], select(0u, 1u, done));\n        var direction = atomicLoad(&counters[14]);\n        if (P.mode == 1u) {\n            direction = 0u;                                                 // top-down only (the test seam)\n        } else if (direction == 0u) {\n            if (degSum > atomicLoad(&counters[6]) / P.alpha && next > finished) { direction = 1u; }   // m_f > m_u / alpha and growing\n        } else {\n            if (next * P.beta < atomicLoad(&counters[5]) && next < finished) { direction = 0u; }      // next * beta < unvisited and shrinking\n        }\n        if (direction != atomicLoad(&counters[14])) { atomicStore(&counters[13], atomicLoad(&counters[13]) + 1u); }   // switches\n        var path = 0u;                                                 // word 24: what the level's kernels run (0 nothing, 1 two-phase, 2 fused, 3 bottom-up; role 1 writes 4 for the retry)\n        if (done) {\n            for (var s = 0u; s < 7u; s = s + 1u) { zero_slot(s); }\n        } else if (direction == 1u) {                                  // the bottom-up level (P8-T8): the bits fill, the bitset build, the sweep\n            zero_slot(0u); zero_slot(1u); zero_slot(2u); zero_slot(6u);\n            write_slot(3u, (P.n + 31u) / 32u); write_slot(4u, next); write_slot(5u, atomicLoad(&counters[7]));\n            path = 3u;\n            atomicStore(&counters[19], atomicLoad(&counters[19]) + 1u);\n        } else if (next < P.fusedMax) {                                // P8-T7 makes this branch reachable (fusedMax is 0 until then)\n            zero_slot(0u); zero_slot(1u); zero_slot(3u); zero_slot(4u); zero_slot(5u); zero_slot(6u);\n            write_slot_groups(2u, next, next);                         // bfs-fused is one WORKGROUP per frontier entry\n            path = 2u;\n            atomicStore(&counters[17], atomicLoad(&counters[17]) + 1u);\n        } else {\n            zero_slot(2u); zero_slot(3u); zero_slot(4u); zero_slot(5u);\n            write_slot(0u, next);                                      // slots 1 and 6 are role 1's\n            path = 1u;\n        }\n        atomicStore(&counters[14], direction);\n        atomicStore(&counters[24], path);\n    } else if (P.role == 1u) {                                         // the edge queue is filled\n        if (args[4u * P.slotBase] == 0u) {                             // role 0 did not choose the two-phase path (done, fused or bottom-up): nothing to size, nothing to count\n            zero_slot(1u); zero_slot(6u);\n            return;\n        }\n        let clamped = min(atomicLoad(&counters[8]), P.edgeCapacity);\n        atomicStore(&counters[8], clamped);\n        if (atomicLoad(&counters[9]) > P.edgeCapacity) {               // PD-23: the fused retry\n            let entries = atomicLoad(&counters[0]);\n            zero_slot(1u); write_slot_groups(6u, entries, entries);    // one workgroup per frontier entry, as slot 2\n            atomicStore(&counters[24], 4u);                            // the path word: bfs-fused runs the retry, bfs-contract nothing\n            atomicStore(&counters[10], atomicLoad(&counters[10]) + 1u);\n            atomicStore(&counters[17], atomicLoad(&counters[17]) + 1u);\n        } else {\n            write_slot(1u, clamped); zero_slot(6u);\n            atomicStore(&counters[18], atomicLoad(&counters[18]) + 1u);   // twoPhaseLevels counts the CHOICE role 0 made, even for zero edges (P8-T7 Step 4's invariant)\n        }\n    } else if (P.role == 2u) {                                         // the SSSP round boundary (P8-T9, PD-20): which pile this round relaxes\n        atomicStore(&counters[8], 0u);                                 // the dedupe counts (words 8 and 9, the SSSP sense) and the path word: nothing unless a pile is chosen below\n        atomicStore(&counters[9], 0u);\n        atomicStore(&counters[24], 0u);\n        if (atomicLoad(&counters[15]) != 0u) {                         // done already: a no-op round the host recorded past the end (rule 1)\n            for (var s = 0u; s < 7u; s = s + 1u) { zero_slot(s); }\n            return;\n        }\n        let nearRaw = atomicLoad(&counters[1]);                        // the raw near half's appends, unclamped\n        let farRaw = atomicLoad(&counters[21]);                        // the raw far half's appends, unclamped\n        if (nearRaw > P.edgeCapacity || farRaw > P.edgeCapacity) {     // a pile overflowed its half: the host raises E_TOO_LARGE\n            atomicStore(&counters[15], 2u);\n            for (var s = 0u; s < 7u; s = s + 1u) { zero_slot(s); }\n            return;\n        }\n        zero_slot(2u); zero_slot(5u); zero_slot(6u);                   // role 3 sizes the relax slots once the piles are deduped\n        if (nearRaw != 0u) {                                           // a near round: dedupe the near half into nearIn\n            atomicStore(&counters[0], 0u);                             // the deduped near count, accumulated by dedupe-filter\n            atomicStore(&counters[14], 0u);                            // mode 0\n            write_slot(0u, nearRaw); write_slot(1u, nearRaw);          // dedupe-claim, dedupe-filter over the near half\n            atomicStore(&counters[8], nearRaw);                        // the near dedupe's count word\n            atomicStore(&counters[24], 5u);                            // the path word: sssp-relax role 0 runs, role 1 nothing\n            zero_slot(3u); zero_slot(4u);\n            atomicStore(&counters[11], atomicLoad(&counters[11]) + 1u);   // rounds dispatched (the done boundary is not counted)\n        } else if (farRaw != 0u) {                                     // the near pile is empty: raise the threshold and re-bucket the far pile\n            let threshold = bitcast<f32>(atomicLoad(&counters[22]));\n            let raised = threshold + bitcast<f32>(atomicLoad(&counters[23]));   // ONE f32 add on the bit patterns (PD-9)\n            if (raised == threshold) {                                 // the delta is below the threshold's ulp: the host raises E_UNSUPPORTED\n                atomicStore(&counters[15], 3u);\n                for (var s = 0u; s < 7u; s = s + 1u) { zero_slot(s); }\n                return;\n            }\n            atomicStore(&counters[4], atomicLoad(&counters[22]));      // prevThresholdBits: what the pass-through drops below\n            atomicStore(&counters[22], bitcast<u32>(raised));\n            atomicStore(&counters[20], 0u);                            // the deduped far count, accumulated by dedupe-filter\n            atomicStore(&counters[14], 1u);                            // mode 1\n            zero_slot(0u); zero_slot(1u);\n            write_slot(3u, farRaw); write_slot(4u, farRaw);            // dedupe-claim, dedupe-filter over the far half\n            atomicStore(&counters[9], farRaw);                         // the far dedupe's count word\n            atomicStore(&counters[24], 6u);                            // the path word: sssp-relax role 1 runs, role 0 nothing\n            atomicStore(&counters[11], atomicLoad(&counters[11]) + 1u);\n        } else {                                                       // both piles empty: finished\n            atomicStore(&counters[15], 1u);\n            for (var s = 0u; s < 7u; s = s + 1u) { zero_slot(s); }\n        }\n    } else if (P.role == 3u) {                                         // the piles are deduped: size the relax\n        if (atomicLoad(&counters[15]) != 0u) { return; }               // role 2 zeroed every slot of the round\n        if (atomicLoad(&counters[14]) == 0u) {\n            write_slot(2u, atomicLoad(&counters[0]));                  // the near round over nearIn\n            atomicStore(&counters[1], 0u);                             // the raw near half restarts\n        } else {\n            write_slot(5u, atomicLoad(&counters[20]));                 // the pass-through over farIn\n            atomicStore(&counters[21], 0u);                            // the raw far half restarts (the pass-through re-appends what stays far)\n        }\n    }\n}\n";
+//# sourceMappingURL=frontier-finalize.wgsl.d.ts.map

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

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