@graphty/webgpu-graph-algorithms 0.6.4 → 0.6.6

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

@@ -1,59 +1,54 @@
 /**
  * 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.
+ * rule 1). It is recorded TWICE per level, in two roles chosen by `P.role`, because a level's counts 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`) and chooses the path; role 1 runs once the
+ * edge queue is filled -- clamps `edgeCount` to `P.edgeCapacity`, or, when `edgeCountUnclamped` exceeds the
+ * capacity, switches the path to the fused retry over `frontierCount` (PD-23). The decision is ONE word of the
+ * counters block, `path` (word 24): 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). Every level kernel is a direct grid-stride
+ * dispatch that reads that word first and runs only when it names it (decision record
+ * design/decisions/2026-09-25-frontier-kernels-dispatch-directly.md: Dawn's validation of an indirect dispatch cost
+ * about 0.4 ms of device time each, and the seven indirect slots this kernel once wrote per level were 97 % of a
+ * traversal's wall time; the slots and their args buffer are gone). Two rules: a boundary that finds `done` set
+ * 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 the path word (a storage write of one dispatch is visible to the next of the same
+ * pass).
  *
  * 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
+ * threshold, 23 the delta, 4 the previous threshold, 14 the round's mode): role 2 finds a non-empty raw near half
+ * and sizes the near dedupe (count word 1, output word 0; the dedupe's count in word 8) 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).
+ * dedupe (count word 21, output word 20; the dedupe's count in word 9) 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 and restarts the
+ * raw half the round consumed: mode 0 restarts the raw near half (word 1 to 0), mode 1 the raw far half (word 21
+ * to 0); the relax kernels size themselves from words 0 and 20.
  *
- * 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.
+ * Beamer's test (P8-T8, PD-21; amended for issue #391), 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 `nextDegreeSum > 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. `nextDegreeSum` (word
+ * 25) is Beamer's m_f measured EXACTLY: `bfs-next-degree` sums the out-degrees of the vertices a level claims at
+ * the end of that level, so the boundary that rotates them in as `next` compares the degree of the frontier it is
+ * about to expand -- not, as before the amendment, `frontierDegreeSum` (word 2), the degree of the frontier the
+ * previous level EXPANDED, one level stale and 0 after a bottom-up level, which on the 1M / 10M R-MAT missed the
+ * switch at the level holding 13.6M of the 21M arcs. Word 2 is still accumulated by the expansion and rotated into
+ * word 4 for the inspect seam. The two unvisited words are rebuilt exactly once per submit by `bfs-unvisited-flags`
+ * (PD-18) and maintained here by subtraction from the SECOND boundary of a submit on, because a boundary may only
+ * subtract what the submit's rebuild counted: the rebuild counts the vertices unclaimed when it runs, the frontier
+ * rotated in at boundary 0 was claimed by the previous submit's last level, so it was never in the sums, and
+ * boundary b subtracts `next = |F_b|` and `nextDegreeSum = deg(F_b)`, both inside the sums iff b >= 1. Both words
+ * are therefore exact at every boundary, bottom-up levels included (the sweep's claims are summed like any other).
+ * 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 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";
+export declare const frontierFinalizeWgsl = "\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            atomicStore(&counters[24], 0u);                            // the path word is the only word that moves (P8-T6's levels formula reads the rest)\n            return;\n        }\n        let finished = atomicLoad(&counters[0]);\n        let next = atomicLoad(&counters[1]);\n        let degSum = atomicLoad(&counters[2]);\n        let nextDeg = atomicLoad(&counters[25]);                       // deg(F_b), summed by bfs-next-degree when F_b was claimed (issue #391)\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[25], 0u);                                // the next level's claims sum from 0\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 (P8-T8, PD-18): F_b was inside the submit's rebuilt sums iff b >= 1\n            atomicStore(&counters[5], atomicLoad(&counters[5]) - next);       // unvisitedCount, exact\n            atomicStore(&counters[6], atomicLoad(&counters[6]) - nextDeg);    // unvisitedDegreeSum, exact (issue #391: no longer one level stale)\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 (nextDeg > atomicLoad(&counters[6]) / P.alpha && next > finished) { direction = 1u; }   // m_f > m_u / alpha and growing, m_f the degree of the frontier about to be expanded\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            path = 0u;\n        } else if (direction == 1u) {                                  // the bottom-up level (P8-T8): the bits fill, the bitset build, the sweep\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            path = 2u;                                                 // bfs-fused: one WORKGROUP per frontier entry\n            atomicStore(&counters[17], atomicLoad(&counters[17]) + 1u);\n        } else {\n            path = 1u;                                                 // advance-expand, then role 1 and bfs-contract\n        }\n        atomicStore(&counters[14], direction);\n        atomicStore(&counters[24], path);\n    } else if (P.role == 1u) {                                         // the edge queue is filled\n        if (atomicLoad(&counters[24]) != 1u) {                         // role 0 did not choose the two-phase path (done, fused or bottom-up): nothing to clamp, nothing to count\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            atomicStore(&counters[24], 4u);                            // the path word: bfs-fused runs the retry over frontierCount, bfs-contract nothing\n            atomicStore(&counters[10], atomicLoad(&counters[10]) + 1u);\n            atomicStore(&counters[17], atomicLoad(&counters[17]) + 1u);\n        } else {\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            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            return;\n        }\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            atomicStore(&counters[8], nearRaw);                        // the near dedupe's count word (dedupe-claim, dedupe-filter over the near half)\n            atomicStore(&counters[24], 5u);                            // the path word: sssp-relax role 0 runs, role 1 nothing\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                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            atomicStore(&counters[9], farRaw);                         // the far dedupe's count word (dedupe-claim, dedupe-filter over the far half)\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        }\n    } else if (P.role == 3u) {                                         // the piles are deduped: restart the raw half the round consumed\n        if (atomicLoad(&counters[15]) != 0u) { return; }               // role 2 chose no pile this round\n        if (atomicLoad(&counters[14]) == 0u) {\n            atomicStore(&counters[1], 0u);                             // the raw near half restarts (sssp-relax role 0 sizes itself from word 0)\n        } else {\n            atomicStore(&counters[21], 0u);                            // the raw far half restarts (the pass-through re-appends what stays far; role 1 sizes itself from word 20)\n        }\n    }\n}\n";
 //# sourceMappingURL=frontier-finalize.wgsl.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"frontier-finalize.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/frontier-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,eAAO,MAAM,oBAAoB,s5RA+GhC,CAAC"}

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

@@ -1,104 +1,80 @@
 /**
  * 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.
+ * rule 1). It is recorded TWICE per level, in two roles chosen by `P.role`, because a level's counts 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`) and chooses the path; role 1 runs once the
+ * edge queue is filled -- clamps `edgeCount` to `P.edgeCapacity`, or, when `edgeCountUnclamped` exceeds the
+ * capacity, switches the path to the fused retry over `frontierCount` (PD-23). The decision is ONE word of the
+ * counters block, `path` (word 24): 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). Every level kernel is a direct grid-stride
+ * dispatch that reads that word first and runs only when it names it (decision record
+ * design/decisions/2026-09-25-frontier-kernels-dispatch-directly.md: Dawn's validation of an indirect dispatch cost
+ * about 0.4 ms of device time each, and the seven indirect slots this kernel once wrote per level were 97 % of a
+ * traversal's wall time; the slots and their args buffer are gone). Two rules: a boundary that finds `done` set
+ * 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 the path word (a storage write of one dispatch is visible to the next of the same
+ * pass).
  *
  * 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
+ * threshold, 23 the delta, 4 the previous threshold, 14 the round's mode): role 2 finds a non-empty raw near half
+ * and sizes the near dedupe (count word 1, output word 0; the dedupe's count in word 8) 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).
+ * dedupe (count word 21, output word 20; the dedupe's count in word 9) 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 and restarts the
+ * raw half the round consumed: mode 0 restarts the raw near half (word 1 to 0), mode 1 the raw far half (word 21
+ * to 0); the relax kernels size themselves from words 0 and 20.
  *
- * 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.
+ * Beamer's test (P8-T8, PD-21; amended for issue #391), 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 `nextDegreeSum > 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. `nextDegreeSum` (word
+ * 25) is Beamer's m_f measured EXACTLY: `bfs-next-degree` sums the out-degrees of the vertices a level claims at
+ * the end of that level, so the boundary that rotates them in as `next` compares the degree of the frontier it is
+ * about to expand -- not, as before the amendment, `frontierDegreeSum` (word 2), the degree of the frontier the
+ * previous level EXPANDED, one level stale and 0 after a bottom-up level, which on the 1M / 10M R-MAT missed the
+ * switch at the level holding 13.6M of the 21M arcs. Word 2 is still accumulated by the expansion and rotated into
+ * word 4 for the inspect seam. The two unvisited words are rebuilt exactly once per submit by `bfs-unvisited-flags`
+ * (PD-18) and maintained here by subtraction from the SECOND boundary of a submit on, because a boundary may only
+ * subtract what the submit's rebuild counted: the rebuild counts the vertices unclaimed when it runs, the frontier
+ * rotated in at boundary 0 was claimed by the previous submit's last level, so it was never in the sums, and
+ * boundary b subtracts `next = |F_b|` and `nextDegreeSum = deg(F_b)`, both inside the sums iff b >= 1. Both words
+ * are therefore exact at every boundary, bottom-up levels included (the sweep's claims are summed like any other).
+ * 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 frontierFinalizeWgsl = /* wgsl */ `
-fn write_slot_groups(slot: u32, groups: u32, count: u32) {           // groups workgroups, split in 2D above the per-dim limit
-    var x = groups;
-    var y = 1u;
-    if (groups > MAX_WORKGROUPS_PER_DIM) {
-        x = MAX_WORKGROUPS_PER_DIM;
-        y = (groups + MAX_WORKGROUPS_PER_DIM - 1u) / MAX_WORKGROUPS_PER_DIM;
-    }
-    let base = 4u * (P.slotBase + slot);                               // 16-byte slots: (x, y, 1, count)
-    args[base] = x; args[base + 1u] = y; args[base + 2u] = 1u; args[base + 3u] = count;
-}
-fn write_slot(slot: u32, count: u32) {                                // one INVOCATION per entry: ceil(count / wg) workgroups
-    let groups = count / P.wg + select(0u, 1u, count % P.wg != 0u);   // ceil(count / wg) without the u32 wrap (indirect-finalize's rule)
-    write_slot_groups(slot, groups, count);
-}
-fn zero_slot(slot: u32) {
-    let base = 4u * (P.slotBase + slot);
-    args[base] = 0u; args[base + 1u] = 0u; args[base + 2u] = 1u; args[base + 3u] = 0u;
-}
-
 @compute @workgroup_size(WG)
 fn frontier_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 == 0u) {                                                // the level boundary
         if (atomicLoad(&counters[15]) != 0u) {                         // done already: a no-op level the host recorded past the end
-            for (var s = 0u; s < 7u; s = s + 1u) { zero_slot(s); }     // this slotBase holds the previous submit's args
-            return;                                                    // no counter word moves (P8-T6's levels formula reads them)
+            atomicStore(&counters[24], 0u);                            // the path word is the only word that moves (P8-T6's levels formula reads the rest)
+            return;
         }
         let finished = atomicLoad(&counters[0]);
         let next = atomicLoad(&counters[1]);
         let degSum = atomicLoad(&counters[2]);
+        let nextDeg = atomicLoad(&counters[25]);                       // deg(F_b), summed by bfs-next-degree when F_b was claimed (issue #391)
         atomicStore(&counters[3], finished);                           // prevFrontierCount
         atomicStore(&counters[4], degSum);                             // prevDegreeSum
         atomicStore(&counters[0], next);                               // the rotation
         atomicStore(&counters[1], 0u);
         atomicStore(&counters[2], 0u);
+        atomicStore(&counters[25], 0u);                                // the next level's claims sum from 0
         atomicStore(&counters[8], 0u);                                 // edgeCount
         atomicStore(&counters[9], 0u);                                 // edgeCountUnclamped
         atomicStore(&counters[12], atomicLoad(&counters[12]) + next);  // visitedCount
-        if (P.firstOfSubmit >= 1u) {                                   // b = the boundary's index inside its submit, clamped to 2 (P8-T8, PD-18)
-            atomicStore(&counters[5], atomicLoad(&counters[5]) - next);    // unvisitedCount (exact): F_b was inside the submit's rebuilt sum iff b >= 1
-        }
-        if (P.firstOfSubmit >= 2u) {
-            atomicStore(&counters[6], atomicLoad(&counters[6]) - degSum);  // unvisitedDegreeSum (one level stale): F_{b-1} was inside it iff b >= 2
+        if (P.firstOfSubmit >= 1u) {                                   // b = the boundary's index inside its submit, clamped (P8-T8, PD-18): F_b was inside the submit's rebuilt sums iff b >= 1
+            atomicStore(&counters[5], atomicLoad(&counters[5]) - next);       // unvisitedCount, exact
+            atomicStore(&counters[6], atomicLoad(&counters[6]) - nextDeg);    // unvisitedDegreeSum, exact (issue #391: no longer one level stale)
         }
         let level = atomicLoad(&counters[11]) + 1u;                    // the seed is U32_MAX, so the first boundary lands on 0
         atomicStore(&counters[11], level);
@@ -108,46 +84,36 @@ fn frontier_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
         if (P.mode == 1u) {
             direction = 0u;                                                 // top-down only (the test seam)
         } else if (direction == 0u) {
-            if (degSum > atomicLoad(&counters[6]) / P.alpha && next > finished) { direction = 1u; }   // m_f > m_u / alpha and growing
+            if (nextDeg > atomicLoad(&counters[6]) / P.alpha && next > finished) { direction = 1u; }   // m_f > m_u / alpha and growing, m_f the degree of the frontier about to be expanded
         } else {
             if (next * P.beta < atomicLoad(&counters[5]) && next < finished) { direction = 0u; }      // next * beta < unvisited and shrinking
         }
         if (direction != atomicLoad(&counters[14])) { atomicStore(&counters[13], atomicLoad(&counters[13]) + 1u); }   // switches
         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)
         if (done) {
-            for (var s = 0u; s < 7u; s = s + 1u) { zero_slot(s); }
+            path = 0u;
         } else if (direction == 1u) {                                  // the bottom-up level (P8-T8): the bits fill, the bitset build, the sweep
-            zero_slot(0u); zero_slot(1u); zero_slot(2u); zero_slot(6u);
-            write_slot(3u, (P.n + 31u) / 32u); write_slot(4u, next); write_slot(5u, atomicLoad(&counters[7]));
             path = 3u;
             atomicStore(&counters[19], atomicLoad(&counters[19]) + 1u);
         } else if (next < P.fusedMax) {                                // P8-T7 makes this branch reachable (fusedMax is 0 until then)
-            zero_slot(0u); zero_slot(1u); zero_slot(3u); zero_slot(4u); zero_slot(5u); zero_slot(6u);
-            write_slot_groups(2u, next, next);                         // bfs-fused is one WORKGROUP per frontier entry
-            path = 2u;
+            path = 2u;                                                 // bfs-fused: one WORKGROUP per frontier entry
             atomicStore(&counters[17], atomicLoad(&counters[17]) + 1u);
         } else {
-            zero_slot(2u); zero_slot(3u); zero_slot(4u); zero_slot(5u);
-            write_slot(0u, next);                                      // slots 1 and 6 are role 1's
-            path = 1u;
+            path = 1u;                                                 // advance-expand, then role 1 and bfs-contract
         }
         atomicStore(&counters[14], direction);
         atomicStore(&counters[24], path);
     } else if (P.role == 1u) {                                         // the edge queue is filled
-        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
-            zero_slot(1u); zero_slot(6u);
+        if (atomicLoad(&counters[24]) != 1u) {                         // role 0 did not choose the two-phase path (done, fused or bottom-up): nothing to clamp, nothing to count
             return;
         }
         let clamped = min(atomicLoad(&counters[8]), P.edgeCapacity);
         atomicStore(&counters[8], clamped);
         if (atomicLoad(&counters[9]) > P.edgeCapacity) {               // PD-23: the fused retry
-            let entries = atomicLoad(&counters[0]);
-            zero_slot(1u); write_slot_groups(6u, entries, entries);    // one workgroup per frontier entry, as slot 2
-            atomicStore(&counters[24], 4u);                            // the path word: bfs-fused runs the retry, bfs-contract nothing
+            atomicStore(&counters[24], 4u);                            // the path word: bfs-fused runs the retry over frontierCount, bfs-contract nothing
             atomicStore(&counters[10], atomicLoad(&counters[10]) + 1u);
             atomicStore(&counters[17], atomicLoad(&counters[17]) + 1u);
         } else {
-            write_slot(1u, clamped); zero_slot(6u);
             atomicStore(&counters[18], atomicLoad(&counters[18]) + 1u);   // twoPhaseLevels counts the CHOICE role 0 made, even for zero edges (P8-T7 Step 4's invariant)
         }
     } else if (P.role == 2u) {                                         // the SSSP round boundary (P8-T9, PD-20): which pile this round relaxes
@@ -155,54 +121,43 @@ fn frontier_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
         atomicStore(&counters[9], 0u);
         atomicStore(&counters[24], 0u);
         if (atomicLoad(&counters[15]) != 0u) {                         // done already: a no-op round the host recorded past the end (rule 1)
-            for (var s = 0u; s < 7u; s = s + 1u) { zero_slot(s); }
             return;
         }
         let nearRaw = atomicLoad(&counters[1]);                        // the raw near half's appends, unclamped
         let farRaw = atomicLoad(&counters[21]);                        // the raw far half's appends, unclamped
         if (nearRaw > P.edgeCapacity || farRaw > P.edgeCapacity) {     // a pile overflowed its half: the host raises E_TOO_LARGE
             atomicStore(&counters[15], 2u);
-            for (var s = 0u; s < 7u; s = s + 1u) { zero_slot(s); }
             return;
         }
-        zero_slot(2u); zero_slot(5u); zero_slot(6u);                   // role 3 sizes the relax slots once the piles are deduped
         if (nearRaw != 0u) {                                           // a near round: dedupe the near half into nearIn
             atomicStore(&counters[0], 0u);                             // the deduped near count, accumulated by dedupe-filter
             atomicStore(&counters[14], 0u);                            // mode 0
-            write_slot(0u, nearRaw); write_slot(1u, nearRaw);          // dedupe-claim, dedupe-filter over the near half
-            atomicStore(&counters[8], nearRaw);                        // the near dedupe's count word
+            atomicStore(&counters[8], nearRaw);                        // the near dedupe's count word (dedupe-claim, dedupe-filter over the near half)
             atomicStore(&counters[24], 5u);                            // the path word: sssp-relax role 0 runs, role 1 nothing
-            zero_slot(3u); zero_slot(4u);
             atomicStore(&counters[11], atomicLoad(&counters[11]) + 1u);   // rounds dispatched (the done boundary is not counted)
         } else if (farRaw != 0u) {                                     // the near pile is empty: raise the threshold and re-bucket the far pile
             let threshold = bitcast<f32>(atomicLoad(&counters[22]));
             let raised = threshold + bitcast<f32>(atomicLoad(&counters[23]));   // ONE f32 add on the bit patterns (PD-9)
             if (raised == threshold) {                                 // the delta is below the threshold's ulp: the host raises E_UNSUPPORTED
                 atomicStore(&counters[15], 3u);
-                for (var s = 0u; s < 7u; s = s + 1u) { zero_slot(s); }
                 return;
             }
             atomicStore(&counters[4], atomicLoad(&counters[22]));      // prevThresholdBits: what the pass-through drops below
             atomicStore(&counters[22], bitcast<u32>(raised));
             atomicStore(&counters[20], 0u);                            // the deduped far count, accumulated by dedupe-filter
             atomicStore(&counters[14], 1u);                            // mode 1
-            zero_slot(0u); zero_slot(1u);
-            write_slot(3u, farRaw); write_slot(4u, farRaw);            // dedupe-claim, dedupe-filter over the far half
-            atomicStore(&counters[9], farRaw);                         // the far dedupe's count word
+            atomicStore(&counters[9], farRaw);                         // the far dedupe's count word (dedupe-claim, dedupe-filter over the far half)
             atomicStore(&counters[24], 6u);                            // the path word: sssp-relax role 1 runs, role 0 nothing
             atomicStore(&counters[11], atomicLoad(&counters[11]) + 1u);
         } else {                                                       // both piles empty: finished
             atomicStore(&counters[15], 1u);
-            for (var s = 0u; s < 7u; s = s + 1u) { zero_slot(s); }
         }
-    } else if (P.role == 3u) {                                         // the piles are deduped: size the relax
-        if (atomicLoad(&counters[15]) != 0u) { return; }               // role 2 zeroed every slot of the round
+    } else if (P.role == 3u) {                                         // the piles are deduped: restart the raw half the round consumed
+        if (atomicLoad(&counters[15]) != 0u) { return; }               // role 2 chose no pile this round
         if (atomicLoad(&counters[14]) == 0u) {
-            write_slot(2u, atomicLoad(&counters[0]));                  // the near round over nearIn
-            atomicStore(&counters[1], 0u);                             // the raw near half restarts
+            atomicStore(&counters[1], 0u);                             // the raw near half restarts (sssp-relax role 0 sizes itself from word 0)
         } else {
-            write_slot(5u, atomicLoad(&counters[20]));                 // the pass-through over farIn
-            atomicStore(&counters[21], 0u);                            // the raw far half restarts (the pass-through re-appends what stays far)
+            atomicStore(&counters[21], 0u);                            // the raw far half restarts (the pass-through re-appends what stays far; role 1 sizes itself from word 20)
         }
     }
 }

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

@@ -1 +1 @@
-{"version":3,"file":"frontier-finalize.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/frontier-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuJ9C,CAAC"}
+{"version":3,"file":"frontier-finalize.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/frontier-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+G9C,CAAC"}

package/dist/src/wgsl/grid-cell-key.wgsl.d.ts

@@ -1,8 +1,9 @@
 /**
  * G1, the `grid-cell-key` kernel body (spec 7.7; P4-T8): the finest cell of every node from the state's robust extent,
  * `floor((p - gridMin) * invCellSize)` (a multiply, correctly rounded everywhere: PD-10), linearised when every axis
- * is in [0, G) and the outside pseudo-cell `cells` otherwise; `cellVal[i] = i`. The clamp before the floor keeps a
+ * is in [0, G), and otherwise one of the 2^dim outside pseudo-cells `cells + orthant`, the orthant of the cell about the
+ * grid centre (bit a set when `c[a] >= G / 2`; issue #90); `cellVal[i] = i`. The clamp before the floor keeps a
  * far-away or NaN coordinate out of an out-of-range float-to-int conversion. Body only; normative text.
  */
-export declare const gridCellKeyWgsl = "\nfn grid_cells() -> u32 { return P.gridMax * P.gridMax * select(1u, P.gridMax, P.dim == 3u); }\n\n@compute @workgroup_size(WG)\nfn grid_cell_key(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let i = linear_id(wid, lid.x);\n    if (i >= P.n) { return; }                                      // no barrier follows\n    let cells = grid_cells();\n    let gf = f32(P.gridMax);\n    let q = (pos[i].xyz - S.gridMin.xyz) * S.invCellSize;          // PD-10: never a division\n    let c = vec3<i32>(floor(clamp(q, vec3f(-1.0), vec3f(gf + 1.0))));\n    let g = i32(P.gridMax);\n    var inside = c.x >= 0 && c.x < g && c.y >= 0 && c.y < g;\n    if (P.dim == 3u) { inside = inside && c.z >= 0 && c.z < g; }\n    var key = cells;                                               // the outside pseudo-cell (7.7)\n    if (inside) {\n        key = u32(c.x) + P.gridMax * u32(c.y);\n        if (P.dim == 3u) { key = key + P.gridMax * P.gridMax * u32(c.z); }\n    }\n    cellKey[i] = key;\n    cellVal[i] = i;\n}\n";
+export declare const gridCellKeyWgsl = "\nfn grid_cells() -> u32 { return P.gridMax * P.gridMax * select(1u, P.gridMax, P.dim == 3u); }\n\n@compute @workgroup_size(WG)\nfn grid_cell_key(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let i = linear_id(wid, lid.x);\n    if (i >= P.n) { return; }                                      // no barrier follows\n    let cells = grid_cells();\n    let gf = f32(P.gridMax);\n    let q = (pos[i].xyz - S.gridMin.xyz) * S.invCellSize;          // PD-10: never a division\n    let c = vec3<i32>(floor(clamp(q, vec3f(-1.0), vec3f(gf + 1.0))));\n    let g = i32(P.gridMax);\n    var inside = c.x >= 0 && c.x < g && c.y >= 0 && c.y < g;\n    if (P.dim == 3u) { inside = inside && c.z >= 0 && c.z < g; }\n    var key = cells + select(0u, 1u, c.x >= g / 2) + select(0u, 2u, c.y >= g / 2);   // an outside pseudo-cell: its orthant (issue #90)\n    if (P.dim == 3u) { key = key + select(0u, 4u, c.z >= g / 2); }\n    if (inside) {\n        key = u32(c.x) + P.gridMax * u32(c.y);\n        if (P.dim == 3u) { key = key + P.gridMax * P.gridMax * u32(c.z); }\n    }\n    cellKey[i] = key;\n    cellVal[i] = i;\n}\n";
 //# sourceMappingURL=grid-cell-key.wgsl.d.ts.map

package/dist/src/wgsl/grid-cell-key.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grid-cell-key.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/grid-cell-key.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,eAAe,uhCAsB3B,CAAC"}
+{"version":3,"file":"grid-cell-key.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/grid-cell-key.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,+nCAuB3B,CAAC"}

package/dist/src/wgsl/grid-cell-key.wgsl.js

@@ -1,7 +1,8 @@
 /**
  * G1, the `grid-cell-key` kernel body (spec 7.7; P4-T8): the finest cell of every node from the state's robust extent,
  * `floor((p - gridMin) * invCellSize)` (a multiply, correctly rounded everywhere: PD-10), linearised when every axis
- * is in [0, G) and the outside pseudo-cell `cells` otherwise; `cellVal[i] = i`. The clamp before the floor keeps a
+ * is in [0, G), and otherwise one of the 2^dim outside pseudo-cells `cells + orthant`, the orthant of the cell about the
+ * grid centre (bit a set when `c[a] >= G / 2`; issue #90); `cellVal[i] = i`. The clamp before the floor keeps a
  * far-away or NaN coordinate out of an out-of-range float-to-int conversion. Body only; normative text.
  */
 export const gridCellKeyWgsl = /* wgsl */ `
@@ -18,7 +19,8 @@ fn grid_cell_key(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocatio
     let g = i32(P.gridMax);
     var inside = c.x >= 0 && c.x < g && c.y >= 0 && c.y < g;
     if (P.dim == 3u) { inside = inside && c.z >= 0 && c.z < g; }
-    var key = cells;                                               // the outside pseudo-cell (7.7)
+    var key = cells + select(0u, 1u, c.x >= g / 2) + select(0u, 2u, c.y >= g / 2);   // an outside pseudo-cell: its orthant (issue #90)
+    if (P.dim == 3u) { key = key + select(0u, 4u, c.z >= g / 2); }
     if (inside) {
         key = u32(c.x) + P.gridMax * u32(c.y);
         if (P.dim == 3u) { key = key + P.gridMax * P.gridMax * u32(c.z); }

package/dist/src/wgsl/grid-cell-key.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"grid-cell-key.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/grid-cell-key.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;CAsBzC,CAAC"}
+{"version":3,"file":"grid-cell-key.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/grid-cell-key.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBzC,CAAC"}

package/dist/src/wgsl/grid-centroid.wgsl.d.ts

@@ -1,8 +1,9 @@
 /**
- * G4, the `grid-centroid` kernel body (spec 7.7; P4-T9): thread per finest cell, the pseudo-cell included; the
+ * G4, the `grid-centroid` kernel body (spec 7.7; P4-T9): thread per finest cell, the 2^dim outside pseudo-cells
+ * included (issue #90); the
  * mass-weighted position sum of a cell's sorted range in index order (no atomics: deterministic), the largest
  * occupancy into hubCounters[1], and cells above GRID_HUB_CELL entries appended to hubList for G4b (PD-13). Body
  * only; normative text.
  */
-export declare const gridCentroidWgsl = "\nfn grid_cells() -> u32 { return P.gridMax * P.gridMax * select(1u, P.gridMax, P.dim == 3u); }\n\n@compute @workgroup_size(WG)\nfn grid_centroid(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let c = linear_id(wid, lid.x);\n    if (c > grid_cells()) { return; }                              // cells [0, cells]: the pseudo-cell is index cells; no barrier follows\n    let start = cellStart[c];\n    let count = cellStart[c + 1u] - start;\n    atomicMax(&hubCounters[1], count);                             // maxCellOccupancy, read by K1 next iteration\n    if (count > GRID_HUB_CELL) {                                   // a hub cell: G4b sums it (PD-13)\n        hubList[atomicAdd(&hubCounters[0], 1u)] = c;\n        return;\n    }\n    var acc = vec4f(0.0);\n    for (var k = start; k < start + count; k = k + 1u) {           // sorted order: deterministic\n        let p = pos[sortedIdx[k]];\n        acc = acc + vec4f(p.xyz * p.w, p.w);                       // (sum m x, sum m y, sum m z, sum m)\n    }\n    pyramid[c] = acc;\n}\n";
+export declare const gridCentroidWgsl = "\nfn grid_cells() -> u32 { return P.gridMax * P.gridMax * select(1u, P.gridMax, P.dim == 3u); }\n\n@compute @workgroup_size(WG)\nfn grid_centroid(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let c = linear_id(wid, lid.x);\n    if (c >= grid_cells() + select(4u, 8u, P.dim == 3u)) { return; }   // cells [0, cells + 2^dim): the pseudo-cells follow the real ones; no barrier follows\n    let start = cellStart[c];\n    let count = cellStart[c + 1u] - start;\n    atomicMax(&hubCounters[1], count);                             // maxCellOccupancy, read by K1 next iteration\n    if (count > GRID_HUB_CELL) {                                   // a hub cell: G4b sums it (PD-13)\n        hubList[atomicAdd(&hubCounters[0], 1u)] = c;\n        return;\n    }\n    var acc = vec4f(0.0);\n    for (var k = start; k < start + count; k = k + 1u) {           // sorted order: deterministic\n        let p = pos[sortedIdx[k]];\n        acc = acc + vec4f(p.xyz * p.w, p.w);                       // (sum m x, sum m y, sum m z, sum m)\n    }\n    pyramid[c] = acc;\n}\n";
 //# sourceMappingURL=grid-centroid.wgsl.d.ts.map

package/dist/src/wgsl/grid-centroid.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grid-centroid.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/grid-centroid.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,+jCAqB5B,CAAC"}
+{"version":3,"file":"grid-centroid.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/grid-centroid.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,klCAqB5B,CAAC"}

package/dist/src/wgsl/grid-centroid.wgsl.js

@@ -1,5 +1,6 @@
 /**
- * G4, the `grid-centroid` kernel body (spec 7.7; P4-T9): thread per finest cell, the pseudo-cell included; the
+ * G4, the `grid-centroid` kernel body (spec 7.7; P4-T9): thread per finest cell, the 2^dim outside pseudo-cells
+ * included (issue #90); the
  * mass-weighted position sum of a cell's sorted range in index order (no atomics: deterministic), the largest
  * occupancy into hubCounters[1], and cells above GRID_HUB_CELL entries appended to hubList for G4b (PD-13). Body
  * only; normative text.
@@ -10,7 +11,7 @@ fn grid_cells() -> u32 { return P.gridMax * P.gridMax * select(1u, P.gridMax, P.
 @compute @workgroup_size(WG)
 fn grid_centroid(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
     let c = linear_id(wid, lid.x);
-    if (c > grid_cells()) { return; }                              // cells [0, cells]: the pseudo-cell is index cells; no barrier follows
+    if (c >= grid_cells() + select(4u, 8u, P.dim == 3u)) { return; }   // cells [0, cells + 2^dim): the pseudo-cells follow the real ones; no barrier follows
     let start = cellStart[c];
     let count = cellStart[c + 1u] - start;
     atomicMax(&hubCounters[1], count);                             // maxCellOccupancy, read by K1 next iteration

package/dist/src/wgsl/grid-centroid.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"grid-centroid.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/grid-centroid.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;CAqB1C,CAAC"}
+{"version":3,"file":"grid-centroid.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/grid-centroid.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;CAqB1C,CAAC"}

package/dist/src/wgsl/grid-downsample.wgsl.d.ts

@@ -1,7 +1,7 @@
 /**
  * G5, the `grid-downsample` kernel body (spec 7.7; P4-T9): one dispatch per coarser level; every parent cell is the
  * sum of its 4 (2D) or 8 (3D) children at the level below, read at P.childBase and written at P.parentBase (the
- * pseudo-cell, index cells of level 0, is never a child). No atomics. Body only; normative text.
+ * pseudo-cells, indices cells .. of level 0, are never children). No atomics. Body only; normative text.
  */
 export declare const gridDownsampleWgsl = "\n@compute @workgroup_size(WG)\nfn grid_downsample(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let pc = linear_id(wid, lid.x);                                // the parent cell inside its level\n    if (pc >= P.parentCells) { return; }                           // no barrier follows\n    let side = P.parentSide;\n    let cs = 2u * side;                                            // the child level's side\n    let px = pc % side;\n    let py = (pc / side) % side;\n    let pz = pc / (side * side);\n    var acc = vec4f(0.0);\n    for (var dz = 0u; dz < P.depth; dz = dz + 1u) {\n        for (var dy = 0u; dy < 2u; dy = dy + 1u) {\n            for (var dx = 0u; dx < 2u; dx = dx + 1u) {\n                let child = (2u * px + dx) + cs * ((2u * py + dy) + cs * (2u * pz + dz));\n                acc = acc + pyramid[P.childBase + child];\n            }\n        }\n    }\n    pyramid[P.parentBase + pc] = acc;\n}\n";
 //# sourceMappingURL=grid-downsample.wgsl.d.ts.map