wgblas 0.1.2 → 1.0.0

package/index.d.mts

@@ -2,6 +2,7 @@
  * @module docs
  */
 export { GpuVector } from "./src/classes/GpuVector.mjs";
+export { GpuMatrix } from "./src/classes/GpuMatrix.mjs";
 export {
   randomFloat32Array,
   randomFloat64Array,
@@ -12,10 +13,15 @@ export { saxpy } from "./src/saxpy/saxpy.mjs";
 export { scopy } from "./src/scopy/scopy.mjs";
 export { sdot } from "./src/sdot/sdot.mjs";
 export { sasum } from "./src/sasum/sasum.mjs";
+export { dasum } from "./src/dasum/dasum.mjs";
 export { snrm2 } from "./src/snrm2/snrm2.mjs";
 export { isamax } from "./src/isamax/isamax.mjs";
 export { srot } from "./src/srot/srot.mjs";
 export { srotm } from "./src/srotm/srotm.mjs";
+export { sgemv } from "./src/sgemv/sgemv.mjs";
+export { ssymv } from "./src/ssymv/ssymv.mjs";
+export { strmv } from "./src/strmv/strmv.mjs";
+export { strsv } from "./src/strsv/strsv.mjs";
 
 /**
  * Initializes the WebGPU device.

package/index.mjs

@@ -1,5 +1,6 @@
 export { init, cleanup, gpuName } from "./src/init.mjs";
 export { GpuVector } from "./src/classes/GpuVector.mjs";
+export { GpuMatrix } from "./src/classes/GpuMatrix.mjs";
 export {
   randomFloat32Array,
   randomFloat64Array,
@@ -10,7 +11,12 @@ export { saxpy } from "./src/saxpy/saxpy.mjs";
 export { scopy } from "./src/scopy/scopy.mjs";
 export { sdot } from "./src/sdot/sdot.mjs";
 export { sasum } from "./src/sasum/sasum.mjs";
+export { dasum } from "./src/dasum/dasum.mjs";
 export { snrm2 } from "./src/snrm2/snrm2.mjs";
 export { isamax } from "./src/isamax/isamax.mjs";
 export { srot } from "./src/srot/srot.mjs";
 export { srotm } from "./src/srotm/srotm.mjs";
+export { sgemv } from "./src/sgemv/sgemv.mjs";
+export { ssymv } from "./src/ssymv/ssymv.mjs";
+export { strmv } from "./src/strmv/strmv.mjs";
+export { strsv } from "./src/strsv/strsv.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wgblas",
-  "version": "0.1.2",
+  "version": "1.0.0",
   "description": "BLAS on WebGPU",
   "type": "module",
   "main": "index.mjs",
@@ -15,6 +15,10 @@
       "import": "./src/classes/GpuVector.mjs",
       "types": "./src/classes/GpuVector.d.mts"
     },
+    "./classes/GpuMatrix": {
+      "import": "./src/classes/GpuMatrix.mjs",
+      "types": "./src/classes/GpuMatrix.d.mts"
+    },
     "./random": {
       "import": "./src/random/random.mjs",
       "types": "./src/random/random.d.mts"
@@ -43,6 +47,10 @@
       "import": "./src/sasum/sasum.mjs",
       "types": "./src/sasum/sasum.d.mts"
     },
+    "./dasum": {
+      "import": "./src/dasum/dasum.mjs",
+      "types": "./src/dasum/dasum.d.mts"
+    },
     "./snrm2": {
       "import": "./src/snrm2/snrm2.mjs",
       "types": "./src/snrm2/snrm2.d.mts"
@@ -58,6 +66,22 @@
     "./srotm": {
       "import": "./src/srotm/srotm.mjs",
       "types": "./src/srotm/srotm.d.mts"
+    },
+    "./sgemv": {
+      "import": "./src/sgemv/sgemv.mjs",
+      "types": "./src/sgemv/sgemv.d.mts"
+    },
+    "./ssymv": {
+      "import": "./src/ssymv/ssymv.mjs",
+      "types": "./src/ssymv/ssymv.d.mts"
+    },
+    "./strmv": {
+      "import": "./src/strmv/strmv.mjs",
+      "types": "./src/strmv/strmv.d.mts"
+    },
+    "./strsv": {
+      "import": "./src/strsv/strsv.mjs",
+      "types": "./src/strsv/strsv.d.mts"
     }
   },
   "files": [
@@ -89,17 +113,24 @@
     "webgpu": "^0.4.0"
   },
   "devDependencies": {
+    "@commitlint/cli": "^21.2.1",
+    "@commitlint/config-conventional": "^21.2.0",
     "@eslint/js": "^10.0.1",
+    "@stdlib/blas-base-dasum": "^0.4.1",
     "@stdlib/blas-base-isamax": "^0.1.1",
     "@stdlib/blas-base-sasum": "^0.3.1",
     "@stdlib/blas-base-saxpy": "^0.3.1",
     "@stdlib/blas-base-scopy": "^0.3.1",
     "@stdlib/blas-base-sdot": "^0.3.1",
+    "@stdlib/blas-base-sgemv": "^0.1.1",
     "@stdlib/blas-base-snrm2": "^0.3.1",
     "@stdlib/blas-base-srot": "^0.2.1",
     "@stdlib/blas-base-srotm": "^0.2.1",
     "@stdlib/blas-base-sscal": "^0.3.1",
     "@stdlib/blas-base-sswap": "^0.3.1",
+    "@stdlib/blas-base-ssymv": "^0.1.1",
+    "@stdlib/blas-base-strmv": "^0.1.0",
+    "@stdlib/blas-base-strsv": "^0.1.1",
     "@stdlib/random-array-uniform": "^0.2.2",
     "@stdlib/random-base-uniform": "^0.2.3",
     "esbuild": "^0.28.1",

package/src/classes/GpuMatrix.d.mts

@@ -0,0 +1,85 @@
+/**
+ * Represents a row-major Float32Array matrix stored in GPU memory.
+ *
+ * The buffer holds `rows * lda` elements. `lda` (leading dimension) is the
+ * number of floats between the start of consecutive rows — must be >= `cols`.
+ * When `lda === cols` the matrix is dense with no padding.
+ *
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/classes/GpuMatrix.mjs#L7">Source code: GpuMatrix.mjs (L7)</a>
+ * @see [MDN: GPUBuffer](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer)
+ * @category Classes
+ */
+export declare class GpuMatrix {
+  private constructor();
+
+  /** @internal */
+  readonly _buf: GPUBuffer;
+
+  /** Number of rows. */
+  readonly rows: number;
+
+  /** Number of columns. */
+  readonly cols: number;
+
+  /** Leading dimension — stride between row starts (>= cols). */
+  readonly lda: number;
+
+  /**
+   * Uploads a row-major Float32Array or Float64Array matrix to GPU memory. A
+   * Float64Array is packed as two f32s per element (WGSL has no f64 type)
+   * and stored across two GPU buffers internally; `read()` reassembles the
+   * original doubles.
+   *
+   * `lda` defaults to `cols` (dense, no padding between rows).
+   * `data` must have at least `rows * lda` elements.
+   *
+   * @param data - matrix data in row-major order
+   * @param rows - number of rows
+   * @param cols - number of columns
+   * @param lda  - leading dimension (default: cols)
+   *
+   * @example
+   * ```js
+   * import { init, GpuMatrix } from "wgblas";
+   *
+   * await init();
+   * // 2×3 matrix: [[1,2,3],[4,5,6]]
+   * const mat = GpuMatrix.from(new Float32Array([1,2,3,4,5,6]), 2, 3);
+   * console.log(mat.rows, mat.cols, mat.lda); // 2 3 3
+   * ```
+   */
+  static from(data: Float32Array | Float64Array, rows: number, cols: number, lda?: number): GpuMatrix;
+
+  /**
+   * Downloads the matrix from GPU memory and returns a dense row-major
+   * array of shape `rows × cols` — a `Float32Array`, or a `Float64Array` if
+   * this matrix was created from one. If `lda > cols`, the leading-dimension
+   * padding is stripped so the returned array is always tightly packed.
+   *
+   * @example
+   * ```js
+   * import { init, GpuMatrix } from "wgblas";
+   *
+   * await init();
+   * const mat = GpuMatrix.from(new Float32Array([1,2,3,4,5,6]), 2, 3);
+   * const data = await mat.read();
+   * console.log(data); // Float32Array [1, 2, 3, 4, 5, 6]
+   * ```
+   */
+  read(): Promise<Float32Array | Float64Array>;
+
+  /**
+   * Destroys the underlying GPU buffer. Call when the matrix is no longer
+   * needed to free GPU memory.
+   *
+   * @example
+   * ```js
+   * import { init, GpuMatrix } from "wgblas";
+   *
+   * await init();
+   * const mat = GpuMatrix.from(new Float32Array([1,2,3,4,5,6]), 2, 3);
+   * mat.destroy();
+   * ```
+   */
+  destroy(): void;
+}

package/src/classes/GpuMatrix.mjs

@@ -0,0 +1,91 @@
+import { getDevice } from "../init.mjs";
+import { uploadBuffer, stageReadback } from "../util/buffer.mjs";
+import { extractResult } from "../util/result.mjs";
+import { packF64, unpackF64 } from "../util/f64pack.mjs";
+
+export class GpuMatrix {
+  constructor(buffer, rows, cols, lda, auxBuffer = null) {
+    this._buf = buffer;
+    // Non-null only for Float64Array-backed matrices — see GpuVector for why
+    // (packF64 splits each element into a "main"/_buf f32 and "aux"/_auxBuf
+    // raw u32 — never a Float32Array, see f64pack.mjs).
+    this._auxBuf = auxBuffer;
+    this.rows = rows;
+    this.cols = cols;
+    this.lda  = lda;
+  }
+
+  /**
+   * Uploads a row-major Float32Array or Float64Array matrix to GPU memory.
+   * lda defaults to cols (dense, no padding between rows).
+   * data must have at least rows * lda elements.
+   */
+  static from(data, rows, cols, lda = cols) {
+    if (!(data instanceof Float32Array) && !(data instanceof Float64Array))
+      throw new Error("GpuMatrix.from expects a Float32Array or Float64Array.");
+    if (!Number.isInteger(rows) || rows <= 0)
+      throw new Error("rows must be a positive integer.");
+    if (!Number.isInteger(cols) || cols <= 0)
+      throw new Error("cols must be a positive integer.");
+    if (!Number.isInteger(lda) || lda < cols)
+      throw new Error("lda must be an integer >= cols.");
+    if (data.length < rows * lda)
+      throw new Error(
+        "data does not have enough elements for the given rows and lda.",
+      );
+
+    if (data instanceof Float64Array) {
+      const n = rows * lda;
+      const main = new Float32Array(n);
+      const aux = new Uint32Array(n);
+      for (let i = 0; i < n; i++) {
+        const packed = packF64(data[i]);
+        main[i] = packed[0];
+        aux[i] = packed[1];
+      }
+      const mainBuf = uploadBuffer(main, "gpu-matrix-f64-main", true);
+      const auxBuf = uploadBuffer(aux, "gpu-matrix-f64-aux", true);
+      return new GpuMatrix(mainBuf, rows, cols, lda, auxBuf);
+    }
+
+    const buf = uploadBuffer(data.subarray(0, rows * lda), "gpu-matrix", true);
+    return new GpuMatrix(buf, rows, cols, lda);
+  }
+
+  async read() {
+    const device = getDevice();
+    const enc = device.createCommandEncoder();
+    const rb = stageReadback(enc, this._buf);
+    device.queue.submit([enc.finish()]);
+
+    if (this._auxBuf) {
+      const encAux = device.createCommandEncoder();
+      const rbAux = stageReadback(encAux, this._auxBuf);
+      device.queue.submit([encAux.finish()]);
+
+      const [main, aux] = await Promise.all([
+        extractResult(rb, Float32Array),
+        extractResult(rbAux, Uint32Array),
+      ]);
+      const raw = new Float64Array(this.rows * this.lda);
+      for (let i = 0; i < raw.length; i++) raw[i] = unpackF64(main[i], aux[i]);
+      if (this.lda === this.cols) return raw;
+      const out = new Float64Array(this.rows * this.cols);
+      for (let r = 0; r < this.rows; r++)
+        out.set(raw.subarray(r * this.lda, r * this.lda + this.cols), r * this.cols);
+      return out;
+    }
+
+    const raw = await extractResult(rb, Float32Array);
+    if (this.lda === this.cols) return raw;
+    const out = new Float32Array(this.rows * this.cols);
+    for (let r = 0; r < this.rows; r++)
+      out.set(raw.subarray(r * this.lda, r * this.lda + this.cols), r * this.cols);
+    return out;
+  }
+
+  destroy() {
+    this._buf.destroy();
+    if (this._auxBuf) this._auxBuf.destroy();
+  }
+}

package/src/classes/GpuVector.d.mts

@@ -12,12 +12,13 @@ export declare class GpuVector {
   /** Number of elements in the vector. */
   readonly length: number;
 
-  // TODO: widen to Float32ArrayConstructor | Float64ArrayConstructor when Float64 support is added
   /** Typed array constructor used when reading data back from the GPU. */
-  readonly dtype: Float32ArrayConstructor;
+  readonly dtype: Float32ArrayConstructor | Float64ArrayConstructor;
 
   /**
-   * Uploads a Float32Array to GPU memory.
+   * Uploads a Float32Array or Float64Array to GPU memory. A Float64Array is
+   * packed as two f32s per element (WGSL has no f64 type) and stored across
+   * two GPU buffers internally; `read()` reassembles the original doubles.
    *
    * @param data - input vector data
    * @returns GpuVector backed by a GPU buffer
@@ -29,15 +30,18 @@ export declare class GpuVector {
    * await init();
    * const vec = GpuVector.from(new Float32Array([1, 2, 3, 4]));
    * console.log("length:", vec.length, "dtype:", vec.dtype.name);
+   *
+   * const dvec = GpuVector.from(new Float64Array([1.1, 2.2, 3.3]));
+   * console.log("dtype:", dvec.dtype.name); // Float64Array
    * ```
    */
-  static from(data: Float32Array): GpuVector;
+  static from(data: Float32Array | Float64Array): GpuVector;
 
-  // TODO: return type will widen to Promise<Float32Array | Float64Array> when Float64 support is added
   /**
    * Reads the vector data back from GPU memory.
    *
-   * @returns vector data as a Float32Array
+   * @returns vector data as a Float32Array, or a Float64Array if this vector
+   * was created from one
    *
    * @example
    * ```js
@@ -49,7 +53,7 @@ export declare class GpuVector {
    * console.log(data);
    * ```
    */
-  read(): Promise<Float32Array>;
+  read(): Promise<Float32Array | Float64Array>;
 
   /**
    * Destroys the underlying GPU buffer. Call when the vector is no longer needed

package/src/classes/GpuVector.mjs

@@ -1,19 +1,31 @@
 import { getDevice } from "../init.mjs";
 import { uploadBuffer, stageReadback } from "../util/buffer.mjs";
 import { extractResult } from "../util/result.mjs";
-
-//TODO: Need to update this when we support Float64Array.
+import { packF64, unpackF64 } from "../util/f64pack.mjs";
 
 export class GpuVector {
-  constructor(buffer, length, dtype = Float32Array) {
+  constructor(buffer, length, dtype = Float32Array, auxBuffer = null) {
     this._buf = buffer;
+    this._auxBuf = auxBuffer;
     this.length = length;
     this.dtype = dtype;
   }
 
   static from(data) {
+    if (data instanceof Float64Array) {
+      const main = new Float32Array(data.length);
+      const aux = new Uint32Array(data.length);
+      for (let i = 0; i < data.length; i++) {
+        const packed = packF64(data[i]);
+        main[i] = packed[0];
+        aux[i] = packed[1];
+      }
+      const mainBuf = uploadBuffer(main, "gpu-vector-f64-main", true);
+      const auxBuf = uploadBuffer(aux, "gpu-vector-f64-aux", true);
+      return new GpuVector(mainBuf, data.length, Float64Array, auxBuf);
+    }
     if (!(data instanceof Float32Array)) {
-      throw new Error("GpuVector.from expects a 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);
@@ -24,10 +36,24 @@ export class GpuVector {
     const enc = device.createCommandEncoder();
     const rb = stageReadback(enc, this._buf);
     device.queue.submit([enc.finish()]);
-    return extractResult(rb, this.dtype);
+
+    if (!this._auxBuf) return extractResult(rb, this.dtype);
+
+    const encAux = device.createCommandEncoder();
+    const rbAux = stageReadback(encAux, this._auxBuf);
+    device.queue.submit([encAux.finish()]);
+
+    const [main, aux] = await Promise.all([
+      extractResult(rb, Float32Array),
+      extractResult(rbAux, Uint32Array),
+    ]);
+    const out = new Float64Array(this.length);
+    for (let i = 0; i < this.length; i++) out[i] = unpackF64(main[i], aux[i]);
+    return out;
   }
 
   destroy() {
     this._buf.destroy();
+    if (this._auxBuf) this._auxBuf.destroy();
   }
 }

package/src/dasum/dasum.d.mts

@@ -0,0 +1,48 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+/**
+ * Computes the sum of absolute values of a vector of doubles in double
+ * precision: result = sum(|x[i]|). Each element of `x` is packed into a
+ * [main, aux] f32 pair (see `packF64`/`GpuVector`) since WGSL has no f64
+ * type; accumulation is done with f64add.wgsl's IEEE-754 binary64 addition.
+ *
+ * {@includeCode ../../examples/dasum/dasum.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/dasum/web/dasum.html}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - Float64Array input vector
+ * @param incx - stride for x (must be a positive integer)
+ * @returns absolute sum scalar — always a CPU readback, even for GpuVector inputs
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/dasum/dasum.mjs#L18">Source code: dasum.mjs (L18)</a>
+ * @category BLAS Level 1
+ */
+export declare function dasum(
+  device: GPUDevice,
+  n: number,
+  x: Float64Array,
+  incx: number,
+): Promise<{ asum: number } | { asum: number; gpuTimeMs: number }>;
+
+/**
+ * Computes the sum of absolute values of a vector of doubles in double
+ * precision: result = sum(|x[i]|).
+ *
+ * {@includeCode ../../examples/dasum/gpuvec.dasum.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - Float64Array-backed GpuVector input vector
+ * @param incx - stride for x (must be a positive integer)
+ * @returns absolute sum scalar — always a CPU readback, even for GpuVector inputs
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/dasum/dasum.mjs#L18">Source code: dasum.mjs (L18)</a>
+ * @category BLAS Level 1
+ */
+export declare function dasum(
+  device: GPUDevice,
+  n: number,
+  x: GpuVector,
+  incx: number,
+): Promise<{ asum: number } | { asum: number; gpuTimeMs: number }>;

package/src/dasum/dasum.mjs

@@ -0,0 +1,121 @@
+import {
+  createStorageBuffer,
+  createParamsBuffer,
+  createResultBuffer,
+  stageReadback,
+  destroyBuffers,
+} from "../util/buffer.mjs";
+import { createBindGroup } from "../util/bindgroup.mjs";
+import { runComputePass, submit } from "../util/compute.mjs";
+import { extractTimestamp } from "../util/benchmark.mjs";
+import { extractResult } from "../util/result.mjs";
+import { getPipeline } from "../util/pipeline.mjs";
+import { unpackF64 } from "../util/f64pack.mjs";
+import { GpuVector } from "../classes/GpuVector.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.");
+  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.");
+  if (!xIsGpu && !(x instanceof Float64Array))
+    throw new Error("x must be a Float64Array or GpuVector.");
+  if (xIsGpu && x.dtype !== Float64Array)
+    throw new Error("x must be a Float64Array-backed GpuVector.");
+  if (n <= 0) return { asum: 0 };
+  if (x.length < (n - 1) * incx + 1)
+    throw new Error(
+      "x does not have enough elements for the given n and incx.",
+    );
+
+  // dasum.wgsl/reduction/sumF64.wgsl are each concatenated with f64add.wgsl
+  // (reusing its decode/encode/computeSum/Packed — WGSL has no #include).
+  // f64add.wgsl declares no bindings/entry point of its own, so each
+  // concatenated module has exactly one @compute entry — omitting entryPoint
+  // here lets getPipeline auto-detect it, the stable path (see pipeline.mjs).
+  const pipelineMain = await getPipeline(device, ["f64add", "dasum"]);
+  const pipelineReduce = await getPipeline(device, ["f64add", "reduction/sumF64"]);
+
+  let xVec = null;
+  let partialsMainBuffer = null;
+  let partialsAuxBuffer = null;
+  let resultMainBuffer = null;
+  let resultAuxBuffer = null;
+  let paramsBuffer = null;
+  let readMainBuffer = null;
+  let readAuxBuffer = null;
+
+  try {
+    xVec = xIsGpu ? x : GpuVector.from(x);
+    partialsMainBuffer = createStorageBuffer(2 * WGS * 4, "dasum-partialsMain"); // 2*WGS partial sums, main halves
+    partialsAuxBuffer = createStorageBuffer(2 * WGS * 4, "dasum-partialsAux"); // 2*WGS partial sums, aux halves (raw u32 bits)
+    resultMainBuffer = createResultBuffer(4, "dasum-result-main"); // final main half
+    resultAuxBuffer = createResultBuffer(4, "dasum-result-aux"); // final aux half (raw u32 bits)
+    paramsBuffer = createParamsBuffer(
+      [
+        { value: n, type: "u32" },
+        { value: incx, type: "u32" },
+      ],
+      "dasum-params",
+    );
+
+    const bgMain = createBindGroup(
+      pipelineMain.getBindGroupLayout(0),
+      [xVec._buf, xVec._auxBuf, partialsMainBuffer, partialsAuxBuffer, paramsBuffer],
+    );
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+      pipelineMain,
+      bgMain,
+      2 * WGS,
+    ); // dispatch 2*WGS workgroups
+
+    submit(enc1);
+
+    const bgReduce = createBindGroup(
+      pipelineReduce.getBindGroupLayout(0),
+      [partialsMainBuffer, partialsAuxBuffer, resultMainBuffer, resultAuxBuffer],
+    );
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+      pipelineReduce,
+      bgReduce,
+      1,
+    ); // dispatch 1 workgroup to reduce the partial sums to a single result
+    readMainBuffer = stageReadback(enc2, resultMainBuffer);
+    readAuxBuffer = stageReadback(enc2, resultAuxBuffer);
+
+    submit(enc2);
+
+    const mainPromise = extractResult(readMainBuffer, Float32Array);
+    const auxPromise = extractResult(readAuxBuffer, Uint32Array);
+    readMainBuffer = null; // ownership transferred — extractResult's own finally destroys it
+    readAuxBuffer = null;
+
+    const [gpuTime1, gpuTime2, mainArr, auxArr] = await Promise.all([
+      extractTimestamp(ts1),
+      extractTimestamp(ts2),
+      mainPromise,
+      auxPromise,
+    ]);
+
+    // asum is always a scalar readback — both paths return { asum }
+    const asum = unpackF64(mainArr[0], auxArr[0]);
+    if (gpuTime1 !== undefined && gpuTime2 !== undefined)
+      return { asum, gpuTimeMs: gpuTime1 + gpuTime2 };
+    return { asum };
+  } finally {
+    if (!xIsGpu && xVec) xVec.destroy();
+    if (partialsMainBuffer) destroyBuffers(partialsMainBuffer);
+    if (partialsAuxBuffer) destroyBuffers(partialsAuxBuffer);
+    if (resultMainBuffer) destroyBuffers(resultMainBuffer);
+    if (resultAuxBuffer) destroyBuffers(resultAuxBuffer);
+    if (paramsBuffer) destroyBuffers(paramsBuffer);
+    // Only reached if submit(enc2) threw before ownership was transferred above.
+    if (readMainBuffer) destroyBuffers(readMainBuffer);
+    if (readAuxBuffer) destroyBuffers(readAuxBuffer);
+  }
+}

package/src/init.mjs

@@ -41,7 +41,9 @@ export async function init({
   }
 
   _benchmarkEnabled = benchmark;
-  _device = await _adapter.requestDevice(benchmarkMode(_adapter, benchmark));
+  const bmConfig = benchmarkMode(_adapter, benchmark);
+  const features = [...(bmConfig.requiredFeatures ?? [])];
+  _device = await _adapter.requestDevice({ requiredFeatures: features });
   // Fires for any GPU error not caught by a pushErrorScope/popErrorScope pair — surfaces silent GPU failures to the console.
   // See: https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/uncapturederror_event
   _device.addEventListener("uncapturederror", (e) => {