@graphty/webgpu-graph-algorithms 0.0.0 → 0.2.0

package/dist/src/types/run.js

@@ -0,0 +1,6 @@
+/**
+ * The run options every algorithm function accepts beside its own (spec 3.3, design 10.7; contract 3.3).
+ * Types only.
+ */
+export {};
+//# sourceMappingURL=run.js.map

package/dist/src/types/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../../../src/types/run.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/src/wgsl/degree.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `degree` kernel body (contract 4.5; spec 6 row 3, 11.5): the out-degree of every row of `[P.start, P.end)`
+ * through the row-walking gather with the USE_PERM dummy pattern, counting the arcs of the bound window whose
+ * neighbour index is a valid node; `P.accumulate == 1` adds into `out[i]` instead of overwriting (the P4 windowed
+ * loop). Bindings, overrides and the `RangeParams` block come from the registry entry (src/kernels.ts); WG,
+ * USE_PERM and `linear_id` from the prelude. The text is normative: test/helpers/sabotage.ts mutates it textually,
+ * so it is copied from the contract and never re-derived or restyled.
+ */
+export declare const degreeWgsl = "\n@compute @workgroup_size(WG)\nfn degree(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let row = linear_id(wid, lid.x) + P.start;\n    if (row >= P.end) { return; }\n    let i = select(row, perm[row], USE_PERM);\n    let a0 = max(rowPtr[i], P.arcBase);\n    let a1 = min(rowPtr[i + 1u], P.arcEnd);\n    var d = 0u;\n    for (var arc = a0; arc < a1; arc = arc + 1u) {\n        let nbr = colIdx[arc - P.arcBase];               // `target` is a WGSL reserved word (spec 16.2); never use it as an identifier\n        d = d + select(0u, 1u, nbr < P.n);\n    }\n    out[i] = select(d, out[i] + d, P.accumulate == 1u);\n}\n";
+//# sourceMappingURL=degree.wgsl.d.ts.map

package/dist/src/wgsl/degree.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"degree.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/degree.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,4pBAetB,CAAC"}

package/dist/src/wgsl/degree.wgsl.js

@@ -0,0 +1,25 @@
+/**
+ * The `degree` kernel body (contract 4.5; spec 6 row 3, 11.5): the out-degree of every row of `[P.start, P.end)`
+ * through the row-walking gather with the USE_PERM dummy pattern, counting the arcs of the bound window whose
+ * neighbour index is a valid node; `P.accumulate == 1` adds into `out[i]` instead of overwriting (the P4 windowed
+ * loop). Bindings, overrides and the `RangeParams` block come from the registry entry (src/kernels.ts); WG,
+ * USE_PERM and `linear_id` from the prelude. The text is normative: test/helpers/sabotage.ts mutates it textually,
+ * so it is copied from the contract and never re-derived or restyled.
+ */
+export const degreeWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn degree(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let row = linear_id(wid, lid.x) + P.start;
+    if (row >= P.end) { return; }
+    let i = select(row, perm[row], USE_PERM);
+    let a0 = max(rowPtr[i], P.arcBase);
+    let a1 = min(rowPtr[i + 1u], P.arcEnd);
+    var d = 0u;
+    for (var arc = a0; arc < a1; arc = arc + 1u) {
+        let nbr = colIdx[arc - P.arcBase];               // \`target\` is a WGSL reserved word (spec 16.2); never use it as an identifier
+        d = d + select(0u, 1u, nbr < P.n);
+    }
+    out[i] = select(d, out[i] + d, P.accumulate == 1u);
+}
+`;
+//# sourceMappingURL=degree.wgsl.js.map

package/dist/src/wgsl/degree.wgsl.js.map

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

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

@@ -0,0 +1,12 @@
+/**
+ * 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`).
+ *
+ * Body only (spec 3.5, D9); normative text (contract 4.5); the K2 sabotage mutations (P3-T5) are textual edits of it.
+ */
+/** 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        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}";
+//# sourceMappingURL=fa2-attraction.wgsl.d.ts.map

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

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

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

@@ -0,0 +1,37 @@
+/**
+ * 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`).
+ *
+ * Body only (spec 3.5, D9); normative text (contract 4.5); the K2 sabotage mutations (P3-T5) are textual edits of it.
+ */
+/** The K2 body: entry point `attraction`; an early return is legal here because no barrier follows (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);
+    let pi = pos[i];                                           // xyz + mass in one load (D23)
+    var f = vec3f(0.0);
+    for (var a = rowPtr[i]; a < rowPtr[i + 1u]; a = a + 1u) {
+        let j = colIdx[a];
+        if (j == i) { continue; }                              // a self-loop exerts no force
+        var w = 1.0;
+        if (HAS_WEIGHTS) { w = weights[a]; }
+        let d = pos[j].xyz - pi.xyz;                           // toward j
+        let len = max(length(d), FA2_DIST_FLOOR);
+        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; }
+    store_force(i, f);                                         // overwrites: attraction is the first writer of force each iteration
+}`;
+//# sourceMappingURL=fa2-attraction.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fa2-attraction.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-attraction.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,yHAAyH;AACzH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;EAyB1C,CAAC"}

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

@@ -0,0 +1,13 @@
+/**
+ * K5 of the ForceAtlas2 iteration, `fa2-integrate` (spec 7.11; contract 4.5): the per-node speed factor
+ * `speed / (1 + sqrt(speed * swing_i))` with the local swing recomputed inline (paper mode `m |F(t) - F(t-1)|`,
+ * networkx mode `m |F|`, contract 4.6), the position update with no displacement clamp (D25), z never integrated
+ * in 2D (spec 7.13), `oldForce` stored in paper mode for fixed nodes too (spec 7.11), and the partials A
+ * (sum p, sum |p - c|^2, min, max with max |p - c|^2 in `max.w`) and C (sum |dp| over free rows, free count) in
+ * uniform control flow.
+ *
+ * Body only (spec 3.5, D9); normative text (contract 4.5); the K5 sabotage mutations (P3-T5) are textual edits of it.
+ */
+/** The K5 body: entry point `integrate`; calls the reduction helpers (`needs: ["subgroups"]`, contract 4.3). */
+export declare const fa2IntegrateWgsl = "fn load_force(i: u32) -> vec3f { return vec3f(force[3u * i], force[3u * i + 1u], force[3u * i + 2u]); }\nfn load_old(i: u32) -> vec3f { return vec3f(oldForce[3u * i], oldForce[3u * i + 1u], oldForce[3u * i + 2u]); }\nfn store_old(i: u32, f: vec3f) {\n    oldForce[3u * i] = f.x;\n    oldForce[3u * i + 1u] = f.y;\n    oldForce[3u * i + 2u] = f.z;\n}\n\n@compute @workgroup_size(WG)\nfn integrate(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let i = linear_id(wid, lid.x);\n    var dp = vec3f(0.0);\n    var p = vec4f(0.0);\n    var free = false;\n    var valid = false;\n    if (i < P.n) {\n        valid = true;\n        let f = load_force(i);\n        p = pos[i];\n        var swing_i = p.w * length(f);                                     // SWING_MODE 1: NetworkX's local swinging m |F| (layout.py line 1497)\n        if (SWING_MODE == 0u) { swing_i = p.w * length(f - load_old(i)); }  // paper: m |F(t) - F(t-1)|, recomputed inline (7.2)\n        let factor = S.speed / (1.0 + sqrt(S.speed * swing_i));\n        let fixed = mask_bit(fixedMask[i >> 5u], i);\n        dp = select(f * factor, vec3f(0.0), fixed);                        // no clamp on dp (D25)\n        if (P.dim == 2u) { dp.z = 0.0; }                                   // 2D never integrates z (7.13)\n        p = vec4f(p.xyz + dp, p.w);\n        pos[i] = p;\n        if (SWING_MODE == 0u) { store_old(i, f); }                         // fixed nodes too, so a later unpin sees no stale swing (7.11)\n        free = !fixed;\n    }\n    // uniform control flow from here (3.5 rule 1): partials A (sum p, sum |p - c|^2, min, max over valid rows) and C (sum |dp|, free count)\n    let c = S.centroid.xyz;\n    var sumv = vec4f(0.0);\n    var lo = vec4f(F32_MAX);\n    var hi = vec4f(-F32_MAX);\n    var dl = 0.0;\n    var fr = 0u;\n    if (valid) {\n        let q = p.xyz - c;\n        sumv = vec4f(p.xyz, dot(q, q));\n        lo = vec4f(p.xyz, 0.0);\n        hi = vec4f(p.xyz, dot(q, q));                                  // max.w carries max |p - c|^2 so K1 can write the exact layoutRadius (spec 3.3)\n    }\n    if (free) { dl = length(dp); fr = 1u; }\n    let tSum = wg_reduce_vec4(sumv, 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 tDl = wg_reduce_f32(dl, lid.x, 0u);\n    let tFr = wg_reduce_u32(fr, lid.x, 0u);\n    if (lid.x == 0u) {\n        let g = group_id(wid);\n        partials[g].sum = tSum;\n        partials[g].min = tLo;\n        partials[g].max = tHi;\n        partials[g].dispFree = vec2f(tDl, f32(tFr));\n    }\n}";
+//# sourceMappingURL=fa2-integrate.wgsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fa2-integrate.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-integrate.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,gHAAgH;AAChH,eAAO,MAAM,gBAAgB,4jFAwD3B,CAAC"}

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

@@ -0,0 +1,69 @@
+/**
+ * K5 of the ForceAtlas2 iteration, `fa2-integrate` (spec 7.11; contract 4.5): the per-node speed factor
+ * `speed / (1 + sqrt(speed * swing_i))` with the local swing recomputed inline (paper mode `m |F(t) - F(t-1)|`,
+ * networkx mode `m |F|`, contract 4.6), the position update with no displacement clamp (D25), z never integrated
+ * in 2D (spec 7.13), `oldForce` stored in paper mode for fixed nodes too (spec 7.11), and the partials A
+ * (sum p, sum |p - c|^2, min, max with max |p - c|^2 in `max.w`) and C (sum |dp| over free rows, free count) in
+ * uniform control flow.
+ *
+ * Body only (spec 3.5, D9); normative text (contract 4.5); the K5 sabotage mutations (P3-T5) are textual edits of it.
+ */
+/** The K5 body: entry point `integrate`; calls the reduction helpers (`needs: ["subgroups"]`, contract 4.3). */
+export const fa2IntegrateWgsl = /* wgsl */ `fn load_force(i: u32) -> vec3f { return vec3f(force[3u * i], force[3u * i + 1u], force[3u * i + 2u]); }
+fn load_old(i: u32) -> vec3f { return vec3f(oldForce[3u * i], oldForce[3u * i + 1u], oldForce[3u * i + 2u]); }
+fn store_old(i: u32, f: vec3f) {
+    oldForce[3u * i] = f.x;
+    oldForce[3u * i + 1u] = f.y;
+    oldForce[3u * i + 2u] = f.z;
+}
+
+@compute @workgroup_size(WG)
+fn integrate(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let i = linear_id(wid, lid.x);
+    var dp = vec3f(0.0);
+    var p = vec4f(0.0);
+    var free = false;
+    var valid = false;
+    if (i < P.n) {
+        valid = true;
+        let f = load_force(i);
+        p = pos[i];
+        var swing_i = p.w * length(f);                                     // SWING_MODE 1: NetworkX's local swinging m |F| (layout.py line 1497)
+        if (SWING_MODE == 0u) { swing_i = p.w * length(f - load_old(i)); }  // paper: m |F(t) - F(t-1)|, recomputed inline (7.2)
+        let factor = S.speed / (1.0 + sqrt(S.speed * swing_i));
+        let fixed = mask_bit(fixedMask[i >> 5u], i);
+        dp = select(f * factor, vec3f(0.0), fixed);                        // no clamp on dp (D25)
+        if (P.dim == 2u) { dp.z = 0.0; }                                   // 2D never integrates z (7.13)
+        p = vec4f(p.xyz + dp, p.w);
+        pos[i] = p;
+        if (SWING_MODE == 0u) { store_old(i, f); }                         // fixed nodes too, so a later unpin sees no stale swing (7.11)
+        free = !fixed;
+    }
+    // uniform control flow from here (3.5 rule 1): partials A (sum p, sum |p - c|^2, min, max over valid rows) and C (sum |dp|, free count)
+    let c = S.centroid.xyz;
+    var sumv = vec4f(0.0);
+    var lo = vec4f(F32_MAX);
+    var hi = vec4f(-F32_MAX);
+    var dl = 0.0;
+    var fr = 0u;
+    if (valid) {
+        let q = p.xyz - c;
+        sumv = vec4f(p.xyz, dot(q, q));
+        lo = vec4f(p.xyz, 0.0);
+        hi = vec4f(p.xyz, dot(q, q));                                  // max.w carries max |p - c|^2 so K1 can write the exact layoutRadius (spec 3.3)
+    }
+    if (free) { dl = length(dp); fr = 1u; }
+    let tSum = wg_reduce_vec4(sumv, lid.x, 0u);
+    let tLo = wg_reduce_vec4(lo, lid.x, 1u);
+    let tHi = wg_reduce_vec4(hi, lid.x, 2u);
+    let tDl = wg_reduce_f32(dl, lid.x, 0u);
+    let tFr = wg_reduce_u32(fr, lid.x, 0u);
+    if (lid.x == 0u) {
+        let g = group_id(wid);
+        partials[g].sum = tSum;
+        partials[g].min = tLo;
+        partials[g].max = tHi;
+        partials[g].dispFree = vec2f(tDl, f32(tFr));
+    }
+}`;
+//# sourceMappingURL=fa2-integrate.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fa2-integrate.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-integrate.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,gHAAgH;AAChH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwDzC,CAAC"}

package/dist/src/wgsl/fa2-repulsion-exact.wgsl.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The `fa2-repulsion-exact` kernel body (K3; contract 4.5; spec 7.6, 7.9, 7.10): the tiled all-pairs repulsion
+ * `|F| = k m_i m_j / d` with the 0.01 distance floor and the antisymmetric coincident kick, the gravity epilogue
+ * (GRAVITY_CENTER 0 = centroid, 1 = origin; STRONG_GRAVITY) added under the `valid` guard, `force += f`, and the
+ * swing / traction workgroup reduction in uniform control flow (SWING_MODE 0 = paper: free nodes only against
+ * `oldForce`; 1 = NetworkX: positions and forces mixed, every node) whose lane 0 writes
+ * `partials[group].swingTraction`. `pos` is `array<vec4f>` with the mass in `.w`; `force` / `oldForce` are stride-3
+ * `array<f32>` read through the per-body helpers (4.4 rule 6). Normative text, copied verbatim: the P1-T5 sabotage
+ * rows (gravity sign, `k / d2`, the `jj != i` guard, the `.w` mass lane) are textual edits of this string.
+ */
+export declare const fa2RepulsionExactWgsl = "\nvar<workgroup> tile: array<vec4f, WG>;                         // xyz + mass, 4 KiB at WG = 256\n\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 load_old(i: u32) -> vec3f { return vec3f(oldForce[3u * i], oldForce[3u * i + 1u], oldForce[3u * i + 2u]); }\nfn gravity_force(pi: vec4f) -> vec3f {                         // spec 7.9: centroid (GRAVITY_CENTER 0) or origin (1); regular or strong\n    var q = pi.xyz;\n    if (GRAVITY_CENTER == 0u) { q = pi.xyz - S.centroid.xyz; }\n    if (STRONG_GRAVITY) { return -P.gravity * pi.w * q; }\n    let d = length(q);\n    if (d > FA2_DIST_FLOOR) { return -P.gravity * pi.w * q / d; }\n    return vec3f(0.0);\n}\n\n@compute @workgroup_size(WG)\nfn repulsion(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let i = linear_id(wid, lid.x);\n    let valid = i < P.n;\n    var pi = vec4f(0.0);\n    if (valid) { pi = pos[i]; }\n    var f = vec3f(0.0);\n    let tiles = (P.n + WG - 1u) / WG;\n    for (var t = 0u; t < tiles; t = t + 1u) {\n        let j = t * WG + lid.x;\n        if (j < P.n) { tile[lid.x] = pos[j]; } else { tile[lid.x] = vec4f(0.0); }   // guarded fill; mass 0 marks the pad\n        workgroupBarrier();                                                       // uniform: every invocation reaches it\n        for (var s = 0u; s < WG; s = s + 1u) {\n            let o = tile[s];\n            let jj = t * WG + s;\n            if (o.w > 0.0 && jj != i) {                                           // mass > 0 for every real node, 0 for the pad\n                let d = pi.xyz - o.xyz;\n                var d2 = dot(d, d);\n                if (d2 < FA2_COINCIDENT_SQ) {                                     // coincident: antisymmetric unit kick of magnitude k m_i m_j / 0.01 (7.2)\n                    f = f + kick_dir(i, jj, P.dim) * (P.scalingRatio * pi.w * o.w / FA2_DIST_FLOOR);\n                    continue;\n                }\n                d2 = max(d2, FA2_DIST_FLOOR_SQ);                                  // d >= 0.01\n                let k = P.scalingRatio * pi.w * o.w;\n                f = f + d * (k / d2);                                             // |F| = k m_i m_j / d along d / d\n            }\n        }\n        workgroupBarrier();\n    }\n    // epilogue (7.9, 7.10): gravity and force += under the guard, the swing / traction reduction outside it\n    var sw = 0.0;\n    var tr = 0.0;\n    if (valid) {\n        f = f + gravity_force(pi);\n        let fnew = load_force(i) + f;\n        store_force(i, fnew);\n        if (SWING_MODE == 1u) {                                                   // NetworkX: positions and forces mixed, every node (7.2)\n            sw = pi.w * length(pi.xyz - fnew);\n            tr = 0.5 * pi.w * length(pi.xyz + fnew);\n        } else if (!mask_bit(fixedMask[i >> 5u], i)) {                            // paper: free nodes only (Gephi ForceAtlas2.java 283-293)\n            let fold = load_old(i);\n            sw = pi.w * length(fnew - fold);\n            tr = 0.5 * pi.w * length(fnew + fold);\n        }\n    }\n    let t = wg_reduce_vec4(vec4f(sw, tr, 0.0, 0.0), lid.x, 0u);                   // uniform control flow: 256 -> 1\n    if (lid.x == 0u) { partials[group_id(wid)].swingTraction = t.xy; }\n}\n";
+//# sourceMappingURL=fa2-repulsion-exact.wgsl.d.ts.map

package/dist/src/wgsl/fa2-repulsion-exact.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fa2-repulsion-exact.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-repulsion-exact.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,g4GAmEjC,CAAC"}

package/dist/src/wgsl/fa2-repulsion-exact.wgsl.js

@@ -0,0 +1,79 @@
+/**
+ * The `fa2-repulsion-exact` kernel body (K3; contract 4.5; spec 7.6, 7.9, 7.10): the tiled all-pairs repulsion
+ * `|F| = k m_i m_j / d` with the 0.01 distance floor and the antisymmetric coincident kick, the gravity epilogue
+ * (GRAVITY_CENTER 0 = centroid, 1 = origin; STRONG_GRAVITY) added under the `valid` guard, `force += f`, and the
+ * swing / traction workgroup reduction in uniform control flow (SWING_MODE 0 = paper: free nodes only against
+ * `oldForce`; 1 = NetworkX: positions and forces mixed, every node) whose lane 0 writes
+ * `partials[group].swingTraction`. `pos` is `array<vec4f>` with the mass in `.w`; `force` / `oldForce` are stride-3
+ * `array<f32>` read through the per-body helpers (4.4 rule 6). Normative text, copied verbatim: the P1-T5 sabotage
+ * rows (gravity sign, `k / d2`, the `jj != i` guard, the `.w` mass lane) are textual edits of this string.
+ */
+export const fa2RepulsionExactWgsl = /* wgsl */ `
+var<workgroup> tile: array<vec4f, WG>;                         // xyz + mass, 4 KiB at WG = 256
+
+fn load_force(i: u32) -> vec3f { return vec3f(force[3u * i], force[3u * i + 1u], force[3u * i + 2u]); }
+fn store_force(i: u32, f: vec3f) {
+    force[3u * i] = f.x;
+    force[3u * i + 1u] = f.y;
+    force[3u * i + 2u] = f.z;
+}
+fn load_old(i: u32) -> vec3f { return vec3f(oldForce[3u * i], oldForce[3u * i + 1u], oldForce[3u * i + 2u]); }
+fn gravity_force(pi: vec4f) -> vec3f {                         // spec 7.9: centroid (GRAVITY_CENTER 0) or origin (1); regular or strong
+    var q = pi.xyz;
+    if (GRAVITY_CENTER == 0u) { q = pi.xyz - S.centroid.xyz; }
+    if (STRONG_GRAVITY) { return -P.gravity * pi.w * q; }
+    let d = length(q);
+    if (d > FA2_DIST_FLOOR) { return -P.gravity * pi.w * q / d; }
+    return vec3f(0.0);
+}
+
+@compute @workgroup_size(WG)
+fn repulsion(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    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 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
+        for (var s = 0u; s < WG; s = s + 1u) {
+            let o = tile[s];
+            let jj = t * WG + s;
+            if (o.w > 0.0 && jj != i) {                                           // mass > 0 for every real node, 0 for the pad
+                let d = pi.xyz - o.xyz;
+                var d2 = dot(d, d);
+                if (d2 < FA2_COINCIDENT_SQ) {                                     // coincident: antisymmetric unit kick of magnitude k m_i m_j / 0.01 (7.2)
+                    f = f + kick_dir(i, jj, P.dim) * (P.scalingRatio * pi.w * o.w / FA2_DIST_FLOOR);
+                    continue;
+                }
+                d2 = max(d2, FA2_DIST_FLOOR_SQ);                                  // d >= 0.01
+                let k = P.scalingRatio * pi.w * o.w;
+                f = f + d * (k / d2);                                             // |F| = k m_i m_j / d along d / d
+            }
+        }
+        workgroupBarrier();
+    }
+    // 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;
+    if (valid) {
+        f = f + gravity_force(pi);
+        let fnew = load_force(i) + f;
+        store_force(i, fnew);
+        if (SWING_MODE == 1u) {                                                   // NetworkX: positions and forces mixed, every node (7.2)
+            sw = pi.w * length(pi.xyz - fnew);
+            tr = 0.5 * pi.w * length(pi.xyz + fnew);
+        } else if (!mask_bit(fixedMask[i >> 5u], i)) {                            // paper: free nodes only (Gephi ForceAtlas2.java 283-293)
+            let fold = load_old(i);
+            sw = pi.w * length(fnew - fold);
+            tr = 0.5 * pi.w * length(fnew + fold);
+        }
+    }
+    let t = wg_reduce_vec4(vec4f(sw, tr, 0.0, 0.0), lid.x, 0u);                   // uniform control flow: 256 -> 1
+    if (lid.x == 0u) { partials[group_id(wid)].swingTraction = t.xy; }
+}
+`;
+//# sourceMappingURL=fa2-repulsion-exact.wgsl.js.map

package/dist/src/wgsl/fa2-repulsion-exact.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fa2-repulsion-exact.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-repulsion-exact.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmE/C,CAAC"}

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

@@ -0,0 +1,15 @@
+/**
+ * The `fa2-speed-finalize` kernel body (K4; contract 4.5; spec 7.10): ONE workgroup sums `partials[*].swingTraction`
+ * sequentially per lane (deterministic), reduces in uniform control flow, then lane 0 runs the line-for-line port
+ * of the CPU `estimateFactor` (SWING_MODE 1 accumulates NetworkX's sums across iterations from S.swing / S.traction)
+ * and writes `S.speed`, `S.speedEfficiency`, `S.swing`, `S.traction` and the four controller fields of
+ * `T[P.iterationIndex]`. `target` is a WGSL reserved word, hence `targetSpeed`. Normative text, copied verbatim:
+ * the P1-T5 sabotage rows (`* 0.5` -> `* 0.9`, the 1.3 rise, the swing / traction swap) are textual edits of it.
+ * The halving predicate is `swing > 2.0 * tr`, the exact form of the port's `swing / traction > 2` (contract 4.5
+ * CONTRACT DECISION K4-1, G3 finding G3-F6): every paper-mode first iteration after load() has oldForce = 0, so
+ * traction is EXACTLY half the swing and the predicate sits on its knife edge; a multiplication by 2 and the
+ * comparison are exact on every device, while WGSL grants f32 division 2.5 ULP and Dawn on NVIDIA returns 2 + 1 ulp
+ * for 2.2% of the inputs x / (x / 2) (tmp/p3-fix/div-probe.mjs), which took the branch the CPU reference never takes.
+ */
+export declare const fa2SpeedFinalizeWgsl = "\n@compute @workgroup_size(WG)\nfn speed_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {\n    let groups = (P.n + WG - 1u) / WG;\n    var st = vec2f(0.0);\n    for (var g = lid.x; g < groups; g = g + WG) { st = st + partials[g].swingTraction; }   // sequential per lane: deterministic\n    let t = wg_reduce_vec4(vec4f(st, 0.0, 0.0), lid.x, 0u);\n    if (lid.x == 0u) {\n        var swing = t.x;\n        var traction = t.y;\n        if (SWING_MODE == 1u) { swing = S.swing + t.x; traction = S.traction + t.y; }   // NetworkX accumulates across iterations from 1\n        let n = f32(P.n);\n        let optJitter = 0.05 * sqrt(n);\n        let minJitter = sqrt(optJitter);\n        let maxJitter = 10.0;\n        let tr = max(traction, 1.0e-30);                                             // guards the division only (7.10)\n        let other = min(maxJitter, optJitter * traction / (n * n));\n        var jitter = P.jitterTolerance * max(minJitter, other);\n        var eff = S.speedEfficiency;\n        if (swing > 2.0 * tr) {                                                      // swing / traction > 2 in the exact form (contract 4.5 CONTRACT DECISION K4-1: 2 x is exact, a WGSL f32 division is not)\n            if (eff > 0.05) { eff = eff * 0.5; }                                     // the CPU's conditional multiply (7.2)\n            jitter = max(jitter, P.jitterTolerance);\n        }\n        let targetSpeed = select(jitter * eff * traction / swing, 1.0e30, swing == 0.0);  // +Inf in the port; 1e30 gives the same min() below (`target` is reserved)\n        if (swing > jitter * traction) {\n            if (eff > 0.05) { eff = eff * 0.7; }\n        } else if (S.speed < 1000.0) {\n            eff = eff * 1.3;\n        }\n        S.speed = S.speed + min(targetSpeed - S.speed, 0.5 * S.speed);\n        S.speedEfficiency = eff;\n        S.swing = swing;\n        S.traction = traction;\n        T[P.iterationIndex].swing = swing;\n        T[P.iterationIndex].traction = traction;\n        T[P.iterationIndex].speed = S.speed;\n        T[P.iterationIndex].speedEfficiency = eff;\n    }\n}\n";
+//# sourceMappingURL=fa2-speed-finalize.wgsl.d.ts.map

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

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

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

@@ -0,0 +1,54 @@
+/**
+ * The `fa2-speed-finalize` kernel body (K4; contract 4.5; spec 7.10): ONE workgroup sums `partials[*].swingTraction`
+ * sequentially per lane (deterministic), reduces in uniform control flow, then lane 0 runs the line-for-line port
+ * of the CPU `estimateFactor` (SWING_MODE 1 accumulates NetworkX's sums across iterations from S.swing / S.traction)
+ * and writes `S.speed`, `S.speedEfficiency`, `S.swing`, `S.traction` and the four controller fields of
+ * `T[P.iterationIndex]`. `target` is a WGSL reserved word, hence `targetSpeed`. Normative text, copied verbatim:
+ * the P1-T5 sabotage rows (`* 0.5` -> `* 0.9`, the 1.3 rise, the swing / traction swap) are textual edits of it.
+ * The halving predicate is `swing > 2.0 * tr`, the exact form of the port's `swing / traction > 2` (contract 4.5
+ * CONTRACT DECISION K4-1, G3 finding G3-F6): every paper-mode first iteration after load() has oldForce = 0, so
+ * traction is EXACTLY half the swing and the predicate sits on its knife edge; a multiplication by 2 and the
+ * comparison are exact on every device, while WGSL grants f32 division 2.5 ULP and Dawn on NVIDIA returns 2 + 1 ulp
+ * for 2.2% of the inputs x / (x / 2) (tmp/p3-fix/div-probe.mjs), which took the branch the CPU reference never takes.
+ */
+export const fa2SpeedFinalizeWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn speed_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
+    let groups = (P.n + WG - 1u) / WG;
+    var st = vec2f(0.0);
+    for (var g = lid.x; g < groups; g = g + WG) { st = st + partials[g].swingTraction; }   // sequential per lane: deterministic
+    let t = wg_reduce_vec4(vec4f(st, 0.0, 0.0), lid.x, 0u);
+    if (lid.x == 0u) {
+        var swing = t.x;
+        var traction = t.y;
+        if (SWING_MODE == 1u) { swing = S.swing + t.x; traction = S.traction + t.y; }   // NetworkX accumulates across iterations from 1
+        let n = f32(P.n);
+        let optJitter = 0.05 * sqrt(n);
+        let minJitter = sqrt(optJitter);
+        let maxJitter = 10.0;
+        let tr = max(traction, 1.0e-30);                                             // guards the division only (7.10)
+        let other = min(maxJitter, optJitter * traction / (n * n));
+        var jitter = P.jitterTolerance * max(minJitter, other);
+        var eff = S.speedEfficiency;
+        if (swing > 2.0 * tr) {                                                      // swing / traction > 2 in the exact form (contract 4.5 CONTRACT DECISION K4-1: 2 x is exact, a WGSL f32 division is not)
+            if (eff > 0.05) { eff = eff * 0.5; }                                     // the CPU's conditional multiply (7.2)
+            jitter = max(jitter, P.jitterTolerance);
+        }
+        let targetSpeed = select(jitter * eff * traction / swing, 1.0e30, swing == 0.0);  // +Inf in the port; 1e30 gives the same min() below (\`target\` is reserved)
+        if (swing > jitter * traction) {
+            if (eff > 0.05) { eff = eff * 0.7; }
+        } else if (S.speed < 1000.0) {
+            eff = eff * 1.3;
+        }
+        S.speed = S.speed + min(targetSpeed - S.speed, 0.5 * S.speed);
+        S.speedEfficiency = eff;
+        S.swing = swing;
+        S.traction = traction;
+        T[P.iterationIndex].swing = swing;
+        T[P.iterationIndex].traction = traction;
+        T[P.iterationIndex].speed = S.speed;
+        T[P.iterationIndex].speedEfficiency = eff;
+    }
+}
+`;
+//# sourceMappingURL=fa2-speed-finalize.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fa2-speed-finalize.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-speed-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuC9C,CAAC"}

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

@@ -0,0 +1,14 @@
+/**
+ * K1 of the ForceAtlas2 iteration, `fa2-stats-finalize` (spec 7.4; contract 4.5): one workgroup folds the partials
+ * the previous integrate (K5) wrote into the state block -- centroid, RMS radius, layout radius (max |p - c|, the
+ * exact spec 3.3 value from `partials.max.w`), bounding box, mean displacement over free nodes (0 when every node
+ * is fixed), the settle counter -- increments the iteration counter and writes the K1 half of the trace record.
+ * On the first iteration after load() (`FA2_FLAG_FIRST`) it folds nothing and keeps the host-written state.
+ *
+ * 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    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        }\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    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    }\n}";
+//# sourceMappingURL=fa2-stats-finalize.wgsl.d.ts.map

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

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

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

@@ -0,0 +1,57 @@
+/**
+ * K1 of the ForceAtlas2 iteration, `fa2-stats-finalize` (spec 7.4; contract 4.5): one workgroup folds the partials
+ * the previous integrate (K5) wrote into the state block -- centroid, RMS radius, layout radius (max |p - c|, the
+ * exact spec 3.3 value from `partials.max.w`), bounding box, mean displacement over free nodes (0 when every node
+ * is fixed), the settle counter -- increments the iteration counter and writes the K1 half of the trace record.
+ * On the first iteration after load() (`FA2_FLAG_FIRST`) it folds nothing and keeps the host-written state.
+ *
+ * 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 const fa2StatsFinalizeWgsl = /* wgsl */ `// K1: folds the previous integrate's partials into the state block (spec 7.4); one workgroup
+@compute @workgroup_size(WG)
+fn stats_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
+    let groups = (P.n + WG - 1u) / WG;
+    let fold = (P.flags & FA2_FLAG_FIRST) == 0u;    // the first iteration after load() keeps the host-written state
+    var sum = vec4f(0.0);
+    var lo = vec4f(F32_MAX);
+    var hi = vec4f(-F32_MAX);
+    var disp = 0.0;
+    var free = 0u;
+    if (fold) {
+        for (var g = lid.x; g < groups; g = g + WG) {   // sequential per lane in index order: deterministic
+            let q = partials[g];
+            sum = sum + q.sum;
+            lo = min(lo, q.min);
+            hi = max(hi, q.max);
+            disp = disp + q.dispFree.x;
+            free = free + u32(q.dispFree.y);
+        }
+    }
+    let tSum = wg_reduce_vec4(sum, lid.x, 0u);
+    let tLo = wg_reduce_vec4(lo, lid.x, 1u);
+    let tHi = wg_reduce_vec4(hi, lid.x, 2u);
+    let tDisp = wg_reduce_f32(disp, lid.x, 0u);
+    let tFree = wg_reduce_u32(free, lid.x, 0u);
+    if (lid.x == 0u) {
+        if (fold) {
+            let n = f32(P.n);
+            let c = tSum.xyz / n;
+            S.centroid = vec4f(c, 0.0);
+            S.rmsRadius = sqrt(max(tSum.w, 0.0) / n);                  // RMS radius about the previous centroid (7.17)
+            S.min = vec4f(tLo.xyz, 0.0);
+            S.max = vec4f(tHi.xyz, 0.0);
+            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.iteration = S.iteration + 1u;
+        T[P.iterationIndex].meanDisplacement = S.meanDisplacement;
+        T[P.iterationIndex].settledCount = S.settledCount;
+        T[P.iterationIndex].iteration = S.iteration;
+    }
+}`;
+//# sourceMappingURL=fa2-stats-finalize.wgsl.js.map

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

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

package/dist/src/wgsl/fa2-to-scene.wgsl.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The per-batch `fa2-to-scene` kernel (spec 7.13, 7.18; contract 4.5): unpacks the vec4f layout-unit positions into
+ * the stride-3 scene array the staging copy reads back, applying `scale` and `center`; in 2D the third component is
+ * `center.z` on every readback whatever z the device holds.
+ *
+ * Body only (spec 3.5, D9); normative text (contract 4.5); exempt from the sabotage matrix (SABOTAGE_EXEMPT: a wrong
+ * toScene fails the exact-equality position tests directly).
+ */
+/** The toScene body: entry point `to_scene`; an early return is legal here because no barrier follows (spec 3.5 rule 1). */
+export declare const fa2ToSceneWgsl = "@compute @workgroup_size(WG)\nfn to_scene(@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; }\n    let s = pos[i].xyz * P.scale + P.center.xyz;\n    scene[3u * i] = s.x;\n    scene[3u * i + 1u] = s.y;\n    scene[3u * i + 2u] = select(s.z, P.center.z, P.dim == 2u);       // 2D writes z = center.z on every readback (7.13)\n}";
+//# sourceMappingURL=fa2-to-scene.wgsl.d.ts.map

package/dist/src/wgsl/fa2-to-scene.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fa2-to-scene.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-to-scene.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,4HAA4H;AAC5H,eAAO,MAAM,cAAc,+aAQzB,CAAC"}

package/dist/src/wgsl/fa2-to-scene.wgsl.js

@@ -0,0 +1,19 @@
+/**
+ * The per-batch `fa2-to-scene` kernel (spec 7.13, 7.18; contract 4.5): unpacks the vec4f layout-unit positions into
+ * the stride-3 scene array the staging copy reads back, applying `scale` and `center`; in 2D the third component is
+ * `center.z` on every readback whatever z the device holds.
+ *
+ * Body only (spec 3.5, D9); normative text (contract 4.5); exempt from the sabotage matrix (SABOTAGE_EXEMPT: a wrong
+ * toScene fails the exact-equality position tests directly).
+ */
+/** The toScene body: entry point `to_scene`; an early return is legal here because no barrier follows (spec 3.5 rule 1). */
+export const fa2ToSceneWgsl = /* wgsl */ `@compute @workgroup_size(WG)
+fn to_scene(@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; }
+    let s = pos[i].xyz * P.scale + P.center.xyz;
+    scene[3u * i] = s.x;
+    scene[3u * i + 1u] = s.y;
+    scene[3u * i + 2u] = select(s.z, P.center.z, P.dim == 2u);       // 2D writes z = center.z on every readback (7.13)
+}`;
+//# sourceMappingURL=fa2-to-scene.wgsl.js.map

package/dist/src/wgsl/fa2-to-scene.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fa2-to-scene.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-to-scene.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,4HAA4H;AAC5H,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;;;;;;;;EAQvC,CAAC"}

package/dist/src/wgsl/fill.wgsl.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The `fill` kernel body (contract 4.5): `dst[i] = P.value` (mode 0) or `i + P.value` (mode 1, iota) for every
+ * `i < P.count`, `i` from the prelude's `linear_id` so a 2D dispatch covers counts above MAX_1D_ITEMS. The 17M-item
+ * linear_id test of spec 5.2 / 11.5 is mode 1 over 16,776,961 words. Normative text, copied verbatim.
+ */
+export declare const fillWgsl = "\n@compute @workgroup_size(WG)\nfn fill(@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; }\n    dst[i] = select(P.value, i + P.value, P.mode == 1u);\n}\n";
+//# sourceMappingURL=fill.wgsl.d.ts.map

package/dist/src/wgsl/fill.wgsl.d.ts.map

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

package/dist/src/wgsl/fill.wgsl.js

@@ -0,0 +1,14 @@
+/**
+ * The `fill` kernel body (contract 4.5): `dst[i] = P.value` (mode 0) or `i + P.value` (mode 1, iota) for every
+ * `i < P.count`, `i` from the prelude's `linear_id` so a 2D dispatch covers counts above MAX_1D_ITEMS. The 17M-item
+ * linear_id test of spec 5.2 / 11.5 is mode 1 over 16,776,961 words. Normative text, copied verbatim.
+ */
+export const fillWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn fill(@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; }
+    dst[i] = select(P.value, i + P.value, P.mode == 1u);
+}
+`;
+//# sourceMappingURL=fill.wgsl.js.map

package/dist/src/wgsl/fill.wgsl.js.map

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

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

@@ -0,0 +1,10 @@
+/**
+ * The `reduce` kernel body (contract 4.5; spec 6 row 1): one level of the 2-3 level reduction. Overrides: OP
+ * 0 sum / 1 min / 2 max, DTYPE 0 f32 / 1 u32 / 2 vec4f (four words per element, loaded through bitcast from the
+ * u32 storage view), FINAL true for the one-workgroup level that folds the partials sequentially per lane in
+ * index order (deterministic) and writes one element at `out[P.outOffset]`; the level-1 form writes
+ * `out[P.outOffset + group]`. Calls the prelude's `wg_reduce_*` helpers (needs: ["subgroups"]) in uniform
+ * control flow: DTYPE is a pipeline constant, so the branch on it is uniform. Normative text, copied verbatim.
+ */
+export declare const reduceWgsl = "\n// DTYPE 0 = f32, 1 = u32, 2 = vec4f (4 words per element); OP 0 = sum, 1 = min, 2 = max; FINAL = the one-workgroup level\nfn identity_f() -> f32 { if (OP == 1u) { return F32_MAX; } if (OP == 2u) { return -F32_MAX; } return 0.0; }\nfn identity_u() -> u32 { if (OP == 1u) { return U32_MAX; } return 0u; }        // U32_MAX from the prelude: the literal is forbidden in bodies (4.1)\nfn comb_f(a: f32, b: f32) -> f32 { if (OP == 1u) { return min(a, b); } if (OP == 2u) { return max(a, b); } return a + b; }\nfn comb_u(a: u32, b: u32) -> u32 { if (OP == 1u) { return min(a, b); } if (OP == 2u) { return max(a, b); } return a + b; }\nfn comb_v(a: vec4f, b: vec4f) -> vec4f { if (OP == 1u) { return min(a, b); } if (OP == 2u) { return max(a, b); } return a + b; }\nfn load_f(i: u32) -> f32 { return bitcast<f32>(src[i]); }\nfn load_v(i: u32) -> vec4f {\n    return vec4f(bitcast<f32>(src[4u * i]), bitcast<f32>(src[4u * i + 1u]), bitcast<f32>(src[4u * i + 2u]), bitcast<f32>(src[4u * i + 3u]));\n}\nfn store_f(i: u32, v: f32) { out[i] = bitcast<u32>(v); }\nfn store_v(i: u32, v: vec4f) {\n    out[4u * i] = bitcast<u32>(v.x);\n    out[4u * i + 1u] = bitcast<u32>(v.y);\n    out[4u * i + 2u] = bitcast<u32>(v.z);\n    out[4u * i + 3u] = bitcast<u32>(v.w);\n}\n\n@compute @workgroup_size(WG)\nfn reduce(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    var accF = identity_f();\n    var accU = identity_u();\n    var accV = vec4f(identity_f());\n    if (FINAL) {\n        for (var i = lid.x; i < P.count; i = i + WG) {           // sequential per lane in index order: deterministic\n            if (DTYPE == 0u) { accF = comb_f(accF, load_f(i)); }\n            else if (DTYPE == 1u) { accU = comb_u(accU, src[i]); }\n            else { accV = comb_v(accV, load_v(i)); }\n        }\n    } else {\n        let i = linear_id(wid, lid.x);\n        if (i < P.count) {\n            if (DTYPE == 0u) { accF = load_f(i); }\n            else if (DTYPE == 1u) { accU = src[i]; }\n            else { accV = load_v(i); }\n        }\n    }\n    // uniform control flow: the workgroup reduction of the selected dtype (DTYPE is a pipeline constant, so the branch is uniform)\n    var tF = 0.0;\n    var tU = 0u;\n    var tV = vec4f(0.0);\n    if (DTYPE == 0u) { tF = wg_reduce_f32(accF, lid.x, OP); }\n    else if (DTYPE == 1u) { tU = wg_reduce_u32(accU, lid.x, OP); }\n    else { tV = wg_reduce_vec4(accV, lid.x, OP); }\n    if (lid.x == 0u) {\n        let g = select(group_id(wid), 0u, FINAL);\n        let o = P.outOffset + g;\n        if (DTYPE == 0u) { store_f(o, tF); }\n        else if (DTYPE == 1u) { out[o] = tU; }\n        else { store_v(o, tV); }\n    }\n}\n";
+//# sourceMappingURL=reduce.wgsl.d.ts.map

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

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