@graphty/webgpu-graph-algorithms 0.6.3 → 0.6.4

package/dist/src/algorithms/bfs.js

@@ -0,0 +1,534 @@
+/**
+ * Breadth-first search on the device (design 8.4, 3.3 line 807, 9.7; P8-T6 / P8-T7 / P8-T8, the P8 plan's PD-5 /
+ * PD-6 / PD-7 / PD-14 / PD-18 / PD-21 / PD-23 / PD-24 / PD-26 / DEP-P8-B): the direction-optimizing traversal over
+ * the `Frontier` of P8-T4, every per-level choice made ON THE DEVICE. Every level is eight recorded dispatches, all
+ * DIRECT (2026-09-25, docs/decisions/G8.md G8-F5: Dawn validates every `dispatchWorkgroupsIndirect` with an internal
+ * clamp pass costing about 0.4 ms of device time whether or not it dispatches anything, in Node and in Chromium
+ * alike, and that was 97 % of a traversal's wall time) -- `frontier-finalize` role 0 (the level boundary: rotates
+ * the counts, advances `level`, decides `done`, evaluates Beamer's test and CHOOSES, writing the choice into the
+ * block's `path` word: 3 bottom-up, 2 fused for a top-down frontier below `fusedMax` entries, 1 two-phase for any
+ * other, 0 done), `advance-expand` (the frontier's rows into the edge queue), `frontier-finalize` role 1 (clamps
+ * `edgeCount`, or, when the edge queue overflowed, sets `path` 4 for the fused retry, PD-23), `bfs-contract` (the
+ * claim `atomicMin(&depth[v], level + 1)`, the winners packed into the next vertex queue), `bfs-fused` (one workgroup
+ * per frontier entry with the same claim inline and no edge queue; the fused level and the retry alike), then the
+ * bottom-up trio: a `fill` zeroing the frontier bitset, `bfs-bitset-build` setting the frontier's bits, and
+ * `bfs-bottom-up` sweeping the unvisited list over the REVERSE core (each unvisited vertex reads its in-neighbours
+ * until the first one in the bitset and claims itself). Every kernel is a grid-stride dispatch of a host-planned
+ * grid (`planGridStride`) that loops to its count word and reads the path word first, so exactly one path does the
+ * level's work and the others cost one uniform load per workgroup. The unvisited set Beamer's test is against (PD-18) is rebuilt exactly once per submit, before
+ * the levels, by `bfs-unvisited-flags` plus `compact` over an iota queue, and maintained between rebuilds by
+ * subtraction inside the selector (whose JSDoc states the boundary rule). The host records `MAX_LEVELS_PER_SUBMIT`
+ * levels into ONE command buffer, submits, and reads four bytes, the `done` word (PD-7): a road network has
+ * thousands of levels and a per-level `mapAsync` would be slower than the CPU. A level recorded past the end is a
+ * no-op (its boundary finds `done` set, zeroes its slots and moves no counter), so the loop needs no diameter and
+ * ends on `done`; a traversal has at most `n` levels, so more submits than that is E_VALIDATION, never a hang. The
+ * thresholds are uniform fields (`FUSED_FRONTIER_MAX`; alpha derived as `max(1, floor(arcCount / n))`, PD-21;
+ * `BEAMER_BETA`; `mode 1` pinning top-down -- each unless the tuning says otherwise), so a test forces any path
+ * without recompiling; the block's `fusedLevels` / `twoPhaseLevels` / `bottomUpLevels` / `overflowLevels` /
+ * `switches` words record which path each level took.
+ *
+ * There is no dedupe (DEP-P8-B, PD-5): the edge queue holds duplicates -- a vertex with three frontier neighbours
+ * appears three times -- but for one level exactly one invocation observes `INVALID_INDEX` at `depth[v]` and
+ * exactly that one appends `v`, so the next vertex frontier is duplicate-free by construction and an ownership
+ * dedupe would have nothing to remove. `parent` is not written by the claim (PD-24): `sssp-pred` in `MODE 1` runs
+ * once over the settled depths and writes the SMALLEST `u` with `depth[u] + 1 == depth[v]` and an arc `u -> v`, so
+ * it is bitwise reproducible where a claim-time parent would be a scheduling accident. `order` (PD-14) is one
+ * stable radix sort of the node indices by `depth`: grouped by level, ascending by index within a level,
+ * `INVALID_INDEX` last, and the first `visitedCount` values are the result. The result batch stages every array
+ * into one staging slot, so a traversal maps `ceil(levels / 32) + 1` buffers in all.
+ *
+ * `maxDepth` reaches the device as a `u32` field of `FrontierParams`, and the uniform writer refuses anything that
+ * is not an integer in `[0, 2^32 - 1]`; the host therefore normalises it first, to exactly the CPU port's rule
+ * (`algorithms/src/indexed/bfs.ts`: a node at depth `d >= maxDepth` is reached and not expanded, unbounded when
+ * absent). The tuning entry `bfsWithTuning` (PD-26) is what the tests drive; nothing public exposes it.
+ *
+ * A core whose `colIdx` exceeds `maxStorageBufferBindingSize` is bound as arc windows and EXECUTED (P8-T12, DEP-P8-E
+ * lifted for the frontier family): `advance-expand`, `bfs-fused` and `sssp-pred` run once per window of the
+ * forward core and `bfs-bottom-up` once per window of the reverse core, every window its own dispatch with its own
+ * `FrontierParams` record carrying the window's owned arc range (`coreWindows`), and the claims, being `atomicMin`s
+ * and an `INVALID_INDEX` entry test, are idempotent across windows. The ring is sized per run by `bfsRingSlots`.
+ */
+import { INVALID_INDEX } from "@graphty/graph-format";
+import { BEAMER_BETA, FUSED_FRONTIER_MAX, MAX_LEVELS_PER_SUBMIT, U32_MAX } from "../constants.js";
+import { WebGpuGraphError } from "../errors.js";
+import { CommandBatch } from "../kernel/batch.js";
+import { plan1d, planGridStride } from "../kernel/dispatch.js";
+import { FILL_PARAMS, FRONTIER_COUNTERS, FRONTIER_PARAMS, graphBindings, graphOverrides, kernelSpec, } from "../kernels.js";
+import { prepareAdvance } from "../primitives/advance.js";
+import { prepareCompact } from "../primitives/compact.js";
+import { coreOfView, coreWindows } from "../primitives/core-shape.js";
+import { prepareFrontier, W } from "../primitives/frontier.js";
+import { prepareRadixSort, radixHistBytes } from "../primitives/radix-sort.js";
+import { assertDeviceComputes } from "../primitives/verify.js";
+import { algorithmScope } from "./scope.js";
+const ALGORITHM = "breadthFirstSearch";
+/**
+ * Params slots of the ring, COUNTED per run (P8-T12), because `UniformRing.reserve` wraps to slot 0 when a submit's
+ * records outrun the ring and silently overwrites a record the submit still reads; the ring's `overruns` counts
+ * exactly that reuse, `AlgorithmScope.ringOverruns()` exposes it, and the faked-limit test holds it at 0 for the
+ * whole run. The bound per level is `5 + 4 x windows`: five recorded once per level (`frontier-finalize` twice,
+ * `bfs-contract`, the bits `fill`, `bfs-bitset-build`) and four re-issued once per arc window (`advance-expand`,
+ * `bfs-fused`, the fused retry, `bfs-bottom-up`). The driver as built writes fewer -- the contract and the bitset
+ * build share one window-free record, a window's two fused dispatches share one, the bits fill has one record per
+ * submit, and a directed snapshot's reverse view is one window whatever the forward core's count -- so at most
+ * `3 + 3 x windows` per level, and the bound holds with room. The 16 covers the per-submit rebuild
+ * (`bfs-unvisited-flags` and `compact`, whose scan is at most 9 dispatches for any n below 2^32, so 10, plus the
+ * bits fill). The result batch flushes in its own submit, so the ring must hold IT too, and its size grows with `n`,
+ * not with the cadence: the iota `fill`, the radix sort's four passes of one record plus its scan's `2 x levels - 1`
+ * (the table is `256 x ceil(n / WG)` words and a level covers `WG` of them, so four levels for any n below 2^32 at
+ * the package's WG of 256), the `pred` `fill` and `sssp-pred` once per window -- `2 + 4 x 8 + windows = 34 + windows`
+ * at most, which a small cadence undercuts (built 2026-09-25: `(5 + 4) x 1 + 16 = 25` slots against the 27 a
+ * 262,143-node result batch records wrapped over the radix sort's own records and returned a wrong `order`, silently
+ * -- the plan's `19 + windows` count had no scan level in it). The slot count is therefore the larger of the two
+ * batches. At one window and `MAX_LEVELS_PER_SUBMIT` it is P8-T6's 304; test/device/constants.test.ts pins the
+ * arithmetic.
+ * @internal
+ * @param windows - the forward core's arc windows (1 when it is not windowed)
+ * @param levelsPerSubmit - the levels recorded per submit
+ * @returns the ring's slot count
+ */
+export function bfsRingSlots(windows, levelsPerSubmit) {
+    return Math.max((5 + 4 * windows) * levelsPerSubmit + 16, RESULT_BATCH_SLOTS + windows);
+}
+/** The result batch's records before its per-window `sssp-pred` dispatches: two `fill`s and the 32-bit radix sort's four passes of at most eight records each (see `bfsRingSlots`). */
+const RESULT_BATCH_SLOTS = 2 + 4 * 8;
+/**
+ * The CPU port's `maxDepth` as a `u32`: `U32_MAX` (no cap) when absent, `NaN` (`d >= NaN` never holds) or at or
+ * above `U32_MAX` (which covers `Infinity`); otherwise `max(0, ceil(maxDepth))` -- `2.5` behaves as 3 because
+ * `d >= 2.5` first holds at `d == 3`, and a negative value gives 0, the source alone, because `0 >= -1` already holds.
+ * @param maxDepth - the caller's option
+ * @returns the value the uniform carries
+ */
+function normaliseMaxDepth(maxDepth) {
+    if (maxDepth === undefined || Number.isNaN(maxDepth) || maxDepth >= U32_MAX) {
+        return U32_MAX;
+    }
+    return Math.max(0, Math.ceil(maxDepth));
+}
+/**
+ * Validates `options.dest` for a depth result of `n` elements.
+ * @param dest - the caller's destination array, if any
+ * @param n - the node count
+ * @returns the destination as a U32, or null when none was given
+ */
+function checkDest(dest, n) {
+    if (dest === undefined) {
+        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`,
+    });
+}
+/**
+ * Whole-buffer binding of a scratch buffer over its first `size` bytes.
+ * @param buffer - the buffer
+ * @param size - the bound byte length
+ * @returns the binding
+ */
+function bindingOf(buffer, size) {
+    return { buffer, offset: 0, size, window: null };
+}
+/**
+ * A degree view's one array on the device (the `outDegree` / `inDegree` views of P7, one u32 per vertex).
+ * @param ctx - the context
+ * @param s - the snapshot
+ * @param name - the view
+ * @returns the binding
+ */
+function degreeView(ctx, s, name) {
+    const { bindings } = ctx.residency.view(s, name);
+    const { [name]: binding } = bindings;
+    if (binding === undefined) {
+        throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM}: the ${name} view has no ${name} binding`, {
+            label: `${ALGORITHM}/${name}`,
+            message: `the ${name} view has no ${name} binding`,
+        });
+    }
+    return binding;
+}
+/**
+ * The E_ABORTED error of a signal.
+ * @param batchId - the last submitted batch, when one exists
+ * @returns the error
+ */
+function aborted(batchId) {
+    return new WebGpuGraphError("E_ABORTED", `${ALGORITHM}: the signal was aborted`, batchId === undefined ? {} : { batchId });
+}
+/**
+ * One scalar word of a decoded block (every FrontierCounters field is a u32, so anything else is a decoder bug).
+ * @param block - the decoded block
+ * @param name - the field
+ * @returns the word
+ */
+function wordOf(block, name) {
+    const value = block[name];
+    if (typeof value !== "number") {
+        throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM}: counters.${name} did not decode to a number`, {
+            label: `${ALGORITHM}/counters`,
+            message: `the field ${name} did not decode to a number`,
+        });
+    }
+    return value;
+}
+/**
+ * Breadth-first search with the test knobs of PD-26; `breadthFirstSearch` is this with an empty tuning.
+ * @internal
+ * @param ctx - the context whose device runs the kernels
+ * @param s - the snapshot (uploaded through ctx.residency, or found there)
+ * @param source - the source node index
+ * @param options - `maxDepth`, plus dest / signal / onProgress
+ * @param tuning - the knobs
+ * @returns the depths, parents, order, visited count, level count and switches
+ */
+export async function bfsWithTuning(ctx, s, source, options, tuning) {
+    ctx.assertReady();
+    await assertDeviceComputes(ctx);
+    const n = s.nodeCount;
+    if (!Number.isInteger(source) || source < 0 || source >= n) {
+        throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM}: source ${source} is outside [0, ${n})`, {
+            argument: "source",
+            value: source,
+            expected: `an integer in [0, ${n})`,
+        });
+    }
+    const levelsPerSubmit = tuning.levelsPerSubmit ?? MAX_LEVELS_PER_SUBMIT;
+    if (!Number.isInteger(levelsPerSubmit) || levelsPerSubmit < 1 || levelsPerSubmit > MAX_LEVELS_PER_SUBMIT) {
+        throw new WebGpuGraphError("E_INVALID_ARGUMENT", `${ALGORITHM}: levelsPerSubmit must be an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`, {
+            argument: "levelsPerSubmit",
+            value: levelsPerSubmit,
+            expected: `an integer in [1, ${MAX_LEVELS_PER_SUBMIT}]`,
+        });
+    }
+    const dest = checkDest(options?.dest, n);
+    const maxDepth = normaliseMaxDepth(options?.maxDepth);
+    const predKind = tuning.predKind ?? 1;
+    if (options?.signal?.aborted) {
+        throw aborted();
+    }
+    const core = ctx.residency.core(s);
+    // a windowed core (colIdx above the binding limit) is executed, not refused (P8-T12 lifts DEP-P8-E): every
+    // frontier-walking kernel is dispatched once per arc window with the window's owned range in its record
+    const forward = coreWindows(core);
+    // the bottom-up sweep walks in-neighbours over the reverse core: on an undirected snapshot the forward arrays
+    // themselves (graph-format invariant I7; P7's residency aliases them, so a windowed core's windows ARE the
+    // reverse's), on a directed one the reverse VIEW, which spec 4.3 never windows -- so a directed snapshot whose
+    // reverse adjacency exceeds one binding is refused here, as the residency refuses the undirected view, instead
+    // of failing at the device's bind-group validation
+    if (s.directed && 4 * s.arcCount > ctx.caps.limits.maxStorageBufferBindingSize) {
+        throw new WebGpuGraphError("E_TOO_LARGE", `${ALGORITHM}: the reverse adjacency of a directed snapshot (${4 * s.arcCount} bytes) needs arc windows, which no view executes (spec 4.3); the bottom-up sweep binds it whole`, {
+            needed: 4 * s.arcCount,
+            limit: ctx.caps.limits.maxStorageBufferBindingSize,
+            path: "windowed",
+            algorithm: ALGORITHM,
+        });
+    }
+    const reverse = s.directed ? coreOfView(ctx.residency.view(s, "reverse"), s.arcCount) : core;
+    const backward = coreWindows(reverse);
+    // the two degree views the unvisited rebuild reads (P8-T8)
+    const outDegree = degreeView(ctx, s, "outDegree");
+    const inDegree = degreeView(ctx, s, "inDegree");
+    const scope = algorithmScope(ctx, ALGORITHM, bfsRingSlots(forward.length, levelsPerSubmit));
+    tuning.onScope?.(scope);
+    try {
+        const bytes = 4 * n;
+        const wg = ctx.workgroupSize;
+        const depth = bindingOf(scope.scratch(bytes, "depth"), bytes);
+        // the sweep's input, one buffer in two regions: the unvisited list at word 0 and the frontier bitset at
+        // word bitsBase = roundUp(n, 64), so the bits region's byte offset is 256-aligned and fill can bind it alone
+        const bitsBase = Math.ceil(n / 64) * 64;
+        const bitsWords = Math.ceil(n / 32);
+        const sweepBytes = 4 * (bitsBase + bitsWords);
+        const sweepIn = bindingOf(scope.scratch(sweepBytes, "sweep-in"), sweepBytes);
+        const unvisitedList = { buffer: sweepIn.buffer, offset: 0, size: bytes, window: null };
+        const frontierBits = {
+            buffer: sweepIn.buffer,
+            offset: 4 * bitsBase,
+            size: 4 * bitsWords,
+            window: null,
+        };
+        const flags = bindingOf(scope.scratch(bytes, "unvisited-flags"), bytes);
+        const iota = bindingOf(scope.scratch(bytes, "iota"), bytes);
+        const compactCount = bindingOf(scope.scratch(4, "compact-count"), 4);
+        await ctx.allocator.check();
+        const planner = await prepareFrontier(scope, n, s.arcCount, tuning.edgeCapacity);
+        const advance = await prepareAdvance(scope, core);
+        const compact = await prepareCompact(scope);
+        const contract = await ctx.pipelines.kernel(kernelSpec("bfs-contract"));
+        const fused = await ctx.pipelines.kernel(kernelSpec("bfs-fused", graphOverrides(core, null)));
+        const bitset = await ctx.pipelines.kernel(kernelSpec("bfs-bitset-build"));
+        const bottomUp = await ctx.pipelines.kernel(kernelSpec("bfs-bottom-up", graphOverrides(reverse, null)));
+        const unvisited = await ctx.pipelines.kernel(kernelSpec("bfs-unvisited-flags"));
+        const pred = await ctx.pipelines.kernel(kernelSpec("sssp-pred", { ...graphOverrides(core, null), MODE: 1 }));
+        const fill = await ctx.pipelines.kernel(kernelSpec("fill"));
+        const sort = await prepareRadixSort(scope);
+        const { frontier } = planner;
+        const { counters } = frontier;
+        const { queue } = ctx.device;
+        const fillPlan = plan1d(n, wg, ctx.caps);
+        // the level kernels are DIRECT grid-stride dispatches gated by the selector's path word (word 24): the plan
+        // bounds the grid, the kernel loops to its count word. The contract walks the edge queue and the bitset build
+        // the frontier from one record, so one plan covers both; bfs-fused is one workgroup per entry and takes the
+        // plan's GROUP count as its stride (planGridStride's cap applies to the groups)
+        const levelPlan = planGridStride(Math.max(n, frontier.edgeCapacity), wg, ctx.caps);
+        const sweepPlan = planGridStride(n, wg, ctx.caps);
+        const fusedPlan = planGridStride(n * wg, wg, ctx.caps);
+        const bitsPlan = plan1d(bitsWords, wg, ctx.caps);
+        const recordFill = (pass, dst, value, mode) => {
+            const params = scope.params(FILL_PARAMS, { count: n, value, mode, pad0: 0 });
+            fill.dispatch(pass, fill.bind({ dst, P: params.binding }), fillPlan, [params.offset]);
+        };
+        const flagsPlan = planGridStride(n, wg, ctx.caps);
+        /**
+         * The rebuild of the unvisited set (PD-18), recorded at the top of every submit before its levels.
+         * @param pass - the compute pass
+         */
+        const recordRebuild = (pass) => {
+            const params = scope.params(FRONTIER_PARAMS, { wg, n, stride: flagsPlan.stride ?? n });
+            const bound = unvisited.bind({ outDegree, inDegree, depth, flags, counters, P: params.binding });
+            unvisited.dispatch(pass, bound, flagsPlan, [params.offset]);
+            compact.record(pass, {
+                queue: iota,
+                flags,
+                count: n,
+                out: unvisitedList,
+                outCount: compactCount,
+                outIndex: 0,
+            });
+        };
+        const submit = (batch) => {
+            scope.flush();
+            return batch.submit();
+        };
+        // setup: depth = INVALID_INDEX everywhere and the iota queue compact reads; then the source at 0 and the
+        // seeded block, both queue writes ordered before the first level submit (the seed is rotated in by the
+        // first boundary, P8-T4)
+        const setup = new CommandBatch(ctx, `${ALGORITHM}/setup`);
+        const setupPass = setup.pass("fill");
+        recordFill(setupPass, depth, INVALID_INDEX, 0);
+        recordFill(setupPass, iota, 0, 1);
+        setup.endPass();
+        await submit(setup).readback;
+        ctx.assertReady();
+        queue.writeBuffer(depth.buffer, depth.offset + 4 * source, Uint32Array.of(0));
+        frontier.reset(queue, source, { nextFrontierCount: 1, level: U32_MAX });
+        // the levels: MAX_LEVELS_PER_SUBMIT per submit, four bytes back (PD-7); Beamer's test chooses the direction
+        // per level (mode 0; mode 1 pins top-down), with the fused path below fusedMax (P8-T7)
+        const fields = {
+            mode: tuning.direction === "top-down" ? 1 : 0,
+            alpha: tuning.alpha ?? Math.max(1, Math.floor(s.arcCount / n)),
+            beta: tuning.beta ?? BEAMER_BETA,
+            fusedMax: tuning.fusedMax ?? FUSED_FRONTIER_MAX,
+            maxDepth,
+        };
+        let levelsRecorded = 0;
+        let submits = 0;
+        for (;;) {
+            // the rebuild (PD-18): the three unvisited words zeroed by a queue write ordered before this submit,
+            // then the flags kernel and compact at the top of the pass, unconditionally, never per level
+            queue.writeBuffer(counters.buffer, counters.offset + 4 * W.unvisitedCount, new Uint32Array(3));
+            const batch = new CommandBatch(ctx, `${ALGORITHM}/levels`);
+            const pass = batch.pass("bfs");
+            recordRebuild(pass);
+            const bitsParams = scope.params(FILL_PARAMS, { count: bitsWords, value: 0, mode: 0, pad0: 0 });
+            const boundBitsFill = fill.bind({ dst: frontierBits, P: bitsParams.binding });
+            for (let level = 0; level < levelsPerSubmit; level++) {
+                planner.recordFinalize(pass, 0, level, { ...fields, firstOfSubmit: Math.min(level, 2) });
+                advance.record(pass, frontier);
+                planner.recordFinalize(pass, 1, level, fields);
+                // one window-free record serves the contract and the bitset build, which read no arc; the kernels that
+                // walk arcs (the fused dispatch, the sweep) get one record per window below (P8-T12)
+                const params = scope.params(FRONTIER_PARAMS, {
+                    wg,
+                    n,
+                    edgeCapacity: frontier.edgeCapacity,
+                    arcBase: 0,
+                    arcEnd: s.arcCount,
+                    bitsBase,
+                    stride: levelPlan.stride ?? wg,
+                });
+                const boundContract = contract.bind({
+                    edgeQueue: frontier.edgeQueue,
+                    counters,
+                    depth,
+                    frontierOut: frontier.output,
+                    P: params.binding,
+                });
+                contract.dispatch(pass, boundContract, levelPlan, [params.offset]);
+                // the fused path (role 0's choice) and the overflow retry (role 1's, PD-23): ONE dispatch per window that
+                // the path word turns into the level's work or into nothing (the claim is idempotent across windows)
+                for (const w of forward) {
+                    const fusedParams = scope.params(FRONTIER_PARAMS, {
+                        wg,
+                        n,
+                        edgeCapacity: frontier.edgeCapacity,
+                        arcBase: w.arcBase,
+                        arcEnd: w.arcEnd,
+                        stride: fusedPlan.x * fusedPlan.y,
+                    });
+                    const boundFused = fused.bind({
+                        ...graphBindings(w.core, null),
+                        frontierIn: frontier.input,
+                        counters,
+                        depth,
+                        frontierOut: frontier.output,
+                        P: fusedParams.binding,
+                    });
+                    fused.dispatch(pass, boundFused, fusedPlan, [fusedParams.offset]);
+                }
+                // the bottom-up level (role 0's choice under Beamer's test, P8-T8): the bitset zeroed (every level: a
+                // top-down level zeroes bits nobody reads, cheaper than a gate), the frontier's bits set, the unvisited
+                // list swept over the reverse core
+                fill.dispatch(pass, boundBitsFill, bitsPlan, [bitsParams.offset]);
+                const boundBitset = bitset.bind({
+                    frontierIn: frontier.input,
+                    counters,
+                    bits: sweepIn,
+                    P: params.binding,
+                });
+                bitset.dispatch(pass, boundBitset, levelPlan, [params.offset]);
+                // the sweep once per window of the REVERSE core (an entry claimed in one window is skipped in the next)
+                for (const w of backward) {
+                    const sweepParams = scope.params(FRONTIER_PARAMS, {
+                        wg,
+                        n,
+                        arcBase: w.arcBase,
+                        arcEnd: w.arcEnd,
+                        bitsBase,
+                        stride: sweepPlan.stride ?? wg,
+                    });
+                    const boundSweep = bottomUp.bind({
+                        ...graphBindings(w.core, null),
+                        sweepIn,
+                        counters,
+                        depth,
+                        frontierOut: frontier.output,
+                        P: sweepParams.binding,
+                    });
+                    bottomUp.dispatch(pass, boundSweep, sweepPlan, [sweepParams.offset]);
+                }
+                frontier.swap();
+            }
+            batch.endPass();
+            const doneRequest = batch.readback(counters.buffer, counters.offset + 4 * W.done, 4);
+            const inspect = tuning.onLevel === undefined
+                ? null
+                : {
+                    block: batch.readback(counters.buffer, counters.offset, FRONTIER_COUNTERS.byteLength),
+                    frontier: batch.readback(frontier.input.buffer, frontier.input.offset, frontier.input.size),
+                    count: batch.readback(compactCount.buffer, compactCount.offset, 4),
+                };
+            const submitted = submit(batch);
+            const back = await submitted.readback;
+            levelsRecorded += levelsPerSubmit;
+            submits += 1;
+            ctx.assertReady();
+            if (options?.signal?.aborted) {
+                throw aborted(submitted.id);
+            }
+            options?.onProgress?.(Math.min(levelsRecorded, n), n);
+            if (inspect !== null && tuning.onLevel !== undefined) {
+                const block = FRONTIER_COUNTERS.read(new DataView(back), inspect.block.offset);
+                const claimed = new Uint32Array(back, inspect.frontier.offset, wordOf(block, "nextFrontierCount"));
+                const rebuilt = new Uint32Array(back, inspect.count.offset, 1)[0];
+                tuning.onLevel(levelsRecorded - 1, block, claimed.slice(), rebuilt);
+            }
+            if (new Uint32Array(back, doneRequest.offset, 1)[0] !== 0) {
+                break;
+            }
+            if (submits > n + 1) {
+                throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM}: the done flag never rose in ${submits} submits (a traversal has at most ${n} levels)`, { label: ALGORITHM, message: `the done flag never rose in ${submits} submits` });
+            }
+        }
+        // the result batch: order by one stable radix sort of the node indices by depth (PD-14), parent by the
+        // post-pass in depth mode (PD-24), then every array through ONE staging slot
+        const keys = bindingOf(scope.scratch(bytes, "order/keys"), bytes);
+        const vals = bindingOf(scope.scratch(bytes, "order/vals"), bytes);
+        const histBytes = radixHistBytes(n, wg);
+        const scratch = {
+            keys: bindingOf(scope.scratch(bytes, "order/keys-scratch"), bytes),
+            vals: bindingOf(scope.scratch(bytes, "order/vals-scratch"), bytes),
+            hist: bindingOf(scope.scratch(histBytes, "order/hist"), histBytes),
+            offsets: bindingOf(scope.scratch(histBytes, "order/offsets"), histBytes),
+        };
+        const parent = bindingOf(scope.scratch(bytes, "parent"), bytes);
+        const result = new CommandBatch(ctx, `${ALGORITHM}/result`);
+        result.copy(depth, keys, bytes);
+        const pass = result.pass("result");
+        recordFill(pass, vals, 0, 1);
+        const sorted = sort.record(pass, keys, vals, n, 32, scratch);
+        recordFill(pass, parent, INVALID_INDEX, 0);
+        // the post-pass once per arc window (its atomicMin admits the same smallest parent whichever window holds the arc)
+        const predPlan = planGridStride(n, wg, ctx.caps);
+        for (const w of forward) {
+            const predParams = scope.params(FRONTIER_PARAMS, {
+                wg,
+                n,
+                arcBase: w.arcBase,
+                arcEnd: w.arcEnd,
+                predKind,
+                source,
+                stride: predPlan.stride ?? n,
+            });
+            const predBound = pred.bind({
+                ...graphBindings(w.core, null),
+                dist: depth,
+                pred: parent,
+                P: predParams.binding,
+            });
+            pred.dispatch(pass, predBound, predPlan, [predParams.offset]);
+        }
+        result.endPass();
+        const depthRequest = result.readback(depth.buffer, depth.offset, bytes);
+        const parentRequest = result.readback(parent.buffer, parent.offset, bytes);
+        const orderRequest = result.readback(sorted.vals.buffer, sorted.vals.offset, bytes);
+        const blockRequest = result.readback(counters.buffer, counters.offset, FRONTIER_COUNTERS.byteLength);
+        const back = await submit(result).readback;
+        ctx.assertReady();
+        const block = FRONTIER_COUNTERS.read(new DataView(back), blockRequest.offset);
+        const visitedCount = wordOf(block, "visitedCount");
+        if (visitedCount > n) {
+            // every vertex is claimed at most once, so a count above n is a kernel bug (a claim that lets two
+            // same-level claimants append), never a result to return
+            throw new WebGpuGraphError("E_VALIDATION", `${ALGORITHM}: visitedCount ${visitedCount} exceeds the ${n} vertices (a duplicate claim)`, {
+                label: `${ALGORITHM}/visitedCount`,
+                message: `the device counted ${visitedCount} visits of ${n} vertices`,
+            });
+        }
+        const level = wordOf(block, "level");
+        // done by an empty frontier (the level word already counts the boundary that found it), or by maxDepth with
+        // a reached-but-unexpanded level
+        const levels = wordOf(block, "frontierCount") === 0 ? level : level + 1;
+        const depthOut = dest ?? new Uint32Array(n);
+        depthOut.set(new Uint32Array(back, depthRequest.offset, n));
+        return {
+            depth: depthOut,
+            parent: new Uint32Array(back, parentRequest.offset, n).slice(),
+            order: new Uint32Array(back, orderRequest.offset, visitedCount).slice(),
+            visitedCount,
+            levels,
+            switches: wordOf(block, "switches"),
+        };
+    }
+    finally {
+        scope.dispose();
+    }
+}
+/**
+ * Breadth-first search on the device (spec 3.3 line 807, design 8.4, 9.7): `depth` exact, `parent` the smallest
+ * predecessor one depth down (PD-24), `order` grouped by depth and ascending by index within a depth (PD-14), all
+ * bitwise reproducible; `maxDepth` as the CPU port reads it (a node at the cap is reached and not expanded).
+ * @param ctx - the context whose device runs the kernels
+ * @param s - the snapshot (uploaded through ctx.residency, or found there)
+ * @param source - the source node index (E_INVALID_ARGUMENT outside `[0, n)`, so the empty graph refuses every source)
+ * @param options - `maxDepth`, plus dest (a Uint32Array of length n for `depth`) / signal / onProgress
+ * @returns the depths, parents, order, visited count, level count and switches (the direction changes Beamer's test made on the device)
+ */
+export function breadthFirstSearch(ctx, s, source, options) {
+    return bfsWithTuning(ctx, s, source, options, {});
+}
+//# sourceMappingURL=bfs.js.map

package/dist/src/algorithms/bfs.js.map

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

package/dist/src/algorithms/closeness.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Closeness centrality on the device (design 8.4, 3.3 line 810, 9.7; P8-T11, the P8 plan's PD-13 / PD-19 / PD-25 /
+ * DEP-P8-E / DEP-P8-F): `score[s] = 1 / sumDist_s`, with `sumDist_s` the exact sum of the finite distances from `s`
+ * to every OTHER node -- an unreached node adds nothing -- and `0` when nothing is reached. No reached factor and no
+ * Wasserman-Faust scaling: this is EXACTLY the legacy default (`normalized: false`) of `closenessCentrality` in
+ * `@graphty/algorithms`, the number graphty-element's closeness panel shows today, so a future `indexed` port has one
+ * number to match (the NetworkX form is 33x it on karate and could never have been substituted silently).
+ *
+ * The unweighted route is ONE bit-parallel multi-source search per batch of 32 sources (`ceil(n / 32)` batches):
+ * the batch's state is one `bits` buffer of four regions of `bitsBase = roundUp(n, 64)` words (`visited`, two
+ * frontier regions that swap by the level's parity, `flags`), bit `s` of word `v` meaning "source `s` has reached /
+ * is at / is next at `v`"; a level is, all host-recorded, `closeness-reduce` role 0 (the boundary: `done` from the
+ * previous level's compacted count, the level's claims folded into the exact 64-bit per-source sums at `level + 1`),
+ * `compact` of the flags into the frontier list, two `fill`s zeroing the level's next region and the flags (AFTER
+ * the compaction that consumed them), and `closeness-sweep` (the block-mapped expansion with the claim inline, a
+ * direct grid-stride dispatch looping to the list's count). `MAX_LEVELS_PER_SUBMIT` levels per submit and
+ * one readback per submit (the `done` word and the 512-byte `perSource` block together, so the finished batch needs
+ * no extra map); the host folds `sumHi x 2^32 + sumLo` into `1 / sum` in f64 and stores f32. The weighted route
+ * (`weighted` true on a snapshot whose column is not all ones) is one `sssp` per source with the sums reduced on the
+ * host between calls: design 8.4's own answer, slow and correct. `weighted` defaults to the snapshot's `flags.weighted`;
+ * `weighted: false` on a weighted snapshot ignores the column by request and sweeps; `weighted: true` over unit
+ * weights or no column sweeps too (every `sssp` would route to a BFS anyway). `maxIterations` and `tolerance` are the
+ * seam's placeholder keys and an exact traversal has neither, so a defined value is REFUSED before any device work
+ * (`E_UNSUPPORTED { option }`, the package's rule for an option it does not implement, PD-25); `undefined` is legal.
+ * `iterations` reports the source batches run (the sources, on the weighted route), `converged` is always true.
+ *
+ * Cost, stated so nobody is surprised: closeness is O(n x m) on any device -- at 1M nodes it is 31,250 batches of a
+ * full multi-source traversal, minutes on the card, and no target in design 10.4 asks for less. `compact.record`
+ * leases its offsets and the scan's block sums afresh on every call, once per LEVEL here, so the planner is given a
+ * scope whose `scratch` hands the same buffer back for the same label and size: the dispatches of one pass run in
+ * order, a level's scan overwrites the previous level's, and the run holds one set instead of `levels x batches`.
+ * The sweep keeps DEP-P8-E's refusal of a windowed core (`assertWholeCore`): the bit-parallel claim needs the whole
+ * arc array bound. The tuning entry `closenessWithTuning` (PD-26's shape) is what the tests drive; nothing public
+ * exposes it.
+ */
+import { type GraphSnapshot } from "@graphty/graph-format";
+import { type GpuContext } from "../context.js";
+import { type HitsOptionsLike } from "../types/accelerator.js";
+import { type GpuScoresResult } from "../types/algorithms.js";
+import { type GpuRunOptions } from "../types/run.js";
+/**
+ * Closeness centrality on the device (spec 3.3 line 810, design 8.4, 9.7): `scores[s] = 1 / sumDist_s` over the finite
+ * distances from `s` to every other node, `0` when nothing is reached -- the legacy default of `@graphty/algorithms`'
+ * `closenessCentrality`, unweighted by one bit-parallel multi-source search per 32 sources, weighted by one `sssp`
+ * per source; `weighted` defaults to the snapshot's flag, `maxIterations` / `tolerance` are refused when defined
+ * (PD-25). `iterations` is the source batches run and `converged` is always true.
+ * @param ctx - the context whose device runs the kernels
+ * @param s - the snapshot (uploaded through ctx.residency, or found there)
+ * @param options - the seam's `HitsOptionsLike`, plus dest (a Float32Array of length n for `scores`) / signal / onProgress
+ * @returns the scores, the batches run, `converged: true` and `precision: "f32"`
+ */
+export declare function closenessCentrality(ctx: GpuContext, s: GraphSnapshot, options?: HitsOptionsLike & GpuRunOptions): Promise<GpuScoresResult>;
+//# sourceMappingURL=closeness.d.ts.map

package/dist/src/algorithms/closeness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closeness.d.ts","sourceRoot":"","sources":["../../../src/algorithms/closeness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,EAAY,KAAK,aAAa,EAAY,MAAM,uBAAuB,CAAC;AAG/E,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAiBhD,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AA8TrD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAC/B,GAAG,EAAE,UAAU,EACf,CAAC,EAAE,aAAa,EAChB,OAAO,CAAC,EAAE,eAAe,GAAG,aAAa,GAC1C,OAAO,CAAC,eAAe,CAAC,CAE1B"}