@graphty/webgpu-graph-algorithms 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphty/webgpu-graph-algorithms",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "WebGPU-accelerated graph algorithms and layouts over the @graphty/graph-format snapshot, for Node (Dawn) and browsers",
   "author": "Adam Powers <apowers@ato.ms>",
   "type": "module",
@@ -60,7 +60,7 @@
   "homepage": "https://github.com/graphty-org/graphty-monorepo/tree/master/webgpu-graph-algorithms#readme",
   "dependencies": {
     "@webgpu/types": "^0.1.72",
-    "@graphty/graph-format": "^1.0.1"
+    "@graphty/graph-format": "^1.0.2"
   },
   "peerDependencies": {
     "@graphty/algorithms": "^1.0.0",
@@ -84,14 +84,16 @@
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "fast-check": "^4.2.0",
+    "ngraph.forcelayout": "^3.3.1",
+    "ngraph.graph": "^20.0.1",
     "playwright": "^1.54.1",
     "tsx": "^4.20.3",
     "typescript": "^5.9.3",
     "vite": "^7.0.5",
     "vitest": "^3.2.4",
     "webgpu": "0.4.0",
-    "@graphty/layout": "^1.7.0",
-    "@graphty/algorithms": "^1.8.0"
+    "@graphty/layout": "^1.8.0",
+    "@graphty/algorithms": "^1.8.1"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
@@ -103,12 +105,13 @@
     "typecheck:strict-consumer": "tsc -p tsconfig.strict-consumer.json",
     "test": "vitest",
     "test:ui": "vitest --ui",
-    "test:run": "vitest run --project=node",
-    "test:node": "vitest run --project=node",
+    "test:run": "vitest run --project=node --project=node-device-errors",
+    "test:node": "vitest run --project=node --project=node-device-errors",
+    "test:node:ci": "node scripts/run-node-shard.js",
     "test:browser": "vitest run --project=browser",
     "test:browser:ci": "node scripts/run-browser-project.js",
     "test:limits": "vitest run --project=node-limits",
-    "coverage": "vitest run --project=node --coverage",
+    "coverage": "vitest run --project=node --project=node-device-errors --coverage",
     "coverage:preview": "npx serve coverage -p 9058",
     "bench": "tsx benchmarks/run.ts",
     "bench:compare": "node scripts/bench-compare.js",

package/src/accelerator.ts

@@ -3,13 +3,13 @@
  * AlgorithmAccelerator and LayoutAccelerator interfaces (spec 9.2, 9.3). Both are the REAL declarations,
  * `LayoutAccelerator` from `@graphty/layout` (W1b, layout half) and `AlgorithmAccelerator` from
  * `@graphty/algorithms` (W1b, algorithms half), `import type`d by src/types/accelerator.ts, so the object built
- * here is checked against the CPU packages' own contracts. It carries P3's `forceAtlas2`, `release` and `dispose`
- * and P7's seven
- * algorithm members (spec 8.2, 8.3; M8b-T8, PD-14) and nothing else: the CPU-side dispatchers (`accelerated()`,
- * `createSimulation()`) test `acc.betweennessCentrality !== undefined` and route to the CPU when the member is
- * absent (spec 2.4 row "method missing"), so a method the GPU does not implement must not exist here -- never a
- * throwing stub. The remaining algorithm members arrive one per shipped algorithm from P8; `fruchtermanReingold` /
- * `springElectrical` with P5.
+ * here is checked against the CPU packages' own contracts. It carries P3's `forceAtlas2`, `release` and `dispose`,
+ * P5's `fruchtermanReingold` and `springElectrical` (the two other layout members of spec 9.3, landed together once
+ * both models were green, P5 PD-19) and P7's seven algorithm members (spec 8.2, 8.3; M8b-T8, PD-14) and nothing
+ * else: the CPU-side dispatchers (`accelerated()`, `createSimulation()`) test `acc.betweennessCentrality !== undefined`
+ * / `acc.fruchtermanReingold !== undefined` and route to the CPU when the member is absent (spec 2.4 row "method
+ * missing"), so a method the GPU does not implement must not exist here -- never a throwing stub. The remaining
+ * algorithm members arrive one per shipped algorithm from P8.
  */
 
 import { type F32, type F64, type GraphSnapshot } from "@graphty/graph-format";
@@ -19,6 +19,8 @@ import { pageRank, personalizedPageRank } from "./algorithms/pagerank.js";
 import { eigenvectorCentrality, hits, katzCentrality } from "./algorithms/spectral.js";
 import { type GpuContext } from "./context.js";
 import { createForceAtlas2 } from "./layouts/forceatlas2.js";
+import { createFruchtermanReingold } from "./layouts/fruchterman-reingold.js";
+import { createSpringElectrical } from "./layouts/spring-electrical.js";
 import { type AcceleratorOptions, type GpuAccelerator } from "./types/accelerator.js";
 import {
     type ComponentsOptions,
@@ -31,8 +33,18 @@ import {
     type KatzOptions,
     type PageRankOptions,
 } from "./types/algorithms.js";
-import { type ForceAtlas2Stats, type GpuLayoutSimulation, type GpuLayoutTuning } from "./types/layout.js";
-import { type ForceAtlas2Options } from "./types/options.js";
+import {
+    type ForceAtlas2Stats,
+    type FruchtermanReingoldStats,
+    type GpuLayoutSimulation,
+    type GpuLayoutTuning,
+    type SpringElectricalStats,
+} from "./types/layout.js";
+import {
+    type ForceAtlas2Options,
+    type FruchtermanReingoldOptions,
+    type SpringElectricalOptions,
+} from "./types/options.js";
 
 /** The `algorithms` record of AcceleratorOptions (spec 3.3), named for the copy helpers. */
 type AlgorithmDefaults = NonNullable<AcceleratorOptions["algorithms"]>;
@@ -91,7 +103,8 @@ function freezeOptions(options: AcceleratorOptions | undefined): Readonly<Accele
 
 /**
  * Spec 3.3 createAccelerator, verbatim: the object implementing AlgorithmAccelerator & LayoutAccelerator
- * structurally; P3's forceAtlas2, release and dispose plus P7's seven algorithm members, each a delegation to
+ * structurally; P3's forceAtlas2, release and dispose, P5's fruchtermanReingold and springElectrical (the same
+ * `{ ...o, ...options.layout }` shape as forceAtlas2) plus P7's seven algorithm members, each a delegation to
  * its algorithm with `ctx.assertReady()` first. The accelerator's algorithm defaults are not consulted by any of
  * them: only `betweenness` has any, and it belongs to P9. One per call (the app creates one and injects
  * it, spec 2.4); `kind` is "webgpu"; `options` is a frozen deep copy; `forceAtlas2(o)` is
@@ -101,8 +114,9 @@ function freezeOptions(options: AcceleratorOptions | undefined): Readonly<Accele
  * @param ctx - the context every simulation the accelerator creates runs on
  * @param options - GPU-only defaults inherited by every simulation (`layout`) and, from P9, the algorithm defaults
  * @returns the injectable accelerator
- * @throws E_DISPOSED / E_DEVICE_LOST from `ctx.assertReady()` (here and inside `forceAtlas2()`); `forceAtlas2()`
- *   also throws what createForceAtlas2 throws (E_UNSUPPORTED for `nodeSize`, E_INVALID_ARGUMENT for a bad range)
+ * @throws E_DISPOSED / E_DEVICE_LOST from `ctx.assertReady()` (here and inside every creating member); `forceAtlas2()`
+ *   also throws what createForceAtlas2 throws (E_UNSUPPORTED for `nodeSize`, E_INVALID_ARGUMENT for a bad range), and
+ *   `fruchtermanReingold()` / `springElectrical()` what their factories throw (E_INVALID_ARGUMENT for a bad range)
  */
 export function createAccelerator(ctx: GpuContext, options?: AcceleratorOptions): GpuAccelerator {
     ctx.assertReady();
@@ -120,6 +134,26 @@ export function createAccelerator(ctx: GpuContext, options?: AcceleratorOptions)
             ctx.assertReady();
             return createForceAtlas2(ctx, { ...o, ...frozen.layout });
         },
+        /**
+         * The Fruchterman-Reingold simulation with this accelerator's layout tuning (spec 3.3, 7.20; P5).
+         * @param o - the CPU option type (spec 9.3 FruchtermanReingoldOptions); GPU tuning keys come from `options.layout`
+         * @returns a fresh simulation in state "created"
+         */
+        fruchtermanReingold(
+            o?: FruchtermanReingoldOptions,
+        ): GpuLayoutSimulation<FruchtermanReingoldOptions, FruchtermanReingoldStats> {
+            ctx.assertReady();
+            return createFruchtermanReingold(ctx, { ...o, ...frozen.layout });
+        },
+        /**
+         * The spring-electrical preset with this accelerator's layout tuning (spec 3.3, 7.20; P5).
+         * @param o - the CPU option type (spec 9.3 SpringElectricalOptions, ngraph's names)
+         * @returns a fresh simulation in state "created"
+         */
+        springElectrical(o?: SpringElectricalOptions): GpuLayoutSimulation<SpringElectricalOptions, SpringElectricalStats> {
+            ctx.assertReady();
+            return createSpringElectrical(ctx, { ...o, ...frozen.layout });
+        },
         /**
          * PageRank on the device (spec 8.2; contract 3.14).
          * @param gs - the snapshot

package/src/algorithms/components.ts

@@ -19,11 +19,13 @@ import { type GraphSnapshot, renumberPartition, type U32 } from "@graphty/graph-
 
 import { U32_MAX } from "../constants.js";
 import { type GpuContext } from "../context.js";
-import { isWebGpuGraphError, WebGpuGraphError } from "../errors.js";
+import { WebGpuGraphError } from "../errors.js";
 import { CommandBatch } from "../kernel/batch.js";
 import { plan1d, planGridStride } from "../kernel/dispatch.js";
 import { FILL_PARAMS, graphBindings, graphOverrides, kernelSpec, WCC_PARAMS } from "../kernels.js";
 import { type CoreBinding } from "../memory/residency.js";
+import { assertWholeCore } from "../primitives/core-shape.js";
+import { assertDeviceComputes } from "../primitives/verify.js";
 import { type ComponentsOptions, type GpuLabelResult } from "../types/algorithms.js";
 import { type Binding } from "../types/memory.js";
 import { type GpuRunOptions } from "../types/run.js";
@@ -66,25 +68,16 @@ function checkDest(dest: Float32Array | Uint32Array | undefined, n: number): U32
 }
 
 /**
- * The resident core; a windowed plan (`E_TOO_LARGE { path: "windowed", algorithm: null }`, spec 3.8) is re-thrown
- * with the algorithm name (3.12). Transcribed from degree.ts, whose coreOf is module-private.
+ * The resident core; a windowed plan is refused with `E_TOO_LARGE { path: "windowed", algorithm }` (spec 3.8, 3.12;
+ * DEP-P4-B: only degree and segmentedReduce execute windows).
  * @param ctx - the context
  * @param s - the snapshot
  * @returns the core binding
  */
 function coreOf(ctx: GpuContext, s: GraphSnapshot): CoreBinding {
-    try {
-        return ctx.residency.core(s);
-    } catch (error: unknown) {
-        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;
-    }
+    const core = ctx.residency.core(s);
+    assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, ALGORITHM);
+    return core;
 }
 
 /**
@@ -197,6 +190,7 @@ export async function connectedComponents(
     options?: ComponentsOptions & GpuRunOptions,
 ): Promise<GpuLabelResult> {
     ctx.assertReady();
+    await assertDeviceComputes(ctx);
     const n = s.nodeCount;
     const renumber = options?.renumber !== false;
     const dest = checkDest(options?.dest, n);
@@ -312,7 +306,9 @@ export async function connectedComponents(
             rounds += ROUNDS_PER_BATCH;
             ctx.assertReady();
             if (options?.signal?.aborted) {
-                throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM}: the signal was aborted`, { batchId: submitted.id });
+                throw new WebGpuGraphError("E_ABORTED", `${ALGORITHM}: the signal was aborted`, {
+                    batchId: submitted.id,
+                });
             }
             if (new Uint32Array(back, flagRequest.offset, 1)[0] === 0) {
                 break;

package/src/algorithms/degree.ts

@@ -9,24 +9,24 @@
  *
  * Contract (3.12): `ctx.assertReady()` first; `nodeCount === 0` returns an empty `Uint32Array` (or `dest`) with no
  * GPU work (spec 5.6: there is no work, which is not a fallback); an already-aborted `signal` is `E_ABORTED` before
- * any work; `dest` must be a `Uint32Array` of length n over an `ArrayBuffer`; a windowed core is `E_TOO_LARGE
- * { path: "windowed", algorithm: "degree" }` until P4 executes windows -- `residency.core()` (3.8) throws that error
- * itself with `algorithm: null` before it would ever return a windowed `CoreBinding`, so `degree` catches it and
- * re-throws the same error with `algorithm: "degree"` (the 3.12 detail) instead of testing `core.plan`, which never
- * observes "windowed" in P1-P3; `arcCount === 0` skips the dispatch (only `rowPtr` is resident)
- * and the result is zeros; otherwise ONE dispatch over rows [0, n) with `accumulate = 0` (every row is written, so no
- * fill precedes it), a readback into the result, `onProgress(1, 1)`, and the scratch returned in a finally. Two runs
- * are bitwise identical (spec 11.9 item 4).
+ * any work; `dest` must be a `Uint32Array` of length n over an `ArrayBuffer`; `arcCount === 0` skips the dispatch
+ * (only `rowPtr` is resident) and the result is zeros; otherwise ONE dispatch over rows [0, n) with `accumulate = 0`
+ * (every row is written, so no fill precedes it) -- or, on a windowed core (spec 4.2, PD-8), a `fill` of zeros and
+ * one dispatch per window over its rows with `arcBase = w.start`, `arcEnd = w.end`, `accumulate = 1`, so a row split
+ * across windows adds its partial counts -- a readback into the result, `onProgress(1, 1)`, and the scratch returned
+ * in a finally. Two runs are bitwise identical (spec 11.9 item 4).
  */
 
 import { type GraphSnapshot, type U32 } from "@graphty/graph-format";
 
 import { type GpuContext } from "../context.js";
 import { BufferUsage } from "../device/webgpu-constants.js";
-import { isWebGpuGraphError, WebGpuGraphError } from "../errors.js";
+import { WebGpuGraphError } from "../errors.js";
 import { plan1d } from "../kernel/dispatch.js";
-import { graphBindings, graphOverrides, kernelSpec, RANGE_PARAMS } from "../kernels.js";
-import { type CoreBinding } from "../memory/residency.js";
+import { type UniformBlock, type UniformValues } from "../kernel/struct-block.js";
+import { FILL_PARAMS, graphBindings, graphOverrides, kernelSpec, RANGE_PARAMS } from "../kernels.js";
+import { windowBinding } from "../primitives/core-shape.js";
+import { assertDeviceComputes } from "../primitives/verify.js";
 import { type Binding } from "../types/memory.js";
 import { type GpuRunOptions } from "../types/run.js";
 
@@ -55,26 +55,21 @@ function checkDest(dest: Float32Array | Uint32Array | undefined, n: number): U32
 }
 
 /**
- * Uploads (or finds) the core through the residency; a windowed plan, which the residency reports as `E_TOO_LARGE
- * { path: "windowed", algorithm: null }` (3.8), is re-thrown with `algorithm: "degree"` (3.12) and its other details
- * (`needed`, `limit`, `path`) kept. Every other error passes through untouched.
- * @param ctx - the context whose residency holds the core
- * @param s - the snapshot
- * @returns the resident core binding (arena or perArray)
+ * One pool-acquired uniform buffer holding one params record (a params buffer per dispatch; the caller releases
+ * `pooled` in its finally).
+ * @param ctx - the context whose pool and queue are used
+ * @param pooled - the list the buffer is appended to for release
+ * @param block - the uniform block
+ * @param values - the record's values
+ * @returns the whole-buffer binding
  */
-function coreOf(ctx: GpuContext, s: GraphSnapshot): CoreBinding {
-    try {
-        return ctx.residency.core(s);
-    } catch (error: unknown) {
-        if (isWebGpuGraphError(error) && error.code === "E_TOO_LARGE" && error.details.path === "windowed") {
-            throw new WebGpuGraphError(
-                "E_TOO_LARGE",
-                "degree: the arc arrays need a windowed upload, which P1-P3 plan but do not execute",
-                { ...error.details, algorithm: "degree" },
-            );
-        }
-        throw error;
-    }
+function paramsBinding(ctx: GpuContext, pooled: GPUBuffer[], block: UniformBlock, values: UniformValues): Binding {
+    const buffer = ctx.pool.acquire(block.byteLength, BufferUsage.UNIFORM | BufferUsage.COPY_DST, "degree/params");
+    pooled.push(buffer);
+    const bytes = new ArrayBuffer(block.byteLength);
+    block.write(new DataView(bytes), values);
+    ctx.device.queue.writeBuffer(buffer, 0, bytes);
+    return { buffer, offset: 0, size: block.byteLength, window: null };
 }
 
 /**
@@ -89,6 +84,7 @@ function coreOf(ctx: GpuContext, s: GraphSnapshot): CoreBinding {
  */
 export async function degree(ctx: GpuContext, s: GraphSnapshot, options?: GpuRunOptions): Promise<U32> {
     ctx.assertReady();
+    await assertDeviceComputes(ctx);
     const n = s.nodeCount;
     const dest = checkDest(options?.dest, n);
     if (options?.signal?.aborted) {
@@ -98,7 +94,7 @@ export async function degree(ctx: GpuContext, s: GraphSnapshot, options?: GpuRun
         options?.onProgress?.(1, 1);
         return dest ?? new Uint32Array(0);
     }
-    const core = coreOf(ctx, s);
+    const core = ctx.residency.core(s);
     if (s.arcCount === 0) {
         const zeros = dest ?? new Uint32Array(n);
         zeros.fill(0);
@@ -111,23 +107,40 @@ export async function degree(ctx: GpuContext, s: GraphSnapshot, options?: GpuRun
         BufferUsage.STORAGE | BufferUsage.COPY_SRC | BufferUsage.COPY_DST,
         "degree/out",
     );
-    const params = ctx.pool.acquire(
-        RANGE_PARAMS.byteLength,
-        BufferUsage.UNIFORM | BufferUsage.COPY_DST,
-        "degree/params",
-    );
+    const pooled: GPUBuffer[] = [];
+    const params = (block: UniformBlock, values: UniformValues): Binding => paramsBinding(ctx, pooled, block, values);
     try {
         await ctx.allocator.check();
         const kernel = await ctx.pipelines.kernel(kernelSpec("degree", graphOverrides(core, null)));
-        const bytes = new ArrayBuffer(RANGE_PARAMS.byteLength);
-        RANGE_PARAMS.write(new DataView(bytes), { start: 0, end: n, arcBase: 0, arcEnd: s.arcCount, accumulate: 0, n });
-        ctx.device.queue.writeBuffer(params, 0, bytes);
         const outBinding: Binding = { buffer: out, offset: 0, size: byteLength, window: null };
-        const paramsBinding: Binding = { buffer: params, offset: 0, size: RANGE_PARAMS.byteLength, window: null };
-        const bound = kernel.bind({ ...graphBindings(core, null), out: outBinding, P: paramsBinding });
         const encoder = ctx.device.createCommandEncoder({ label: "degree" });
         const pass = encoder.beginComputePass({ label: "degree" });
-        kernel.dispatch(pass, bound, plan1d(n, ctx.workgroupSize, ctx.caps), [0]);
+        if (core.windows === null) {
+            const P = params(RANGE_PARAMS, { start: 0, end: n, arcBase: 0, arcEnd: s.arcCount, accumulate: 0, n });
+            const bound = kernel.bind({ ...graphBindings(core, null), out: outBinding, P });
+            kernel.dispatch(pass, bound, plan1d(n, ctx.workgroupSize, ctx.caps), [0]);
+        } else {
+            const fill = await ctx.pipelines.kernel(kernelSpec("fill"));
+            const zero = fill.bind({ dst: outBinding, P: params(FILL_PARAMS, { count: n, value: 0, mode: 0 }) });
+            fill.dispatch(pass, zero, plan1d(n, ctx.workgroupSize, ctx.caps), [0]);
+            for (const w of core.windows) {
+                const windowed = {
+                    ...core,
+                    colIdx: windowBinding(core, "colIdx", w),
+                    weights: core.weights === null ? null : windowBinding(core, "weights", w),
+                };
+                const P = params(RANGE_PARAMS, {
+                    start: w.rowFirst,
+                    end: w.rowLast + 1,
+                    arcBase: w.start,
+                    arcEnd: w.end,
+                    accumulate: 1,
+                    n,
+                });
+                const bound = kernel.bind({ ...graphBindings(windowed, null), out: outBinding, P });
+                kernel.dispatch(pass, bound, plan1d(w.rowLast - w.rowFirst + 1, ctx.workgroupSize, ctx.caps), [0]);
+            }
+        }
         pass.end();
         ctx.device.queue.submit([encoder.finish()]);
         ctx.assertReady();
@@ -136,7 +149,9 @@ export async function degree(ctx: GpuContext, s: GraphSnapshot, options?: GpuRun
         options?.onProgress?.(1, 1);
         return dest ?? new Uint32Array(result);
     } finally {
-        ctx.pool.release(params);
+        for (const buffer of pooled) {
+            ctx.pool.release(buffer);
+        }
         ctx.pool.release(out);
     }
 }

package/src/algorithms/pagerank.ts

@@ -18,14 +18,15 @@ import { type F32, type GraphSnapshot } from "@graphty/graph-format";
 
 import { U32_MAX } from "../constants.js";
 import { type GpuContext } from "../context.js";
-import { isWebGpuGraphError, WebGpuGraphError } from "../errors.js";
+import { WebGpuGraphError } from "../errors.js";
 import { CommandBatch } from "../kernel/batch.js";
 import { groupsOf, plan1d } from "../kernel/dispatch.js";
 import { kernelSpec, PR_PARAMS, PR_PARTIAL } from "../kernels.js";
 import { type ArrayBinding, type CoreBinding } from "../memory/residency.js";
-import { coreOfView } from "../primitives/core-shape.js";
+import { assertWholeCore, coreOfView } from "../primitives/core-shape.js";
 import { prepareSegmentedReduce } from "../primitives/segmented-reduce.js";
 import { prepareSpmvPull } from "../primitives/spmv.js";
+import { assertDeviceComputes } from "../primitives/verify.js";
 import { type GpuPageRankResult, type PageRankOptions } from "../types/algorithms.js";
 import { type Binding } from "../types/memory.js";
 import { type GpuRunOptions } from "../types/run.js";
@@ -62,26 +63,17 @@ function checkDest(dest: Float32Array | Uint32Array | undefined, n: number, algo
 }
 
 /**
- * The resident core; a windowed plan (`E_TOO_LARGE { path: "windowed", algorithm: null }`, spec 3.8) is re-thrown
- * with the algorithm name (3.12). Transcribed from degree.ts, whose coreOf is module-private.
+ * The resident core; a windowed plan is refused with `E_TOO_LARGE { path: "windowed", algorithm }` (spec 3.8, 3.12;
+ * DEP-P4-B: only degree and segmentedReduce execute windows).
  * @param ctx - the context
  * @param s - the snapshot
  * @param algorithm - the caller's name
  * @returns the core binding
  */
 function coreOf(ctx: GpuContext, s: GraphSnapshot, algorithm: string): CoreBinding {
-    try {
-        return ctx.residency.core(s);
-    } catch (error: unknown) {
-        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;
-    }
+    const core = ctx.residency.core(s);
+    assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, algorithm);
+    return core;
 }
 
 /**
@@ -126,6 +118,7 @@ async function run(
     algorithm: string,
 ): Promise<GpuPageRankResult> {
     ctx.assertReady();
+    await assertDeviceComputes(ctx);
     const n = s.nodeCount;
     const alpha = options?.dampingFactor ?? 0.85;
     const maxIterations = options?.maxIterations ?? 100;
@@ -144,7 +137,13 @@ async function run(
     }
     if (n === 0) {
         options?.onProgress?.(maxIterations, maxIterations);
-        return { scores: dest ?? new Float32Array(0), iterations: 0, converged: true, danglingMass: 0, precision: "f32" };
+        return {
+            scores: dest ?? new Float32Array(0),
+            iterations: 0,
+            converged: true,
+            danglingMass: 0,
+            precision: "f32",
+        };
     }
     const core = coreOf(ctx, s, algorithm);
     if (s.arcCount === 0) {
@@ -322,7 +321,10 @@ export async function personalizedPageRank(
             expected,
         });
     if (!(personalization instanceof Float32Array) || personalization.length !== n) {
-        throw invalid(`${personalization.constructor.name}(${personalization.length})`, `a Float32Array of length ${n}`);
+        throw invalid(
+            `${personalization.constructor.name}(${personalization.length})`,
+            `a Float32Array of length ${n}`,
+        );
     }
     let total = 0;
     for (let v = 0; v < n; v++) {

package/src/algorithms/power-iteration.ts

@@ -20,13 +20,14 @@ import { type F32, type GraphSnapshot } from "@graphty/graph-format";
 
 import { U32_MAX } from "../constants.js";
 import { type GpuContext } from "../context.js";
-import { isWebGpuGraphError, WebGpuGraphError } from "../errors.js";
+import { WebGpuGraphError } from "../errors.js";
 import { CommandBatch } from "../kernel/batch.js";
 import { groupsOf, plan1d } from "../kernel/dispatch.js";
 import { kernelSpec, PR_PARAMS, PR_PARTIAL } from "../kernels.js";
 import { type CoreBinding } from "../memory/residency.js";
-import { coreOfView } from "../primitives/core-shape.js";
+import { assertWholeCore, coreOfView } from "../primitives/core-shape.js";
 import { prepareSpmvPull } from "../primitives/spmv.js";
+import { assertDeviceComputes } from "../primitives/verify.js";
 import { type Binding } from "../types/memory.js";
 import { algorithmScope } from "./scope.js";
 
@@ -103,26 +104,17 @@ export function checkDest(dest: Float32Array | Uint32Array | undefined, n: numbe
 }
 
 /**
- * The resident core; a windowed plan (`E_TOO_LARGE { path: "windowed", algorithm: null }`, spec 3.8) is re-thrown
- * with the algorithm name (3.12). Transcribed from degree.ts, whose coreOf is module-private.
+ * The resident core; a windowed plan is refused with `E_TOO_LARGE { path: "windowed", algorithm }` (spec 3.8, 3.12;
+ * DEP-P4-B: only degree and segmentedReduce execute windows).
  * @param ctx - the context
  * @param s - the snapshot
  * @param algorithm - the caller's name
  * @returns the core binding
  */
 export function coreOf(ctx: GpuContext, s: GraphSnapshot, algorithm: string): CoreBinding {
-    try {
-        return ctx.residency.core(s);
-    } catch (error: unknown) {
-        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;
-    }
+    const core = ctx.residency.core(s);
+    assertWholeCore(core, s.arcCount, ctx.caps.limits.maxStorageBufferBindingSize, algorithm);
+    return core;
 }
 
 /**
@@ -179,6 +171,7 @@ export async function runPowerIteration(
     n: number,
     config: PowerIterationConfig,
 ): Promise<PowerIterationRun> {
+    await assertDeviceComputes(ctx);
     const scope = algorithmScope(ctx, config.label, RING_SLOTS);
     try {
         const bytes = 4 * n;
@@ -231,7 +224,14 @@ export async function runPowerIteration(
                 const rankOut = ring[iteration % ring.length];
                 const { core, pull } = pulls[(iteration - 1) % pulls.length];
                 // outWeightSum takes rankIn as its dummy: storage-ro, read only under NORM_MODE 0, never compiled here
-                const scaleBindings = { rankIn, rankPrev: rankOut, outWeightSum: rankIn, xNorm, partials, P: params.binding };
+                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) {
@@ -265,7 +265,8 @@ export async function runPowerIteration(
                 }
                 return {
                     scores: new Float32Array(back, scoresRequest.offset, n).slice(),
-                    previous: previousRequest === null ? null : new Float32Array(back, previousRequest.offset, n).slice(),
+                    previous:
+                        previousRequest === null ? null : new Float32Array(back, previousRequest.offset, n).slice(),
                     iterations: converged ? firstConverged : iterationsRun,
                     converged,
                     iterationsRun,