@graphty/webgpu-graph-algorithms 0.5.1 → 0.6.1

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

@@ -1 +1 @@
-{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../src/types/layout.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../src/types/layout.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,8 @@
+/**
+ * The `counting-scatter` kernel body (spec 6 row 5; P4-T3): the scatter of a counting sort. `start[k]` is the
+ * exclusive scan of the histogram, `cursor[k]` a zeroed per-bin atomic; an element takes the slot `start[k] +
+ * atomicAdd(&cursor[k], 1u)`. The order inside a bin depends on the schedule (set-deterministic, design 6). Body
+ * only; normative text.
+ */
+export declare const countingScatterWgsl = "\n@compute @workgroup_size(WG)\nfn counting_scatter(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let i = linear_id(wid, lid.x);\n    if (i >= P.count) { return; }                                  // no barrier follows\n    let k = keys[i];\n    let slot = atomicAdd(&cursor[k], 1u);                          // the per-bin cursor (6 row 5)\n    outIndex[start[k] + slot] = i;\n}\n";
+//# sourceMappingURL=counting-scatter.wgsl.d.ts.map

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

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

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

@@ -0,0 +1,17 @@
+/**
+ * The `counting-scatter` kernel body (spec 6 row 5; P4-T3): the scatter of a counting sort. `start[k]` is the
+ * exclusive scan of the histogram, `cursor[k]` a zeroed per-bin atomic; an element takes the slot `start[k] +
+ * atomicAdd(&cursor[k], 1u)`. The order inside a bin depends on the schedule (set-deterministic, design 6). Body
+ * only; normative text.
+ */
+export const countingScatterWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn counting_scatter(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let i = linear_id(wid, lid.x);
+    if (i >= P.count) { return; }                                  // no barrier follows
+    let k = keys[i];
+    let slot = atomicAdd(&cursor[k], 1u);                          // the per-bin cursor (6 row 5)
+    outIndex[start[k] + slot] = i;
+}
+`;
+//# sourceMappingURL=counting-scatter.wgsl.js.map

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

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

package/dist/src/wgsl/fa2-attraction.wgsl.d.ts

@@ -1,15 +1,27 @@
 /**
- * K2 of the ForceAtlas2 iteration, `fa2-attraction` (spec 7.5; contract 4.5): the thread-per-row gather of the
- * attraction force over the undirected CSR rows (both arcs present, so the sum is symmetric with no atomics), the
- * linear or linlog law, the optional weights, the distributed-action division by the mass in `pos.w`, written as
- * the FIRST writer of `force` each iteration. P3 ships the thread-per-row tier over `[tierStart, tierEnd)` = `[0, n)`
- * with `USE_PERM = false`; the subgroup / workgroup tiers arrive with P4 (`TIER`). `LAW` (P5, spec 7.20) picks the
- * pair law: 0 = the FA2 text, 1 = Fruchterman-Reingold `d^2 / k` (unfloored), 2 = ngraph's Hooke spring
- * `k_s (d - L)`; under 1 / 2 the models compile `LINLOG = false` and `HAS_WEIGHTS = false`, and the law overwrites
- * `w` so weights are ignored either way.
+ * K2 of the ForceAtlas2 iteration, `fa2-attraction` (spec 7.5; contract 4.5): the gather of the attraction force
+ * over the undirected CSR rows (both arcs present, so the sum is symmetric with no atomics), the linear or linlog
+ * law, the optional weights, the distributed-action division by the mass in `pos.w`, written as the FIRST writer of
+ * `force` each iteration (or combined into it under `P.accumulate`, the windowed pattern of 4.2). The arcs are read
+ * inside the bound window [P.arcBase, P.arcEnd). P4-T5 (PD-6, PD-7) gives it the three degree tiers: TIER 0 is one
+ * row per thread over `[P.tierStart, P.tierEnd)`; TIER 1 is 32 lanes per row over `[P.hiEnd, P.midEnd)` with a
+ * five-step tree in workgroup memory; TIER 2 is one workgroup per row over `[0, P.hiEnd)` through `wg_reduce_vec4`
+ * (hence `needs: ["subgroups"]`); the row is `perm[row]` under USE_PERM. `LAW` (P5, spec 7.20) picks the pair law:
+ * 0 = the FA2 text, 1 = Fruchterman-Reingold `d^2 / k` (unfloored), 2 = ngraph's Hooke spring `k_s (d - L)`; under
+ * 1 / 2 the models compile `LINLOG = false` and `HAS_WEIGHTS = false`, and the law overwrites `w` so weights are
+ * ignored either way.
  *
- * Body only (spec 3.5, D9); normative text (contract 4.5); the K2 sabotage mutations (P3-T5) are textual edits of it.
+ * Body only (spec 3.5, D9); normative text (contract 4.5); the K2 sabotage mutations (P3-T5, P5-T7, P4-T5 / T6) are
+ * textual edits of it.
+ *
+ * TIER 0 folds its row through `row_force_dense`, a stride-one copy of `row_force`, because the shader compiler
+ * emits `row_force(i, 0u, 1u)` as a call and leaves the stride in a parameter: the loop then walks the row with a
+ * runtime step, which costs the strength-reduced addressing into colIdx / weights and the unrolling that keeps
+ * several loads in flight per thread. TIER 0 runs on every load -- alone when no row reaches degree 32, and over
+ * the low-degree rows, which are most of them, when the tiers are bound. The two folds spell their locals apart
+ * (`arc` / `nbr` / `weight` / `total` against `a` / `j` / `w` / `f`) so that each sabotage row names exactly one
+ * of them.
  */
-/** The K2 body: entry point `attraction`; an early return is legal here because no barrier follows (spec 3.5 rule 1). */
-export declare const fa2AttractionWgsl = "fn store_force(i: u32, f: vec3f) {\n    force[3u * i] = f.x;\n    force[3u * i + 1u] = f.y;\n    force[3u * i + 2u] = f.z;\n}\n\n@compute @workgroup_size(WG)\nfn attraction(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let row = linear_id(wid, lid.x) + P.tierStart;\n    if (row >= P.tierEnd) { return; }                          // no barrier follows in this tier (3.5 rule 1)\n    let i = select(row, perm[row], USE_PERM);\n    let pi = pos[i];                                           // xyz + mass in one load (D23)\n    var f = vec3f(0.0);\n    for (var a = rowPtr[i]; a < rowPtr[i + 1u]; a = a + 1u) {\n        let j = colIdx[a];\n        if (j == i) { continue; }                              // a self-loop exerts no force\n        var w = 1.0;\n        if (HAS_WEIGHTS) { w = weights[a]; }\n        let d = pos[j].xyz - pi.xyz;                           // toward j\n        let len = max(length(d), FA2_DIST_FLOOR);\n        if (LAW == 1u) { w = length(d) / P.frK; }              // LAW 1 (FR, 7.20): |F| = d^2 / k along d / d, unfloored; the linear select below applies w as is\n        if (LAW == 2u) { w = P.springCoefficient * (len - P.springLength) / len; }   // LAW 2 (spring, ngraph generateCreateSpringForce.js:33-36): Hooke k_s (d - L) toward j\n        let mag = select(w, w * log(1.0 + len) / len, LINLOG); // linear: |F| = w len; linlog: |F| = w log(1 + len)\n        f = f + d * mag;\n    }\n    if (DISTRIBUTED) { f = f / pi.w; }\n    store_force(i, f);                                         // overwrites: attraction is the first writer of force each iteration\n}";
+/** The K2 body: entry point `attraction`; the tier bodies are functions called under the uniform `TIER` override, so the barriers of `tiered` are reached in uniform control flow and `tier0`'s early return is legal (spec 3.5 rule 1). */
+export declare const fa2AttractionWgsl = "fn store_force(i: u32, f: vec3f) {\n    force[3u * i] = f.x;\n    force[3u * i + 1u] = f.y;\n    force[3u * i + 2u] = f.z;\n}\nfn load_force(i: u32) -> vec3f { return vec3f(force[3u * i], force[3u * i + 1u], force[3u * i + 2u]); }\nfn row_node(row: u32) -> u32 { return select(row, perm[row], USE_PERM); }\nfn row_force(i: u32, lane: u32, step: u32) -> vec3f {           // the arcs of row i this lane walks inside the bound window [P.arcBase, P.arcEnd) (4.2)\n    let pi = pos[i];                                           // xyz + mass in one load (D23)\n    let a0 = max(rowPtr[i], P.arcBase);\n    let a1 = min(rowPtr[i + 1u], P.arcEnd);\n    var f = vec3f(0.0);\n    for (var a = a0 + lane; a < a1; a = a + step) {\n        let j = colIdx[a - P.arcBase];\n        if (j == i) { continue; }                              // a self-loop exerts no force\n        var w = 1.0;\n        if (HAS_WEIGHTS) { w = weights[a - P.arcBase]; }\n        let d = pos[j].xyz - pi.xyz;                           // toward j\n        let len = max(length(d), FA2_DIST_FLOOR);\n        if (LAW == 1u) { w = length(d) / P.frK; }              // LAW 1 (FR, 7.20): |F| = d^2 / k along d / d, unfloored; the linear select below applies w as is\n        if (LAW == 2u) { w = P.springCoefficient * (len - P.springLength) / len; }   // LAW 2 (spring, ngraph generateCreateSpringForce.js:33-36): Hooke k_s (d - L) toward j\n        let mag = select(w, w * log(1.0 + len) / len, LINLOG); // linear: |F| = w len; linlog: |F| = w log(1 + len)\n        f = f + d * mag;\n    }\n    return f;\n}\nfn row_force_dense(i: u32) -> vec3f {                          // TIER 0's stride-one twin of row_force (see the header)\n    let pi = pos[i];\n    let lo = max(rowPtr[i], P.arcBase);\n    let hi = min(rowPtr[i + 1u], P.arcEnd);\n    var total = vec3f(0.0);\n    for (var arc = lo; arc < hi; arc = arc + 1u) {\n        let k = arc - P.arcBase;                               // the window-local index; this walk is contiguous\n        let nbr = colIdx[k];\n        if (nbr == i) { continue; }                            // a self-loop exerts no force\n        var weight = 1.0;\n        if (HAS_WEIGHTS) { weight = weights[k]; }\n        let d = pos[nbr].xyz - pi.xyz;                         // toward the neighbour\n        let len = max(length(d), FA2_DIST_FLOOR);\n        if (LAW == 1u) { weight = length(d) / P.frK; }         // LAW 1 (FR, 7.20), as in row_force\n        if (LAW == 2u) { weight = P.springCoefficient * (len - P.springLength) / len; }   // LAW 2 (spring), as in row_force\n        let mag = select(weight, weight * log(1.0 + len) / len, LINLOG);\n        total = total + d * mag;\n    }\n    return total;\n}\nfn finish(i: u32, f0: vec3f) {\n    var f = f0;\n    if (DISTRIBUTED) { f = f / pos[i].w; }\n    if (P.accumulate == 1u) { f = f + load_force(i); }         // the windowed loop of 4.2 (arcBase != 0 dispatches after the first)\n    store_force(i, f);                                         // overwrites: attraction is the first writer of force each iteration\n}\nfn tier0(wid: vec3<u32>, lane: u32) {                          // TIER 0: one row per thread over [tierStart, tierEnd); no barrier, so the early return is legal (3.5 rule 1)\n    let row = linear_id(wid, lane) + P.tierStart;\n    if (row >= P.tierEnd) { return; }\n    let i = row_node(row);\n    finish(i, row_force_dense(i));\n}\n\nvar<workgroup> sh: array<vec3f, WG>;\n\nfn tiered(wid: vec3<u32>, lid: u32) {                          // TIER 1: 32 lanes per row over [hiEnd, midEnd); TIER 2: WG lanes per row over [0, hiEnd) (PD-6, PD-7)\n    let g = group_id(wid);\n    var row = g;\n    var end = P.hiEnd;\n    var lane = lid;\n    var step = WG;\n    if (TIER == 1u) { row = P.hiEnd + g * (WG / 32u) + lid / 32u; end = P.midEnd; lane = lid % 32u; step = 32u; }\n    let valid = row < end;\n    var i = 0u;\n    var f = vec3f(0.0);\n    if (valid) { i = row_node(row); f = row_force(i, lane, step); }\n    if (TIER == 1u) {\n        sh[lid] = f;\n        workgroupBarrier();\n        for (var s = 16u; s >= 1u; s = s / 2u) {                 // the five-step tree over each 32-lane group; every lane runs every step\n            var t = vec3f(0.0);\n            if (lane < s) { t = sh[lid + s]; }\n            workgroupBarrier();\n            sh[lid] = sh[lid] + t;\n            workgroupBarrier();\n        }\n        if (valid && lane == 0u) { finish(i, sh[lid]); }\n    }\n    if (TIER == 2u) {\n        let t = wg_reduce_vec4(vec4f(f, 0.0), lid, 0u);\n        if (valid && lid == 0u) { finish(i, t.xyz); }\n    }\n}\n\n@compute @workgroup_size(WG)\nfn attraction(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    if (TIER == 0u) { tier0(wid, lid.x); } else { tiered(wid, lid.x); }\n}";
 //# sourceMappingURL=fa2-attraction.wgsl.d.ts.map

package/dist/src/wgsl/fa2-attraction.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fa2-attraction.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-attraction.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,yHAAyH;AACzH,eAAO,MAAM,iBAAiB,0mDA2B5B,CAAC"}
+{"version":3,"file":"fa2-attraction.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-attraction.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,4OAA4O;AAC5O,eAAO,MAAM,iBAAiB,msJA6F5B,CAAC"}

package/dist/src/wgsl/fa2-attraction.wgsl.js

@@ -1,34 +1,45 @@
 /**
- * K2 of the ForceAtlas2 iteration, `fa2-attraction` (spec 7.5; contract 4.5): the thread-per-row gather of the
- * attraction force over the undirected CSR rows (both arcs present, so the sum is symmetric with no atomics), the
- * linear or linlog law, the optional weights, the distributed-action division by the mass in `pos.w`, written as
- * the FIRST writer of `force` each iteration. P3 ships the thread-per-row tier over `[tierStart, tierEnd)` = `[0, n)`
- * with `USE_PERM = false`; the subgroup / workgroup tiers arrive with P4 (`TIER`). `LAW` (P5, spec 7.20) picks the
- * pair law: 0 = the FA2 text, 1 = Fruchterman-Reingold `d^2 / k` (unfloored), 2 = ngraph's Hooke spring
- * `k_s (d - L)`; under 1 / 2 the models compile `LINLOG = false` and `HAS_WEIGHTS = false`, and the law overwrites
- * `w` so weights are ignored either way.
+ * K2 of the ForceAtlas2 iteration, `fa2-attraction` (spec 7.5; contract 4.5): the gather of the attraction force
+ * over the undirected CSR rows (both arcs present, so the sum is symmetric with no atomics), the linear or linlog
+ * law, the optional weights, the distributed-action division by the mass in `pos.w`, written as the FIRST writer of
+ * `force` each iteration (or combined into it under `P.accumulate`, the windowed pattern of 4.2). The arcs are read
+ * inside the bound window [P.arcBase, P.arcEnd). P4-T5 (PD-6, PD-7) gives it the three degree tiers: TIER 0 is one
+ * row per thread over `[P.tierStart, P.tierEnd)`; TIER 1 is 32 lanes per row over `[P.hiEnd, P.midEnd)` with a
+ * five-step tree in workgroup memory; TIER 2 is one workgroup per row over `[0, P.hiEnd)` through `wg_reduce_vec4`
+ * (hence `needs: ["subgroups"]`); the row is `perm[row]` under USE_PERM. `LAW` (P5, spec 7.20) picks the pair law:
+ * 0 = the FA2 text, 1 = Fruchterman-Reingold `d^2 / k` (unfloored), 2 = ngraph's Hooke spring `k_s (d - L)`; under
+ * 1 / 2 the models compile `LINLOG = false` and `HAS_WEIGHTS = false`, and the law overwrites `w` so weights are
+ * ignored either way.
  *
- * Body only (spec 3.5, D9); normative text (contract 4.5); the K2 sabotage mutations (P3-T5) are textual edits of it.
+ * Body only (spec 3.5, D9); normative text (contract 4.5); the K2 sabotage mutations (P3-T5, P5-T7, P4-T5 / T6) are
+ * textual edits of it.
+ *
+ * TIER 0 folds its row through `row_force_dense`, a stride-one copy of `row_force`, because the shader compiler
+ * emits `row_force(i, 0u, 1u)` as a call and leaves the stride in a parameter: the loop then walks the row with a
+ * runtime step, which costs the strength-reduced addressing into colIdx / weights and the unrolling that keeps
+ * several loads in flight per thread. TIER 0 runs on every load -- alone when no row reaches degree 32, and over
+ * the low-degree rows, which are most of them, when the tiers are bound. The two folds spell their locals apart
+ * (`arc` / `nbr` / `weight` / `total` against `a` / `j` / `w` / `f`) so that each sabotage row names exactly one
+ * of them.
  */
-/** The K2 body: entry point `attraction`; an early return is legal here because no barrier follows (spec 3.5 rule 1). */
+/** The K2 body: entry point `attraction`; the tier bodies are functions called under the uniform `TIER` override, so the barriers of `tiered` are reached in uniform control flow and `tier0`'s early return is legal (spec 3.5 rule 1). */
 export const fa2AttractionWgsl = /* wgsl */ `fn store_force(i: u32, f: vec3f) {
     force[3u * i] = f.x;
     force[3u * i + 1u] = f.y;
     force[3u * i + 2u] = f.z;
 }
-
-@compute @workgroup_size(WG)
-fn attraction(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
-    let row = linear_id(wid, lid.x) + P.tierStart;
-    if (row >= P.tierEnd) { return; }                          // no barrier follows in this tier (3.5 rule 1)
-    let i = select(row, perm[row], USE_PERM);
+fn load_force(i: u32) -> vec3f { return vec3f(force[3u * i], force[3u * i + 1u], force[3u * i + 2u]); }
+fn row_node(row: u32) -> u32 { return select(row, perm[row], USE_PERM); }
+fn row_force(i: u32, lane: u32, step: u32) -> vec3f {           // the arcs of row i this lane walks inside the bound window [P.arcBase, P.arcEnd) (4.2)
     let pi = pos[i];                                           // xyz + mass in one load (D23)
+    let a0 = max(rowPtr[i], P.arcBase);
+    let a1 = min(rowPtr[i + 1u], P.arcEnd);
     var f = vec3f(0.0);
-    for (var a = rowPtr[i]; a < rowPtr[i + 1u]; a = a + 1u) {
-        let j = colIdx[a];
+    for (var a = a0 + lane; a < a1; a = a + step) {
+        let j = colIdx[a - P.arcBase];
         if (j == i) { continue; }                              // a self-loop exerts no force
         var w = 1.0;
-        if (HAS_WEIGHTS) { w = weights[a]; }
+        if (HAS_WEIGHTS) { w = weights[a - P.arcBase]; }
         let d = pos[j].xyz - pi.xyz;                           // toward j
         let len = max(length(d), FA2_DIST_FLOOR);
         if (LAW == 1u) { w = length(d) / P.frK; }              // LAW 1 (FR, 7.20): |F| = d^2 / k along d / d, unfloored; the linear select below applies w as is
@@ -36,7 +47,74 @@ fn attraction(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_i
         let mag = select(w, w * log(1.0 + len) / len, LINLOG); // linear: |F| = w len; linlog: |F| = w log(1 + len)
         f = f + d * mag;
     }
-    if (DISTRIBUTED) { f = f / pi.w; }
+    return f;
+}
+fn row_force_dense(i: u32) -> vec3f {                          // TIER 0's stride-one twin of row_force (see the header)
+    let pi = pos[i];
+    let lo = max(rowPtr[i], P.arcBase);
+    let hi = min(rowPtr[i + 1u], P.arcEnd);
+    var total = vec3f(0.0);
+    for (var arc = lo; arc < hi; arc = arc + 1u) {
+        let k = arc - P.arcBase;                               // the window-local index; this walk is contiguous
+        let nbr = colIdx[k];
+        if (nbr == i) { continue; }                            // a self-loop exerts no force
+        var weight = 1.0;
+        if (HAS_WEIGHTS) { weight = weights[k]; }
+        let d = pos[nbr].xyz - pi.xyz;                         // toward the neighbour
+        let len = max(length(d), FA2_DIST_FLOOR);
+        if (LAW == 1u) { weight = length(d) / P.frK; }         // LAW 1 (FR, 7.20), as in row_force
+        if (LAW == 2u) { weight = P.springCoefficient * (len - P.springLength) / len; }   // LAW 2 (spring), as in row_force
+        let mag = select(weight, weight * log(1.0 + len) / len, LINLOG);
+        total = total + d * mag;
+    }
+    return total;
+}
+fn finish(i: u32, f0: vec3f) {
+    var f = f0;
+    if (DISTRIBUTED) { f = f / pos[i].w; }
+    if (P.accumulate == 1u) { f = f + load_force(i); }         // the windowed loop of 4.2 (arcBase != 0 dispatches after the first)
     store_force(i, f);                                         // overwrites: attraction is the first writer of force each iteration
+}
+fn tier0(wid: vec3<u32>, lane: u32) {                          // TIER 0: one row per thread over [tierStart, tierEnd); no barrier, so the early return is legal (3.5 rule 1)
+    let row = linear_id(wid, lane) + P.tierStart;
+    if (row >= P.tierEnd) { return; }
+    let i = row_node(row);
+    finish(i, row_force_dense(i));
+}
+
+var<workgroup> sh: array<vec3f, WG>;
+
+fn tiered(wid: vec3<u32>, lid: u32) {                          // TIER 1: 32 lanes per row over [hiEnd, midEnd); TIER 2: WG lanes per row over [0, hiEnd) (PD-6, PD-7)
+    let g = group_id(wid);
+    var row = g;
+    var end = P.hiEnd;
+    var lane = lid;
+    var step = WG;
+    if (TIER == 1u) { row = P.hiEnd + g * (WG / 32u) + lid / 32u; end = P.midEnd; lane = lid % 32u; step = 32u; }
+    let valid = row < end;
+    var i = 0u;
+    var f = vec3f(0.0);
+    if (valid) { i = row_node(row); f = row_force(i, lane, step); }
+    if (TIER == 1u) {
+        sh[lid] = f;
+        workgroupBarrier();
+        for (var s = 16u; s >= 1u; s = s / 2u) {                 // the five-step tree over each 32-lane group; every lane runs every step
+            var t = vec3f(0.0);
+            if (lane < s) { t = sh[lid + s]; }
+            workgroupBarrier();
+            sh[lid] = sh[lid] + t;
+            workgroupBarrier();
+        }
+        if (valid && lane == 0u) { finish(i, sh[lid]); }
+    }
+    if (TIER == 2u) {
+        let t = wg_reduce_vec4(vec4f(f, 0.0), lid, 0u);
+        if (valid && lid == 0u) { finish(i, t.xyz); }
+    }
+}
+
+@compute @workgroup_size(WG)
+fn attraction(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    if (TIER == 0u) { tier0(wid, lid.x); } else { tiered(wid, lid.x); }
 }`;
 //# sourceMappingURL=fa2-attraction.wgsl.js.map

package/dist/src/wgsl/fa2-attraction.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"fa2-attraction.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-attraction.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,yHAAyH;AACzH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2B1C,CAAC"}
+{"version":3,"file":"fa2-attraction.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-attraction.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,4OAA4O;AAC5O,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6F1C,CAAC"}

package/dist/src/wgsl/fa2-stats-finalize.wgsl.d.ts

@@ -10,12 +10,16 @@
  * free nodes into `partials.swingTraction.x`) against `S.frEnergy` grows the temperature by 1 / FR_COOLING_STEP after
  * FR_COOLING_PATIENCE consecutive falls and shrinks it by FR_COOLING_STEP on a rise (Yifan Hu 2005, section 3.2);
  * 2 = the spring-electrical kinetic energy K5 folded into `partials.swingTraction.x` (PD-4) into `S.kineticEnergy`
- * and the trace.
+ * and the trace. On the grid tier (`P.gridMax > 0`, P4-T10, PD-14) it also derives the grid frame of the next build
+ * from the fold (`extent = max(min(bboxExtent * GRID_BBOX_MARGIN, extentFactor * rmsRadius), GRID_EXTENT_FLOOR)`,
+ * `cellSize = extent / G`, `gridMin = centroid - extent / 2` with `cellSize` in `.w`, `invCellSize`, `eps = 0.25
+ * cellSize`), copies the previous iteration's pseudo-cell count and occupancy max into the state, and resets the
+ * hub counters; the exact tier writes `gridMax: 0` and binds two dummies, so the block is dead there.
  *
  * This file holds the kernel BODY only (spec 3.5, D9): no bind-group lines and no `override` lines -- the composer
  * emits them from the registry entry in src/kernels.ts (contract 3.10.1). The text is normative (contract 4.5) and
  * is the target of the K1 sabotage mutations (test/helpers/sabotage.ts, P3-T5); amend the contract before editing.
  */
 /** The K1 body: entry point `stats_finalize`; calls the reduction helpers (`needs: ["subgroups"]`, contract 4.3). */
-export declare const fa2StatsFinalizeWgsl = "// K1: folds the previous integrate's partials into the state block (spec 7.4); one workgroup\n@compute @workgroup_size(WG)\nfn stats_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {\n    let groups = (P.n + WG - 1u) / WG;\n    let fold = (P.flags & FA2_FLAG_FIRST) == 0u;    // the first iteration after load() keeps the host-written state\n    var sum = vec4f(0.0);\n    var lo = vec4f(F32_MAX);\n    var hi = vec4f(-F32_MAX);\n    var disp = 0.0;\n    var free = 0u;\n    var ke = 0.0;\n    if (fold) {\n        for (var g = lid.x; g < groups; g = g + WG) {   // sequential per lane in index order: deterministic\n            let q = partials[g];\n            sum = sum + q.sum;\n            lo = min(lo, q.min);\n            hi = max(hi, q.max);\n            disp = disp + q.dispFree.x;\n            free = free + u32(q.dispFree.y);\n            ke = ke + q.swingTraction.x;\n        }\n    }\n    let tSum = wg_reduce_vec4(sum, lid.x, 0u);\n    let tLo = wg_reduce_vec4(lo, lid.x, 1u);\n    let tHi = wg_reduce_vec4(hi, lid.x, 2u);\n    let tDisp = wg_reduce_f32(disp, lid.x, 0u);\n    let tFree = wg_reduce_u32(free, lid.x, 0u);\n    let tKe = wg_reduce_f32(ke, lid.x, 0u);\n    if (lid.x == 0u) {\n        if (fold) {\n            let n = f32(P.n);\n            let c = tSum.xyz / n;\n            S.centroid = vec4f(c, 0.0);\n            S.rmsRadius = sqrt(max(tSum.w, 0.0) / n);                  // RMS radius about the previous centroid (7.17)\n            S.min = vec4f(tLo.xyz, 0.0);\n            S.max = vec4f(tHi.xyz, 0.0);\n            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)\n            let meanDisp = select(tDisp / f32(tFree), 0.0, tFree == 0u);  // all-fixed: 0, never NaN (7.4)\n            S.meanDisplacement = meanDisp;\n            S.settledCount = select(0u, S.settledCount + 1u, meanDisp <= P.settleThreshold * S.rmsRadius);\n        }\n        S.iteration = S.iteration + 1u;\n        T[P.iterationIndex].meanDisplacement = S.meanDisplacement;\n        T[P.iterationIndex].settledCount = S.settledCount;\n        T[P.iterationIndex].iteration = S.iteration;\n        if (STATS_MODE == 1u) {                                    // FR: this iteration's temperature (7.20) into the state and the trace\n            if ((P.flags & FA2_FLAG_ADAPTIVE) != 0u) {                // adaptive cooling (Yifan Hu 2005 3.2): tKe is the previous iteration's sum |F|^2 over free nodes\n                if (fold) {\n                    var t = S.temperature;\n                    if (tKe < S.frEnergy) {\n                        S.frProgress = S.frProgress + 1u;\n                        if (S.frProgress >= FR_COOLING_PATIENCE) { S.frProgress = 0u; t = t / FR_COOLING_STEP; }\n                    } else {\n                        S.frProgress = 0u;\n                        t = t * FR_COOLING_STEP;\n                    }\n                    S.frEnergy = tKe;\n                    S.temperature = t;\n                }\n            } else {\n                S.temperature = P.temperature;\n            }\n            T[P.iterationIndex].modelScalar = S.temperature;\n        }\n        if (STATS_MODE == 2u) {                                    // spring-electrical: the kinetic energy K5 folded into partials B (PD-4); 0 on the first iteration after load()\n            S.kineticEnergy = tKe;\n            T[P.iterationIndex].modelScalar = tKe;\n        }\n    }\n}";
+export declare const fa2StatsFinalizeWgsl = "// K1: folds the previous integrate's partials into the state block (spec 7.4); one workgroup\n@compute @workgroup_size(WG)\nfn stats_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {\n    let groups = (P.n + WG - 1u) / WG;\n    let fold = (P.flags & FA2_FLAG_FIRST) == 0u;    // the first iteration after load() keeps the host-written state\n    var sum = vec4f(0.0);\n    var lo = vec4f(F32_MAX);\n    var hi = vec4f(-F32_MAX);\n    var disp = 0.0;\n    var free = 0u;\n    var ke = 0.0;\n    if (fold) {\n        for (var g = lid.x; g < groups; g = g + WG) {   // sequential per lane in index order: deterministic\n            let q = partials[g];\n            sum = sum + q.sum;\n            lo = min(lo, q.min);\n            hi = max(hi, q.max);\n            disp = disp + q.dispFree.x;\n            free = free + u32(q.dispFree.y);\n            ke = ke + q.swingTraction.x;\n        }\n    }\n    let tSum = wg_reduce_vec4(sum, lid.x, 0u);\n    let tLo = wg_reduce_vec4(lo, lid.x, 1u);\n    let tHi = wg_reduce_vec4(hi, lid.x, 2u);\n    let tDisp = wg_reduce_f32(disp, lid.x, 0u);\n    let tFree = wg_reduce_u32(free, lid.x, 0u);\n    let tKe = wg_reduce_f32(ke, lid.x, 0u);\n    if (lid.x == 0u) {\n        if (fold) {\n            let n = f32(P.n);\n            let c = tSum.xyz / n;\n            S.centroid = vec4f(c, 0.0);\n            S.rmsRadius = sqrt(max(tSum.w, 0.0) / n);                  // RMS radius about the previous centroid (7.17)\n            S.min = vec4f(tLo.xyz, 0.0);\n            S.max = vec4f(tHi.xyz, 0.0);\n            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)\n            let meanDisp = select(tDisp / f32(tFree), 0.0, tFree == 0u);  // all-fixed: 0, never NaN (7.4)\n            S.meanDisplacement = meanDisp;\n            S.settledCount = select(0u, S.settledCount + 1u, meanDisp <= P.settleThreshold * S.rmsRadius);\n        }\n        S.iteration = S.iteration + 1u;\n        T[P.iterationIndex].meanDisplacement = S.meanDisplacement;\n        T[P.iterationIndex].settledCount = S.settledCount;\n        T[P.iterationIndex].iteration = S.iteration;\n        if (P.gridMax > 0u) {                                      // the grid tier (7.7): the robust extent, the cell size, eps, last iteration's counts, the hub counter reset (PD-14)\n            let cells = P.gridMax * P.gridMax * select(1u, P.gridMax, P.dim == 3u);\n            if (fold) {\n                let box = (S.max.xyz - S.min.xyz) * GRID_BBOX_MARGIN;\n                var bboxExtent = max(box.x, box.y);\n                if (P.dim == 3u) { bboxExtent = max(bboxExtent, box.z); }\n                let extent = max(min(bboxExtent, P.extentFactor * S.rmsRadius), GRID_EXTENT_FLOOR);   // min(bbox, extentFactor x rms), floored (7.7)\n                let cellSize = extent / f32(P.gridMax);\n                S.gridMin = vec4f(S.centroid.xyz - vec3f(0.5 * extent), cellSize);   // gridMin.w carries cellSize\n                S.invCellSize = 1.0 / cellSize;\n                S.eps = 0.25 * cellSize;\n            }\n            S.outsideGrid = cellHist[cells];                         // the previous iteration's pseudo-cell count (0 after load)\n            S.maxCellOccupancy = atomicLoad(&hubCounters[1]);\n            atomicStore(&hubCounters[0], 0u);\n            atomicStore(&hubCounters[1], 0u);\n        }\n        if (STATS_MODE == 1u) {                                    // FR: this iteration's temperature (7.20) into the state and the trace\n            if ((P.flags & FA2_FLAG_ADAPTIVE) != 0u) {                // adaptive cooling (Yifan Hu 2005 3.2): tKe is the previous iteration's sum |F|^2 over free nodes\n                if (fold) {\n                    var t = S.temperature;\n                    if (tKe < S.frEnergy) {\n                        S.frProgress = S.frProgress + 1u;\n                        if (S.frProgress >= FR_COOLING_PATIENCE) { S.frProgress = 0u; t = t / FR_COOLING_STEP; }\n                    } else {\n                        S.frProgress = 0u;\n                        t = t * FR_COOLING_STEP;\n                    }\n                    S.frEnergy = tKe;\n                    S.temperature = t;\n                }\n            } else {\n                S.temperature = P.temperature;\n            }\n            T[P.iterationIndex].modelScalar = S.temperature;\n        }\n        if (STATS_MODE == 2u) {                                    // spring-electrical: the kinetic energy K5 folded into partials B (PD-4); 0 on the first iteration after load()\n            S.kineticEnergy = tKe;\n            T[P.iterationIndex].modelScalar = tKe;\n        }\n    }\n}";
 //# sourceMappingURL=fa2-stats-finalize.wgsl.d.ts.map

package/dist/src/wgsl/fa2-stats-finalize.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fa2-stats-finalize.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-stats-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,qHAAqH;AACrH,eAAO,MAAM,oBAAoB,86GAqE/B,CAAC"}
+{"version":3,"file":"fa2-stats-finalize.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-stats-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,qHAAqH;AACrH,eAAO,MAAM,oBAAoB,snJAsF/B,CAAC"}

package/dist/src/wgsl/fa2-stats-finalize.wgsl.js

@@ -10,7 +10,11 @@
  * free nodes into `partials.swingTraction.x`) against `S.frEnergy` grows the temperature by 1 / FR_COOLING_STEP after
  * FR_COOLING_PATIENCE consecutive falls and shrinks it by FR_COOLING_STEP on a rise (Yifan Hu 2005, section 3.2);
  * 2 = the spring-electrical kinetic energy K5 folded into `partials.swingTraction.x` (PD-4) into `S.kineticEnergy`
- * and the trace.
+ * and the trace. On the grid tier (`P.gridMax > 0`, P4-T10, PD-14) it also derives the grid frame of the next build
+ * from the fold (`extent = max(min(bboxExtent * GRID_BBOX_MARGIN, extentFactor * rmsRadius), GRID_EXTENT_FLOOR)`,
+ * `cellSize = extent / G`, `gridMin = centroid - extent / 2` with `cellSize` in `.w`, `invCellSize`, `eps = 0.25
+ * cellSize`), copies the previous iteration's pseudo-cell count and occupancy max into the state, and resets the
+ * hub counters; the exact tier writes `gridMax: 0` and binds two dummies, so the block is dead there.
  *
  * This file holds the kernel BODY only (spec 3.5, D9): no bind-group lines and no `override` lines -- the composer
  * emits them from the registry entry in src/kernels.ts (contract 3.10.1). The text is normative (contract 4.5) and
@@ -62,6 +66,23 @@ fn stats_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
         T[P.iterationIndex].meanDisplacement = S.meanDisplacement;
         T[P.iterationIndex].settledCount = S.settledCount;
         T[P.iterationIndex].iteration = S.iteration;
+        if (P.gridMax > 0u) {                                      // the grid tier (7.7): the robust extent, the cell size, eps, last iteration's counts, the hub counter reset (PD-14)
+            let cells = P.gridMax * P.gridMax * select(1u, P.gridMax, P.dim == 3u);
+            if (fold) {
+                let box = (S.max.xyz - S.min.xyz) * GRID_BBOX_MARGIN;
+                var bboxExtent = max(box.x, box.y);
+                if (P.dim == 3u) { bboxExtent = max(bboxExtent, box.z); }
+                let extent = max(min(bboxExtent, P.extentFactor * S.rmsRadius), GRID_EXTENT_FLOOR);   // min(bbox, extentFactor x rms), floored (7.7)
+                let cellSize = extent / f32(P.gridMax);
+                S.gridMin = vec4f(S.centroid.xyz - vec3f(0.5 * extent), cellSize);   // gridMin.w carries cellSize
+                S.invCellSize = 1.0 / cellSize;
+                S.eps = 0.25 * cellSize;
+            }
+            S.outsideGrid = cellHist[cells];                         // the previous iteration's pseudo-cell count (0 after load)
+            S.maxCellOccupancy = atomicLoad(&hubCounters[1]);
+            atomicStore(&hubCounters[0], 0u);
+            atomicStore(&hubCounters[1], 0u);
+        }
         if (STATS_MODE == 1u) {                                    // FR: this iteration's temperature (7.20) into the state and the trace
             if ((P.flags & FA2_FLAG_ADAPTIVE) != 0u) {                // adaptive cooling (Yifan Hu 2005 3.2): tKe is the previous iteration's sum |F|^2 over free nodes
                 if (fold) {

package/dist/src/wgsl/fa2-stats-finalize.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"fa2-stats-finalize.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-stats-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,qHAAqH;AACrH,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqE7C,CAAC"}
+{"version":3,"file":"fa2-stats-finalize.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-stats-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,qHAAqH;AACrH,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsF7C,CAAC"}

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

@@ -0,0 +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
+ * 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";
+//# sourceMappingURL=grid-cell-key.wgsl.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,30 @@
+/**
+ * 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
+ * far-away or NaN coordinate out of an out-of-range float-to-int conversion. Body only; normative text.
+ */
+export const gridCellKeyWgsl = /* wgsl */ `
+fn grid_cells() -> u32 { return P.gridMax * P.gridMax * select(1u, P.gridMax, P.dim == 3u); }
+
+@compute @workgroup_size(WG)
+fn grid_cell_key(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let i = linear_id(wid, lid.x);
+    if (i >= P.n) { return; }                                      // no barrier follows
+    let cells = grid_cells();
+    let gf = f32(P.gridMax);
+    let q = (pos[i].xyz - S.gridMin.xyz) * S.invCellSize;          // PD-10: never a division
+    let c = vec3<i32>(floor(clamp(q, vec3f(-1.0), vec3f(gf + 1.0))));
+    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)
+    if (inside) {
+        key = u32(c.x) + P.gridMax * u32(c.y);
+        if (P.dim == 3u) { key = key + P.gridMax * P.gridMax * u32(c.z); }
+    }
+    cellKey[i] = key;
+    cellVal[i] = i;
+}
+`;
+//# sourceMappingURL=grid-cell-key.wgsl.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,8 @@
+/**
+ * G4b, the `grid-centroid-hub` kernel body (spec 7.7; P4-T9): one workgroup per hub cell of hubList, dispatched
+ * indirectly from hubArgs (the T1 finalize over hubCounters[0]); a WG-strided mass-weighted sum reduced by the
+ * prelude's tree. The work is guarded by `valid`, never an early return, so the reduction is uniform (PD-13). Body
+ * only; normative text.
+ */
+export declare const gridCentroidHubWgsl = "\n@compute @workgroup_size(WG)\nfn grid_centroid_hub(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let h = group_id(wid);\n    let valid = h < hubCount[0];                                   // a workgroup past the count sums nothing\n    var c = 0u;\n    var start = 0u;\n    var count = 0u;\n    if (valid) {\n        c = hubList[h];\n        start = cellStart[c];\n        count = cellStart[c + 1u] - start;\n    }\n    var acc = vec4f(0.0);\n    for (var k = start + lid.x; k < start + count; k = k + WG) {   // strided over the cell's sorted range\n        let p = pos[sortedIdx[k]];\n        acc = acc + vec4f(p.xyz * p.w, p.w);\n    }\n    let t = wg_reduce_vec4(acc, lid.x, 0u);                        // uniform control flow: 256 -> 1\n    if (valid && lid.x == 0u) { pyramid[c] = t; }\n}\n";
+//# sourceMappingURL=grid-centroid-hub.wgsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grid-centroid-hub.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/grid-centroid-hub.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,i1BAqB/B,CAAC"}

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

@@ -0,0 +1,29 @@
+/**
+ * G4b, the `grid-centroid-hub` kernel body (spec 7.7; P4-T9): one workgroup per hub cell of hubList, dispatched
+ * indirectly from hubArgs (the T1 finalize over hubCounters[0]); a WG-strided mass-weighted sum reduced by the
+ * prelude's tree. The work is guarded by `valid`, never an early return, so the reduction is uniform (PD-13). Body
+ * only; normative text.
+ */
+export const gridCentroidHubWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn grid_centroid_hub(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let h = group_id(wid);
+    let valid = h < hubCount[0];                                   // a workgroup past the count sums nothing
+    var c = 0u;
+    var start = 0u;
+    var count = 0u;
+    if (valid) {
+        c = hubList[h];
+        start = cellStart[c];
+        count = cellStart[c + 1u] - start;
+    }
+    var acc = vec4f(0.0);
+    for (var k = start + lid.x; k < start + count; k = k + WG) {   // strided over the cell's sorted range
+        let p = pos[sortedIdx[k]];
+        acc = acc + vec4f(p.xyz * p.w, p.w);
+    }
+    let t = wg_reduce_vec4(acc, lid.x, 0u);                        // uniform control flow: 256 -> 1
+    if (valid && lid.x == 0u) { pyramid[c] = t; }
+}
+`;
+//# sourceMappingURL=grid-centroid-hub.wgsl.js.map

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * G4, the `grid-centroid` kernel body (spec 7.7; P4-T9): thread per finest cell, the pseudo-cell included; 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";
+//# sourceMappingURL=grid-centroid.wgsl.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,29 @@
+/**
+ * G4, the `grid-centroid` kernel body (spec 7.7; P4-T9): thread per finest cell, the pseudo-cell included; 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 const gridCentroidWgsl = /* wgsl */ `
+fn grid_cells() -> u32 { return P.gridMax * P.gridMax * select(1u, P.gridMax, P.dim == 3u); }
+
+@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
+    let start = cellStart[c];
+    let count = cellStart[c + 1u] - start;
+    atomicMax(&hubCounters[1], count);                             // maxCellOccupancy, read by K1 next iteration
+    if (count > GRID_HUB_CELL) {                                   // a hub cell: G4b sums it (PD-13)
+        hubList[atomicAdd(&hubCounters[0], 1u)] = c;
+        return;
+    }
+    var acc = vec4f(0.0);
+    for (var k = start; k < start + count; k = k + 1u) {           // sorted order: deterministic
+        let p = pos[sortedIdx[k]];
+        acc = acc + vec4f(p.xyz * p.w, p.w);                       // (sum m x, sum m y, sum m z, sum m)
+    }
+    pyramid[c] = acc;
+}
+`;
+//# sourceMappingURL=grid-centroid.wgsl.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +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.
+ */
+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

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

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

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

@@ -0,0 +1,28 @@
+/**
+ * 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.
+ */
+export const gridDownsampleWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn grid_downsample(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let pc = linear_id(wid, lid.x);                                // the parent cell inside its level
+    if (pc >= P.parentCells) { return; }                           // no barrier follows
+    let side = P.parentSide;
+    let cs = 2u * side;                                            // the child level's side
+    let px = pc % side;
+    let py = (pc / side) % side;
+    let pz = pc / (side * side);
+    var acc = vec4f(0.0);
+    for (var dz = 0u; dz < P.depth; dz = dz + 1u) {
+        for (var dy = 0u; dy < 2u; dy = dy + 1u) {
+            for (var dx = 0u; dx < 2u; dx = dx + 1u) {
+                let child = (2u * px + dx) + cs * ((2u * py + dy) + cs * (2u * pz + dz));
+                acc = acc + pyramid[P.childBase + child];
+            }
+        }
+    }
+    pyramid[P.parentBase + pc] = acc;
+}
+`;
+//# sourceMappingURL=grid-downsample.wgsl.js.map

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

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

package/dist/src/wgsl/grid-far-field.wgsl.d.ts

@@ -0,0 +1,13 @@
+/**
+ * G6, the `grid-far-field` kernel body (spec 7.7; P4-T10; D24): per node `i = sortedIdx[t]`, its finest cell
+ * recomputed from `pos[i]` and the state (PD-10); for an inside node the coarsest level minus the 3x3 (3x3x3)
+ * around its coarsest cell, then at every finer level the 6x6 (6x6x6) block that is the parent's 3x3 minus this
+ * level's own 3x3 -- space tiled exactly once, no theta -- plus the outside pseudo-cell's centroid; for an outside
+ * node the coarsest level in full and no pseudo-cell. Every cell term is the per-cell law on the mass-weighted
+ * centroid (Gephi Region semantics), softened by `eps^2`: `LAW` 0 (FA2) `d * (k m_i M / d2)`, `LAW` 1 (FR, 7.20)
+ * `d * (k^2 M / d2)` (mass 1 per node, so `M` is the cell's count), `LAW` 2 (coulomb) `d * (-g m_i M / d2^1.5)`
+ * (P4-T13, PD-22). `force += f` (K2 wrote it). The loop bounds are `P.levels` and `P.gridMax` from the uniform,
+ * not a `LEVELS` override (PD-16, DEP-P4-G). Body only; normative text.
+ */
+export declare const gridFarFieldWgsl = "\nfn load_force(i: u32) -> vec3f { return vec3f(force[3u * i], force[3u * i + 1u], force[3u * i + 2u]); }\nfn store_force(i: u32, f: vec3f) {\n    force[3u * i] = f.x;\n    force[3u * i + 1u] = f.y;\n    force[3u * i + 2u] = f.z;\n}\nfn grid_cells() -> u32 { return P.gridMax * P.gridMax * select(1u, P.gridMax, P.dim == 3u); }\nfn grid_side(level: u32) -> u32 { return P.gridMax >> level; }\nfn level_base(level: u32) -> u32 {                             // the pyramid index of level L's cell 0 (level 0 carries the pseudo-cell at index cells)\n    var base = 0u;\n    for (var l = 0u; l < level; l = l + 1u) {\n        let s = grid_side(l);\n        base = base + s * s * select(1u, s, P.dim == 3u) + select(0u, 1u, l == 0u);\n    }\n    return base;\n}\nfn cell_at(level: u32, cx: i32, cy: i32, cz: i32) -> u32 {\n    let s = grid_side(level);\n    return level_base(level) + u32(cx) + s * (u32(cy) + select(0u, s * u32(cz), P.dim == 3u));\n}\nfn cell_force(pi: vec4f, q: vec4f) -> vec3f {                  // one far-field term, softened by state.eps (7.7)\n    if (q.w <= 0.0) { return vec3f(0.0); }                     // an empty cell\n    let d = pi.xyz - q.xyz / q.w;                              // to the mass-weighted centroid\n    let d2 = dot(d, d) + S.eps * S.eps;\n    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\n    if (LAW == 2u) { return d * (-P.coulomb * pi.w * q.w / (d2 * sqrt(d2))); }     // LAW 2 (coulomb): -g m_i M_cell / d^2\n    return d * (P.scalingRatio * pi.w * q.w / d2);             // LAW 0 (FA2): |F| = k m_i M_cell / d\n}\n\n@compute @workgroup_size(WG)\nfn grid_far_field(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let t = linear_id(wid, lid.x);\n    if (t >= P.n) { return; }                                      // no barrier follows\n    let i = sortedIdx[t];                                          // sorted order (D24)\n    let pi = pos[i];\n    let gf = f32(P.gridMax);\n    let q = (pi.xyz - S.gridMin.xyz) * S.invCellSize;              // PD-10\n    var c0 = vec3<i32>(floor(clamp(q, vec3f(-1.0), vec3f(gf + 1.0))));\n    if (P.dim == 2u) { c0.z = 0; }                                 // 2D: one z plane; the loops below visit cz = 0 only, so the 3x3 test must see cz - 0\n    let g = i32(P.gridMax);\n    var inside = c0.x >= 0 && c0.x < g && c0.y >= 0 && c0.y < g;\n    if (P.dim == 3u) { inside = inside && c0.z >= 0 && c0.z < g; }\n    let top = P.levels - 1u;\n    let ts = i32(grid_side(top));                                  // the coarsest side (4)\n    let zTop = select(0, ts - 1, P.dim == 3u);                     // z ranges: one plane in 2D\n    var f = vec3f(0.0);\n    if (inside) {\n        let ct = c0 / i32(1u << top);                              // the node's coarsest cell\n        for (var cz = 0; cz <= zTop; cz = cz + 1) {\n            for (var cy = 0; cy < ts; cy = cy + 1) {\n                for (var cx = 0; cx < ts; cx = cx + 1) {\n                    if (abs(cx - ct.x) <= 1 && abs(cy - ct.y) <= 1 && abs(cz - ct.z) <= 1) { continue; }   // the 3x3(x3) is finer levels' work\n                    f = f + cell_force(pi, pyramid[cell_at(top, cx, cy, cz)]);\n                }\n            }\n        }\n        for (var l = top; l > 0u; l = l - 1u) {                    // level l - 1: the parent's 3x3 at level l, refined, minus this level's own 3x3\n            let level = l - 1u;\n            let cl = c0 / i32(1u << level);\n            let cp = cl / 2;\n            let side = i32(grid_side(level));\n            let zLo = select(0, max(0, 2 * (cp.z - 1)), P.dim == 3u);\n            let zHi = select(0, min(side - 1, 2 * (cp.z + 1) + 1), P.dim == 3u);\n            for (var cz = zLo; cz <= zHi; cz = cz + 1) {\n                for (var cy = max(0, 2 * (cp.y - 1)); cy <= min(side - 1, 2 * (cp.y + 1) + 1); cy = cy + 1) {\n                    for (var cx = max(0, 2 * (cp.x - 1)); cx <= min(side - 1, 2 * (cp.x + 1) + 1); cx = cx + 1) {\n                        if (abs(cx - cl.x) <= 1 && abs(cy - cl.y) <= 1 && abs(cz - cl.z) <= 1) { continue; }\n                        f = f + cell_force(pi, pyramid[cell_at(level, cx, cy, cz)]);\n                    }\n                }\n            }\n        }\n        f = f + cell_force(pi, pyramid[grid_cells()]);             // the outside pseudo-cell as one far-field term\n    } else {\n        for (var cz = 0; cz <= zTop; cz = cz + 1) {                // an outside node: the coarsest level in full, no pseudo-cell (it would include itself)\n            for (var cy = 0; cy < ts; cy = cy + 1) {\n                for (var cx = 0; cx < ts; cx = cx + 1) {\n                    f = f + cell_force(pi, pyramid[cell_at(top, cx, cy, cz)]);\n                }\n            }\n        }\n    }\n    store_force(i, load_force(i) + f);\n}\n";
+//# sourceMappingURL=grid-far-field.wgsl.d.ts.map

package/dist/src/wgsl/grid-far-field.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-far-field.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/grid-far-field.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,mzJAqF5B,CAAC"}