@graphty/webgpu-graph-algorithms 0.6.4 → 0.6.6

package/dist/webgpu-graph-algorithms.js

@@ -1,5 +1,5 @@
-import { W as WebGpuGraphError, U as UNIFORM_SLOT_BYTES, B as BufferUsage, M as MAX_WORKGROUPS_PER_DIM, a as WGSL_RESERVED_WORDS, S as STATE_HEADER_BYTES, d as deviceLostError, i as isWebGpuGraphError, b as U32_MAX$2, c as MAX_LEVELS_PER_SUBMIT, F as FRONTIER_CANDIDATES, I as INDIRECT_ARGS_STRIDE, R as RADIX_BINS, e as FUSED_FRONTIER_MAX, f as BEAMER_BETA, g as SSSP_DELTA_FACTOR, h as F32_INF_BITS, j as GRID_COARSEST_SIDE, k as GRID_MIN_SIDE, l as GRID_SORT_BITS, m as FA2_DEFAULTS, n as MAX_ITERATIONS_PER_STEP, o as MAX_1D_ITEMS, p as hasErrorCode, q as FA2_FLAG_FIRST, P as PARTIAL_BYTES, r as GRID_HUB_CELL, L as LAYOUT_TUNING_DEFAULTS, E as EXACT_MAX_NODES, T as TRACE_RECORD_BYTES, s as GRID_BBOX_MARGIN, t as GRID_EXTENT_FLOOR, u as FR_ADAPTIVE_MAX_ITERATIONS, v as FR_START_TEMPERATURE, w as FA2_FLAG_ADAPTIVE, x as FR_REHEAT_FRACTION, y as FR_DEFAULTS, z as SE_DEFAULTS, A as SE_SCALE_REFERENCE_NODES } from "./chunks/context-Dvq-Cc6v.js";
-import { C, G, D, H, J, K } from "./chunks/context-Dvq-Cc6v.js";
+import { W as WebGpuGraphError, U as UNIFORM_SLOT_BYTES, B as BufferUsage, M as MAX_WORKGROUPS_PER_DIM, a as WGSL_RESERVED_WORDS, S as STATE_HEADER_BYTES, d as deviceLostError, i as isWebGpuGraphError, b as U32_MAX$2, c as MAX_LEVELS_PER_SUBMIT, R as RADIX_BINS, F as FUSED_FRONTIER_MAX, e as BEAMER_BETA, f as SSSP_DELTA_FACTOR, g as F32_INF_BITS, h as GRID_COARSEST_SIDE, j as GRID_MIN_SIDE, k as GRID_SORT_BITS, l as FA2_DEFAULTS, m as MAX_ITERATIONS_PER_STEP, n as MAX_1D_ITEMS, o as hasErrorCode, p as FA2_FLAG_FIRST, P as PARTIAL_BYTES, E as EXACT_TILES_PER_PASS, I as INDIRECT_ARGS_STRIDE, q as GRID_HUB_CELL, L as LAYOUT_TUNING_DEFAULTS, r as EXACT_MAX_NODES, s as SETTLE_FLOOR_UNBOUNDED, T as TRACE_RECORD_BYTES, t as GRID_BBOX_MARGIN, u as GRID_EXTENT_FLOOR, v as FR_ADAPTIVE_MAX_ITERATIONS, w as FR_START_TEMPERATURE, x as FA2_FLAG_ADAPTIVE, y as SETTLE_FLOOR_FRACTION, z as FR_REHEAT_FRACTION, A as FR_DEFAULTS, C as SE_DEFAULTS, D as SETTLE_FLOOR_REFERENCE_NODES, H as SE_SCALE_REFERENCE_NODES } from "./chunks/context-DiSr6eiz.js";
+import { J, G, K, N, O, Q } from "./chunks/context-DiSr6eiz.js";
 import { renumberPartition, INVALID_INDEX, makeMask, maskTest, expandEdges, fromEdgeArrays } from "@graphty/graph-format";
 class UniformRing {
   /**
@@ -217,7 +217,7 @@ function planGridStride(items, wg, caps, maxGroups) {
   if (items === 0) {
     return { x: 0, y: 1, z: 1, items, stride: null };
   }
-  const cap = Math.min(caps.software ? 64 : 4096, perDimension(caps));
+  const cap = Math.min(maxGroups ?? (caps.software ? 64 : 4096), perDimension(caps));
   const groups = Math.min(Math.ceil(items / wg), cap);
   return { x: groups, y: 1, z: 1, items, stride: groups * wg };
 }
@@ -582,7 +582,7 @@ fn advance_expand(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocati
         if (lid.x == 0u) {
             base = atomicAdd(&counters[8], aggregate);                   // edgeCount: ONE reservation per workgroup, not one per arc
             atomicAdd(&counters[9], aggregate);                          // edgeCountUnclamped: the overflow detector (PD-23)
-            atomicAdd(&counters[2], aggregate);                          // frontierDegreeSum: Beamer's m_f (P8-T8)
+            atomicAdd(&counters[2], aggregate);                          // frontierDegreeSum: what this level expanded (the inspect seam)
         }
         workgroupBarrier();
         for (var p = lid.x; p < aggregate; p = p + WG) {                 // strip [0, aggregate): lane j takes j, j + WG, ...
@@ -773,7 +773,7 @@ fn bfs_fused(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id
             let d = select(0u, a1 - a0, a1 > a0);
             wdeg = d;
             wstart = a0;
-            atomicAdd(&counters[2], d);                                  // frontierDegreeSum, so Beamer's test (P8-T8) sees fused levels too
+            atomicAdd(&counters[2], d);                                  // frontierDegreeSum, so the inspect seam sees fused levels too
         }
         let deg = workgroupUniformLoad(&wdeg);                           // uniform: the loop below may hold barriers
         let start = workgroupUniformLoad(&wstart);
@@ -805,6 +805,21 @@ fn bfs_fused(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id
 }
 `
 );
+const bfsNextDegreeWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn bfs_next_degree(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let count = select(0u, atomicLoad(&counters[1]), atomicLoad(&counters[24]) != 0u);   // nextFrontierCount, on a level that claimed (the path word)
+    var sum = 0u;
+    for (var i = linear_id(wid, lid.x); i < count; i = i + P.stride) {   // no barrier inside: the trip count is per lane
+        sum = sum + outDegree[frontier[i]];
+    }
+    let total = wg_reduce_u32(sum, lid.x, 0u);                       // the prelude's workgroup sum; uniform: after the loop
+    if (lid.x == 0u) { atomicAdd(&counters[25], total); }            // nextDegreeSum: ONE atomic per workgroup
+}
+`
+);
 const bfsUnvisitedFlagsWgsl = (
   /* wgsl */
   `
@@ -1265,14 +1280,23 @@ fn gravity_force(pi: vec4f) -> vec3f {                         // spec 7.9: cent
 }
 
 @compute @workgroup_size(WG)
-fn repulsion(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+fn repulsion(
+    @builtin(workgroup_id) wid: vec3<u32>,
+    @builtin(local_invocation_id) lid: vec3<u32>,
+    @builtin(num_workgroups) nwg: vec3<u32>,
+) {
+    // issue #87: pass p of the tile range is dispatched with p + 1 z slices; only the last slice works, so the pass
+    // index needs no uniform. Uniform: keyed on workgroup_id and num_workgroups only.
+    if (wid.z + 1u < nwg.z) { return; }
     let i = linear_id(wid, lid.x);
     let valid = i < P.n;
     var pi = vec4f(0.0);
     if (valid) { pi = pos[i]; }
     var f = vec3f(0.0);
     let tiles = (P.n + WG - 1u) / WG;
-    for (var t = 0u; t < tiles; t = t + 1u) {
+    let tileBegin = (nwg.z - 1u) * EXACT_TILES_PER_PASS;
+    let tileEnd = min(tiles, tileBegin + EXACT_TILES_PER_PASS);
+    for (var t = tileBegin; t < tileEnd; t = t + 1u) {
         let j = t * WG + lid.x;
         if (j < P.n) { tile[lid.x] = pos[j]; } else { tile[lid.x] = vec4f(0.0); }   // guarded fill; mass 0 marks the pad
         workgroupBarrier();                                                       // uniform: every invocation reaches it
@@ -1295,6 +1319,10 @@ fn repulsion(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id
         }
         workgroupBarrier();
     }
+    if (tileEnd < tiles) {                                                        // an earlier pass: its partial sum only (uniform: P.n, nwg)
+        if (valid) { store_force(i, load_force(i) + f); }
+        return;
+    }
     // epilogue (7.9, 7.10): gravity and force += under the guard, the swing / traction reduction outside it
     var sw = 0.0;
     var tr = 0.0;
@@ -1400,7 +1428,7 @@ fn stats_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
             S.radius = sqrt(max(tHi.w, 0.0));                          // max |p - centroid| about the same previous centroid as rmsRadius (K5 puts |q|^2 in max.w)
             let meanDisp = select(tDisp / f32(tFree), 0.0, tFree == 0u);  // all-fixed: 0, never NaN (7.4)
             S.meanDisplacement = meanDisp;
-            S.settledCount = select(0u, S.settledCount + 1u, meanDisp <= P.settleThreshold * S.rmsRadius);
+            S.settledCount = select(0u, S.settledCount + 1u, meanDisp <= min(P.settleThreshold * S.rmsRadius, P.settleFloor));   // relative AND absolute (issue #97)
         }
         S.iteration = S.iteration + 1u;
         T[P.iterationIndex].meanDisplacement = S.meanDisplacement;
@@ -1418,7 +1446,9 @@ fn stats_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
                 S.invCellSize = 1.0 / cellSize;
                 S.eps = 0.25 * cellSize;
             }
-            S.outsideGrid = cellHist[cells];                         // the previous iteration's pseudo-cell count (0 after load)
+            var outside = 0u;                                        // the previous iteration's pseudo-cell counts, one per orthant (issue #90; 0 after load)
+            for (var o = 0u; o < select(4u, 8u, P.dim == 3u); o = o + 1u) { outside = outside + cellHist[cells + o]; }
+            S.outsideGrid = outside;
             S.maxCellOccupancy = atomicLoad(&hubCounters[1]);
             atomicStore(&hubCounters[0], 0u);
             atomicStore(&hubCounters[1], 0u);
@@ -1475,49 +1505,30 @@ fn fill(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid
 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);
@@ -1527,46 +1538,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
@@ -1574,54 +1575,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)
         }
     }
 }
@@ -1643,7 +1633,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); }
@@ -1661,7 +1652,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
@@ -1739,11 +1730,12 @@ fn store_force(i: u32, f: vec3f) {
 }
 fn grid_cells() -> u32 { return P.gridMax * P.gridMax * select(1u, P.gridMax, P.dim == 3u); }
 fn grid_side(level: u32) -> u32 { return P.gridMax >> level; }
-fn level_base(level: u32) -> u32 {                             // the pyramid index of level L's cell 0 (level 0 carries the pseudo-cell at index cells)
+fn outside_cells() -> u32 { return select(4u, 8u, P.dim == 3u); }   // one pseudo-cell per orthant (issue #90)
+fn level_base(level: u32) -> u32 {                             // the pyramid index of level L's cell 0 (level 0 carries the pseudo-cells at cells ..)
     var base = 0u;
     for (var l = 0u; l < level; l = l + 1u) {
         let s = grid_side(l);
-        base = base + s * s * select(1u, s, P.dim == 3u) + select(0u, 1u, l == 0u);
+        base = base + s * s * select(1u, s, P.dim == 3u) + select(0u, outside_cells(), l == 0u);
     }
     return base;
 }
@@ -1754,7 +1746,9 @@ fn cell_at(level: u32, cx: i32, cy: i32, cz: i32) -> u32 {
 fn cell_force(pi: vec4f, q: vec4f) -> vec3f {                  // one far-field term, softened by state.eps (7.7)
     if (q.w <= 0.0) { return vec3f(0.0); }                     // an empty cell
     let d = pi.xyz - q.xyz / q.w;                              // to the mass-weighted centroid
-    let d2 = dot(d, d) + S.eps * S.eps;
+    var d2 = dot(d, d);
+    if (LAW == 0u) { d2 = max(d2, FA2_DIST_FLOOR_SQ); }        // FA2 alone floors d >= 0.01, as K3 and G7 do (issue #89); FR and coulomb are unfloored (7.20)
+    d2 = d2 + S.eps * S.eps;
     if (LAW == 1u) { return d * (P.frK * P.frK * q.w / d2); }                       // LAW 1 (FR, 7.20): k^2 / d per node, q.w nodes at the centroid
     if (LAW == 2u) { return d * (-P.coulomb * pi.w * q.w / (d2 * sqrt(d2))); }     // LAW 2 (coulomb): -g m_i M_cell / d^2
     return d * (P.scalingRatio * pi.w * q.w / d2);             // LAW 0 (FA2): |F| = k m_i M_cell / d
@@ -1803,9 +1797,11 @@ fn grid_far_field(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocati
                 }
             }
         }
-        f = f + cell_force(pi, pyramid[grid_cells()]);             // the outside pseudo-cell as one far-field term
+        for (var o = 0u; o < outside_cells(); o = o + 1u) {        // every outside pseudo-cell: one far-field term per orthant
+            f = f + cell_force(pi, pyramid[grid_cells() + o]);
+        }
     } else {
-        for (var cz = 0; cz <= zTop; cz = cz + 1) {                // an outside node: the coarsest level in full, no pseudo-cell (it would include itself)
+        for (var cz = 0; cz <= zTop; cz = cz + 1) {                // an outside node: the coarsest level in full, no pseudo-cell (G7 sums them pair by pair)
             for (var cy = 0; cy < ts; cy = cy + 1) {
                 for (var cx = 0; cx < ts; cx = cx + 1) {
                     f = f + cell_force(pi, pyramid[cell_at(top, cx, cy, cz)]);
@@ -1907,7 +1903,11 @@ fn grid_near_field(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocat
                 }
             }
         } else {
-            f = cell_sum(i, pi, grid_cells(), true);               // an outside node: the pseudo-cell alone
+            var own = grid_cells() + select(0u, 1u, c0.x >= g / 2) + select(0u, 2u, c0.y >= g / 2);   // G1's orthant key
+            if (P.dim == 3u) { own = own + select(0u, 4u, c0.z >= g / 2); }
+            for (var o = grid_cells(); o < grid_cells() + select(4u, 8u, P.dim == 3u); o = o + 1u) {   // an outside node: every outside pseudo-cell
+                f = f + cell_sum(i, pi, o, o == own);
+            }
         }
     }
     // epilogue (7.9, 7.10): gravity and force += under the guard, the swing / traction reduction outside it (K3's text)
@@ -2629,7 +2629,8 @@ const FA2_PARAMS = UniformBlock.define("Fa2Params", [
   ["coulomb", "f32"],
   ["dragCoefficient", "f32"],
   ["timeStep", "f32"],
-  ["midEnd", "u32"]
+  ["midEnd", "u32"],
+  ["settleFloor", "f32"]
 ]);
 const FA2_STATE = UniformBlock.define(
   "Fa2State",
@@ -2803,13 +2804,13 @@ const FRONTIER_COUNTERS = UniformBlock.define(
     ["nextFarCount", "u32"],
     ["thresholdBits", "u32"],
     ["deltaBits", "u32"],
-    ["path", "u32"]
+    ["path", "u32"],
+    ["nextDegreeSum", "u32"]
   ],
   { layout: "storage" }
 );
 const FRONTIER_PARAMS = UniformBlock.define("FrontierParams", [
   ["role", "u32"],
-  ["slotBase", "u32"],
   ["wg", "u32"],
   ["alpha", "u32"],
   ["beta", "u32"],
@@ -2827,7 +2828,8 @@ const FRONTIER_PARAMS = UniformBlock.define("FrontierParams", [
   ["stride", "u32"],
   ["firstOfSubmit", "u32"],
   ["iteration", "u32"],
-  ["pad1", "u32"]
+  ["pad1", "u32"],
+  ["pad2", "u32"]
 ]);
 const BF_PARAMS = UniformBlock.define("BfParams", [
   ["edgeCount", "u32"],
@@ -3406,11 +3408,7 @@ const FRONTIER_FINALIZE = {
   id: "frontier-finalize",
   body: frontierFinalizeWgsl,
   entryPoint: "frontier_finalize",
-  bindings: [
-    decl(1, 0, "counters", "storage", "array<atomic<u32>>"),
-    decl(1, 1, "args", "storage", "array<u32>"),
-    decl(2, 0, "P", "uniform", "FrontierParams")
-  ],
+  bindings: [decl(1, 0, "counters", "storage", "array<atomic<u32>>"), decl(2, 0, "P", "uniform", "FrontierParams")],
   overrideDecls: [],
   uniforms: [FRONTIER_PARAMS],
   needs: [],
@@ -3533,6 +3531,22 @@ const BFS_UNVISITED_FLAGS = {
   snippetSlots: [],
   phase: "P8"
 };
+const BFS_NEXT_DEGREE = {
+  id: "bfs-next-degree",
+  body: bfsNextDegreeWgsl,
+  entryPoint: "bfs_next_degree",
+  bindings: [
+    decl(1, 0, "frontier", "storage-ro", "array<u32>"),
+    decl(1, 1, "outDegree", "storage-ro", "array<u32>"),
+    decl(1, 2, "counters", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "FrontierParams")
+  ],
+  overrideDecls: [],
+  uniforms: [FRONTIER_PARAMS],
+  needs: ["subgroups"],
+  snippetSlots: [],
+  phase: "P8"
+};
 const SSSP_RELAX = {
   id: "sssp-relax",
   body: ssspRelaxWgsl,
@@ -3644,6 +3658,7 @@ const REGISTRY = Object.freeze({
   "bfs-bottom-up": BFS_BOTTOM_UP,
   "bfs-bitset-build": BFS_BITSET_BUILD,
   "bfs-unvisited-flags": BFS_UNVISITED_FLAGS,
+  "bfs-next-degree": BFS_NEXT_DEGREE,
   "sssp-relax": SSSP_RELAX,
   "bf-relax": BF_RELAX,
   "closeness-sweep": CLOSENESS_SWEEP,
@@ -4486,11 +4501,6 @@ function algorithmScope(ctx, label, slots) {
     pool: ctx.pool,
     workgroupSize: ctx.workgroupSize,
     scratch: (byteLength, scratchLabel) => lease.storage(byteLength, `${label}/${scratchLabel}`),
-    indirect: (byteLength, indirectLabel) => lease.acquire(
-      byteLength,
-      BufferUsage.STORAGE | BufferUsage.INDIRECT | BufferUsage.COPY_DST | BufferUsage.COPY_SRC,
-      `${label}/${indirectLabel}`
-    ),
     params(block, values) {
       const slot = ring.reserve(1);
       ring.write(slot, block, values);
@@ -5796,7 +5806,8 @@ const W = Object.freeze({
   nextFarCount: 21,
   thresholdBits: 22,
   deltaBits: 23,
-  path: 24
+  path: 24,
+  nextDegreeSum: 25
 });
 function definedWords(words) {
   const out = {};
@@ -5822,16 +5833,14 @@ class Frontier {
    * Wraps the leased buffers; use prepareFrontier().
    * @param vertices - the two vertex queues
    * @param counters - the counters block
-   * @param args - the args buffer
    * @param edgeQueue - the edge queue
    * @param edgeCapacity - the edge queue's entry count
    * @param n - the vertex count
    */
-  constructor(vertices, counters, args, edgeQueue, edgeCapacity, n) {
+  constructor(vertices, counters, edgeQueue, edgeCapacity, n) {
     this.sideIndex = 0;
     this.vertices = vertices;
     this.counters = counters;
-    this.args = args;
     this.edgeQueue = edgeQueue;
     this.edgeCapacity = edgeCapacity;
     this.n = n;
@@ -5862,7 +5871,7 @@ class Frontier {
     this.sideIndex = this.sideIndex === 0 ? 1 : 0;
   }
   /**
-   * Seeds a traversal: one `queue.writeBuffer` of the whole 96-byte block (zero except the caller's words) and one of
+   * Seeds a traversal: one `queue.writeBuffer` of the whole 112-byte block (zero except the caller's words) and one of
    * `vertices[0][0] = source`, both ordered before the submit that follows; the source is on side 0 afterwards.
    * `frontierCount` is not a word to seed: the first boundary rotates word 1 into it (the BFS seed is
    * `{ nextFrontierCount: 1, level: U32_MAX }`). A source outside `[0, n)`, an unknown word or a value that is not a
@@ -5899,7 +5908,6 @@ async function prepareFrontier(scope, n, arcCount, edgeCapacity) {
   }
   const kernel = await scope.pipelines.kernel(kernelSpec("frontier-finalize"));
   const queueBytes = 4 * Math.max(1, n);
-  const argsBytes = MAX_LEVELS_PER_SUBMIT * FRONTIER_CANDIDATES * INDIRECT_ARGS_STRIDE;
   const vertices = [
     { buffer: scope.scratch(queueBytes, "frontier/vertices-0"), offset: 0, size: queueBytes, window: null },
     { buffer: scope.scratch(queueBytes, "frontier/vertices-1"), offset: 0, size: queueBytes, window: null }
@@ -5910,19 +5918,13 @@ async function prepareFrontier(scope, n, arcCount, edgeCapacity) {
     size: FRONTIER_COUNTERS.byteLength,
     window: null
   };
-  const args = {
-    buffer: scope.indirect(argsBytes, "frontier/args"),
-    offset: 0,
-    size: argsBytes,
-    window: null
-  };
   const edgeQueue = {
     buffer: scope.scratch(4 * capacity, "frontier/edge-queue"),
     offset: 0,
     size: 4 * capacity,
     window: null
   };
-  const frontier = new Frontier(vertices, counters, args, edgeQueue, capacity, n);
+  const frontier = new Frontier(vertices, counters, edgeQueue, capacity, n);
   return new FrontierPlannerImpl(scope, kernel, frontier);
 }
 class FrontierPlannerImpl {
@@ -5963,12 +5965,11 @@ class FrontierPlannerImpl {
     const params = scope.params(FRONTIER_PARAMS, {
       ...definedWords(fields),
       role,
-      slotBase: level * FRONTIER_CANDIDATES,
       wg: scope.workgroupSize,
       edgeCapacity: frontier.edgeCapacity,
       n: frontier.n
     });
-    const bound = this.kernel.bind({ counters: frontier.counters, args: frontier.args, P: params.binding });
+    const bound = this.kernel.bind({ counters: frontier.counters, P: params.binding });
     this.kernel.dispatch(pass, bound, plan1d(1, scope.workgroupSize, scope.caps), [params.offset]);
   }
 }
@@ -6141,6 +6142,7 @@ class RadixSortPlannerImpl {
   }
 }
 const ALGORITHM$3 = "breadthFirstSearch";
+const NEXT_DEGREE_MAX_GROUPS = 128;
 function bfsRingSlots(windows, levelsPerSubmit) {
   return Math.max((5 + 4 * windows) * levelsPerSubmit + 16, RESULT_BATCH_SLOTS + windows);
 }
@@ -6275,6 +6277,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
     const bitset = await ctx.pipelines.kernel(kernelSpec("bfs-bitset-build"));
     const bottomUp = await ctx.pipelines.kernel(kernelSpec("bfs-bottom-up", graphOverrides(reverse, null)));
     const unvisited = await ctx.pipelines.kernel(kernelSpec("bfs-unvisited-flags"));
+    const nextDegree = await ctx.pipelines.kernel(kernelSpec("bfs-next-degree"));
     const pred = await ctx.pipelines.kernel(kernelSpec("sssp-pred", { ...graphOverrides(core, null), MODE: 1 }));
     const fill = await ctx.pipelines.kernel(kernelSpec("fill"));
     const sort = await prepareRadixSort(scope);
@@ -6284,6 +6287,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
     const fillPlan = plan1d(n, wg, ctx.caps);
     const levelPlan = planGridStride(Math.max(n, frontier.edgeCapacity), wg, ctx.caps);
     const sweepPlan = planGridStride(n, wg, ctx.caps);
+    const degreePlan = planGridStride(n, wg, ctx.caps, NEXT_DEGREE_MAX_GROUPS);
     const fusedPlan = planGridStride(n * wg, wg, ctx.caps);
     const bitsPlan = plan1d(bitsWords, wg, ctx.caps);
     const recordFill = (pass2, dst, value, mode) => {
@@ -6334,7 +6338,7 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
       const bitsParams = scope.params(FILL_PARAMS, { count: bitsWords, value: 0, mode: 0, pad0: 0 });
       const boundBitsFill = fill.bind({ dst: frontierBits, P: bitsParams.binding });
       for (let level2 = 0; level2 < levelsPerSubmit; level2++) {
-        planner.recordFinalize(pass2, 0, level2, { ...fields, firstOfSubmit: Math.min(level2, 2) });
+        planner.recordFinalize(pass2, 0, level2, { ...fields, firstOfSubmit: Math.min(level2, 1) });
         advance.record(pass2, frontier);
         planner.recordFinalize(pass2, 1, level2, fields);
         const params = scope.params(FRONTIER_PARAMS, {
@@ -6400,6 +6404,14 @@ async function bfsWithTuning(ctx, s, source, options, tuning) {
           });
           bottomUp.dispatch(pass2, boundSweep, sweepPlan, [sweepParams.offset]);
         }
+        const degreeParams = scope.params(FRONTIER_PARAMS, { wg, n, stride: degreePlan.stride ?? wg });
+        const boundDegree = nextDegree.bind({
+          frontier: frontier.output,
+          outDegree,
+          counters,
+          P: degreeParams.binding
+        });
+        nextDegree.dispatch(pass2, boundDegree, degreePlan, [degreeParams.offset]);
         frontier.swap();
       }
       batch.endPass();
@@ -7563,10 +7575,11 @@ function gridSpecFor(n, dim, tuning) {
     levels++;
   }
   const cells = g ** dim;
+  const outsideCells = 2 ** dim;
   const levelOffsets = [0];
   let s = g;
   for (let level = 0; level + 1 < levels; level++) {
-    levelOffsets.push(levelOffsets[level] + s ** dim + (level === 0 ? 1 : 0));
+    levelOffsets.push(levelOffsets[level] + s ** dim + (level === 0 ? outsideCells : 0));
     s /= 2;
   }
   return {
@@ -7574,7 +7587,8 @@ function gridSpecFor(n, dim, tuning) {
     g,
     levels,
     cells,
-    histWords: cells + 2,
+    outsideCells,
+    histWords: cells + outsideCells + 1,
     levelOffsets: Object.freeze(levelOffsets),
     pyramidCells: levelOffsets[levels - 1] + GRID_COARSEST_SIDE ** dim,
     deterministic: tuning.deterministic
@@ -9890,6 +9904,12 @@ function subset(merged, defaults) {
   }
   return out;
 }
+function recordExactRepulsion(kernel, pass, bound, plan, n, paramsOffset) {
+  const passes = Math.max(1, Math.ceil(Math.ceil(n / kernel.workgroupSize) / EXACT_TILES_PER_PASS));
+  for (let z = 1; z <= passes; z++) {
+    kernel.dispatch(pass, bound, { ...plan, z }, [paramsOffset]);
+  }
+}
 class RepulsionExact {
   /**
    * Holds the two compiled kernels; create() is the only caller.
@@ -9982,7 +10002,7 @@ class RepulsionExact {
   recordRepulsion(pass, n, paramsOffset) {
     const bound = this.bound(this.boundRepulsion, "recordRepulsion");
     const plan = plan1d(n, this.repulsion.workgroupSize, this.caps);
-    this.repulsion.dispatch(pass, bound, plan, [paramsOffset]);
+    recordExactRepulsion(this.repulsion, pass, bound, plan, n, paramsOffset);
   }
   /**
    * Records K4 only.
@@ -10115,7 +10135,8 @@ class GridPyramidPlannerImpl {
     }
     const { centroid, finalize, hub, downsample } = this.kernels;
     const one = { x: 1, y: 1, z: 1, items: 1, stride: null };
-    centroid.dispatch(pass, bound.centroid, plan1d(spec.cells + 1, scope.workgroupSize, scope.caps), [paramsOffset]);
+    const level0 = spec.cells + spec.outsideCells;
+    centroid.dispatch(pass, bound.centroid, plan1d(level0, scope.workgroupSize, scope.caps), [paramsOffset]);
     finalize.dispatch(pass, bound.finalize, one, [bound.finalizeOffset]);
     hub.dispatchIndirect(pass, bound.hub, bound.hubArgs, 0, [paramsOffset]);
     this.dispatches = 3;
@@ -10188,7 +10209,7 @@ class RepulsionGrid {
   }
   /**
    * The model-owned buffers of the grid tier (spec 7.3; PD-11): `cellKey` / `cellVal` / `sortedKey` / `sortedIdx`
-   * 4n, `cellHist` / `cellStart` 4 (cells + 2) zeroed, `hubList` one word per possible hub cell, `hubArgs` one
+   * 4n, `cellHist` / `cellStart` 4 histWords (cells + 2^dim + 1) zeroed, `hubList` one word per possible hub cell, `hubArgs` one
    * indirect slot, `pyramid` 16 B per pyramid cell zeroed. `hubCounters` (16 B, zeroed) is the MODEL's on every
    * tier (PD-14: K1 binds it on the exact tier too). n = 0 reports one node's worth of bytes (spec 3.6).
    * @param n - the node count
@@ -10784,7 +10805,9 @@ class ForceAtlas2Model {
       arcEnd: arcCountOf(core),
       accumulate: 0,
       hiEnd,
-      midEnd
+      midEnd,
+      settleFloor: SETTLE_FLOOR_UNBOUNDED
+      // ForceAtlas2 does not drift after settling (issue #97)
     };
   }
   /**
@@ -11483,6 +11506,7 @@ class FruchtermanReingoldModel {
       hiEnd,
       midEnd,
       frK: resolved.k ?? 1 / Math.sqrt(n),
+      settleFloor: SETTLE_FLOOR_FRACTION.fruchtermanReingold * (resolved.k ?? 1 / Math.sqrt(n)),
       temperature: adaptive ? FR_START_TEMPERATURE : this.temperatureAt(iteration, resolved)
     };
   }
@@ -11535,7 +11559,7 @@ class FruchtermanReingoldModel {
     if (stop < 2) {
       return;
     }
-    k3.dispatch(pass, k3Bound, bound.plan, [offset]);
+    recordExactRepulsion(k3, pass, k3Bound, bound.plan, bound.n, offset);
     if (stop < STAGE_K5$1) {
       return;
     }
@@ -12114,6 +12138,7 @@ class SpringElectricalModel {
       frK: 0,
       temperature: 0,
       springLength: resolved.springLength,
+      settleFloor: SETTLE_FLOOR_FRACTION.springElectrical * resolved.springLength * (SETTLE_FLOOR_REFERENCE_NODES / Math.max(n, 1)) ** 0.25,
       springCoefficient: resolved.springCoefficient ?? SE_DEFAULTS.springCoefficient * springSizeFactor(n),
       coulomb: resolved.gravity ?? SE_DEFAULTS.gravity * springSizeFactor(n),
       dragCoefficient: resolved.dragCoefficient,
@@ -12167,7 +12192,7 @@ class SpringElectricalModel {
     if (stop < 2) {
       return;
     }
-    k3.dispatch(pass, k3Bound, bound.plan, [offset]);
+    recordExactRepulsion(k3, pass, k3Bound, bound.plan, bound.n, offset);
     if (stop < STAGE_K5) {
       return;
     }
@@ -12653,7 +12678,7 @@ async function calibrateLayout(ctx, options) {
   };
 }
 export {
-  C as ARC_WINDOW_ALIGN,
+  J as ARC_WINDOW_ALIGN,
   EXACT_MAX_NODES,
   FA2_DEFAULTS,
   FR_DEFAULTS,
@@ -12661,10 +12686,10 @@ export {
   LAYOUT_TUNING_DEFAULTS,
   MAX_1D_ITEMS,
   MAX_WORKGROUPS_PER_DIM,
-  D as PASSTHROUGH_FORMAT_CODES,
+  K as PASSTHROUGH_FORMAT_CODES,
   SE_DEFAULTS,
-  H as STORAGE_ALIGN,
-  J as WORKGROUP_SIZE,
+  N as STORAGE_ALIGN,
+  O as WORKGROUP_SIZE,
   WebGpuGraphError,
   bellmanFord,
   breadthFirstSearch,
@@ -12679,7 +12704,7 @@ export {
   eigenvectorCentrality,
   hasErrorCode,
   hits,
-  K as isSoftwareAdapter,
+  Q as isSoftwareAdapter,
   isWebGpuGraphError,
   katzCentrality,
   pageRank,