wgblas 2.0.0 → 2.1.0

package/index.d.mts

@@ -38,11 +38,20 @@ export { strsm } from "./src/strsm/strsm.mjs";
 /**
  * Initializes the WebGPU device.
  *
+ * Devices are cached per option set: the same options return the same device,
+ * different options a separate one — so one process can drive several GPUs
+ * (`"high-performance"` and `"low-power"` typically resolve to the discrete and
+ * integrated adapters). Each routine dispatches to the device you pass it; GPU
+ * buffers cannot cross devices, so a `GpuVector`/`GpuMatrix` from one is
+ * rejected by another. {@link cleanup} releases them all.
+ *
  * @param options.powerPreference - GPU power preference (default: `"high-performance"`).
  *   This is a hint to the browser: on dual-GPU systems, `"high-performance"` typically favors the discrete GPU
  *   and `"low-power"` favors the integrated one.
  *   See [MDN: GPU.requestAdapter()](https://developer.mozilla.org/en-US/docs/Web/API/GPU/requestAdapter).
- * @param options.benchmark - enable GPU timestamp queries; BLAS functions return `{ result, gpuTimeMs }` (default: `false`)
+ * @param options.benchmark - enable GPU timestamp queries; BLAS functions then also return `gpuTimeMs`
+ *   alongside their normal result (e.g. sscal returns `{ x, gpuTimeMs }`, saxpy returns `{ y, gpuTimeMs }`) —
+ *   see each routine's own docs for its exact return shape (default: `false`)
  * @param options.dumpShaders - Node-only. Forwards Dawn's `dump_shaders` debug toggle, printing
  *   each pipeline's WGSL and compiled backend IR (SPIR-V/Vulkan, MSL/Metal, or HLSL/D3D12,
  *   whichever Dawn picked) to stderr as it compiles. A Dawn passthrough, not a wgblas format —
@@ -71,10 +80,23 @@ export { strsm } from "./src/strsm/strsm.mjs";
  * const n = 5;
  * const alpha = 2.0;
  * const x = new Float32Array([1, 2, 3, 4, 5]);
- * const { result, gpuTimeMs } = await sscal(device, n, alpha, x, 1);
+ * const { x: result, gpuTimeMs } = await sscal(device, n, alpha, x, 1);
  * console.log(`Result: [${Array.from(result).join(", ")}]`);
  * console.log(`GPU time: ${gpuTimeMs.toFixed(3)} ms`);
  * ```
+ * @example Two GPUs at once
+ * ```js
+ * import { init, cleanup, gpuName, sscal } from "wgblas";
+ * const dGpu = await init({ powerPreference: "high-performance" });
+ * const iGpu = await init({ powerPreference: "low-power" });
+ * console.log(gpuName(dGpu).description, "and", gpuName(iGpu).description);
+ * const [a, b] = await Promise.all([
+ *   sscal(dGpu, 4, 2, new Float32Array([1, 2, 3, 4]), 1),
+ *   sscal(iGpu, 4, 5, new Float32Array([1, 2, 3, 4]), 1),
+ * ]);
+ * cleanup(); // releases both
+ * ```
+ *
  * @see [Source code: init.mjs](https://github.com/manit2004/wgblas/blob/main/src/init.mjs#L18-L54)
  * @category Core
  */
@@ -85,8 +107,15 @@ export declare function init(options?: {
 }): Promise<GPUDevice>;
 
 /**
- * Destroys the WebGPU device, releases the adapter, resets benchmark state, and fires all internal
- * cleanup callbacks (e.g. releasing cached GPU pipelines and buffers). Call when done (required in Node.js to prevent crash on exit).
+ * Destroys devices created by {@link init} and releases their cached pipelines and buffers.
+ * Call when done (required in Node.js to prevent crash on exit).
+ *
+ * With no argument, releases every device at once. Pass a device to release
+ * just that one and leave the others usable — handy when driving several GPUs.
+ * Unknown or already-released devices are ignored, so this is safe to call
+ * more than once.
+ *
+ * @param device - the device to release; omit to release all of them.
  *
  * @example
  * ```js
@@ -99,11 +128,14 @@ export declare function init(options?: {
  * @see [Source code: init.mjs](https://github.com/manit2004/wgblas/blob/main/src/init.mjs#L56-L65)
  * @category Core
  */
-export declare function cleanup(): void;
+export declare function cleanup(device?: GPUDevice): void;
 
 /**
  * Returns the GPU device name from the WebGPU adapter info. Must be called after `init()`.
  *
+ * @param device - which device to report on; defaults to the one from the first
+ *   `init()` call. Pass it explicitly when driving more than one GPU.
+ *
  * @example
  * ```js
  * import { init, gpuName } from "wgblas";
@@ -114,4 +146,4 @@ export declare function cleanup(): void;
  * @see [Source code: init.mjs](https://github.com/manit2004/wgblas/blob/main/src/init.mjs#L81-L87)
  * @category Core
  */
-export declare function gpuName(): { description: string; device: string };
+export declare function gpuName(device?: GPUDevice): { description: string; device: string };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wgblas",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "BLAS on WebGPU",
   "type": "module",
   "main": "index.mjs",
@@ -209,6 +209,7 @@
     "lint-staged": "^17.0.8",
     "prettier": "^3.9.4",
     "typedoc": "^0.28.19",
+    "typedoc-plugin-katex": "^0.1.2",
     "typescript": "^6.0.3",
     "vite": "^8.0.16"
   },

package/src/classes/GpuMatrix.mjs

@@ -4,13 +4,15 @@ import { extractResult } from "../util/result.mjs";
 import { splitDoubleDouble, mergeDoubleDouble } from "../util/f64.mjs";
 
 export class GpuMatrix {
-  constructor(buffer, rows, cols, lda, loBuffer = null, layout = "row-major") {
+  constructor(buffer, rows, cols, lda, loBuffer = null, layout = "row-major", device = null) {
     this._buf = buffer;
     this._loBuf = loBuffer; // Non-null only for Float64Array-backed matrices
     this.rows = rows;
     this.cols = cols;
     this.lda  = lda;
     this.layout = layout;
+    // See GpuVector: a GPUBuffer is bound to one device for life.
+    this.device = device ?? getDevice();
   }
 
   /**
@@ -21,7 +23,12 @@ export class GpuMatrix {
    * no padding). `data` must have at least `rows * lda` (row-major) or
    * `cols * lda` (column-major) elements.
    */
-  static from(data, rows, cols, lda, layout = "row-major") {
+  static from(deviceOrData, ...rest) {
+    const explicit = deviceOrData instanceof GPUDevice;
+    const device = explicit ? deviceOrData : getDevice();
+    const data = explicit ? rest.shift() : deviceOrData;
+    let [rows, cols, lda, layout = "row-major"] = rest;
+
     if (layout !== "row-major" && layout !== "column-major")
       throw new Error("layout must be 'row-major' or 'column-major'.");
     const isRowMajor = layout === "row-major";
@@ -48,19 +55,19 @@ export class GpuMatrix {
     if (data instanceof Float64Array) {
       const n = outerCount * lda;
       const { hi, lo } = splitDoubleDouble(data.subarray(0, n));
-      const hiBuf = uploadBuffer(hi, "gpu-matrix-f64-hi", true);
-      const loBuf = uploadBuffer(lo, "gpu-matrix-f64-lo", true);
-      return new GpuMatrix(hiBuf, rows, cols, lda, loBuf, layout);
+      const hiBuf = uploadBuffer(device, hi, "gpu-matrix-f64-hi", true);
+      const loBuf = uploadBuffer(device, lo, "gpu-matrix-f64-lo", true);
+      return new GpuMatrix(hiBuf, rows, cols, lda, loBuf, layout, device);
     }
 
-    const buf = uploadBuffer(data.subarray(0, outerCount * lda), "gpu-matrix", true);
-    return new GpuMatrix(buf, rows, cols, lda, null, layout);
+    const buf = uploadBuffer(device, data.subarray(0, outerCount * lda), "gpu-matrix", true);
+    return new GpuMatrix(buf, rows, cols, lda, null, layout, device);
   }
 
   async read() {
-    const device = getDevice();
+    const device = this.device;
     const enc = device.createCommandEncoder();
-    const rb = stageReadback(enc, this._buf);
+    const rb = stageReadback(device, enc, this._buf);
     device.queue.submit([enc.finish()]);
 
     const isRowMajor = this.layout !== "column-major";
@@ -69,7 +76,7 @@ export class GpuMatrix {
 
     if (this._loBuf) {
       const encLo = device.createCommandEncoder();
-      const rbLo = stageReadback(encLo, this._loBuf);
+      const rbLo = stageReadback(device, encLo, this._loBuf);
       device.queue.submit([encLo.finish()]);
 
       const [hi, lo] = await Promise.all([

package/src/classes/GpuVector.mjs

@@ -4,37 +4,55 @@ import { extractResult } from "../util/result.mjs";
 import { splitDoubleDouble, mergeDoubleDouble } from "../util/f64.mjs";
 
 export class GpuVector {
-  constructor(buffer, length, dtype = Float32Array, loBuffer = null) {
+  constructor(buffer, length, dtype = Float32Array, loBuffer = null, device = null) {
     this._buf = buffer;
     this._loBuf = loBuffer; // Non-null only for Float64Array-backed vectors
     this.length = length;
     this.dtype = dtype;
+    // A GPUBuffer belongs to exactly one device and WebGPU rejects any attempt
+    // to use it with another, so every handle remembers where it lives. Routines
+    // check this to reject mixed-device operands with a clear message instead of
+    // a raw GPUValidationError.
+    this.device = device ?? getDevice();
   }
 
-  static from(data) {
+  /**
+   * Uploads a vector to GPU memory.
+   *
+   * Pass the target `GPUDevice` first — matching every routine's own
+   * `(device, ...)` convention. Omitting it falls back to the device from the
+   * last `init()`, which is the historical form and only works single-device.
+   *
+   * @param {GPUDevice|Float32Array|Float64Array} deviceOrData
+   */
+  static from(deviceOrData, maybeData) {
+    const explicit = deviceOrData instanceof GPUDevice;
+    const device = explicit ? deviceOrData : getDevice();
+    const data = explicit ? maybeData : deviceOrData;
+
     if (data instanceof Float64Array) {
       const { hi, lo } = splitDoubleDouble(data);
-      const hiBuf = uploadBuffer(hi, "gpu-vector-f64-hi", true);
-      const loBuf = uploadBuffer(lo, "gpu-vector-f64-lo", true);
-      return new GpuVector(hiBuf, data.length, Float64Array, loBuf);
+      const hiBuf = uploadBuffer(device, hi, "gpu-vector-f64-hi", true);
+      const loBuf = uploadBuffer(device, lo, "gpu-vector-f64-lo", true);
+      return new GpuVector(hiBuf, data.length, Float64Array, loBuf, device);
     }
     if (!(data instanceof Float32Array)) {
       throw new Error("GpuVector.from expects a Float32Array or Float64Array.");
     }
-    const buf = uploadBuffer(data, "gpu-vector", true);
-    return new GpuVector(buf, data.length, data.constructor);
+    const buf = uploadBuffer(device, data, "gpu-vector", true);
+    return new GpuVector(buf, data.length, data.constructor, null, device);
   }
 
   async read() {
-    const device = getDevice();
+    const device = this.device;
     const enc = device.createCommandEncoder();
-    const rb = stageReadback(enc, this._buf);
+    const rb = stageReadback(device, enc, this._buf);
     device.queue.submit([enc.finish()]);
 
     if (!this._loBuf) return extractResult(rb, this.dtype);
 
     const encLo = device.createCommandEncoder();
-    const rbLo = stageReadback(encLo, this._loBuf);
+    const rbLo = stageReadback(device, encLo, this._loBuf);
     device.queue.submit([encLo.finish()]);
 
     const [hi, lo] = await Promise.all([

package/src/dasum/dasum.d.mts

@@ -2,9 +2,9 @@ import { GpuVector } from "../classes/GpuVector.mjs";
 
 /**
  * Computes the sum of absolute values of a vector of doubles in extended
- * precision: result = sum(|x[i]|). Each element of `x` has abs() applied,
- * then is split into a (hi, lo) double-double f32 pair (see
- * `splitDoubleDouble`/`f64.mjs`) since WGSL has no f64 type; accumulation
+ * precision: $$\text{result} = \sum_{i} |x_i|$$
+ * Each element of `x` has abs() applied, then is split into a (hi, lo) double-double f32 pair 
+ * (see `splitDoubleDouble`/`f64.mjs`) since WGSL has no f64 type; accumulation
  * uses Dekker's double-double algorithm (see `shaders/f64/`), giving ~48 bits
  * of mantissa — more than a single f32 (24 bits) but less than true f64
  * (52 bits), so results are not bit-exact with a CPU double.
@@ -31,7 +31,7 @@ export declare function dasum(
 
 /**
  * Computes the sum of absolute values of a vector of doubles in double
- * precision: result = sum(|x[i]|).
+ * precision: $$\text{result} = \sum_{i} |x_i|$$.
  *
  * {@includeCode ../../examples/dasum/gpu.dasum.js}
  *

package/src/dasum/dasum.mjs

@@ -13,14 +13,16 @@ import { extractResult } from "../util/result.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
 import { splitDoubleDouble, mergeDoubleDouble } from "../util/f64.mjs";
+import { WGS } from "../util/constants.mjs";
+import { requireSameDevice } from "../util/device.mjs";
 
-const WGS = 64; // workgroup size
 
 export async function dasum(device, n, x, incx) {
   const xIsGpu = x instanceof GpuVector;
 
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
+  requireSameDevice(device, "dasum", { x });
   if (!Number.isInteger(n) || !Number.isInteger(incx))
     throw new Error("n and incx must be integers.");
   if (incx <= 0) throw new Error("incx must be positive.");
@@ -57,14 +59,14 @@ export async function dasum(device, n, x, incx) {
       xLoBuffer = x._loBuf;
     } else {
       const { hi, lo } = splitDoubleDouble(x.map(Math.abs));
-      xHiBuffer = uploadBuffer(hi, "dasum-xHi", false);
-      xLoBuffer = uploadBuffer(lo, "dasum-xLo", false);
+      xHiBuffer = uploadBuffer(device, hi, "dasum-xHi", false);
+      xLoBuffer = uploadBuffer(device, lo, "dasum-xLo", false);
     }
-    partialsHiBuffer = createStorageBuffer(2 * WGS * 4, "dasum-partialsHi");
-    partialsLoBuffer = createStorageBuffer(2 * WGS * 4, "dasum-partialsLo");
-    resultHiBuffer = createResultBuffer(4, "dasum-result-hi");
-    resultLoBuffer = createResultBuffer(4, "dasum-result-lo");
-    paramsBuffer = createParamsBuffer(
+    partialsHiBuffer = createStorageBuffer(device, 2 * WGS * 4, "dasum-partialsHi");
+    partialsLoBuffer = createStorageBuffer(device, 2 * WGS * 4, "dasum-partialsLo");
+    resultHiBuffer = createResultBuffer(device, 4, "dasum-result-hi");
+    resultLoBuffer = createResultBuffer(device, 4, "dasum-result-lo");
+    paramsBuffer = createParamsBuffer(device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -72,31 +74,31 @@ export async function dasum(device, n, x, incx) {
       "dasum-params",
     );
 
-    const bgMain = createBindGroup(
+    const bgMain = createBindGroup(device,
       pipelineMain.getBindGroupLayout(0),
       [xHiBuffer, xLoBuffer, partialsHiBuffer, partialsLoBuffer, paramsBuffer],
     );
-    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(device,
       pipelineMain,
       bgMain,
       2 * WGS,
     ); // dispatch 2*WGS workgroups
 
-    submit(enc1);
+    submit(device, enc1);
 
-    const bgReduce = createBindGroup(
+    const bgReduce = createBindGroup(device,
       pipelineReduce.getBindGroupLayout(0),
       [partialsHiBuffer, partialsLoBuffer, resultHiBuffer, resultLoBuffer],
     );
-    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(device,
       pipelineReduce,
       bgReduce,
       1,
     ); // dispatch 1 workgroup to reduce the partial sums to a single result
-    readHiBuffer = stageReadback(enc2, resultHiBuffer);
-    readLoBuffer = stageReadback(enc2, resultLoBuffer);
+    readHiBuffer = stageReadback(device, enc2, resultHiBuffer);
+    readLoBuffer = stageReadback(device, enc2, resultLoBuffer);
 
-    submit(enc2);
+    submit(device, enc2);
 
     const hiPromise = extractResult(readHiBuffer, Float32Array);
     const loPromise = extractResult(readLoBuffer, Float32Array);
@@ -123,7 +125,7 @@ export async function dasum(device, n, x, incx) {
     if (resultHiBuffer) destroyBuffers(resultHiBuffer);
     if (resultLoBuffer) destroyBuffers(resultLoBuffer);
     if (paramsBuffer) destroyBuffers(paramsBuffer);
-    // Only reached if submit(enc2) threw before ownership was transferred above.
+    // Only reached if submit(device, enc2) threw before ownership was transferred above.
     if (readHiBuffer) destroyBuffers(readHiBuffer);
     if (readLoBuffer) destroyBuffers(readLoBuffer);
   }

package/src/devdocs.mjs

@@ -4,6 +4,19 @@
  * repository and explains the reasoning behind it — not just what the code
  * does, but why it is shaped the way it is.
  *
+ * ## How These Docs Are Organized
+ *
+ * The sidebar's top-level modules mirror the repository's top-level folders.
+ * `devdocs` stands in for `src/` — the module you're reading right now is a
+ * narrated walkthrough of it, with `devdocs/blas-routines` and
+ * `devdocs/shaders` covering `src/index.mjs` and `src/shaders/`
+ * respectively. Its siblings — `assets`, `benchmarks`, `examples`, `scripts`,
+ * `tests` — each document the identically-named top-level folder.
+ *
+ * `docs` is the one exception: it's the public API reference generated from
+ * `index.d.mts`, not a tour of the top-level `docs/` folder. That folder is
+ * this site's own generated output — the two just happen to share a name.
+ *
  * ## What is BLAS?
  *
  * BLAS (Basic Linear Algebra Subprograms) is a standard API for vector and

package/src/idamax/idamax.d.mts

@@ -2,13 +2,22 @@ import { GpuVector } from "../classes/GpuVector.mjs";
 
 /**
  * Returns the 0-based index of the element with the largest absolute value,
- * for a vector of doubles. Each element of `x` is split into a (hi, lo)
+ * for a vector of doubles: $$\text{index} = \arg\max_{i} |x_i|$$
+ * Each element of `x` is split into a (hi, lo)
  * double-double f32 pair (see `splitDoubleDouble`/`f64.mjs`) since WGSL has
  * no f64 type; comparisons use the double-double pair directly (hi, falling
  * back to lo on an exact tie), giving ~48 bits of discriminating precision —
  * more than a single f32 (24 bits) but less than true f64 (52 bits). Ties
  * are broken in favour of the lower index, matching CBLAS behaviour.
  *
+ * **NaN handling.** The search compares with `>`, which is false for NaN, so
+ * NaN elements are skipped rather than selected: a vector of all NaN returns
+ * `0`. This matches CBLAS except when `x[0]` itself is NaN — CBLAS seeds its
+ * running maximum from `x[0]`, and since no comparison against NaN succeeds it
+ * returns `0` however large the later elements are, whereas this returns the
+ * index of the largest non-NaN element. `+-Infinity` compares normally and is
+ * selected as the maximum.
+ *
  * {@includeCode ../../examples/idamax/idamax.js}
  *
  * **Browser (standalone HTML):**
@@ -30,9 +39,18 @@ export declare function idamax(
 ): Promise<{ index: number } | { index: number; gpuTimeMs: number }>;
 
 /**
- * Returns the 0-based index of the element with the largest absolute value.
+ * Returns the 0-based index of the element with the largest absolute value:
+ * $$\text{index} = \arg\max_{i} |x_i|$$
  * Ties are broken in favour of the lower index, matching CBLAS behaviour.
  *
+ * **NaN handling.** The search compares with `>`, which is false for NaN, so
+ * NaN elements are skipped rather than selected: a vector of all NaN returns
+ * `0`. This matches CBLAS except when `x[0]` itself is NaN — CBLAS seeds its
+ * running maximum from `x[0]`, and since no comparison against NaN succeeds it
+ * returns `0` however large the later elements are, whereas this returns the
+ * index of the largest non-NaN element. `+-Infinity` compares normally and is
+ * selected as the maximum.
+ *
  * {@includeCode ../../examples/idamax/gpu.idamax.js}
  *
  * @param device - GPUDevice from `init()`

package/src/idamax/idamax.mjs

@@ -13,14 +13,16 @@ import { extractResult } from "../util/result.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
 import { splitDoubleDouble } from "../util/f64.mjs";
+import { WGS } from "../util/constants.mjs";
+import { requireSameDevice } from "../util/device.mjs";
 
-const WGS = 64;
 
 export async function idamax(device, n, x, incx) {
   const xIsGpu = x instanceof GpuVector;
 
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
+  requireSameDevice(device, "idamax", { x });
   if (!Number.isInteger(n) || !Number.isInteger(incx))
     throw new Error("n and incx must be integers.");
   if (incx <= 0) throw new Error("incx must be positive.");
@@ -54,14 +56,14 @@ export async function idamax(device, n, x, incx) {
       xLoBuffer = x._loBuf;
     } else {
       const { hi, lo } = splitDoubleDouble(x);
-      xHiBuffer = uploadBuffer(hi, "idamax-xHi", false);
-      xLoBuffer = uploadBuffer(lo, "idamax-xLo", false);
+      xHiBuffer = uploadBuffer(device, hi, "idamax-xHi", false);
+      xLoBuffer = uploadBuffer(device, lo, "idamax-xLo", false);
     }
-    partialsValHiBuffer = createStorageBuffer(2 * WGS * 4, "idamax-partials-val-hi");
-    partialsValLoBuffer = createStorageBuffer(2 * WGS * 4, "idamax-partials-val-lo");
-    partialsIdxBuffer = createStorageBuffer(2 * WGS * 4, "idamax-partials-idx");
-    resultBuffer = createResultBuffer(4, "idamax-result"); // u32 index
-    paramsBuffer = createParamsBuffer(
+    partialsValHiBuffer = createStorageBuffer(device, 2 * WGS * 4, "idamax-partials-val-hi");
+    partialsValLoBuffer = createStorageBuffer(device, 2 * WGS * 4, "idamax-partials-val-lo");
+    partialsIdxBuffer = createStorageBuffer(device, 2 * WGS * 4, "idamax-partials-idx");
+    resultBuffer = createResultBuffer(device, 4, "idamax-result"); // u32 index
+    paramsBuffer = createParamsBuffer(device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -69,7 +71,7 @@ export async function idamax(device, n, x, incx) {
       "idamax-params",
     );
 
-    const bgMain = createBindGroup(pipelineMain.getBindGroupLayout(0), [
+    const bgMain = createBindGroup(device, pipelineMain.getBindGroupLayout(0), [
       xHiBuffer,
       xLoBuffer,
       partialsValHiBuffer,
@@ -77,28 +79,28 @@ export async function idamax(device, n, x, incx) {
       partialsIdxBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(device,
       pipelineMain,
       bgMain,
       2 * WGS,
     ); // dispatch 2*WGS workgroups
 
-    submit(enc1);
+    submit(device, enc1);
 
-    const bgReduce = createBindGroup(pipelineReduce.getBindGroupLayout(0), [
+    const bgReduce = createBindGroup(device, pipelineReduce.getBindGroupLayout(0), [
       partialsValHiBuffer,
       partialsValLoBuffer,
       partialsIdxBuffer,
       resultBuffer,
     ]);
-    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(device,
       pipelineReduce,
       bgReduce,
       1,
     ); // dispatch 1 workgroup to reduce the partials to a single index
-    readBuffer = stageReadback(enc2, resultBuffer);
+    readBuffer = stageReadback(device, enc2, resultBuffer);
 
-    submit(enc2);
+    submit(device, enc2);
 
     const resultPromise = extractResult(readBuffer, Uint32Array);
     readBuffer = null; // ownership transferred — extractResult's own finally destroys it
@@ -122,7 +124,7 @@ export async function idamax(device, n, x, incx) {
     if (partialsIdxBuffer) destroyBuffers(partialsIdxBuffer);
     if (resultBuffer) destroyBuffers(resultBuffer);
     if (paramsBuffer) destroyBuffers(paramsBuffer);
-    // Only reached if submit(enc2) threw before ownership was transferred above.
+    // Only reached if submit(device, enc2) threw before ownership was transferred above.
     if (readBuffer) destroyBuffers(readBuffer);
   }
 }