@graphty/webgpu-graph-algorithms 0.2.0 → 0.3.0

package/dist/webgpu-graph-algorithms.js

@@ -1,6 +1,6 @@
-import { W as WebGpuGraphError, M as MAX_WORKGROUPS_PER_DIM, a as WGSL_RESERVED_WORDS, S as STATE_HEADER_BYTES, B as BufferUsage, i as isWebGpuGraphError, d as deviceLostError, U as UNIFORM_SLOT_BYTES, F as FA2_DEFAULTS, b as MAX_ITERATIONS_PER_STEP, c as MAX_1D_ITEMS, h as hasErrorCode, e as FA2_FLAG_FIRST, P as PARTIAL_BYTES, L as LAYOUT_TUNING_DEFAULTS, T as TRACE_RECORD_BYTES } from "./chunks/context-E6iKaeuJ.js";
-import { A, E, G, f, g, j, k } from "./chunks/context-E6iKaeuJ.js";
-import { makeMask, maskTest, expandEdges } from "@graphty/graph-format";
+import { W as WebGpuGraphError, M as MAX_WORKGROUPS_PER_DIM, a as WGSL_RESERVED_WORDS, S as STATE_HEADER_BYTES, B as BufferUsage, i as isWebGpuGraphError, d as deviceLostError, U as UNIFORM_SLOT_BYTES, b as U32_MAX, F as FA2_DEFAULTS, c as MAX_ITERATIONS_PER_STEP, e as MAX_1D_ITEMS, h as hasErrorCode, f as FA2_FLAG_FIRST, P as PARTIAL_BYTES, L as LAYOUT_TUNING_DEFAULTS, T as TRACE_RECORD_BYTES } from "./chunks/context-CRbw2Wyo.js";
+import { A, E, G, g, j, k, l } from "./chunks/context-CRbw2Wyo.js";
+import { renumberPartition, makeMask, maskTest, expandEdges } from "@graphty/graph-format";
 function perDimension(caps) {
   return Math.min(MAX_WORKGROUPS_PER_DIM, caps.limits.maxComputeWorkgroupsPerDimension);
 }
@@ -55,6 +55,19 @@ function plan1d(items, wg, caps) {
   assertWorkgroupSize(wg);
   return grid(Math.ceil(items / wg), items, caps);
 }
+function planGridStride(items, wg, caps, maxGroups) {
+  assertCount("items", items);
+  assertWorkgroupSize(wg);
+  if (items === 0) {
+    return { x: 0, y: 1, z: 1, items, stride: null };
+  }
+  const cap = Math.min(caps.software ? 64 : 4096, perDimension(caps));
+  const groups = Math.min(Math.ceil(items / wg), cap);
+  return { x: groups, y: 1, z: 1, items, stride: groups * wg };
+}
+function groupsOf(plan) {
+  return plan.x * plan.y;
+}
 const TYPE_INFO = Object.freeze({
   u32: { size: 4, align: 4, width: 1, scalar: "u32" },
   i32: { size: 4, align: 4, width: 1, scalar: "i32" },
@@ -247,7 +260,7 @@ ${lines.join("\n")}
         throw new WebGpuGraphError("E_INVALID_ARGUMENT", `UniformBlock ${this.name}: unknown field "${key}"`, {
           argument: "values",
           value: key,
-          expected: this.laidOut.map((f2) => f2.name).join(", ")
+          expected: this.laidOut.map((f) => f.name).join(", ")
         });
       }
     }
@@ -337,7 +350,7 @@ ${lines.join("\n")}
       throw new WebGpuGraphError("E_INVALID_ARGUMENT", `UniformBlock ${this.name}: unknown field "${field}"`, {
         argument: "field",
         value: field,
-        expected: this.laidOut.map((f2) => f2.name).join(", ")
+        expected: this.laidOut.map((f) => f.name).join(", ")
       });
     }
     return layout;
@@ -674,6 +687,73 @@ fn fill(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid
 }
 `
 );
+const prFinalizeWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn pr_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
+    var d = 0.0;
+    var e = 0.0;
+    var m = 0.0;
+    for (var g = lid.x; g < P.groups; g = g + WG) {
+        d = d + partials[1u + g].danglingMass;
+        e = e + partials[1u + g].delta;
+        m = m + partials[1u + g].norm;
+    }
+    let folded = wg_reduce_vec4(vec4f(d, e, m, 0.0), lid.x, 0u);
+    if (lid.x == 0u) {
+        partials[0].danglingMass = folded.x;
+        partials[0].delta = folded.y;
+        var norm = folded.z;
+        if (NORM_MODE == 2u) { norm = sqrt(max(0.0, folded.z)); }
+        partials[0].norm = norm;
+        partials[0].iteration = P.iteration;
+        let unset = partials[0].firstConverged == U32_MAX;
+        if (P.trackConvergence == 1u && P.iteration >= 2u && folded.y < P.convergeThreshold && unset) {
+            partials[0].firstConverged = P.iteration - 1u;
+        }
+    }
+}
+`
+);
+const prScaleWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn pr_scale(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let u = linear_id(wid, lid.x);
+    let inRange = u < P.n;
+    var x = 0.0;
+    var prev = 0.0;
+    if (inRange) { x = rankIn[u]; prev = rankPrev[u]; }
+    var dangling = 0.0;
+    var delta = 0.0;
+    var normTerm = 0.0;
+    if (inRange) {
+        delta = abs(x - prev);
+        if (NORM_MODE == 0u) {
+            let divisor = outWeightSum[u];
+            if (divisor <= 0.0) { dangling = x; xNorm[u] = 0.0; } else { xNorm[u] = x / divisor; }
+        }
+        if (NORM_MODE == 1u) { normTerm = abs(x); }
+        if (NORM_MODE == 2u) { normTerm = x * x; }
+        if (NORM_MODE == 3u) {
+            var scale = partials[0].norm;
+            if (scale <= 0.0) { scale = 1.0; }
+            xNorm[u] = x / scale;
+        }
+        if (NORM_MODE == 4u) { xNorm[u] = x; }
+    }
+    let folded = wg_reduce_vec4(vec4f(dangling, delta, normTerm, 0.0), lid.x, 0u);
+    if (lid.x == 0u) {
+        let slot = 1u + group_id(wid);
+        partials[slot].danglingMass = folded.x;
+        partials[slot].delta = folded.y;
+        partials[slot].norm = folded.z;
+    }
+}
+`
+);
 const reduceWgsl = (
   /* wgsl */
   `
@@ -757,6 +837,150 @@ fn segmented_reduce(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invoca
 }
 `
 );
+const spmvPullWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn spmv_pull(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    var dangling = 0.0;
+    if (USE_DANGLING) { dangling = partials[0].danglingMass; }
+    let first = linear_id(wid, lid.x);
+    for (var row = first; row < P.n; row = row + P.stride) {
+        let v = select(row, perm[row], USE_PERM);
+        let a0 = max(rowPtr[v], P.arcBase);
+        let a1 = min(rowPtr[v + 1u], P.arcEnd);
+        var acc = 0.0;
+        var chunk = 0.0;
+        var inChunk = 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)
+            var weight = 1.0;
+            if (HAS_WEIGHTS) { weight = weights[arc - P.arcBase]; }
+            // two-level sum: 64 terms into chunk, chunk into acc (see the header; no compensation, no select)
+            chunk = chunk + (weight * xNorm[nbr]);
+            inChunk = inChunk + 1u;
+            if (inChunk == 64u) {
+                acc = acc + chunk;
+                chunk = 0.0;
+                inChunk = 0u;
+            }
+        }
+        acc = acc + chunk;
+        var pv = P.uniformP;
+        if (HAS_PERSONALIZATION) { pv = personalization[v]; }
+        rankOut[v] = (P.beta * pv) + (P.alpha * (acc + (dangling * pv)));
+    }
+}
+`
+);
+const wccCompressWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn wcc_compress(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let first = linear_id(wid, lid.x);
+    for (var v = first; v < P.items; v = v + P.stride) {
+        var root = atomicLoad(&comp[v]);
+        var steps = 0u;
+        loop {
+            let parent = atomicLoad(&comp[root]);
+            if (parent == root) { break; }
+            if (steps >= P.maxSteps) { break; }
+            steps = steps + 1u;
+            root = parent;
+        }
+        atomicStore(&comp[v], root);
+    }
+}
+`
+);
+const wccLinkEdgesWgsl = (
+  /* wgsl */
+  `
+fn link_pair(a: u32, b: u32) {
+    var p1 = atomicLoad(&comp[a]);
+    var p2 = atomicLoad(&comp[b]);
+    var steps = 0u;
+    loop {
+        if (p1 == p2) { break; }
+        if (steps >= P.maxSteps) { atomicStore(&comp[P.flagIndex], 1u); break; }
+        steps = steps + 1u;
+        let hi = max(p1, p2);
+        let lo = min(p1, p2);
+        let pHigh = atomicLoad(&comp[hi]);
+        if (pHigh == lo) { break; }
+        if (pHigh == hi) {
+            let swapped = atomicCompareExchangeWeak(&comp[hi], hi, lo);
+            if (swapped.exchanged) { atomicStore(&comp[P.flagIndex], 1u); break; }
+        }
+        p1 = atomicLoad(&comp[atomicLoad(&comp[hi])]);
+        p2 = atomicLoad(&comp[lo]);
+    }
+}
+
+@compute @workgroup_size(WG)
+fn wcc_link_edges(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let first = linear_id(wid, lid.x);
+    for (var e = first; e < P.items; e = e + P.stride) {
+        let u = edgeSrc[e];
+        let v = edgeDst[e];
+        if (u == v) { continue; }
+        if (atomicLoad(&comp[u]) == P.giant && atomicLoad(&comp[v]) == P.giant) { continue; }
+        link_pair(u, v);
+    }
+}
+`
+);
+const wccLinkSampleWgsl = (
+  /* wgsl */
+  `
+fn link_pair(a: u32, b: u32) {
+    var p1 = atomicLoad(&comp[a]);
+    var p2 = atomicLoad(&comp[b]);
+    var steps = 0u;
+    loop {
+        if (p1 == p2) { break; }
+        if (steps >= P.maxSteps) { atomicStore(&comp[P.flagIndex], 1u); break; }
+        steps = steps + 1u;
+        let hi = max(p1, p2);
+        let lo = min(p1, p2);
+        let pHigh = atomicLoad(&comp[hi]);
+        if (pHigh == lo) { break; }
+        if (pHigh == hi) {
+            let swapped = atomicCompareExchangeWeak(&comp[hi], hi, lo);
+            if (swapped.exchanged) { atomicStore(&comp[P.flagIndex], 1u); break; }
+        }
+        p1 = atomicLoad(&comp[atomicLoad(&comp[hi])]);
+        p2 = atomicLoad(&comp[lo]);
+    }
+}
+
+@compute @workgroup_size(WG)
+fn wcc_link_sample(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let first = linear_id(wid, lid.x);
+    for (var row = first; row < P.items; row = row + P.stride) {
+        let v = select(row, perm[row], USE_PERM);
+        let a0 = rowPtr[v];
+        let a1 = rowPtr[v + 1u];
+        if (a0 + P.r < a1) {
+            link_pair(v, colIdx[a0 + P.r]);
+        }
+    }
+}
+`
+);
+const wccSampleWgsl = (
+  /* wgsl */
+  `
+@compute @workgroup_size(WG)
+fn wcc_sample(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let i = linear_id(wid, lid.x);
+    if (i >= P.items) { return; }
+    let v = lowbias32(i + P.r) % P.n;
+    hist[i] = atomicLoad(&comp[v]);
+}
+`
+);
 const RANGE_PARAMS = UniformBlock.define("RangeParams", [
   ["start", "u32"],
   ["end", "u32"],
@@ -855,6 +1079,50 @@ const FA2_PARTIAL = UniformBlock.define(
   ],
   { layout: "storage" }
 );
+const SPMV_PARAMS = UniformBlock.define("SpmvParams", [
+  ["n", "u32"],
+  ["arcBase", "u32"],
+  ["arcEnd", "u32"],
+  ["stride", "u32"],
+  ["alpha", "f32"],
+  ["beta", "f32"],
+  ["uniformP", "f32"],
+  ["pad0", "u32"]
+]);
+const PR_PARAMS = UniformBlock.define("PrParams", [
+  ["n", "u32"],
+  ["groups", "u32"],
+  ["iteration", "u32"],
+  ["trackConvergence", "u32"],
+  ["convergeThreshold", "f32"],
+  ["pad0", "u32"],
+  ["pad1", "u32"],
+  ["pad2", "u32"]
+]);
+const PR_PARTIAL = UniformBlock.define(
+  "PrPartial",
+  [
+    ["danglingMass", "f32"],
+    ["delta", "f32"],
+    ["firstConverged", "u32"],
+    ["iteration", "u32"],
+    ["norm", "f32"],
+    ["pad0", "f32"],
+    ["pad1", "f32"],
+    ["pad2", "f32"]
+  ],
+  { layout: "storage" }
+);
+const WCC_PARAMS = UniformBlock.define("WccParams", [
+  ["n", "u32"],
+  ["items", "u32"],
+  ["stride", "u32"],
+  ["r", "u32"],
+  ["flagIndex", "u32"],
+  ["giant", "u32"],
+  ["maxSteps", "u32"],
+  ["pad0", "u32"]
+]);
 function decl(group, binding, name, kind, wgslType) {
   return { group, binding, name, kind, wgslType };
 }
@@ -1027,6 +1295,111 @@ const FA2_TO_SCENE = {
   snippetSlots: [],
   phase: "P3"
 };
+const SPMV_PULL = {
+  id: "spmv-pull",
+  body: spmvPullWgsl,
+  entryPoint: "spmv_pull",
+  bindings: GRAPH_SLOTS.concat(
+    decl(1, 0, "xNorm", "storage-ro", "array<f32>"),
+    decl(1, 1, "rankOut", "storage", "array<f32>"),
+    decl(1, 2, "personalization", "storage-ro", "array<f32>"),
+    decl(1, 3, "partials", "storage-ro", "array<PrPartial>"),
+    decl(2, 0, "P", "uniform", "SpmvParams")
+  ),
+  overrideDecls: [
+    { name: "HAS_PERSONALIZATION", type: "bool", default: false },
+    { name: "USE_DANGLING", type: "bool", default: false }
+  ],
+  uniforms: [SPMV_PARAMS, PR_PARTIAL],
+  needs: [],
+  snippetSlots: [],
+  phase: "P7"
+};
+const PR_SCALE = {
+  id: "pr-scale",
+  body: prScaleWgsl,
+  entryPoint: "pr_scale",
+  bindings: [
+    decl(1, 0, "rankIn", "storage-ro", "array<f32>"),
+    decl(1, 1, "rankPrev", "storage-ro", "array<f32>"),
+    decl(1, 2, "outWeightSum", "storage-ro", "array<f32>"),
+    decl(1, 3, "xNorm", "storage", "array<f32>"),
+    decl(1, 4, "partials", "storage", "array<PrPartial>"),
+    decl(2, 0, "P", "uniform", "PrParams")
+  ],
+  overrideDecls: [{ name: "NORM_MODE", type: "u32", default: 0 }],
+  uniforms: [PR_PARAMS, PR_PARTIAL],
+  needs: ["subgroups"],
+  snippetSlots: [],
+  phase: "P7"
+};
+const PR_FINALIZE = {
+  id: "pr-finalize",
+  body: prFinalizeWgsl,
+  entryPoint: "pr_finalize",
+  bindings: [decl(1, 0, "partials", "storage", "array<PrPartial>"), decl(2, 0, "P", "uniform", "PrParams")],
+  overrideDecls: [{ name: "NORM_MODE", type: "u32", default: 0 }],
+  uniforms: [PR_PARAMS, PR_PARTIAL],
+  needs: ["subgroups"],
+  snippetSlots: [],
+  phase: "P7"
+};
+const WCC_LINK_SAMPLE = {
+  id: "wcc-link-sample",
+  body: wccLinkSampleWgsl,
+  entryPoint: "wcc_link_sample",
+  bindings: GRAPH_SLOTS.concat(
+    decl(1, 0, "comp", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "WccParams")
+  ),
+  overrideDecls: [],
+  uniforms: [WCC_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P7"
+};
+const WCC_LINK_EDGES = {
+  id: "wcc-link-edges",
+  body: wccLinkEdgesWgsl,
+  entryPoint: "wcc_link_edges",
+  bindings: [
+    decl(1, 0, "edgeSrc", "storage-ro", "array<u32>"),
+    decl(1, 1, "edgeDst", "storage-ro", "array<u32>"),
+    decl(1, 2, "comp", "storage", "array<atomic<u32>>"),
+    decl(2, 0, "P", "uniform", "WccParams")
+  ],
+  overrideDecls: [],
+  uniforms: [WCC_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P7"
+};
+const WCC_COMPRESS = {
+  id: "wcc-compress",
+  body: wccCompressWgsl,
+  entryPoint: "wcc_compress",
+  bindings: [decl(1, 0, "comp", "storage", "array<atomic<u32>>"), decl(2, 0, "P", "uniform", "WccParams")],
+  overrideDecls: [],
+  uniforms: [WCC_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P7"
+};
+const WCC_SAMPLE = {
+  id: "wcc-sample",
+  body: wccSampleWgsl,
+  entryPoint: "wcc_sample",
+  bindings: [
+    decl(1, 0, "comp", "storage", "array<atomic<u32>>"),
+    decl(1, 1, "hist", "storage", "array<u32>"),
+    decl(2, 0, "P", "uniform", "WccParams")
+  ],
+  overrideDecls: [],
+  uniforms: [WCC_PARAMS],
+  needs: [],
+  snippetSlots: [],
+  phase: "P7"
+};
 const REGISTRY = Object.freeze({
   degree: DEGREE,
   reduce: REDUCE,
@@ -1037,7 +1410,14 @@ const REGISTRY = Object.freeze({
   "fa2-repulsion-exact": FA2_REPULSION_EXACT,
   "fa2-speed-finalize": FA2_SPEED_FINALIZE,
   "fa2-integrate": FA2_INTEGRATE,
-  "fa2-to-scene": FA2_TO_SCENE
+  "fa2-to-scene": FA2_TO_SCENE,
+  "spmv-pull": SPMV_PULL,
+  "pr-scale": PR_SCALE,
+  "pr-finalize": PR_FINALIZE,
+  "wcc-link-sample": WCC_LINK_SAMPLE,
+  "wcc-link-edges": WCC_LINK_EDGES,
+  "wcc-compress": WCC_COMPRESS,
+  "wcc-sample": WCC_SAMPLE
 });
 const bodyOverrides = /* @__PURE__ */ new Map();
 function entryOf(id) {
@@ -1078,7 +1458,7 @@ function graphOverrides(core, perm, weights) {
   const resolved = weights === void 0 ? core.weights : weights;
   return { USE_PERM: perm !== null, HAS_WEIGHTS: resolved !== null };
 }
-function checkDest(dest, n) {
+function checkDest$3(dest, n) {
   if (dest === void 0) {
     return null;
   }
@@ -1095,7 +1475,7 @@ function checkDest(dest, n) {
     }
   );
 }
-function coreOf(ctx, s) {
+function coreOf$3(ctx, s) {
   try {
     return ctx.residency.core(s);
   } catch (error) {
@@ -1112,7 +1492,7 @@ function coreOf(ctx, s) {
 async function degree(ctx, s, options) {
   ctx.assertReady();
   const n = s.nodeCount;
-  const dest = checkDest(options?.dest, n);
+  const dest = checkDest$3(options?.dest, n);
   if (options?.signal?.aborted) {
     throw new WebGpuGraphError("E_ABORTED", "degree: the signal was aborted before any work started", {});
   }
@@ -1120,7 +1500,7 @@ async function degree(ctx, s, options) {
     options?.onProgress?.(1, 1);
     return dest ?? new Uint32Array(0);
   }
-  const core = coreOf(ctx, s);
+  const core = coreOf$3(ctx, s);
   if (s.arcCount === 0) {
     const zeros = dest ?? new Uint32Array(n);
     zeros.fill(0);
@@ -1165,8 +1545,8 @@ async function degree(ctx, s, options) {
 const LOSS_GRACE_MS = 2e3;
 async function settled(pending, graceMs) {
   let timer;
-  const grace = new Promise((resolve) => {
-    timer = setTimeout(resolve, graceMs);
+  const grace = new Promise((resolve2) => {
+    timer = setTimeout(resolve2, graceMs);
   });
   await Promise.race([
     pending.then(
@@ -1393,9 +1773,9 @@ class CommandBatch {
       }
     }
     let timer;
-    const grace = new Promise((resolve) => {
+    const grace = new Promise((resolve2) => {
       timer = setTimeout(() => {
-        resolve(null);
+        resolve2(null);
       }, LOSS_GRACE_MS);
     });
     const late = await Promise.race([
@@ -1638,6 +2018,1068 @@ class UniformRing {
     }
   }
 }
+function algorithmScope(ctx, label, slots) {
+  const lease = ctx.pool.lease();
+  const ring = new UniformRing(ctx.device, ctx.allocator, slots, `${label}/ring`);
+  return {
+    device: ctx.device,
+    caps: ctx.caps,
+    pipelines: ctx.pipelines,
+    pool: ctx.pool,
+    workgroupSize: ctx.workgroupSize,
+    scratch: (byteLength, scratchLabel) => lease.storage(byteLength, `${label}/${scratchLabel}`),
+    params(block, values) {
+      const slot = ring.reserve(1);
+      ring.write(slot, block, values);
+      return { binding: ring.binding(block), offset: ring.offsetOf(slot) };
+    },
+    flush: () => {
+      ring.flush();
+    },
+    dispose() {
+      ring.destroy();
+      lease.release();
+    }
+  };
+}
+const ALGORITHM = "connectedComponents";
+const ROUNDS_PER_BATCH = 4;
+const MAX_WCC_ROUNDS = 64;
+const SAMPLE_SIZE = 1024;
+const MAX_STEPS = 1024;
+const RING_SLOTS$2 = 2 * ROUNDS_PER_BATCH;
+function checkDest$2(dest, n) {
+  if (dest === void 0) {
+    return null;
+  }
+  if (dest instanceof Uint32Array && dest.length === n && dest.buffer instanceof ArrayBuffer) {
+    return dest;
+  }
+  throw new WebGpuGraphError(
+    "E_INVALID_ARGUMENT",
+    `${ALGORITHM}: dest must be a Uint32Array of length ${n} over an ArrayBuffer`,
+    {
+      argument: "dest",
+      value: `${dest.constructor.name}(${dest.length})`,
+      expected: `Uint32Array(${n}) over an ArrayBuffer`
+    }
+  );
+}
+function coreOf$2(ctx, s) {
+  try {
+    return ctx.residency.core(s);
+  } catch (error) {
+    if (isWebGpuGraphError(error) && error.code === "E_TOO_LARGE" && error.details.path === "windowed") {
+      throw new WebGpuGraphError(
+        "E_TOO_LARGE",
+        `${ALGORITHM}: the arc arrays need a windowed upload, which P1-P3 plan but do not execute`,
+        { ...error.details, algorithm: ALGORITHM }
+      );
+    }
+    throw error;
+  }
+}
+function bindingOf$1(buffer, size) {
+  return { buffer, offset: 0, size, window: null };
+}
+function labelResult(labels, count) {
+  let groups = null;
+  return {
+    labels,
+    count,
+    groups() {
+      if (groups !== null) {
+        return groups;
+      }
+      const n = labels.length;
+      const dense = new Uint32Array(n).fill(U32_MAX);
+      const sizes = new Uint32Array(count);
+      let next = 0;
+      for (let v = 0; v < n; v++) {
+        let k2 = dense[labels[v]];
+        if (k2 === U32_MAX) {
+          k2 = next++;
+          dense[labels[v]] = k2;
+        }
+        sizes[k2]++;
+      }
+      const built = Array.from(sizes, (size) => new Uint32Array(size));
+      const filled = new Uint32Array(count);
+      for (let v = 0; v < n; v++) {
+        const k2 = dense[labels[v]];
+        built[k2][filled[k2]++] = v;
+      }
+      groups = built;
+      return built;
+    }
+  };
+}
+function modeOf(sample) {
+  const counts = /* @__PURE__ */ new Map();
+  let best = sample[0];
+  let bestCount = 0;
+  for (const label of sample) {
+    const c = (counts.get(label) ?? 0) + 1;
+    counts.set(label, c);
+    if (c > bestCount) {
+      best = label;
+      bestCount = c;
+    }
+  }
+  return best;
+}
+function checkLabels(raw) {
+  const n = raw.length;
+  const seen = new Uint8Array(n);
+  let count = 0;
+  for (let v = 0; v < n; v++) {
+    const label = raw[v];
+    if (label >= n) {
+      throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM}: labels[${v}] = ${label} is not a node index`, {
+        label: `${ALGORITHM}/labels`,
+        message: `the device produced a label outside [0, ${n})`
+      });
+    }
+    if (seen[label] === 0) {
+      seen[label] = 1;
+      count++;
+    }
+  }
+  return count;
+}
+async function connectedComponents(ctx, s, options) {
+  ctx.assertReady();
+  const n = s.nodeCount;
+  const renumber = options?.renumber !== false;
+  const dest = checkDest$2(options?.dest, n);
+  if (options?.signal?.aborted) {
+    throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM}: the signal was aborted before any work started`, {});
+  }
+  if (n === 0) {
+    options?.onProgress?.(1, 1);
+    return labelResult(dest ?? new Uint32Array(0), 0);
+  }
+  const core = coreOf$2(ctx, s);
+  if (s.arcCount === 0) {
+    const labels = dest ?? new Uint32Array(n);
+    for (let v = 0; v < n; v++) {
+      labels[v] = v;
+    }
+    options?.onProgress?.(1, 1);
+    return labelResult(labels, n);
+  }
+  const edges = ctx.residency.view(s, "edgeList");
+  const edgeCount = edges.scalars.edgeCount[0];
+  const scope = algorithmScope(ctx, ALGORITHM, RING_SLOTS$2);
+  try {
+    const compBytes = 4 * (n + 1);
+    const comp = scope.scratch(compBytes, "comp");
+    const items = Math.min(SAMPLE_SIZE, n);
+    const hist = scope.scratch(4 * items, "hist");
+    await ctx.allocator.check();
+    const fill = await ctx.pipelines.kernel(kernelSpec("fill", {}));
+    const linkSample = await ctx.pipelines.kernel(kernelSpec("wcc-link-sample", graphOverrides(core, null)));
+    const linkEdges = await ctx.pipelines.kernel(kernelSpec("wcc-link-edges", {}));
+    const compress = await ctx.pipelines.kernel(kernelSpec("wcc-compress", {}));
+    const sample = await ctx.pipelines.kernel(kernelSpec("wcc-sample", {}));
+    const { queue } = ctx.device;
+    const compBinding = bindingOf$1(comp, compBytes);
+    const histBinding = bindingOf$1(hist, 4 * items);
+    const rowPlan = planGridStride(n, ctx.workgroupSize, ctx.caps);
+    const edgePlan = planGridStride(edgeCount, ctx.workgroupSize, ctx.caps);
+    const flagIndex = n;
+    const zero = new Uint32Array(1);
+    const wccParams = (fields) => scope.params(WCC_PARAMS, { n, ...fields, flagIndex, maxSteps: MAX_STEPS, pad0: 0 });
+    const recordCompress = (pass2) => {
+      const params = wccParams({ items: n, stride: rowPlan.stride ?? n, r: 0, giant: U32_MAX });
+      compress.dispatch(pass2, compress.bind({ comp: compBinding, P: params.binding }), rowPlan, [params.offset]);
+    };
+    const submit = (batch) => {
+      scope.flush();
+      return batch.submit();
+    };
+    queue.writeBuffer(comp, 4 * flagIndex, zero);
+    const setup = new CommandBatch(ctx, `${ALGORITHM}/setup`);
+    let pass = setup.pass("sample-rounds");
+    const fillParams = scope.params(FILL_PARAMS, { count: n, value: 0, mode: 1, pad0: 0 });
+    fill.dispatch(
+      pass,
+      fill.bind({ dst: bindingOf$1(comp, 4 * n), P: fillParams.binding }),
+      plan1d(n, ctx.workgroupSize, ctx.caps),
+      [fillParams.offset]
+    );
+    const graph = graphBindings(core, null);
+    for (let r = 0; r < 2; r++) {
+      const params = wccParams({ items: n, stride: rowPlan.stride ?? n, r, giant: U32_MAX });
+      const bound = linkSample.bind({ ...graph, comp: compBinding, P: params.binding });
+      linkSample.dispatch(pass, bound, rowPlan, [params.offset]);
+    }
+    recordCompress(pass);
+    setup.endPass();
+    await submit(setup).readback;
+    ctx.assertReady();
+    const sampler = new CommandBatch(ctx, `${ALGORITHM}/sample`);
+    pass = sampler.pass("sample");
+    const sampleParams = wccParams({ items, stride: 0, r: 0, giant: U32_MAX });
+    sample.dispatch(
+      pass,
+      sample.bind({ comp: compBinding, hist: histBinding, P: sampleParams.binding }),
+      plan1d(items, ctx.workgroupSize, ctx.caps),
+      [sampleParams.offset]
+    );
+    sampler.endPass();
+    const histRequest = sampler.readback(hist, 0, 4 * items);
+    const histBytes = await submit(sampler).readback;
+    ctx.assertReady();
+    const giant = modeOf(new Uint32Array(histBytes, histRequest.offset, items));
+    const edgeBindings = { edgeSrc: edges.bindings.src, edgeDst: edges.bindings.dst, comp: compBinding };
+    let rounds = 0;
+    for (; ; ) {
+      queue.writeBuffer(comp, 4 * flagIndex, zero);
+      const batch = new CommandBatch(ctx, `${ALGORITHM}/rounds`);
+      pass = batch.pass("edge-rounds");
+      for (let i = 0; i < ROUNDS_PER_BATCH; i++) {
+        const params = wccParams({ items: edgeCount, stride: edgePlan.stride ?? edgeCount, r: 0, giant });
+        const bound = linkEdges.bind({ ...edgeBindings, P: params.binding });
+        linkEdges.dispatch(pass, bound, edgePlan, [params.offset]);
+        recordCompress(pass);
+      }
+      batch.endPass();
+      const flagRequest = batch.readback(comp, 4 * flagIndex, 4);
+      const submitted = submit(batch);
+      const back = await submitted.readback;
+      rounds += ROUNDS_PER_BATCH;
+      ctx.assertReady();
+      if (options?.signal?.aborted) {
+        throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM}: the signal was aborted`, { batchId: submitted.id });
+      }
+      if (new Uint32Array(back, flagRequest.offset, 1)[0] === 0) {
+        break;
+      }
+      if (rounds >= MAX_WCC_ROUNDS) {
+        throw new WebGpuGraphError(
+          "E_VALIDATION",
+          `${ALGORITHM}: the changed flag never settled in ${MAX_WCC_ROUNDS} rounds`,
+          { label: ALGORITHM, message: `the changed flag never settled in ${MAX_WCC_ROUNDS} rounds` }
+        );
+      }
+    }
+    const final = new CommandBatch(ctx, `${ALGORITHM}/final`);
+    recordCompress(final.pass("compress"));
+    final.endPass();
+    await submit(final).readback;
+    ctx.assertReady();
+    const raw = !renumber && dest !== null ? dest : new Uint32Array(n);
+    await ctx.readback.read(comp, 4 * n, raw);
+    ctx.assertReady();
+    const distinct = checkLabels(raw);
+    options?.onProgress?.(1, 1);
+    if (!renumber) {
+      return labelResult(raw, distinct);
+    }
+    const { labels, count } = renumberPartition(raw, dest ?? void 0);
+    return labelResult(labels, count);
+  } finally {
+    scope.dispose();
+  }
+}
+function rowCountOf(core, primitive) {
+  const bytes = core.rowPtr.size;
+  if (bytes < 4 || bytes % 4 !== 0) {
+    throw new WebGpuGraphError(
+      "E_INVALID_ARGUMENT",
+      `${primitive}: a rowPtr binding of ${bytes} bytes is not 4(n + 1)`,
+      {
+        argument: "core.rowPtr",
+        value: bytes,
+        expected: "a positive multiple of 4"
+      }
+    );
+  }
+  return bytes / 4 - 1;
+}
+function arcCountOf(core) {
+  return core.colIdx === null ? 0 : core.colIdx.size / 4;
+}
+function assertNotWindowed(core, primitive) {
+  if (core.plan === "windowed" || core.windows !== null) {
+    throw new WebGpuGraphError("E_UNSUPPORTED", `${primitive}: windowed cores are executed at P4`, {
+      feature: `${primitive}.windowed`
+    });
+  }
+}
+function coreOfView(v, arcCount) {
+  const { rowPtr } = v.bindings;
+  if (rowPtr === void 0) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `the ${v.view} view has no rowPtr binding`, {
+      argument: "view",
+      value: v.view,
+      expected: "a view with a rowPtr binding (reverse)"
+    });
+  }
+  const colIdx = v.bindings.colIdx ?? null;
+  const weights = v.bindings.weights ?? null;
+  const bound = colIdx === null ? 0 : colIdx.size / 4;
+  if (bound !== arcCount) {
+    throw new WebGpuGraphError(
+      "E_INVALID_ARGUMENT",
+      `the ${v.view} view binds ${bound} arcs but its arcCount scalar says ${arcCount}`,
+      {
+        argument: "arcCount",
+        value: arcCount,
+        expected: bound
+      }
+    );
+  }
+  return Object.freeze({
+    serial: -1,
+    plan: "perArray",
+    rowPtr,
+    colIdx,
+    weights,
+    arcToEdge: null,
+    edgeToArc: null,
+    windows: null,
+    hasWeights: weights !== null
+  });
+}
+const VALUE_SNIPPET_VOCABULARY = /* @__PURE__ */ new Set(["row", "arc", "nbr", "weight", "v"]);
+const VALUE_SNIPPET_WGSL_WORDS = /* @__PURE__ */ new Set([
+  "if",
+  "else",
+  "let",
+  "var",
+  "const",
+  "true",
+  "false",
+  "f32",
+  "u32",
+  "i32",
+  "bool",
+  "abs",
+  "ceil",
+  "clamp",
+  "exp",
+  "exp2",
+  "floor",
+  "fract",
+  "inverseSqrt",
+  "log",
+  "log2",
+  "max",
+  "min",
+  "mix",
+  "pow",
+  "round",
+  "select",
+  "sign",
+  "sqrt",
+  "step",
+  "trunc"
+]);
+function opCode(op) {
+  switch (op) {
+    case "sum":
+      return 0;
+    case "min":
+      return 1;
+    case "max":
+      return 2;
+    default:
+      throw new WebGpuGraphError("E_INVALID_ARGUMENT", `segmentedReduce: unknown op ${String(op)}`, {
+        argument: "op",
+        value: op,
+        expected: "sum | min | max"
+      });
+  }
+}
+function stripComments(text) {
+  return text.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, " ");
+}
+function validateValueSnippet(snippet) {
+  const code = stripComments(snippet);
+  if (!/\bv\s*[-+*/]?=(?!=)/.test(code)) {
+    throw new WebGpuGraphError("E_SHADER_COMPILE", "segmentedReduce: the VALUE snippet never assigns v", {
+      id: "segmented-reduce",
+      stage: "compose",
+      slot: "VALUE"
+    });
+  }
+  const tokens = code.match(/[A-Za-z_][A-Za-z0-9_]*|[0-9][0-9A-Za-z_.]*/g) ?? [];
+  for (const token of tokens) {
+    if (/^[0-9]/.test(token) || VALUE_SNIPPET_VOCABULARY.has(token) || VALUE_SNIPPET_WGSL_WORDS.has(token)) {
+      continue;
+    }
+    throw new WebGpuGraphError(
+      "E_SHADER_COMPILE",
+      `segmentedReduce: the VALUE snippet names "${token}"; the only identifiers allowed are row, arc, nbr, weight and v`,
+      { id: "segmented-reduce", stage: "compose", slot: "VALUE", identifier: token }
+    );
+  }
+}
+class ThreadPerRowPlanner {
+  /**
+   * Wraps a compiled thread-per-row pipeline with the pattern it was compiled for.
+   * @param scope - the scope the pipeline was prepared in
+   * @param kernel - the compiled kernel
+   * @param hasWeights - the HAS_WEIGHTS the pipeline was compiled with
+   * @param accumulate - whether record() combines into out instead of overwriting
+   */
+  constructor(scope, kernel, hasWeights, accumulate) {
+    this.scope = scope;
+    this.kernel = kernel;
+    this.hasWeights = hasWeights;
+    this.accumulate = accumulate;
+  }
+  /**
+   * Records the dispatch: rows [0, n), arcs [0, arcCount), plan1d(n); nothing for n = 0 (no zero-length binding is
+   * ever created).
+   * @param pass - the pass to record into
+   * @param core - a core with the SAME weights pattern as the one prepared (any snapshot)
+   * @param out - at least 4n bytes of f32
+   */
+  record(pass, core, out) {
+    assertNotWindowed(core, "segmentedReduce");
+    if (core.weights !== null !== this.hasWeights) {
+      throw new WebGpuGraphError(
+        "E_INVALID_ARGUMENT",
+        "segmentedReduce: the core's weights pattern differs from the one prepared",
+        {
+          argument: "core",
+          value: core.weights !== null,
+          expected: this.hasWeights
+        }
+      );
+    }
+    const n = rowCountOf(core, "segmentedReduce");
+    if (n === 0) {
+      return;
+    }
+    const arcCount = core.colIdx === null ? 0 : core.colIdx.size / 4;
+    if (out.size < 4 * n) {
+      throw new WebGpuGraphError(
+        "E_INVALID_ARGUMENT",
+        `segmentedReduce: out holds ${out.size} bytes, ${4 * n} needed`,
+        {
+          argument: "out",
+          value: out.size,
+          expected: `>= ${4 * n}`
+        }
+      );
+    }
+    const params = this.scope.params(RANGE_PARAMS, {
+      start: 0,
+      end: n,
+      arcBase: 0,
+      arcEnd: arcCount,
+      accumulate: this.accumulate ? 1 : 0,
+      n
+    });
+    const bound = this.kernel.bind({ ...graphBindings(core, null), out, P: params.binding });
+    this.kernel.dispatch(pass, bound, plan1d(n, this.scope.workgroupSize, this.scope.caps), [params.offset]);
+  }
+}
+async function prepareSegmentedReduce(scope, core, options) {
+  assertNotWindowed(core, "segmentedReduce");
+  const op = opCode(options.op);
+  validateValueSnippet(options.valueSnippet);
+  const overrides = { ...graphOverrides(core, null), OP: op, TIER: 0 };
+  const spec = kernelSpec("segmented-reduce", overrides, { VALUE: options.valueSnippet });
+  const kernel = await scope.pipelines.kernel(spec);
+  return new ThreadPerRowPlanner(scope, kernel, core.weights !== null, options.accumulate === true);
+}
+class SpmvPullPlannerImpl {
+  /**
+   * Wraps a compiled pipeline with the weights choice it was compiled for.
+   * @param scope - the scope the pipeline was prepared in
+   * @param kernel - the compiled kernel
+   * @param weights - the weights option the pipeline's HAS_WEIGHTS was derived from; record() binds the same way
+   */
+  constructor(scope, kernel, weights) {
+    this.dispatches = 0;
+    this.scope = scope;
+    this.kernel = kernel;
+    this.weights = weights;
+  }
+  /**
+   * Dispatches the last record() issued.
+   * @returns 1, or 0 when the last record covered no rows
+   */
+  get lastDispatches() {
+    return this.dispatches;
+  }
+  /**
+   * Records the dispatch: rows [0, n), arcs [0, arcCount), planGridStride(n); nothing for n = 0 (no zero-length
+   * binding is ever created). `personalization ?? xNorm` follows the group-0 dummy rule: both slots are
+   * storage-ro, so the aliasing check of Kernel.bind does not fire, and HAS_PERSONALIZATION false never reads it.
+   * @param pass - the pass to record into
+   * @param rev - the reverse core (any snapshot with the weights pattern the planner was prepared for)
+   * @param resources - xNorm, rankOut, personalization, partials
+   * @param coefficients - alpha, beta, uniformP
+   */
+  record(pass, rev, resources, coefficients) {
+    const n = rowCountOf(rev, "spmvPull");
+    const plan = planGridStride(n, this.scope.workgroupSize, this.scope.caps);
+    if (plan.x === 0) {
+      this.dispatches = 0;
+      return;
+    }
+    const params = this.scope.params(SPMV_PARAMS, {
+      n,
+      arcBase: 0,
+      arcEnd: arcCountOf(rev),
+      stride: plan.stride ?? n,
+      alpha: coefficients.alpha,
+      beta: coefficients.beta,
+      uniformP: coefficients.uniformP,
+      pad0: 0
+    });
+    const bound = this.kernel.bind({
+      ...graphBindings(rev, null, this.weights),
+      xNorm: resources.xNorm,
+      rankOut: resources.rankOut,
+      personalization: resources.personalization ?? resources.xNorm,
+      partials: resources.partials,
+      P: params.binding
+    });
+    this.kernel.dispatch(pass, bound, plan, [params.offset]);
+    this.dispatches = 1;
+  }
+}
+async function prepareSpmvPull(scope, rev, options) {
+  if (options.tiers !== null) {
+    throw new WebGpuGraphError("E_UNSUPPORTED", "spmvPull: the in-degree tiers land at P4; pass tiers: null", {
+      feature: "spmvPull.tiers"
+    });
+  }
+  assertNotWindowed(rev, "spmvPull");
+  const spec = kernelSpec("spmv-pull", {
+    ...graphOverrides(rev, null, options.weights),
+    HAS_PERSONALIZATION: options.personalization,
+    USE_DANGLING: options.dangling
+  });
+  const kernel = await scope.pipelines.kernel(spec);
+  return new SpmvPullPlannerImpl(scope, kernel, options.weights);
+}
+const PR_BATCH = 8;
+const RING_SLOTS$1 = 2 * PR_BATCH + 1;
+function checkDest$1(dest, n, algorithm) {
+  if (dest === void 0) {
+    return null;
+  }
+  if (dest instanceof Float32Array && dest.length === n && dest.buffer instanceof ArrayBuffer) {
+    return dest;
+  }
+  throw new WebGpuGraphError(
+    "E_INVALID_ARGUMENT",
+    `${algorithm}: dest must be a Float32Array of length ${n} over an ArrayBuffer`,
+    {
+      argument: "dest",
+      value: `${dest.constructor.name}(${dest.length})`,
+      expected: `Float32Array(${n}) over an ArrayBuffer`
+    }
+  );
+}
+function coreOf$1(ctx, s, algorithm) {
+  try {
+    return ctx.residency.core(s);
+  } catch (error) {
+    if (isWebGpuGraphError(error) && error.code === "E_TOO_LARGE" && error.details.path === "windowed") {
+      throw new WebGpuGraphError(
+        "E_TOO_LARGE",
+        `${algorithm}: the arc arrays need a windowed upload, which P1-P3 plan but do not execute`,
+        { ...error.details, algorithm }
+      );
+    }
+    throw error;
+  }
+}
+function bindingOf(buffer, size) {
+  return { buffer, offset: 0, size, window: null };
+}
+function aborted$1(algorithm, batchId) {
+  return new WebGpuGraphError(
+    "E_ABORTED",
+    `${algorithm}: the signal was aborted`,
+    batchId === void 0 ? {} : { batchId }
+  );
+}
+async function run(ctx, s, personalization, options, algorithm) {
+  ctx.assertReady();
+  const n = s.nodeCount;
+  const alpha = options?.dampingFactor ?? 0.85;
+  const maxIterations = options?.maxIterations ?? 100;
+  const tolerance = options?.tolerance ?? 1e-6;
+  const useWeights = options?.weighted !== false;
+  if (!Number.isInteger(maxIterations) || maxIterations < 1) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${algorithm}: maxIterations must be a positive integer`, {
+      argument: "maxIterations",
+      value: maxIterations,
+      expected: "a positive integer"
+    });
+  }
+  const dest = checkDest$1(options?.dest, n, algorithm);
+  if (options?.signal?.aborted) {
+    throw aborted$1(algorithm);
+  }
+  if (n === 0) {
+    options?.onProgress?.(maxIterations, maxIterations);
+    return { scores: dest ?? new Float32Array(0), iterations: 0, converged: true, danglingMass: 0, precision: "f32" };
+  }
+  const core = coreOf$1(ctx, s, algorithm);
+  if (s.arcCount === 0) {
+    const scores = dest ?? new Float32Array(n);
+    if (personalization === null) {
+      scores.fill(1 / n);
+    } else {
+      scores.set(personalization);
+    }
+    options?.onProgress?.(maxIterations, maxIterations);
+    return { scores, iterations: 0, converged: true, danglingMass: 1, precision: "f32" };
+  }
+  const view = ctx.residency.view(s, "reverse");
+  const rev = coreOfView(view, view.scalars.arcCount[0]);
+  const weights = useWeights ? void 0 : null;
+  const weightedCore = useWeights ? core : { ...core, weights: null, hasWeights: false };
+  const weightedRev = useWeights ? rev : { ...rev, weights: null, hasWeights: false };
+  const scope = algorithmScope(ctx, algorithm, RING_SLOTS$1);
+  let uploaded = null;
+  try {
+    const bytes = 4 * n;
+    const rankA = scope.scratch(bytes, "rankA");
+    const rankB = scope.scratch(bytes, "rankB");
+    const xNorm = scope.scratch(bytes, "xNorm");
+    const outWeightSum = scope.scratch(bytes, "outWeightSum");
+    const scalePlan = plan1d(n, ctx.workgroupSize, ctx.caps);
+    const groups = groupsOf(scalePlan);
+    const partialsBytes = PR_PARTIAL.byteLength * (1 + groups);
+    const partials = scope.scratch(partialsBytes, "partials");
+    if (personalization !== null) {
+      uploaded = ctx.residency.array(personalization, `${algorithm}/personalization`);
+    }
+    await ctx.allocator.check();
+    const normaliser = await prepareSegmentedReduce(scope, weightedCore, {
+      op: "sum",
+      valueSnippet: "v = weight;",
+      tiers: null
+    });
+    const pull = await prepareSpmvPull(scope, weightedRev, {
+      personalization: personalization !== null,
+      dangling: true,
+      weights,
+      tiers: null
+    });
+    const scale = await ctx.pipelines.kernel(kernelSpec("pr-scale", { NORM_MODE: 0 }));
+    const finalize = await ctx.pipelines.kernel(kernelSpec("pr-finalize", { NORM_MODE: 0 }));
+    const finalizePlan = plan1d(1, ctx.workgroupSize, ctx.caps);
+    const { queue } = ctx.device;
+    queue.writeBuffer(rankA, 0, new Float32Array(n).fill(1 / n));
+    queue.writeBuffer(rankB, 0, new Float32Array(n));
+    const header = new ArrayBuffer(PR_PARTIAL.byteLength);
+    PR_PARTIAL.write(new DataView(header), { firstConverged: U32_MAX, iteration: 0 });
+    queue.writeBuffer(partials, 0, header);
+    const rank = [bindingOf(rankA, bytes), bindingOf(rankB, bytes)];
+    const xNormBinding = bindingOf(xNorm, bytes);
+    const outWeightSumBinding = bindingOf(outWeightSum, bytes);
+    const partialsBinding = bindingOf(partials, partialsBytes);
+    const coefficients = { alpha, beta: 1 - alpha, uniformP: 1 / n };
+    let cur = 0;
+    let iterationsRun = 0;
+    for (; ; ) {
+      const k2 = Math.min(PR_BATCH, maxIterations - iterationsRun);
+      const batch = new CommandBatch(ctx, algorithm);
+      const pass = batch.pass("iterations");
+      if (iterationsRun === 0) {
+        normaliser.record(pass, weightedCore, outWeightSumBinding);
+      }
+      for (let i = 0; i < k2; i++) {
+        const params = scope.params(PR_PARAMS, {
+          n,
+          groups,
+          iteration: iterationsRun + i + 1,
+          trackConvergence: 1,
+          convergeThreshold: tolerance * n
+        });
+        const other = 1 - cur;
+        const scaleBound = scale.bind({
+          rankIn: rank[cur],
+          rankPrev: rank[other],
+          outWeightSum: outWeightSumBinding,
+          xNorm: xNormBinding,
+          partials: partialsBinding,
+          P: params.binding
+        });
+        scale.dispatch(pass, scaleBound, scalePlan, [params.offset]);
+        const finalizeBound = finalize.bind({ partials: partialsBinding, P: params.binding });
+        finalize.dispatch(pass, finalizeBound, finalizePlan, [params.offset]);
+        pull.record(
+          pass,
+          weightedRev,
+          {
+            xNorm: xNormBinding,
+            rankOut: rank[other],
+            personalization: uploaded?.binding ?? null,
+            partials: partialsBinding
+          },
+          coefficients
+        );
+        cur = other;
+      }
+      batch.endPass();
+      const headerRequest = batch.readback(partials, 0, PR_PARTIAL.byteLength);
+      const scoresRequest = batch.readback(rank[cur].buffer, 0, bytes);
+      scope.flush();
+      const submitted = batch.submit();
+      const back = await submitted.readback;
+      iterationsRun += k2;
+      ctx.assertReady();
+      if (options?.signal?.aborted) {
+        throw aborted$1(algorithm, submitted.id);
+      }
+      options?.onProgress?.(iterationsRun, maxIterations);
+      const folded = PR_PARTIAL.read(new DataView(back), headerRequest.offset);
+      const firstConverged = folded.firstConverged;
+      const converged = firstConverged !== U32_MAX;
+      if (converged || iterationsRun >= maxIterations) {
+        const scores = dest ?? new Float32Array(n);
+        scores.set(new Float32Array(back, scoresRequest.offset, n));
+        if (converged && iterationsRun < maxIterations) {
+          options?.onProgress?.(maxIterations, maxIterations);
+        }
+        return {
+          scores,
+          iterations: converged ? firstConverged : iterationsRun,
+          converged,
+          danglingMass: folded.danglingMass,
+          precision: "f32"
+        };
+      }
+    }
+  } finally {
+    uploaded?.destroy();
+    scope.dispose();
+  }
+}
+function pageRank(ctx, s, options) {
+  return run(ctx, s, null, options, "pageRank");
+}
+async function personalizedPageRank(ctx, s, personalization, options) {
+  const n = s.nodeCount;
+  const invalid2 = (value, expected) => new WebGpuGraphError("E_INVALID_ARGUMENT", `personalizedPageRank: personalization must be ${expected}`, {
+    argument: "personalization",
+    value,
+    expected
+  });
+  if (!(personalization instanceof Float32Array) || personalization.length !== n) {
+    throw invalid2(`${personalization.constructor.name}(${personalization.length})`, `a Float32Array of length ${n}`);
+  }
+  let total = 0;
+  for (let v = 0; v < n; v++) {
+    const mass = personalization[v];
+    if (!Number.isFinite(mass) || mass < 0) {
+      throw invalid2(mass, "finite and non-negative in every entry");
+    }
+    total += mass;
+  }
+  if (n > 0 && !(total > 0)) {
+    throw invalid2(total, "a vector whose entries sum to a positive number");
+  }
+  const normalised2 = new Float32Array(n);
+  for (let v = 0; v < n; v++) {
+    normalised2[v] = personalization[v] / total;
+  }
+  return run(ctx, s, normalised2, options, "personalizedPageRank");
+}
+const BATCH = 8;
+const RING_SLOTS = 4 * BATCH + 8;
+function checkDest(dest, n, algorithm) {
+  if (dest === void 0) {
+    return null;
+  }
+  if (dest instanceof Float32Array && dest.length === n && dest.buffer instanceof ArrayBuffer) {
+    return dest;
+  }
+  throw new WebGpuGraphError(
+    "E_INVALID_ARGUMENT",
+    `${algorithm}: dest must be a Float32Array of length ${n} over an ArrayBuffer`,
+    {
+      argument: "dest",
+      value: `${dest.constructor.name}(${dest.length})`,
+      expected: `Float32Array(${n}) over an ArrayBuffer`
+    }
+  );
+}
+function coreOf(ctx, s, algorithm) {
+  try {
+    return ctx.residency.core(s);
+  } catch (error) {
+    if (isWebGpuGraphError(error) && error.code === "E_TOO_LARGE" && error.details.path === "windowed") {
+      throw new WebGpuGraphError(
+        "E_TOO_LARGE",
+        `${algorithm}: the arc arrays need a windowed upload, which P1-P3 plan but do not execute`,
+        { ...error.details, algorithm }
+      );
+    }
+    throw error;
+  }
+}
+function reverseOf(ctx, s) {
+  const view = ctx.residency.view(s, "reverse");
+  return coreOfView(view, view.scalars.arcCount[0]);
+}
+function aborted(algorithm, batchId) {
+  return new WebGpuGraphError(
+    "E_ABORTED",
+    `${algorithm}: the signal was aborted`,
+    batchId === void 0 ? {} : { batchId }
+  );
+}
+function whole(buffer, size) {
+  return { buffer, offset: 0, size, window: null };
+}
+async function runPowerIteration(ctx, n, config) {
+  const scope = algorithmScope(ctx, config.label, RING_SLOTS);
+  try {
+    const bytes = 4 * n;
+    const ring = (config.alternate === null ? ["rankA", "rankB"] : ["rankA", "rankB", "rankC"]).map(
+      (label) => whole(scope.scratch(bytes, label), bytes)
+    );
+    const xNorm = whole(scope.scratch(bytes, "xNorm"), bytes);
+    const scalePlan = plan1d(n, ctx.workgroupSize, ctx.caps);
+    const groups = groupsOf(scalePlan);
+    const partialsBytes = PR_PARTIAL.byteLength * (1 + groups);
+    const partialsBuffer = scope.scratch(partialsBytes, "partials");
+    const partials = whole(partialsBuffer, partialsBytes);
+    await ctx.allocator.check();
+    const pullOptions = { personalization: false, dangling: false, weights: config.weights, tiers: null };
+    const pulls = [{ core: config.adjacency, pull: await prepareSpmvPull(scope, config.adjacency, pullOptions) }];
+    if (config.alternate !== null) {
+      pulls.push({ core: config.alternate, pull: await prepareSpmvPull(scope, config.alternate, pullOptions) });
+    }
+    const scaleNorm = await ctx.pipelines.kernel(kernelSpec("pr-scale", { NORM_MODE: config.normMode }));
+    const scaleApply = config.normMode === 4 ? null : await ctx.pipelines.kernel(kernelSpec("pr-scale", { NORM_MODE: 3 }));
+    const finalize = await ctx.pipelines.kernel(kernelSpec("pr-finalize", { NORM_MODE: config.normMode }));
+    const finalizePlan = plan1d(1, ctx.workgroupSize, ctx.caps);
+    const { queue } = ctx.device;
+    queue.writeBuffer(ring[0].buffer, 0, new Float32Array(n).fill(1 / n));
+    for (const slot of ring.slice(1)) {
+      queue.writeBuffer(slot.buffer, 0, new Float32Array(n));
+    }
+    const header = new ArrayBuffer(PR_PARTIAL.byteLength);
+    PR_PARTIAL.write(new DataView(header), { firstConverged: U32_MAX, iteration: 0 });
+    queue.writeBuffer(partialsBuffer, 0, header);
+    const coefficients = { alpha: config.alpha, beta: config.beta, uniformP: config.uniformP };
+    let iterationsRun = 0;
+    for (; ; ) {
+      const k2 = Math.min(BATCH, config.maxIterations - iterationsRun);
+      const batch = new CommandBatch(ctx, config.label);
+      const pass = batch.pass("iterations");
+      for (let i = 0; i < k2; i++) {
+        const iteration = iterationsRun + i + 1;
+        const params = scope.params(PR_PARAMS, {
+          n,
+          groups,
+          iteration,
+          trackConvergence: 1,
+          convergeThreshold: config.tolerance * n
+        });
+        const rankIn = ring[(iteration - 1) % ring.length];
+        const rankOut = ring[iteration % ring.length];
+        const { core, pull } = pulls[(iteration - 1) % pulls.length];
+        const scaleBindings = { rankIn, rankPrev: rankOut, outWeightSum: rankIn, xNorm, partials, P: params.binding };
+        scaleNorm.dispatch(pass, scaleNorm.bind(scaleBindings), scalePlan, [params.offset]);
+        finalize.dispatch(pass, finalize.bind({ partials, P: params.binding }), finalizePlan, [params.offset]);
+        if (scaleApply !== null) {
+          scaleApply.dispatch(pass, scaleApply.bind(scaleBindings), scalePlan, [params.offset]);
+        }
+        pull.record(pass, core, { xNorm, rankOut, personalization: null, partials }, coefficients);
+      }
+      batch.endPass();
+      const headerRequest = batch.readback(partialsBuffer, 0, PR_PARTIAL.byteLength);
+      const scoresRequest = batch.readback(ring[(iterationsRun + k2) % ring.length].buffer, 0, bytes);
+      const previousRequest = config.alternate === null ? null : batch.readback(ring[(iterationsRun + k2 - 1) % ring.length].buffer, 0, bytes);
+      scope.flush();
+      const submitted = batch.submit();
+      const back = await submitted.readback;
+      iterationsRun += k2;
+      ctx.assertReady();
+      if (config.signal?.aborted === true) {
+        throw aborted(config.label, submitted.id);
+      }
+      config.onProgress?.(iterationsRun, config.maxIterations);
+      const folded = PR_PARTIAL.read(new DataView(back), headerRequest.offset);
+      const firstConverged = folded.firstConverged;
+      const converged = firstConverged !== U32_MAX;
+      if (converged || iterationsRun >= config.maxIterations) {
+        if (converged && iterationsRun < config.maxIterations) {
+          config.onProgress?.(config.maxIterations, config.maxIterations);
+        }
+        return {
+          scores: new Float32Array(back, scoresRequest.offset, n).slice(),
+          previous: previousRequest === null ? null : new Float32Array(back, previousRequest.offset, n).slice(),
+          iterations: converged ? firstConverged : iterationsRun,
+          converged,
+          iterationsRun
+        };
+      }
+    }
+  } finally {
+    scope.dispose();
+  }
+}
+function resolve(ctx, s, options, algorithm) {
+  ctx.assertReady();
+  const n = s.nodeCount;
+  const maxIterations = options?.maxIterations ?? 100;
+  const tolerance = options?.tolerance ?? 1e-6;
+  if (!Number.isInteger(maxIterations) || maxIterations < 1) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${algorithm}: maxIterations must be a positive integer`, {
+      argument: "maxIterations",
+      value: maxIterations,
+      expected: "a positive integer"
+    });
+  }
+  const dest = checkDest(options?.dest, n, algorithm);
+  if (options?.signal?.aborted) {
+    throw aborted(algorithm);
+  }
+  return { n, maxIterations, tolerance, weights: options?.weighted === false ? null : void 0, dest };
+}
+function finite(value, fallback, argument) {
+  const resolved = value ?? fallback;
+  if (!Number.isFinite(resolved)) {
+    throw new WebGpuGraphError("E_INVALID_ARGUMENT", `katzCentrality: ${argument} must be a finite number`, {
+      argument,
+      value: resolved,
+      expected: "a finite number"
+    });
+  }
+  return resolved;
+}
+function normalised(raw, dest, norm) {
+  let acc = 0;
+  for (const v of raw) {
+    acc += norm === "sum" ? Math.abs(v) : v * v;
+  }
+  const scale = norm === "sum" ? acc : Math.sqrt(acc);
+  const out = dest ?? raw;
+  for (let v = 0; v < raw.length; v++) {
+    out[v] = scale > 0 ? raw[v] / scale : raw[v];
+  }
+  return out;
+}
+function scoresOf(run2, dest, norm) {
+  return {
+    scores: normalised(run2.scores, dest, norm),
+    iterations: run2.iterations,
+    converged: run2.converged,
+    precision: "f32"
+  };
+}
+function empty(dest, total, onProgress) {
+  onProgress?.(total, total);
+  return { scores: dest ?? new Float32Array(0), iterations: 0, converged: true, precision: "f32" };
+}
+function latestOfKind(sameSeed, otherSeed) {
+  const fromSame = sameSeed.iterationsRun % 2 === 0 ? sameSeed.iterationsRun : sameSeed.iterationsRun - 1;
+  const fromOther = otherSeed.iterationsRun % 2 === 1 ? otherSeed.iterationsRun : otherSeed.iterationsRun - 1;
+  const chain = fromSame >= fromOther ? sameSeed : otherSeed;
+  const index = Math.max(fromSame, fromOther);
+  return (index === chain.iterationsRun ? chain.scores : chain.previous) ?? chain.scores;
+}
+async function eigenvectorCentrality(ctx, s, options) {
+  const algorithm = "eigenvectorCentrality";
+  const r = resolve(ctx, s, options, algorithm);
+  if (r.n === 0) {
+    return empty(r.dest, r.maxIterations, options?.onProgress);
+  }
+  const run2 = await runPowerIteration(ctx, r.n, {
+    normMode: 2,
+    adjacency: coreOf(ctx, s, algorithm),
+    alternate: null,
+    alpha: 1,
+    beta: 0,
+    uniformP: 0,
+    maxIterations: r.maxIterations,
+    tolerance: r.tolerance,
+    weights: r.weights,
+    label: algorithm,
+    signal: options?.signal,
+    onProgress: options?.onProgress
+  });
+  return scoresOf(run2, r.dest, "l2");
+}
+async function katzCentrality(ctx, s, options) {
+  const algorithm = "katzCentrality";
+  const alpha = finite(options?.alpha, 0.1, "alpha");
+  const beta = finite(options?.beta, 1, "beta");
+  const r = resolve(ctx, s, options, algorithm);
+  if (r.n === 0) {
+    return empty(r.dest, r.maxIterations, options?.onProgress);
+  }
+  const run2 = await runPowerIteration(ctx, r.n, {
+    normMode: 4,
+    adjacency: reverseOf(ctx, s),
+    alternate: null,
+    alpha,
+    beta,
+    uniformP: 1,
+    maxIterations: r.maxIterations,
+    tolerance: r.tolerance,
+    weights: r.weights,
+    label: algorithm,
+    signal: options?.signal,
+    onProgress: options?.onProgress
+  });
+  return scoresOf(run2, r.dest, "l2");
+}
+async function hits(ctx, s, options) {
+  const algorithm = "hits";
+  const r = resolve(ctx, s, options, algorithm);
+  const total = 2 * r.maxIterations;
+  if (r.n === 0) {
+    const { scores, iterations, converged, precision } = empty(r.dest, total, options?.onProgress);
+    return { hubs: scores, authorities: new Float32Array(0), iterations, converged, precision };
+  }
+  const onProgress = options?.onProgress;
+  const shared = {
+    normMode: 1,
+    alpha: 1,
+    beta: 0,
+    uniformP: 0,
+    maxIterations: r.maxIterations,
+    tolerance: r.tolerance,
+    weights: r.weights,
+    signal: options?.signal
+  };
+  const forward = coreOf(ctx, s, algorithm);
+  const reverse = reverseOf(ctx, s);
+  const hubSeeded = await runPowerIteration(ctx, r.n, {
+    ...shared,
+    adjacency: reverse,
+    alternate: forward,
+    label: `${algorithm}/hub-seeded`,
+    onProgress: onProgress === void 0 ? void 0 : (done) => {
+      onProgress(done, total);
+    }
+  });
+  const authoritySeeded = await runPowerIteration(ctx, r.n, {
+    ...shared,
+    adjacency: forward,
+    alternate: reverse,
+    label: `${algorithm}/authority-seeded`,
+    onProgress: onProgress === void 0 ? void 0 : (done) => {
+      onProgress(r.maxIterations + done, total);
+    }
+  });
+  return {
+    hubs: normalised(latestOfKind(hubSeeded, authoritySeeded), r.dest, "sum"),
+    authorities: normalised(latestOfKind(authoritySeeded, hubSeeded), null, "sum"),
+    iterations: Math.max(hubSeeded.iterations, authoritySeeded.iterations),
+    converged: hubSeeded.converged && authoritySeeded.converged,
+    precision: "f32"
+  };
+}
 const LCG_M = 34359738337;
 const LCG_A = 185852;
 const LCG_C = 1;
@@ -1710,7 +3152,7 @@ function seedPositions(s, positions, seed, dim, scale, center, range) {
   let finiteRows = 0;
   let unseededRows = 0;
   for (let i = 0; i < n; i++) {
-    let finite = true;
+    let finite2 = true;
     for (let axis = 0; axis < dim; axis++) {
       const v = positions[3 * i + axis];
       if (Number.isFinite(v)) {
@@ -1721,10 +3163,10 @@ function seedPositions(s, positions, seed, dim, scale, center, range) {
           hi[axis] = v;
         }
       } else {
-        finite = false;
+        finite2 = false;
       }
     }
-    if (finite) {
+    if (finite2) {
       finiteRows++;
     } else {
       unseededRows++;
@@ -1837,7 +3279,7 @@ function fieldTypeOf(block, field) {
     throw invalidArgument(
       "field",
       field,
-      block.fields.map((f2) => f2[0]),
+      block.fields.map((f) => f[0]),
       `block ${block.name} has no field ${field}`
     );
   }
@@ -1950,7 +3392,7 @@ class HeaderWriter {
       throw invalidArgument(
         "field",
         field,
-        this.block.fields.map((f2) => f2[0]),
+        this.block.fields.map((f) => f[0]),
         `state block has no field ${field}`
       );
     }
@@ -2002,8 +3444,8 @@ class HeaderWriter {
 function createPending(k2, generation) {
   let resolveFn = () => void 0;
   let rejectFn = () => void 0;
-  const promise = new Promise((resolve, reject) => {
-    resolveFn = resolve;
+  const promise = new Promise((resolve2, reject) => {
+    resolveFn = resolve2;
     rejectFn = reject;
   });
   return {
@@ -2034,7 +3476,7 @@ class ForceSimulation {
    * @param tuning - the resolved GPU tuning
    * @param resolve - how setParams merges a patch into the current record
    */
-  constructor(ctx, model, options, tuning, resolve) {
+  constructor(ctx, model, options, tuning, resolve2) {
     this.overrideList = /* @__PURE__ */ new Map();
     this.pending = [];
     this.stateValue = "created";
@@ -2109,7 +3551,7 @@ class ForceSimulation {
     this.ctx = ctx;
     this.model = model;
     this.tuning = tuning;
-    this.resolveOptions = resolve;
+    this.resolveOptions = resolve2;
     this.optionsValue = options;
     this.maxInFlight = maxInFlight;
     this.dimValue = dim;
@@ -3299,8 +4741,8 @@ class ForceSimulation {
    */
   startBind(resources, overrides) {
     const generation = this.generationValue;
-    const run = () => this.compileAndBind(resources, overrides, generation);
-    const promise = this.ready.catch(() => void 0).then(run);
+    const run2 = () => this.compileAndBind(resources, overrides, generation);
+    const promise = this.ready.catch(() => void 0).then(run2);
     void promise.catch(() => void 0);
     this.ready = promise;
   }
@@ -4416,6 +5858,79 @@ function createAccelerator(ctx, options) {
       ctx.assertReady();
       return createForceAtlas2(ctx, { ...o, ...frozen.layout });
     },
+    /**
+     * PageRank on the device (spec 8.2; contract 3.14).
+     * @param gs - the snapshot
+     * @param o - the CPU option record (spec 9.2 PageRankOptions)
+     * @returns the f32 scores with `precision: "f32"` (spec 9.7)
+     */
+    async pageRank(gs, o) {
+      ctx.assertReady();
+      return await pageRank(ctx, gs, o);
+    },
+    /**
+     * Personalized PageRank on the device (spec 8.2; contract 3.14). The mirror admits an f64 personalization
+     * (spec 9.2 `F32 | F64`); the kernel reads f32, so an f64 vector is narrowed on the host first.
+     * @param gs - the snapshot
+     * @param personalization - one finite non-negative mass per node, not all zero
+     * @param o - the CPU option record (spec 9.2 PageRankOptions)
+     * @returns the f32 scores with `precision: "f32"` (spec 9.7)
+     */
+    async personalizedPageRank(gs, personalization, o) {
+      ctx.assertReady();
+      const mass = personalization instanceof Float32Array ? personalization : Float32Array.from(personalization);
+      return await personalizedPageRank(ctx, gs, mass, o);
+    },
+    /**
+     * HITS hubs and authorities on the device (spec 8.2; contract 3.14).
+     * @param gs - the snapshot
+     * @param o - the CPU option record (spec 9.2 HitsOptions)
+     * @returns hubs and authorities with `precision: "f32"` (spec 9.7)
+     */
+    async hits(gs, o) {
+      ctx.assertReady();
+      return await hits(ctx, gs, o);
+    },
+    /**
+     * Eigenvector centrality on the device (spec 8.2; contract 3.14).
+     * @param gs - the snapshot
+     * @param o - the CPU option record (spec 9.2 EigenvectorOptions)
+     * @returns the f32 scores with `precision: "f32"` (spec 9.7)
+     */
+    async eigenvectorCentrality(gs, o) {
+      ctx.assertReady();
+      return await eigenvectorCentrality(ctx, gs, o);
+    },
+    /**
+     * Katz centrality on the device (spec 8.2; contract 3.14).
+     * @param gs - the snapshot
+     * @param o - the CPU option record (spec 9.2 KatzOptions)
+     * @returns the f32 scores with `precision: "f32"` (spec 9.7)
+     */
+    async katzCentrality(gs, o) {
+      ctx.assertReady();
+      return await katzCentrality(ctx, gs, o);
+    },
+    /**
+     * Weakly connected components on the device (spec 8.3; contract 3.14): WCC semantics on directed input.
+     * @param gs - the snapshot
+     * @param o - `renumber` (default true); the mirror passes none
+     * @returns the labels, the count and groups() (spec 9.7 LabelResultLike)
+     */
+    async connectedComponents(gs, o) {
+      ctx.assertReady();
+      return await connectedComponents(ctx, gs, o);
+    },
+    /**
+     * The same algorithm as `connectedComponents` under the mirror's other name (spec 3.3, 9.2).
+     * @param gs - the snapshot
+     * @param o - `renumber` (default true); the mirror passes none
+     * @returns the labels, the count and groups() (spec 9.7 LabelResultLike)
+     */
+    async weaklyConnectedComponents(gs, o) {
+      ctx.assertReady();
+      return await connectedComponents(ctx, gs, o);
+    },
     /**
      * Destroys every device buffer recorded for the snapshot (spec 4.5); delegates to ctx.release.
      * @param s - the snapshot the app is done with
@@ -4439,16 +5954,22 @@ export {
   LAYOUT_TUNING_DEFAULTS,
   MAX_1D_ITEMS,
   MAX_WORKGROUPS_PER_DIM,
-  f as PASSTHROUGH_FORMAT_CODES,
-  g as STORAGE_ALIGN,
-  j as WORKGROUP_SIZE,
+  g as PASSTHROUGH_FORMAT_CODES,
+  j as STORAGE_ALIGN,
+  k as WORKGROUP_SIZE,
   WebGpuGraphError,
+  connectedComponents,
   createAccelerator,
   createForceAtlas2,
   degree,
+  eigenvectorCentrality,
   hasErrorCode,
-  k as isSoftwareAdapter,
+  hits,
+  l as isSoftwareAdapter,
   isWebGpuGraphError,
+  katzCentrality,
+  pageRank,
+  personalizedPageRank,
   seedPositions
 };
 //# sourceMappingURL=webgpu-graph-algorithms.js.map