@graphty/webgpu-graph-algorithms 0.6.4 → 0.6.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphty/webgpu-graph-algorithms",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "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",

package/src/algorithms/bfs.ts

@@ -20,7 +20,7 @@
  * 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
+ * no-op (its boundary finds `done` set, writes path 0 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

package/src/algorithms/scope.ts

@@ -8,12 +8,11 @@
  */
 
 import { type GpuContext } from "../context.js";
-import { BufferUsage } from "../device/webgpu-constants.js";
 import { UniformRing } from "../kernel/uniform-ring.js";
-import { type FrontierScope } from "../primitives/frontier.js";
+import { type ReduceScope } from "../primitives/reduce.js";
 
-/** A FrontierScope (a ReduceScope plus `indirect()`, P8-T4) over a context plus the two lifecycle calls an algorithm makes: flush() before submit, dispose() in its finally. */
-export interface AlgorithmScope extends FrontierScope {
+/** A ReduceScope over a context plus the two lifecycle calls an algorithm makes: flush() before submit, dispose() in its finally. (The `indirect()` lease it once added for the frontier's args buffer went with that buffer, 2026-09-25.) */
+export interface AlgorithmScope extends ReduceScope {
     /** queue.writeBuffer of the params slots written since the last flush (called before the batch is submitted). */
     flush(): void;
     /** Destroys the ring and releases every scratch buffer of the lease; idempotent. */
@@ -39,12 +38,6 @@ export function algorithmScope(ctx: GpuContext, label: string, slots: number): A
         pool: ctx.pool,
         workgroupSize: ctx.workgroupSize,
         scratch: (byteLength, scratchLabel) => lease.storage(byteLength, `${label}/${scratchLabel}`),
-        indirect: (byteLength, indirectLabel) =>
-            lease.acquire(
-                byteLength,
-                BufferUsage.STORAGE | BufferUsage.INDIRECT | BufferUsage.COPY_DST | BufferUsage.COPY_SRC,
-                `${label}/${indirectLabel}`,
-            ),
         params(block, values) {
             const slot = ring.reserve(1);
             ring.write(slot, block, values);

package/src/algorithms/sssp.ts

@@ -11,9 +11,10 @@
  * delta and dedupes the far half into `farIn` for a pass-through; both empty is `done`), `dedupe-claim` and
  * `dedupe-filter` over each half (direct grid-stride dispatches; role 2 writes the chosen half's raw count into that
  * dedupe's count word -- `edgeCount` for the near half, `edgeCountUnclamped` for the far one, two words SSSP borrows
- * -- and 0 into the other's, so the half not chosen is a no-op), role 3 (restarts the raw half), and `sssp-relax`
- * twice (role 0 over `nearIn`, role 1 over `farIn`; the block's `path` word, 5 a near round and 6 a far one, makes
- * the other role's dispatch a no-op). The far pile is re-bucketed by the
+ * -- and 0 into the other's, so the half not chosen is a no-op), role 3 (restarts the raw half the round consumed),
+ * and `sssp-relax` twice (role 0 over `nearIn` sized by `frontierCount`, role 1 over `farIn` sized by `farCount`;
+ * the block's `path` word, 5 a near round and 6 a far one, makes the other role's dispatch a no-op). Nothing in a
+ * round is an indirect dispatch (2026-09-25). The far pile is re-bucketed by the
  * relax kernel's pass-through, not by `compact` (PD-20): a far entry whose settled distance fell below the previous
  * threshold was relaxed in the near band already and is dropped, the rest go back to near or far against the raised
  * threshold. The near pile is ONE pile (no sub-partitions). The host records `MAX_LEVELS_PER_SUBMIT` rounds per

package/src/constants.ts

@@ -218,8 +218,6 @@ export const GRID_SORT_BITS = 24;
 export const MAX_LEVELS_PER_SUBMIT = 32;
 /** Design 8.4 and 6 row 8 (P8): a frontier at most this long runs the fused expand-contract kernel (Merrill's "fleeting iterations"); the default of the `fusedMax` uniform, which a test may set to 0 or `U32_MAX`. */
 export const FUSED_FRONTIER_MAX = 4096;
-/** P8-T4: the indirect dispatch slots `frontier-finalize` writes per level (expand, contract, fused, fill-bits, bitset-build, bottom-up, fused-retry); the args buffer is `MAX_LEVELS_PER_SUBMIT x FRONTIER_CANDIDATES x 16` bytes. */
-export const FRONTIER_CANDIDATES = 7;
 /** Design 8.4 (P8 PD-21): Beamer's beta -- switch back to top-down when `frontierCount * BEAMER_BETA < unvisitedCount` and the frontier is shrinking; alpha is derived from the graph, so it has no constant. */
 export const BEAMER_BETA = 24;
 /** Design 8.4 (P8 PD-22): the near-far split `delta = SSSP_DELTA_FACTOR * avgWeight / avgDegree`, computed on the host from the weight vector the run uses. */

package/src/kernels.ts

@@ -423,17 +423,17 @@ export const FRONTIER_COUNTERS: UniformBlock = UniformBlock.define(
 
 /**
  * `FrontierParams` (uniform, 80 B; P8-T4): the params block every P8 kernel except the three compact / dedupe
- * primitives and `bf-relax` binds -- `role` @0 (the finalize role), `slotBase` @4 (`level x FRONTIER_CANDIDATES`),
- * `wg` @8 (the consumers' workgroup size), `alpha` @12, `beta` @16 (Beamer's thresholds, P8-T8), `fusedMax` @20,
- * `edgeCapacity` @24, `maxDepth` @28, `n` @32, `mode` @36 (BFS: 0 auto, 1 top-down only; `sssp-pred`: the PD-27 key
- * rule), `cutoffBits` @40, `arcBase` @44, `arcEnd` @48 (the bound arc window), `predKind` @52 (0 arc, 1 node),
- * `bitsBase` @56, `source` @60, `stride` @64 (a grid-stride plan's stride), `firstOfSubmit` @68 (the boundary's index
- * inside its submit, clamped to 2: the unvisited-count subtraction runs at >= 1, the degree-sum one at >= 2),
- * `iteration` @72 (an `sssp-pred` hop pass, P8-T9), `pad1` @76.
+ * primitives and `bf-relax` binds -- `role` @0 (the finalize role), `wg` @4 (the consumers' workgroup size),
+ * `alpha` @8, `beta` @12 (Beamer's thresholds, P8-T8), `fusedMax` @16, `edgeCapacity` @20, `maxDepth` @24, `n` @28,
+ * `mode` @32 (BFS: 0 auto, 1 top-down only; `sssp-pred`: the PD-27 key rule), `cutoffBits` @36, `arcBase` @40,
+ * `arcEnd` @44 (the bound arc window), `predKind` @48 (0 arc, 1 node), `bitsBase` @52, `source` @56, `stride` @60
+ * (a grid-stride plan's stride), `firstOfSubmit` @64 (the boundary's index inside its submit, clamped to 2: the
+ * unvisited-count subtraction runs at >= 1, the degree-sum one at >= 2), `iteration` @68 (an `sssp-pred` hop pass,
+ * P8-T9), `pad1` @72, `pad2` @76. The `slotBase` field that once addressed the selector's indirect slots went with
+ * the slots (2026-09-25); `pad2` keeps the block an explicit 80 bytes, the way every block here is padded.
  */
 export const FRONTIER_PARAMS: UniformBlock = UniformBlock.define("FrontierParams", [
     ["role", "u32"],
-    ["slotBase", "u32"],
     ["wg", "u32"],
     ["alpha", "u32"],
     ["beta", "u32"],
@@ -452,6 +452,7 @@ export const FRONTIER_PARAMS: UniformBlock = UniformBlock.define("FrontierParams
     ["firstOfSubmit", "u32"],
     ["iteration", "u32"],
     ["pad1", "u32"],
+    ["pad2", "u32"],
 ]);
 
 /** `BfParams` (uniform, 16 B; P8-T10): `edgeCount` @0 (the logical edges of the `edgeList` view), `stride` @4 (the grid-stride plan's stride), `maxRetries` @8 (PD-12's compare-exchange bound), `cutoffBits` @12 (the f32 bit pattern of the CPU port's `cutoff`, `+Inf` when absent). */
@@ -1117,16 +1118,12 @@ const DEDUPE_FILTER: KernelEntry = {
     phase: "P8",
 };
 
-/** `frontier-finalize` (design 5.4, 8.10 "BFS finalizeArgs"; P8-T4, PD-3): the one-lane level-boundary selector that rotates the counters block and writes the level's seven indirect slots (role 0), then clamps the edge count and sizes the contract or the fused-retry slot (role 1); 2 storage bindings (the block as `array<atomic<u32>>`, the args). */
+/** `frontier-finalize` (design 5.4, 8.10 "BFS finalizeArgs"; P8-T4, PD-3): the one-lane level-boundary selector that rotates the counters block and writes the level's `path` word (role 0), then clamps the edge count or switches the path to the fused retry (role 1); 1 storage binding (the block as `array<atomic<u32>>`). Since 2026-09-25 it writes no indirect slots: every level kernel is a direct dispatch gated by the path word. */
 const FRONTIER_FINALIZE: KernelEntry = {
     id: "frontier-finalize",
     body: frontierFinalizeWgsl,
     entryPoint: "frontier_finalize",
-    bindings: [
-        decl(1, 0, "counters", "storage", "array<atomic<u32>>"),
-        decl(1, 1, "args", "storage", "array<u32>"),
-        decl(2, 0, "P", "uniform", "FrontierParams"),
-    ],
+    bindings: [decl(1, 0, "counters", "storage", "array<atomic<u32>>"), decl(2, 0, "P", "uniform", "FrontierParams")],
     overrideDecls: [],
     uniforms: [FRONTIER_PARAMS],
     needs: [],
@@ -1188,7 +1185,7 @@ const SSSP_PRED: KernelEntry = {
     phase: "P8",
 };
 
-/** `bfs-fused` (design 8.4 "the fused variant", 6 row 8 "the workgroup-per-row tier", 8.10 "BFS fused expand-contract"; P8-T7, PD-23): one level's expansion and contraction in one dispatch, one WORKGROUP per frontier entry, every lane stripping the entry's row with `bfs-contract`'s claim inline and no edge queue traffic; dispatched from `SLOT.fused` (a frontier below `P.fusedMax`) and from `SLOT.fusedRetry` (an overflowed level); 8 storage bindings (the four graph slots, `frontierIn`, the counters block as `array<atomic<u32>>`, `depth` as `array<atomic<u32>>`, `frontierOut`) -- exactly at the budget, which is why no `parent` lives here (PD-24). */
+/** `bfs-fused` (design 8.4 "the fused variant", 6 row 8 "the workgroup-per-row tier", 8.10 "BFS fused expand-contract"; P8-T7, PD-23): one level's expansion and contraction in one dispatch, one WORKGROUP per frontier entry, every lane stripping the entry's row with `bfs-contract`'s claim inline and no edge queue traffic; a direct grid-stride dispatch that runs when the path word is 2 (a frontier below `P.fusedMax`) or 4 (the overflow retry, role 1's), sized from `frontierCount`; 8 storage bindings (the four graph slots, `frontierIn`, the counters block as `array<atomic<u32>>`, `depth` as `array<atomic<u32>>`, `frontierOut`) -- exactly at the budget, which is why no `parent` lives here (PD-24). */
 const BFS_FUSED: KernelEntry = {
     id: "bfs-fused",
     body: bfsFusedWgsl,

package/src/primitives/advance.ts

@@ -34,7 +34,8 @@ import { type Kernel } from "../kernel/kernel.js";
 import { FRONTIER_PARAMS, graphBindings, graphOverrides, kernelSpec } from "../kernels.js";
 import { type CoreBinding } from "../memory/residency.js";
 import { type CoreWindow, coreWindows, rowCountOf } from "./core-shape.js";
-import { type Frontier, type FrontierScope } from "./frontier.js";
+import { type Frontier } from "./frontier.js";
+import { type ReduceScope } from "./reduce.js";
 
 /** A prepared advance (design 6 row 8): records one expansion of a frontier per level. */
 export interface AdvancePlanner {
@@ -64,7 +65,7 @@ export interface AdvancePlanner {
  * @param core - the resident core arrays of the snapshot the frontier walks (windowed or not)
  * @returns the planner
  */
-export async function prepareAdvance(scope: FrontierScope, core: CoreBinding): Promise<AdvancePlanner> {
+export async function prepareAdvance(scope: ReduceScope, core: CoreBinding): Promise<AdvancePlanner> {
     const kernel = await scope.pipelines.kernel(kernelSpec("advance-expand", graphOverrides(core, null)));
     return new AdvancePlannerImpl(scope, core, kernel);
 }
@@ -73,7 +74,7 @@ export async function prepareAdvance(scope: FrontierScope, core: CoreBinding): P
 class AdvancePlannerImpl implements AdvancePlanner {
     readonly kernel: Kernel;
     readonly windows: readonly CoreWindow[];
-    private readonly scope: FrontierScope;
+    private readonly scope: ReduceScope;
     private readonly n: number;
 
     /**
@@ -82,7 +83,7 @@ class AdvancePlannerImpl implements AdvancePlanner {
      * @param core - the core the kernel was compiled for
      * @param kernel - the `advance-expand` kernel
      */
-    constructor(scope: FrontierScope, core: CoreBinding, kernel: Kernel) {
+    constructor(scope: ReduceScope, core: CoreBinding, kernel: Kernel) {
         this.scope = scope;
         this.kernel = kernel;
         this.windows = coreWindows(core);

package/src/primitives/frontier.ts

@@ -1,46 +1,48 @@
 /**
  * The `Frontier` of design 6 row 7 and the device-side dispatch selector of design 5.4 (P8-T4; the P8 plan's PD-1,
- * PD-3, PD-8, PD-23, DEP-P8-A, DEP-P8-C). A traversal's per-level state is two n-slot vertex queues, ONE 24-word
+ * PD-3, PD-8, PD-23, DEP-P8-A, DEP-P8-C). A traversal's per-level state is two n-slot vertex queues, ONE 25-word
  * counters block (every counter of the phase is a word of it: a four-byte word is never a legal storage-binding
- * offset, and the selector must reach every count it acts on through one binding), the indirect args buffer of
- * `MAX_LEVELS_PER_SUBMIT x FRONTIER_CANDIDATES` 16-byte slots, and the edge queue. The host never reads a counter
- * inside a submit: `frontier-finalize`, one lane, runs at the START of every level (role 0: rotates
- * `nextFrontierCount` into `frontierCount`, advances `level`, decides `done`, writes this level's slots) and again once
- * the edge queue is filled (role 1: clamps `edgeCount`, sizes the contract slot, or on an overflow --
- * `edgeCountUnclamped > edgeCapacity` -- sizes the fused-retry slot instead, PD-23), and the kernels that follow
- * dispatch indirectly from those slots. The host records up to `MAX_LEVELS_PER_SUBMIT` levels per submit and reads
- * `done` (four bytes) once per submit; a boundary that finds `done` set zeroes its slots and moves no counter, so the
- * recorded levels past the end are no-ops and the counters freeze at the finishing boundary's values.
+ * offset, and the selector must reach every count it acts on through one binding) and the edge queue. The host
+ * never reads a counter inside a submit: `frontier-finalize`, one lane, runs at the START of every level (role 0:
+ * rotates `nextFrontierCount` into `frontierCount`, advances `level`, decides `done`, chooses the level's path) and
+ * again once the edge queue is filled (role 1: clamps `edgeCount`, or on an overflow -- `edgeCountUnclamped >
+ * edgeCapacity` -- switches the path to the fused retry, PD-23). The choice is the block's `path` word (`W.path`,
+ * word 24); every level kernel is a direct grid-stride dispatch that reads it first and does nothing unless the
+ * word names it (design/decisions/2026-09-25-frontier-kernels-dispatch-directly.md: the seven indirect slots the
+ * selector once wrote per level cost about 0.4 ms of Dawn validation each and were 97 % of a traversal's wall
+ * time; they and their args buffer are gone). The host records up to `MAX_LEVELS_PER_SUBMIT` levels per submit and
+ * reads `done` (four bytes) once per submit; a boundary that finds `done` set writes path 0 and moves no counter,
+ * so the recorded levels past the end are no-ops and the counters freeze at the finishing boundary's values.
  *
  * The seed: `frontierCount` is NEVER seeded, because the first boundary rotates it out unread. A BFS driver calls
  * `reset(queue, source, { nextFrontierCount: 1, level: U32_MAX })`: the first boundary rotates the 1 in, adds it into
  * `visitedCount`, and wraps `level` to 0, so the level-0 expansion claims the source's neighbours at `level + 1 == 1`.
  * `reset` is a queue write, ordered before the submit that follows, and it puts the source on side 0.
  *
- * Every buffer comes from the caller's ONE lease (`scope.scratch`, `scope.indirect`) so the algorithm's dispose()
+ * Every buffer comes from the caller's ONE lease (`scope.scratch`) so the algorithm's dispose()
  * releases them together (design 4.4). The two vertex queues are two BUFFERS, never two ranges of one: `Kernel.bind`
  * rejects one buffer bound read-only and read-write in one dispatch even for disjoint ranges. `src/primitives/**`
  * never imports `src/context.ts`.
  */
 
-import { FRONTIER_CANDIDATES, MAX_LEVELS_PER_SUBMIT, U32_MAX } from "../constants.js";
+import { MAX_LEVELS_PER_SUBMIT, U32_MAX } from "../constants.js";
 import { WebGpuGraphError } from "../errors.js";
 import { plan1d } from "../kernel/dispatch.js";
-import { INDIRECT_ARGS_STRIDE, type Kernel } from "../kernel/kernel.js";
+import { type Kernel } from "../kernel/kernel.js";
 import { FRONTIER_COUNTERS, FRONTIER_PARAMS, kernelSpec } from "../kernels.js";
 import { type Binding } from "../types/memory.js";
 import { type ReduceScope } from "./reduce.js";
 
-/** The seven indirect slots of one level (`FRONTIER_CANDIDATES`), by the kernel that dispatches from each. */
-export const SLOT: Readonly<{
-    expand: 0;
-    contract: 1;
+/** The values of the `path` word (`W.path`): what a level's kernels run; every level kernel reads it first. */
+export const PATH: Readonly<{
+    none: 0;
+    twoPhase: 1;
     fused: 2;
-    fillBits: 3;
-    bitset: 4;
-    bottomUp: 5;
-    fusedRetry: 6;
-}> = Object.freeze({ expand: 0, contract: 1, fused: 2, fillBits: 3, bitset: 4, bottomUp: 5, fusedRetry: 6 });
+    bottomUp: 3;
+    fusedRetry: 4;
+    near: 5;
+    far: 6;
+}> = Object.freeze({ none: 0, twoPhase: 1, fused: 2, bottomUp: 3, fusedRetry: 4, near: 5, far: 6 });
 
 /** The words of the counters block (`FRONTIER_COUNTERS`), by index: byte offset 4 x word; no driver types a number. */
 export const W: Readonly<{
@@ -100,13 +102,7 @@ export const W: Readonly<{
 /** The words a `reset` seeds (every other word is zeroed). */
 export type FrontierSeed = Readonly<Partial<Record<keyof typeof W, number>>>;
 
-/** A ReduceScope that can also lease an INDIRECT buffer (the args of the frontier); `algorithmScope` is one. */
-export interface FrontierScope extends ReduceScope {
-    /** A STORAGE | INDIRECT | COPY_DST | COPY_SRC buffer of the scope's lease. */
-    indirect(byteLength: number, label: string): GPUBuffer;
-}
-
-/** The `FrontierParams` fields a caller passes to `recordFinalize`; the planner fills `role`, `slotBase`, `wg`, `edgeCapacity` and `n` itself. A missing field is written as 0. */
+/** The `FrontierParams` fields a caller passes to `recordFinalize`; the planner fills `role`, `wg`, `edgeCapacity` and `n` itself. A missing field is written as 0. */
 export type FrontierFinalizeFields = Readonly<
     Partial<
         Record<
@@ -163,14 +159,12 @@ function assertCount(argument: string, value: number): void {
     }
 }
 
-/** The frontier queue of design 6 row 7: two vertex queues, the counters block, the args buffer and the edge queue, all leased by the caller's scope. */
+/** The frontier queue of design 6 row 7: two vertex queues, the counters block and the edge queue, all leased by the caller's scope. */
 export class Frontier {
     /** The two n-slot u32 vertex queues (`vertices[side]` is the input of the current level). */
     readonly vertices: readonly [Binding, Binding];
-    /** The `FrontierCounters` block, 96 B, bound by every kernel as `array<atomic<u32>>`. */
+    /** The `FrontierCounters` block, 112 B, bound by every kernel as `array<atomic<u32>>`. */
     readonly counters: Binding;
-    /** The indirect args, `MAX_LEVELS_PER_SUBMIT x FRONTIER_CANDIDATES` 16-byte slots (usage INDIRECT | STORAGE | COPY_DST | COPY_SRC). */
-    readonly args: Binding;
     /** The edge queue: `edgeCapacity` entries of u32 (the target vertex of an arc). */
     readonly edgeQueue: Binding;
     /** How many entries the edge queue holds; role 1 clamps `edgeCount` to it and detects an overflow above it. */
@@ -183,7 +177,6 @@ export class Frontier {
      * Wraps the leased buffers; use prepareFrontier().
      * @param vertices - the two vertex queues
      * @param counters - the counters block
-     * @param args - the args buffer
      * @param edgeQueue - the edge queue
      * @param edgeCapacity - the edge queue's entry count
      * @param n - the vertex count
@@ -191,14 +184,12 @@ export class Frontier {
     constructor(
         vertices: readonly [Binding, Binding],
         counters: Binding,
-        args: Binding,
         edgeQueue: Binding,
         edgeCapacity: number,
         n: number,
     ) {
         this.vertices = vertices;
         this.counters = counters;
-        this.args = args;
         this.edgeQueue = edgeQueue;
         this.edgeCapacity = edgeCapacity;
         this.n = n;
@@ -234,7 +225,7 @@ export class Frontier {
     }
 
     /**
-     * Seeds a traversal: one `queue.writeBuffer` of the whole 96-byte block (zero except the caller's words) and one of
+     * Seeds a traversal: one `queue.writeBuffer` of the whole 112-byte block (zero except the caller's words) and one of
      * `vertices[0][0] = source`, both ordered before the submit that follows; the source is on side 0 afterwards.
      * `frontierCount` is not a word to seed: the first boundary rotates word 1 into it (the BFS seed is
      * `{ nextFrontierCount: 1, level: U32_MAX }`). A source outside `[0, n)`, an unknown word or a value that is not a
@@ -261,13 +252,14 @@ export class Frontier {
 
 /** A prepared frontier (design 6 row 7): the leased queue and the recorded selector dispatches. */
 export interface FrontierPlanner {
-    /** The queue the planner sizes the slots of. */
+    /** The queue the planner's selector rotates and chooses the path of. */
     readonly frontier: Frontier;
     /**
      * Records one `frontier-finalize` dispatch (one workgroup) in `role` for `level` of the current submit: one
-     * `FrontierParams` record with `slotBase = level x FRONTIER_CANDIDATES`, `wg`, `edgeCapacity` and `n` filled by the
-     * planner and every other field from `fields`. A level outside `[0, MAX_LEVELS_PER_SUBMIT)` or a role outside
-     * `[0, 3]` is E_INVALID_ARGUMENT before anything is recorded.
+     * `FrontierParams` record with `wg`, `edgeCapacity` and `n` filled by the planner and every other field from
+     * `fields`. A level outside `[0, MAX_LEVELS_PER_SUBMIT)` (the selector addresses nothing by level any more, but
+     * the host's submit cadence still is the bound) or a role outside `[0, 3]` is E_INVALID_ARGUMENT before
+     * anything is recorded.
      * @param pass - the compute pass
      * @param role - 0 the level boundary, 1 the edge-queue role (2 and 3 are P8-T9's)
      * @param level - the level inside the submit
@@ -281,14 +273,14 @@ export interface FrontierPlanner {
  * edge capacity defaults to `max(1, min(arcCount, floor(maxStorageBufferBindingSize / 4)))` (never a zero-length
  * buffer: the one-node graph has no arcs); a test passes a small one to force the overflow path. The planner lives
  * exactly as long as the scope: never use it after the scope's dispose().
- * @param scope - the caller's scope (device, caps, cache, scratch, indirect, params)
+ * @param scope - the caller's scope (device, caps, cache, scratch, params)
  * @param n - the vertex count
  * @param arcCount - the arc count (the natural edge-queue size)
  * @param edgeCapacity - the edge queue's entry count, when the caller chooses it (an integer >= 1)
  * @returns the planner
  */
 export async function prepareFrontier(
-    scope: FrontierScope,
+    scope: ReduceScope,
     n: number,
     arcCount: number,
     edgeCapacity?: number,
@@ -306,7 +298,6 @@ export async function prepareFrontier(
     }
     const kernel = await scope.pipelines.kernel(kernelSpec("frontier-finalize"));
     const queueBytes = 4 * Math.max(1, n);
-    const argsBytes = MAX_LEVELS_PER_SUBMIT * FRONTIER_CANDIDATES * INDIRECT_ARGS_STRIDE;
     const vertices: readonly [Binding, Binding] = [
         { buffer: scope.scratch(queueBytes, "frontier/vertices-0"), offset: 0, size: queueBytes, window: null },
         { buffer: scope.scratch(queueBytes, "frontier/vertices-1"), offset: 0, size: queueBytes, window: null },
@@ -317,26 +308,20 @@ export async function prepareFrontier(
         size: FRONTIER_COUNTERS.byteLength,
         window: null,
     };
-    const args: Binding = {
-        buffer: scope.indirect(argsBytes, "frontier/args"),
-        offset: 0,
-        size: argsBytes,
-        window: null,
-    };
     const edgeQueue: Binding = {
         buffer: scope.scratch(4 * capacity, "frontier/edge-queue"),
         offset: 0,
         size: 4 * capacity,
         window: null,
     };
-    const frontier = new Frontier(vertices, counters, args, edgeQueue, capacity, n);
+    const frontier = new Frontier(vertices, counters, edgeQueue, capacity, n);
     return new FrontierPlannerImpl(scope, kernel, frontier);
 }
 
-/** The planner: the selector kernel bound once to the frontier's block and args. */
+/** The planner: the selector kernel bound once to the frontier's block. */
 class FrontierPlannerImpl implements FrontierPlanner {
     readonly frontier: Frontier;
-    private readonly scope: FrontierScope;
+    private readonly scope: ReduceScope;
     private readonly kernel: Kernel;
 
     /**
@@ -345,7 +330,7 @@ class FrontierPlannerImpl implements FrontierPlanner {
      * @param kernel - the `frontier-finalize` kernel
      * @param frontier - the leased queue
      */
-    constructor(scope: FrontierScope, kernel: Kernel, frontier: Frontier) {
+    constructor(scope: ReduceScope, kernel: Kernel, frontier: Frontier) {
         this.scope = scope;
         this.kernel = kernel;
         this.frontier = frontier;
@@ -377,12 +362,11 @@ class FrontierPlannerImpl implements FrontierPlanner {
         const params = scope.params(FRONTIER_PARAMS, {
             ...definedWords(fields),
             role,
-            slotBase: level * FRONTIER_CANDIDATES,
             wg: scope.workgroupSize,
             edgeCapacity: frontier.edgeCapacity,
             n: frontier.n,
         });
-        const bound = this.kernel.bind({ counters: frontier.counters, args: frontier.args, P: params.binding });
+        const bound = this.kernel.bind({ counters: frontier.counters, P: params.binding });
         this.kernel.dispatch(pass, bound, plan1d(1, scope.workgroupSize, scope.caps), [params.offset]);
     }
 }