@graphty/webgpu-graph-algorithms 0.6.5 → 0.6.7

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, 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, I as INDIRECT_ARGS_STRIDE, q as GRID_HUB_CELL, L as LAYOUT_TUNING_DEFAULTS, E as EXACT_MAX_NODES, T as TRACE_RECORD_BYTES, r as GRID_BBOX_MARGIN, s as GRID_EXTENT_FLOOR, t as FR_ADAPTIVE_MAX_ITERATIONS, u as FR_START_TEMPERATURE, v as FA2_FLAG_ADAPTIVE, w as FR_REHEAT_FRACTION, x as FR_DEFAULTS, y as SE_DEFAULTS, z as SE_SCALE_REFERENCE_NODES } from "./chunks/context-hzGggHeM.js";
-import { A, G, C, D, H, J } from "./chunks/context-hzGggHeM.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-Cezi7qpi.js";
+import { J, G, K, N, O, Q } from "./chunks/context-Cezi7qpi.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);
@@ -1486,19 +1516,19 @@ fn frontier_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
         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);
@@ -1508,7 +1538,7 @@ 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
         }
@@ -1603,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); }
@@ -1621,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
@@ -1699,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;
 }
@@ -1714,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
@@ -1763,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)]);
@@ -1867,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)
@@ -2589,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",
@@ -2763,7 +2804,8 @@ const FRONTIER_COUNTERS = UniformBlock.define(
     ["nextFarCount", "u32"],
     ["thresholdBits", "u32"],
     ["deltaBits", "u32"],
-    ["path", "u32"]
+    ["path", "u32"],
+    ["nextDegreeSum", "u32"]
   ],
   { layout: "storage" }
 );
@@ -3489,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,
@@ -3600,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,
@@ -5039,7 +5098,7 @@ async function prepareSpmvPull(scope, rev, options) {
   return new SpmvPullPlannerImpl(scope, compiled, perm, options.weights);
 }
 const PR_BATCH = 8;
-const RING_SLOTS$4 = 2 * PR_BATCH + 1;
+const RING_SLOTS$4 = 2 * PR_BATCH + 2;
 function checkDest$3(dest, n, algorithm) {
   if (dest === void 0) {
     return null;
@@ -5129,6 +5188,7 @@ async function run(ctx, s, personalization, options, algorithm) {
     const groups = groupsOf(scalePlan);
     const partialsBytes = PR_PARTIAL.byteLength * (1 + groups);
     const partials = scope.scratch(partialsBytes, "partials");
+    const lastHeader = scope.scratch(PR_PARTIAL.byteLength, "lastHeader");
     if (personalization !== null) {
       uploaded = ctx.residency.array(personalization, `${algorithm}/personalization`);
     }
@@ -5157,17 +5217,19 @@ async function run(ctx, s, personalization, options, algorithm) {
     const xNormBinding = bindingOf$2(xNorm, bytes);
     const outWeightSumBinding = bindingOf$2(outWeightSum, bytes);
     const partialsBinding = bindingOf$2(partials, partialsBytes);
+    const lastHeaderBinding = bindingOf$2(lastHeader, PR_PARTIAL.byteLength);
     const coefficients = { alpha, beta: 1 - alpha, uniformP: 1 / n };
     let cur = 0;
     let iterationsRun = 0;
     for (; ; ) {
       const k = Math.min(PR_BATCH, maxIterations - iterationsRun);
       const batch = new CommandBatch(ctx, algorithm);
-      const pass = batch.pass("iterations");
+      let pass = batch.pass("iterations");
       if (iterationsRun === 0) {
         normaliser.record(pass, weightedCore, outWeightSumBinding);
       }
-      for (let i = 0; i < k; i++) {
+      const last = iterationsRun + k === maxIterations;
+      for (let i = 0; i < k + (last ? 1 : 0); i++) {
         const params = scope.params(PR_PARAMS, {
           n,
           groups,
@@ -5176,6 +5238,10 @@ async function run(ctx, s, personalization, options, algorithm) {
           convergeThreshold: tolerance * n
         });
         const other = 1 - cur;
+        if (i === k) {
+          batch.copy(partialsBinding, lastHeaderBinding, PR_PARTIAL.byteLength);
+          pass = batch.pass("convergence");
+        }
         const scaleBound = scale.bind({
           rankIn: rank[cur],
           rankPrev: rank[other],
@@ -5187,6 +5253,9 @@ async function run(ctx, s, personalization, options, algorithm) {
         scale.dispatch(pass, scaleBound, scalePlan, [params.offset]);
         const finalizeBound = finalize.bind({ partials: partialsBinding, P: params.binding });
         finalize.dispatch(pass, finalizeBound, finalizePlan, [params.offset]);
+        if (i === k) {
+          break;
+        }
         pull.record(
           pass,
           weightedRev,
@@ -5202,6 +5271,7 @@ async function run(ctx, s, personalization, options, algorithm) {
       }
       batch.endPass();
       const headerRequest = batch.readback(partials, 0, PR_PARTIAL.byteLength);
+      const lastHeaderRequest = last ? batch.readback(lastHeader, 0, PR_PARTIAL.byteLength) : headerRequest;
       const scoresRequest = batch.readback(rank[cur].buffer, 0, bytes);
       scope.flush();
       const submitted = batch.submit();
@@ -5225,7 +5295,7 @@ async function run(ctx, s, personalization, options, algorithm) {
           scores,
           iterations: converged ? firstConverged : iterationsRun,
           converged,
-          danglingMass: folded.danglingMass,
+          danglingMass: PR_PARTIAL.read(new DataView(back), lastHeaderRequest.offset).danglingMass,
           precision: "f32"
         };
       }
@@ -5344,7 +5414,8 @@ async function runPowerIteration(ctx, n, config) {
       const k = Math.min(BATCH, config.maxIterations - iterationsRun);
       const batch = new CommandBatch(ctx, config.label);
       const pass = batch.pass("iterations");
-      for (let i = 0; i < k; i++) {
+      const last = iterationsRun + k === config.maxIterations;
+      for (let i = 0; i < k + (last ? 1 : 0); i++) {
         const iteration = iterationsRun + i + 1;
         const params = scope.params(PR_PARAMS, {
           n,
@@ -5366,6 +5437,9 @@ async function runPowerIteration(ctx, n, config) {
         };
         scaleNorm.dispatch(pass, scaleNorm.bind(scaleBindings), scalePlan, [params.offset]);
         finalize.dispatch(pass, finalize.bind({ partials, P: params.binding }), finalizePlan, [params.offset]);
+        if (i === k) {
+          break;
+        }
         if (scaleApply !== null) {
           scaleApply.dispatch(pass, scaleApply.bind(scaleBindings), scalePlan, [params.offset]);
         }
@@ -5747,7 +5821,8 @@ const W = Object.freeze({
   nextFarCount: 21,
   thresholdBits: 22,
   deltaBits: 23,
-  path: 24
+  path: 24,
+  nextDegreeSum: 25
 });
 function definedWords(words) {
   const out = {};
@@ -6082,6 +6157,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);
 }
@@ -6216,6 +6292,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);
@@ -6225,6 +6302,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) => {
@@ -6275,7 +6353,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, {
@@ -6341,6 +6419,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();
@@ -7504,10 +7590,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 {
@@ -7515,7 +7602,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
@@ -9831,6 +9919,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.
@@ -9923,7 +10017,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.
@@ -10056,7 +10150,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;
@@ -10129,7 +10224,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
@@ -10725,7 +10820,9 @@ class ForceAtlas2Model {
       arcEnd: arcCountOf(core),
       accumulate: 0,
       hiEnd,
-      midEnd
+      midEnd,
+      settleFloor: SETTLE_FLOOR_UNBOUNDED
+      // ForceAtlas2 does not drift after settling (issue #97)
     };
   }
   /**
@@ -11424,6 +11521,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)
     };
   }
@@ -11476,7 +11574,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;
     }
@@ -12055,6 +12153,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,
@@ -12108,7 +12207,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;
     }
@@ -12594,7 +12693,7 @@ async function calibrateLayout(ctx, options) {
   };
 }
 export {
-  A as ARC_WINDOW_ALIGN,
+  J as ARC_WINDOW_ALIGN,
   EXACT_MAX_NODES,
   FA2_DEFAULTS,
   FR_DEFAULTS,
@@ -12602,10 +12701,10 @@ export {
   LAYOUT_TUNING_DEFAULTS,
   MAX_1D_ITEMS,
   MAX_WORKGROUPS_PER_DIM,
-  C as PASSTHROUGH_FORMAT_CODES,
+  K as PASSTHROUGH_FORMAT_CODES,
   SE_DEFAULTS,
-  D as STORAGE_ALIGN,
-  H as WORKGROUP_SIZE,
+  N as STORAGE_ALIGN,
+  O as WORKGROUP_SIZE,
   WebGpuGraphError,
   bellmanFord,
   breadthFirstSearch,
@@ -12620,7 +12719,7 @@ export {
   eigenvectorCentrality,
   hasErrorCode,
   hits,
-  J as isSoftwareAdapter,
+  Q as isSoftwareAdapter,
   isWebGpuGraphError,
   katzCentrality,
   pageRank,