wgblas 0.1.2 → 1.1.0

package/dist/wgblas.browser.js

@@ -1,4 +1,4 @@
-var wgblas=(()=>{var jr=Object.create;var L=Object.defineProperty;var Qr=Object.getOwnPropertyDescriptor;var Xr=Object.getOwnPropertyNames;var Hr=Object.getPrototypeOf,Kr=Object.prototype.hasOwnProperty;var q=(t=>typeof require<"u"?require:typeof Proxy<"u"?new Proxy(t,{get:(r,e)=>(typeof require<"u"?require:r)[e]}):t)(function(t){if(typeof require<"u")return require.apply(this,arguments);throw Error('Dynamic require of "'+t+'" is not supported')});var I=(t,r,e)=>()=>{if(e)throw e[0];try{return t&&(r=t(t=0)),r}catch(a){throw e=[a],a}};var X=(t,r)=>{for(var e in r)L(t,e,{get:r[e],enumerable:!0})},H=(t,r,e,a)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of Xr(r))!Kr.call(t,o)&&o!==e&&L(t,o,{get:()=>r[o],enumerable:!(a=Qr(r,o))||a.enumerable});return t};var Y=(t,r,e)=>(e=t!=null?jr(Hr(t)):{},H(r||!t||!t.__esModule?L(e,"default",{value:t,enumerable:!0}):e,t)),Zr=t=>H(L({},"__esModule",{value:!0}),t);var ur,sr=I(()=>{ur=`// amax reduction: collapses 2*WGS (value, index) pairs into one index.
+var wgblas=(()=>{var ct=Object.create;var ur=Object.defineProperty;var mt=Object.getOwnPropertyDescriptor;var dt=Object.getOwnPropertyNames;var pt=Object.getPrototypeOf,gt=Object.prototype.hasOwnProperty;var lr=(a=>typeof require<"u"?require:typeof Proxy<"u"?new Proxy(a,{get:(r,e)=>(typeof require<"u"?require:r)[e]}):a)(function(a){if(typeof require<"u")return require.apply(this,arguments);throw Error('Dynamic require of "'+a+'" is not supported')});var I=(a,r,e)=>()=>{if(e)throw e[0];try{return a&&(r=a(a=0)),r}catch(o){throw e=[o],o}};var yr=(a,r)=>{for(var e in r)ur(a,e,{get:r[e],enumerable:!0})},_r=(a,r,e,o)=>{if(r&&typeof r=="object"||typeof r=="function")for(let t of dt(r))!gt.call(a,t)&&t!==e&&ur(a,t,{get:()=>r[t],enumerable:!(o=mt(r,t))||o.enumerable});return a};var fr=(a,r,e)=>(e=a!=null?ct(pt(a)):{},_r(r||!a||!a.__esModule?ur(e,"default",{value:a,enumerable:!0}):e,a)),wt=a=>_r(ur({},"__esModule",{value:!0}),a);var Mr,Ir=I(()=>{Mr=`// amax reduction: collapses 2*WGS (value, index) pairs into one index.
 // dispatch: 1 workgroup of WGS threads.
 // partials_val and partials_idx must have exactly 2*WGS entries.
 
@@ -41,7 +41,7 @@ fn reduce(
 
   if (i == 0u) { result[0] = tile_idx[0]; }
 }
-`});var cr,fr=I(()=>{cr=`// sum reduction: collapses 2*WGS partials into one scalar.
+`});var Tr,Ur=I(()=>{Tr=`// sum reduction: collapses 2*WGS partials into one scalar.
 // dispatch: 1 workgroup of WGS threads.
 // partials must have exactly 2*WGS entries.
 
@@ -67,7 +67,56 @@ fn reduce(
 
   if (i == 0u) { result[0] = tile[0]; }
 }
-`});var mr,pr=I(()=>{mr=`// sscal: x = alpha * x
+`});var Rr,Vr=I(()=>{Rr=`// sum reduction (f64): collapses 2*WGS partial [main, aux] pairs into one,
+// using computeSum instead of plain f32 \`+\` (see reduction/sum.wgsl for the
+// f32 original this mirrors).
+// dispatch: 1 workgroup of WGS threads. partialsMain/partialsAux must have
+// exactly 2*WGS entries each.
+//
+// Concatenated after f64add.wgsl by getPipeline (WGSL has no #include),
+// reusing its decode/encode/computeSum and Packed struct \u2014 f64add.wgsl
+// declares no bindings and no entry point of its own (just helper functions),
+// so bindings here start at 0 and the entry point is simply \`reduce_f64\`.
+//
+// partialsAux/result's aux slot are array<u32>, not array<f32> \u2014 aux's bits
+// must never pass through an f32-typed storage slot (NaN-bit-pattern
+// corruption risk, see f64pack.mjs and the Packed struct comment above
+// decode()/encode() in f64add.wgsl).
+
+@group(0) @binding(0) var<storage, read>       partialsMain: array<f32>;
+@group(0) @binding(1) var<storage, read>       partialsAux:  array<u32>;
+@group(0) @binding(2) var<storage, read_write> resultMain:   array<f32, 1>;
+@group(0) @binding(3) var<storage, read_write> resultAux:    array<u32, 1>;
+
+const WGS: u32 = 64;
+
+var<workgroup> tile: array<Packed, 64>;
+
+fn addPair(a: Packed, b: Packed) -> Packed {
+  return computeSum(decode(bitcast<u32>(a.main), a.aux), decode(bitcast<u32>(b.main), b.aux));
+}
+
+@compute @workgroup_size(64)
+fn reduce_f64(
+  @builtin(local_invocation_id) lid: vec3u,
+) {
+  let i = lid.x;
+  let a = Packed(partialsMain[i], partialsAux[i]);
+  let b = Packed(partialsMain[i + WGS], partialsAux[i + WGS]);
+  tile[i] = addPair(a, b);
+  workgroupBarrier();
+
+  for (var s = WGS / 2u; s > 0u; s >>= 1u) {
+    if (i < s) { tile[i] = addPair(tile[i], tile[i + s]); }
+    workgroupBarrier();
+  }
+
+  if (i == 0u) {
+    resultMain[0] = tile[0].main;
+    resultAux[0] = tile[0].aux;
+  }
+}
+`});var Dr,Hr=I(()=>{Dr=`// sscal: x = alpha * x
 
 @group(0) @binding(0) var<storage, read_write> x: array<f32>;
 
@@ -90,7 +139,7 @@ fn main(
     x[id * params.x_inc] = params.alpha * x[id * params.x_inc];
   }
 }
-`});var dr,lr=I(()=>{dr=`// sswap: x <-> y
+`});var Or,Cr=I(()=>{Or=`// sswap: x <-> y
 
 @group(0) @binding(0) var<storage, read_write> x: array<f32>;
 @group(0) @binding(1) var<storage, read_write> y: array<f32>;
@@ -116,7 +165,7 @@ fn main(
     y[id * params.y_inc] = temp;
   }
 }
-`});var wr,gr=I(()=>{wr=`// saxpy: y = alpha * x + y
+`});var Qr,zr=I(()=>{Qr=`// saxpy: y = alpha * x + y
 
 @group(0) @binding(0) var<storage, read>       x: array<f32>;
 @group(0) @binding(1) var<storage, read_write> y: array<f32>;
@@ -141,7 +190,7 @@ fn main(
     y[id * params.y_inc] = params.alpha * x[id * params.x_inc] + y[id * params.y_inc];
   }
 }
-`});var vr,yr=I(()=>{vr=`// scopy: y = x
+`});var Zr,qr=I(()=>{Zr=`// scopy: y = x
 
 @group(0) @binding(0) var<storage, read>       x: array<f32>;
 @group(0) @binding(1) var<storage, read_write> y: array<f32>;
@@ -165,7 +214,7 @@ fn main(
     y[id * params.y_inc] = x[id * params.x_inc];
   }
 }
-`});var xr,br=I(()=>{xr=`// sdot: result = sum(x[i] * y[i])
+`});var Xr,Kr=I(()=>{Xr=`// sdot: result = sum(x[i] * y[i])
 // pass 1 dispatches exactly 2 * WGS workgroups; pass 2 uses reduction/sum.wgsl.
 
 @group(0) @binding(0) var<storage, read>       x:        array<f32>;
@@ -190,11 +239,25 @@ fn main(
   @builtin(workgroup_id)         wgid:   vec3u,
   @builtin(num_workgroups)       num_wg: vec3u,
 ) {
-  var acc: f32 = 0.0;
-  for (var id = gid.x; id < params.n; id += num_wg.x * WGS) {
-    acc += x[id * params.x_inc] * y[id * params.y_inc];
+  var acc0: f32 = 0.0;
+  var acc1: f32 = 0.0;
+  var acc2: f32 = 0.0;
+  var acc3: f32 = 0.0;
+
+  let stride   = num_wg.x * WGS;
+  let n4_floor = (params.n / (4u * stride)) * (4u * stride);
+
+  for (var id = gid.x; id < n4_floor; id += 4u * stride) {
+    acc0 += x[ id                * params.x_inc] * y[ id                * params.y_inc];
+    acc1 += x[(id +      stride) * params.x_inc] * y[(id +      stride) * params.y_inc];
+    acc2 += x[(id + 2u * stride) * params.x_inc] * y[(id + 2u * stride) * params.y_inc];
+    acc3 += x[(id + 3u * stride) * params.x_inc] * y[(id + 3u * stride) * params.y_inc];
+  }
+  for (var id = n4_floor + gid.x; id < params.n; id += stride) {
+    acc0 += x[id * params.x_inc] * y[id * params.y_inc];
   }
-  tile[lid.x] = acc;
+
+  tile[lid.x] = acc0 + acc1 + acc2 + acc3;
   workgroupBarrier();
 
   for (var s = WGS / 2u; s > 0u; s >>= 1u) {
@@ -204,7 +267,7 @@ fn main(
 
   if (lid.x == 0u) { partials[wgid.x] = tile[0]; }
 }
-`});var _r,hr=I(()=>{_r=`// sasum: result = sum(|x[i]|)
+`});var Yr,$r=I(()=>{Yr=`// sasum: result = sum(|x[i]|)
 // pass 1 dispatches exactly 2 * WGS workgroups; pass 2 uses reduction/abssum.wgsl.
 
 @group(0) @binding(0) var<storage, read>       x:        array<f32>;
@@ -227,11 +290,25 @@ fn main(
   @builtin(workgroup_id)         wgid:   vec3u,
   @builtin(num_workgroups)       num_wg: vec3u,
 ) {
-  var acc: f32 = 0.0;
-  for (var id = gid.x; id < params.n; id += num_wg.x * WGS) {
-    acc += abs(x[id * params.x_inc]);
+  var acc0: f32 = 0.0;
+  var acc1: f32 = 0.0;
+  var acc2: f32 = 0.0;
+  var acc3: f32 = 0.0;
+
+  let stride   = num_wg.x * WGS;
+  let n4_floor = (params.n / (4u * stride)) * (4u * stride);
+
+  for (var id = gid.x; id < n4_floor; id += 4u * stride) {
+    acc0 += abs(x[ id                * params.x_inc]);
+    acc1 += abs(x[(id +      stride) * params.x_inc]);
+    acc2 += abs(x[(id + 2u * stride) * params.x_inc]);
+    acc3 += abs(x[(id + 3u * stride) * params.x_inc]);
+  }
+  for (var id = n4_floor + gid.x; id < params.n; id += stride) {
+    acc0 += abs(x[id * params.x_inc]);
   }
-  tile[lid.x] = acc;
+
+  tile[lid.x] = acc0 + acc1 + acc2 + acc3;
   workgroupBarrier();
 
   for (var s = WGS / 2u; s > 0u; s >>= 1u) {
@@ -241,7 +318,7 @@ fn main(
 
   if (lid.x == 0u) { partials[wgid.x] = tile[0]; }
 }
-`});var Br,Gr=I(()=>{Br=`// snrm2: result = sqrt(sum(x[i] * x[i]))
+`});var re,Jr=I(()=>{re=`// snrm2: result = sqrt(sum(x[i] * x[i]))
 // pass 1 dispatches exactly 2 * WGS workgroups; pass 2 uses reduction/sqsum.wgsl.
 
 @group(0) @binding(0) var<storage, read>       x:        array<f32>;
@@ -264,12 +341,30 @@ fn main(
   @builtin(workgroup_id)         wgid:   vec3u,
   @builtin(num_workgroups)       num_wg: vec3u,
 ) {
-  var acc: f32 = 0.0;
-  for (var id = gid.x; id < params.n; id += num_wg.x * WGS) {
+  var acc0: f32 = 0.0;
+  var acc1: f32 = 0.0;
+  var acc2: f32 = 0.0;
+  var acc3: f32 = 0.0;
+
+  let stride   = num_wg.x * WGS;
+  let n4_floor = (params.n / (4u * stride)) * (4u * stride);
+
+  for (var id = gid.x; id < n4_floor; id += 4u * stride) {
+    let v0 = x[ id                * params.x_inc];
+    let v1 = x[(id +      stride) * params.x_inc];
+    let v2 = x[(id + 2u * stride) * params.x_inc];
+    let v3 = x[(id + 3u * stride) * params.x_inc];
+    acc0 += v0 * v0;
+    acc1 += v1 * v1;
+    acc2 += v2 * v2;
+    acc3 += v3 * v3;
+  }
+  for (var id = n4_floor + gid.x; id < params.n; id += stride) {
     let v = x[id * params.x_inc];
-    acc += v * v;
+    acc0 += v * v;
   }
-  tile[lid.x] = acc;
+
+  tile[lid.x] = acc0 + acc1 + acc2 + acc3;
   workgroupBarrier();
 
   for (var s = WGS / 2u; s > 0u; s >>= 1u) {
@@ -279,7 +374,7 @@ fn main(
 
   if (lid.x == 0u) { partials[wgid.x] = tile[0]; }
 }
-`});var Pr,Er=I(()=>{Pr=`// srot: x = c*x + s*y,  y = -s*x + c*y
+`});var te,ee=I(()=>{te=`// srot: x = c*x + s*y,  y = -s*x + c*y
 
 @group(0) @binding(0) var<storage, read_write> x: array<f32>;
 @group(0) @binding(1) var<storage, read_write> y: array<f32>;
@@ -308,7 +403,7 @@ fn main(
     y[id * params.y_inc] = -params.s * xi + params.c * yi;
   }
 }
-`});var kr,Ar=I(()=>{kr=`// srotm: applies modified Givens rotation H to vectors x and y.
+`});var oe,ae=I(()=>{oe=`// srotm: applies modified Givens rotation H to vectors x and y.
 // param[0] = flag: -1 (full H), 0 (unit diagonal), 1 (unit off-diagonal)
 // param = [ flag, h11, h21, h12, h22 ]
 // flag == -2 (identity/no-op) is handled in JS before dispatch reaches here.
@@ -358,7 +453,7 @@ fn main(
     y[id * params.y_inc] = h21 * xi + h22 * yi;
   }
 }
-`});var Fr,Sr=I(()=>{Fr=`// isamax: returns index of element with largest absolute value
+`});var ne,ie=I(()=>{ne=`// isamax: returns index of element with largest absolute value
 // pass 1 dispatches exactly 2 * WGS workgroups; pass 2 uses reduction/argmax.wgsl.
 
 @group(0) @binding(0) var<storage, read>       x:            array<f32>;
@@ -385,19 +480,42 @@ fn main(
 ) {
   // -1.0 is a safe sentinel: any |x[i]| >= 0 beats it,
   // so workgroups with no elements lose gracefully in the epilogue.
-  var best_val: f32 = -1.0;
-  var best_idx: u32 = 0u;
-
-  for (var id = gid.x; id < params.n; id += num_wg.x * WGS) {
+  var best_val0: f32 = -1.0; var best_idx0: u32 = 0u;
+  var best_val1: f32 = -1.0; var best_idx1: u32 = 0u;
+  var best_val2: f32 = -1.0; var best_idx2: u32 = 0u;
+  var best_val3: f32 = -1.0; var best_idx3: u32 = 0u;
+
+  let stride   = num_wg.x * WGS;
+  let n4_floor = (params.n / (4u * stride)) * (4u * stride);
+
+  for (var id = gid.x; id < n4_floor; id += 4u * stride) {
+    let v0 = abs(x[ id                * params.x_inc]);
+    let v1 = abs(x[(id +      stride) * params.x_inc]);
+    let v2 = abs(x[(id + 2u * stride) * params.x_inc]);
+    let v3 = abs(x[(id + 3u * stride) * params.x_inc]);
+    if (v0 > best_val0) { best_val0 = v0; best_idx0 = id; }
+    if (v1 > best_val1) { best_val1 = v1; best_idx1 = id +      stride; }
+    if (v2 > best_val2) { best_val2 = v2; best_idx2 = id + 2u * stride; }
+    if (v3 > best_val3) { best_val3 = v3; best_idx3 = id + 3u * stride; }
+  }
+  for (var id = n4_floor + gid.x; id < params.n; id += stride) {
     let v = abs(x[id * params.x_inc]);
-    if (v > best_val) {
-      best_val = v;
-      best_idx = id;
-    }
+    if (v > best_val0) { best_val0 = v; best_idx0 = id; }
+  }
+
+  // merge 4 independent lanes; prefer lower index on tie (first occurrence wins)
+  if (best_val1 > best_val0 || (best_val1 == best_val0 && best_idx1 < best_idx0)) {
+    best_val0 = best_val1; best_idx0 = best_idx1;
+  }
+  if (best_val2 > best_val0 || (best_val2 == best_val0 && best_idx2 < best_idx0)) {
+    best_val0 = best_val2; best_idx0 = best_idx2;
+  }
+  if (best_val3 > best_val0 || (best_val3 == best_val0 && best_idx3 < best_idx0)) {
+    best_val0 = best_val3; best_idx0 = best_idx3;
   }
 
-  tile_val[lid.x] = best_val;
-  tile_idx[lid.x] = best_idx;
+  tile_val[lid.x] = best_val0;
+  tile_idx[lid.x] = best_idx0;
   workgroupBarrier();
 
   for (var s = WGS / 2u; s > 0u; s >>= 1u) {
@@ -417,6 +535,1100 @@ fn main(
     partials_idx[wgid.x] = tile_idx[0];
   }
 }
-`});var Rr={};X(Rr,{shaderSources:()=>pe});var pe,Wr=I(()=>{sr();fr();pr();lr();gr();yr();br();hr();Gr();Er();Ar();Sr();pe={"reduction/argmax":ur,"reduction/sum":cr,sscal:mr,sswap:dr,saxpy:wr,scopy:vr,sdot:xr,sasum:_r,snrm2:Br,srot:Pr,srotm:kr,isamax:Fr}});var we={};X(we,{GpuVector:()=>m,cleanup:()=>ar,gpuName:()=>or,init:()=>tr,isamax:()=>qr,randomFloat32Array:()=>ir,randomFloat64Array:()=>nr,sasum:()=>zr,saxpy:()=>Tr,scopy:()=>Dr,sdot:()=>Vr,snrm2:()=>Lr,srot:()=>Yr,srotm:()=>$r,sscal:()=>Ir,sswap:()=>Mr});function K(t,r){return r?t.features.has("timestamp-query")?{requiredFeatures:["timestamp-query"]}:(console.warn("timestamp-query not supported on this device \u2014 benchmark mode disabled."),{}):{}}function Z(){if(!rr())return{querySet:null,passDescriptor:void 0};let r=F().createQuerySet({type:"timestamp",count:2});return{querySet:r,passDescriptor:{timestampWrites:{querySet:r,beginningOfPassWriteIndex:0,endOfPassWriteIndex:1}}}}function J(t,r){if(!r)return null;let e=F(),a=e.createBuffer({label:"timestamp-resolve",size:16,usage:GPUBufferUsage.QUERY_RESOLVE|GPUBufferUsage.COPY_SRC});t.resolveQuerySet(r,0,2,a,0);let o=e.createBuffer({label:"timestamp-readback",size:16,usage:GPUBufferUsage.COPY_DST|GPUBufferUsage.MAP_READ});return t.copyBufferToBuffer(a,0,o,0,16),{tsReadBuffer:o,resolveBuffer:a,querySet:r}}async function G(t){if(!t)return;let{tsReadBuffer:r,resolveBuffer:e,querySet:a}=t;await r.mapAsync(GPUMapMode.READ);let o=new BigInt64Array(r.getMappedRange().slice());return r.unmap(),r.destroy(),e.destroy(),a.destroy(),Number(o[1]-o[0])/1e6}var T=null,C=null,er=null,$=!1;async function tr({powerPreference:t="high-performance",benchmark:r=!1}={}){if(T)return T;let e;if(typeof window>"u"){let{create:a,globals:o}=await import("webgpu");Object.assign(globalThis,o),e=a([]),er=e}else e=navigator.gpu;if(!e)throw new Error("WebGPU not supported in this environment.");if(C=await e.requestAdapter({powerPreference:t})??await e.requestAdapter(),!C)throw new Error("No WebGPU adapter found.");return $=r,T=await C.requestDevice(K(C,r)),T.addEventListener("uncapturederror",a=>{console.error("Uncaptured GPU error:",a.error.message)}),T}function ar(){T&&(T.destroy(),T=null),C=null,er=null,$=!1}function or(){if(!C)throw new Error("WebGPU adapter not initialized \u2014 call init() first.");let{device:t,description:r}=C.info;return{description:r||"unknown",device:t||"unknown"}}function rr(){return $}function F(){if(!T)throw new Error("WebGPU device not initialized \u2014 call init() first.");return T}function w(...t){t.flat().forEach(r=>r.destroy())}function v(t,r="blas-input",e=!1){let a=F(),o=a.limits.maxStorageBufferBindingSize,n=t.byteLength;if(n>o)throw new Error(`Buffer size ${n} bytes exceeds device limit of ${o} bytes.`);let s=e?GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_SRC:GPUBufferUsage.STORAGE,i=a.createBuffer({label:r,size:n,usage:s,mappedAtCreation:!0});return new Float32Array(i.getMappedRange()).set(t),i.unmap(),i}function N(t,r="blas-storage"){return F().createBuffer({label:r,size:t,usage:GPUBufferUsage.STORAGE})}function V(t,r="blas-result"){return F().createBuffer({label:r,size:t,usage:GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_SRC})}function h(t,r){let a=F().createBuffer({label:"blas-readback",size:r.size,usage:GPUBufferUsage.COPY_DST|GPUBufferUsage.MAP_READ});return t.copyBufferToBuffer(r,0,a,0,r.size),a}function R(t,r="blas-params"){let e=F(),a=t.length*4,o=Math.ceil(a/16)*16,n=new ArrayBuffer(o),s=new DataView(n);t.forEach(({value:u,type:f},c)=>{let p=c*4;if(f==="u32")s.setUint32(p,u,!0);else if(f==="i32")s.setInt32(p,u,!0);else if(f==="f32")s.setFloat32(p,u,!0);else throw new Error(`Unknown param type "${f}". Use "f32", "u32", or "i32".`)});let i=e.createBuffer({label:r,size:o,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});return e.queue.writeBuffer(i,0,n),i}async function _(t,r=Float32Array){await t.mapAsync(GPUMapMode.READ);let e=new r(t.getMappedRange().slice());return t.unmap(),e}var m=class t{constructor(r,e,a=Float32Array){this._buf=r,this.length=e,this.dtype=a}static from(r){if(!(r instanceof Float32Array))throw new Error("GpuVector.from expects a Float32Array.");let e=v(r,"gpu-vector",!0);return new t(e,r.length,r.constructor)}async read(){let r=F(),e=r.createCommandEncoder(),a=h(e,this._buf);return r.queue.submit([e.finish()]),_(a,this.dtype)}destroy(){this._buf.destroy()}};function ir(t,r=-1,e=1){let a=new Float32Array(t);for(let o=0;o<t;o++)a[o]=r+Math.random()*(e-r);return a}function nr(t,r=-1,e=1){let a=new Float64Array(t);for(let o=0;o<t;o++)a[o]=r+Math.random()*(e-r);return a}function B(t,r,e=null){let a=F(),n=(e?[...r,e]:[...r]).map((s,i)=>({binding:i,resource:{buffer:s}}));return a.createBindGroup({layout:t,entries:n})}function E(t){F().queue.submit([t.finish()])}function P(t,r,e){let a=F(),{querySet:o,passDescriptor:n}=Z(),s=a.createCommandEncoder(),i=s.beginComputePass(n);i.setPipeline(t),i.setBindGroup(0,r),typeof e=="number"?i.dispatchWorkgroups(e):i.dispatchWorkgroups(e.x,e.y),i.end();let u=J(s,o);return s._passEncoder=i,{commandEncoder:s,ts:u}}var de={},j=new WeakMap;async function A(t,r){j.has(t)||j.set(t,new Map);let e=j.get(t);return e.has(r)||e.set(r,await le(r)),e.get(r)}async function me(t){if(typeof window<"u"){let{shaderSources:r}=await Promise.resolve().then(()=>(Wr(),Rr)),e=r[t];if(!e)throw new Error(`Shader "${t}" not found in browser bundle.`);return e}else{let{readFileSync:r}=await import("fs"),{fileURLToPath:e}=await import("url"),{dirname:a,join:o}=await import("path"),n=a(e(de.url));return r(o(n,`../shaders/${t}.wgsl`),"utf8")}}async function le(t){let r=F(),e=await me(t),a=r.createShaderModule({label:t,code:e}),n=(await a.getCompilationInfo()).messages.filter(i=>i.type==="error");if(n.length>0)throw new Error(`Shader "${t}" compilation failed:
-${n.map(i=>`  line ${i.lineNum}: ${i.message}`).join(`
-`)}`);let s=r.createComputePipeline({label:t,layout:"auto",compute:{module:a}});return s._shaderModule=a,s}var ge=64,Ur=8;function M(t,r){let e=F().limits.maxComputeWorkgroupsPerDimension;return r===void 0?Math.min(Math.ceil(t/ge),e):{x:Math.min(Math.ceil(r/Ur),e),y:Math.min(Math.ceil(t/Ur),e)}}async function Ir(t,r,e,a,o){let n=a instanceof m;if(!(t instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(o))throw new Error("n and incx must be integers.");if(isNaN(e))throw new Error("alpha must not be NaN.");if(!isFinite(e))throw new Error("alpha must be finite.");if(o<=0)throw new Error("incx must be positive.");if(!(a instanceof Float32Array)&&!(a instanceof m))throw new Error("x must be a Float32Array or GpuVector.");if(r<=0)return n?{}:a;if(a.length<(r-1)*o+1)throw new Error("x does not have enough elements for the given n and incx.");let s=await A(t,"sscal"),i=n?a._buf:v(a,"sscal-x",!0),u=R([{value:r,type:"u32"},{value:e,type:"f32"},{value:o,type:"u32"}],"sscal-params"),f=B(s.getBindGroupLayout(0),[i,u]),{commandEncoder:c,ts:p}=P(s,f,M(r)),y=n?null:h(c,i);E(c);let l=await G(p);if(n)return w(u),l!==void 0?{gpuTimeMs:l}:{};let k=await _(y,Float32Array);return w(i,u,y),l!==void 0?{result:k,gpuTimeMs:l}:k}async function Mr(t,r,e,a,o,n){let s=e instanceof m,i=o instanceof m;if(!(t instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(a)||!Number.isInteger(n))throw new Error("n, incx, and incy must be integers.");if(a<=0||n<=0)throw new Error("incx and incy must be positive.");if(!(e instanceof Float32Array)&&!(e instanceof m))throw new Error("x must be a Float32Array or GpuVector.");if(!(o instanceof Float32Array)&&!(o instanceof m))throw new Error("y must be a Float32Array or GpuVector.");if(e.constructor!==o.constructor)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(r<=0)return s?{}:{x:e,y:o};if(e.length<(r-1)*a+1)throw new Error("x does not have enough elements for the given n and incx.");if(o.length<(r-1)*n+1)throw new Error("y does not have enough elements for the given n and incy.");let u=await A(t,"sswap"),f=s?e._buf:v(e,"sswap-x",!0),c=i?o._buf:v(o,"sswap-y",!0),p=R([{value:r,type:"u32"},{value:a,type:"u32"},{value:n,type:"u32"}],"sswap-params"),y=B(u.getBindGroupLayout(0),[f,c,p]),{commandEncoder:l,ts:k}=P(u,y,M(r)),x=s?null:h(l,f),S=i?null:h(l,c);E(l);let d=await G(k);if(s&&i)return w(p),d!==void 0?{gpuTimeMs:d}:{};let b=await _(x,Float32Array),g=await _(S,Float32Array);return w(f,x,c,S,p),d!==void 0?{x:b,y:g,gpuTimeMs:d}:{x:b,y:g}}async function Tr(t,r,e,a,o,n,s){let i=a instanceof m,u=n instanceof m;if(!(t instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(o)||!Number.isInteger(s))throw new Error("n, incx, and incy must be integers.");if(isNaN(e))throw new Error("alpha must not be NaN.");if(!isFinite(e))throw new Error("alpha must be finite.");if(o<=0||s<=0)throw new Error("incx and incy must be positive.");if(!i&&!(a instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!u&&!(n instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(i!==u)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(r<=0)return u?{}:{y:n};if(a.length<(r-1)*o+1)throw new Error("x does not have enough elements for the given n and incx.");if(n.length<(r-1)*s+1)throw new Error("y does not have enough elements for the given n and incy.");let f=await A(t,"saxpy"),c=i?a._buf:v(a,"saxpy-x",!1),p=u?n._buf:v(n,"saxpy-y",!0),y=R([{value:r,type:"u32"},{value:e,type:"f32"},{value:o,type:"u32"},{value:s,type:"u32"}],"saxpy-params"),l=B(f.getBindGroupLayout(0),[c,p,y]),{commandEncoder:k,ts:x}=P(f,l,M(r)),S=u?null:h(k,p);E(k);let d=await G(x);if(u&&i)return w(y),d!==void 0?{gpuTimeMs:d}:{};let b=await _(S,Float32Array);return w(c,p,y,S),d!==void 0?{y:b,gpuTimeMs:d}:{y:b}}async function Dr(t,r,e,a,o,n){let s=e instanceof m,i=o instanceof m;if(!(t instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(a)||!Number.isInteger(n))throw new Error("n, incx, and incy must be integers.");if(a<=0||n<=0)throw new Error("incx and incy must be positive.");if(!s&&!(e instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!i&&!(o instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(s!==i)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(r<=0)return i?{}:{y:o};if(e.length<(r-1)*a+1)throw new Error("x does not have enough elements for the given n and incx.");if(o.length<(r-1)*n+1)throw new Error("y does not have enough elements for the given n and incy.");let u=await A(t,"scopy"),f=s?e._buf:v(e,"scopy-x",!1),c=i?o._buf:v(o,"scopy-y",!0),p=R([{value:r,type:"u32"},{value:a,type:"u32"},{value:n,type:"u32"}],"scopy-params"),y=B(u.getBindGroupLayout(0),[f,c,p]),{commandEncoder:l,ts:k}=P(u,y,M(r)),x=i?null:h(l,c);E(l);let S=await G(k);if(i&&s)return w(p),S!==void 0?{gpuTimeMs:S}:{};let d=await _(x,Float32Array);return w(f,c,p,x),S!==void 0?{y:d,gpuTimeMs:S}:{y:d}}var Nr=64;async function Vr(t,r,e,a,o,n){let s=e instanceof m,i=o instanceof m;if(!(t instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(a)||!Number.isInteger(n))throw new Error("n, incx, and incy must be integers.");if(a<=0||n<=0)throw new Error("incx and incy must be positive.");if(!s&&!(e instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!i&&!(o instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(s!==i)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(r<=0)return{dot:0};if(e.length<(r-1)*a+1)throw new Error("x does not have enough elements for the given n and incx.");if(o.length<(r-1)*n+1)throw new Error("y does not have enough elements for the given n and incy.");let u=await A(t,"sdot"),f=await A(t,"reduction/sum"),c=s?e._buf:v(e,"sdot-x",!1),p=i?o._buf:v(o,"sdot-y",!1),y=N(2*Nr*4,"sdot-partials"),l=V(4,"sdot-result"),k=R([{value:r,type:"u32"},{value:a,type:"u32"},{value:n,type:"u32"}],"sdot-params"),x=B(u.getBindGroupLayout(0),[c,p,y,k]),{commandEncoder:S,ts:d}=P(u,x,2*Nr);E(S);let b=B(f.getBindGroupLayout(0),[y,l]),{commandEncoder:g,ts:W}=P(f,b,1),U=h(g,l);E(g);let[D,z,O]=await Promise.all([G(d),G(W),_(U,Float32Array)]);return s&&i?(w(y,l,k,U),D!==void 0&&z!==void 0?{dot:O[0],gpuTimeMs:D+z}:{dot:O[0]}):(w(c,p,y,l,k,U),D!==void 0&&z!==void 0?{dot:O[0],gpuTimeMs:D+z}:{dot:O[0]})}var Cr=64;async function zr(t,r,e,a){let o=e instanceof m;if(!(t instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(a))throw new Error("n and incx must be integers.");if(a<=0)throw new Error("incx must be positive.");if(!o&&!(e instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(r<=0)return{asum:0};if(e.length<(r-1)*a+1)throw new Error("x does not have enough elements for the given n and incx.");let n=await A(t,"sasum"),s=await A(t,"reduction/sum"),i=o?e._buf:v(e,"sasum-x",!1),u=N(2*Cr*4,"sasum-partials"),f=V(4,"sasum-result"),c=R([{value:r,type:"u32"},{value:a,type:"u32"}],"sasum-params"),p=B(n.getBindGroupLayout(0),[i,u,c]),{commandEncoder:y,ts:l}=P(n,p,2*Cr);E(y);let k=B(s.getBindGroupLayout(0),[u,f]),{commandEncoder:x,ts:S}=P(s,k,1),d=h(x,f);E(x);let[b,g,W]=await Promise.all([G(l),G(S),_(d,Float32Array)]);return o?(w(u,f,c,d),b!==void 0&&g!==void 0?{asum:W[0],gpuTimeMs:b+g}:{asum:W[0]}):(w(i,u,f,c,d),b!==void 0&&g!==void 0?{asum:W[0],gpuTimeMs:b+g}:{asum:W[0]})}var Or=64;async function Lr(t,r,e,a){let o=e instanceof m;if(!(t instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(a))throw new Error("n and incx must be integers.");if(a<=0)throw new Error("incx must be positive.");if(!o&&!(e instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(r<=0)return{nrm2:0};if(e.length<(r-1)*a+1)throw new Error("x does not have enough elements for the given n and incx.");let n=await A(t,"snrm2"),s=await A(t,"reduction/sum"),i=o?e._buf:v(e,"snrm2-x",!1),u=N(2*Or*4,"snrm2-partials"),f=V(4,"snrm2-result"),c=R([{value:r,type:"u32"},{value:a,type:"u32"}],"snrm2-params"),p=B(n.getBindGroupLayout(0),[i,u,c]),{commandEncoder:y,ts:l}=P(n,p,2*Or);E(y);let k=B(s.getBindGroupLayout(0),[u,f]),{commandEncoder:x,ts:S}=P(s,k,1),d=h(x,f);E(x);let[b,g,W]=await Promise.all([G(l),G(S),_(d,Float32Array)]),U=Math.sqrt(W[0]);return o?(w(u,f,c,d),b!==void 0&&g!==void 0?{nrm2:U,gpuTimeMs:b+g}:{nrm2:U}):(w(i,u,f,c,d),b!==void 0&&g!==void 0?{nrm2:U,gpuTimeMs:b+g}:{nrm2:U})}var Q=64;async function qr(t,r,e,a){let o=e instanceof m;if(!(t instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(a))throw new Error("n and incx must be integers.");if(a<=0)throw new Error("incx must be positive.");if(!o&&!(e instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(r<=0)return{index:0};if(e.length<(r-1)*a+1)throw new Error("x does not have enough elements for the given n and incx.");let n=await A(t,"isamax"),s=await A(t,"reduction/argmax"),i=o?e._buf:v(e,"isamax-x",!1),u=N(2*Q*4,"isamax-partials-val"),f=N(2*Q*4,"isamax-partials-idx"),c=V(4,"isamax-result"),p=R([{value:r,type:"u32"},{value:a,type:"u32"}],"isamax-params"),y=B(n.getBindGroupLayout(0),[i,u,f,p]),{commandEncoder:l,ts:k}=P(n,y,2*Q);E(l);let x=B(s.getBindGroupLayout(0),[u,f,c]),{commandEncoder:S,ts:d}=P(s,x,1),b=h(S,c);E(S);let[g,W,U]=await Promise.all([G(k),G(d),_(b,Uint32Array)]),D=U[0];return o?(w(u,f,c,p,b),g!==void 0&&W!==void 0?{index:D,gpuTimeMs:g+W}:{index:D}):(w(i,u,f,c,p,b),g!==void 0&&W!==void 0?{index:D,gpuTimeMs:g+W}:{index:D})}async function Yr(t,r,e,a,o,n,s,i){let u=e instanceof m,f=o instanceof m;if(!(t instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(a)||!Number.isInteger(n))throw new Error("n, incx, and incy must be integers.");if(isNaN(s)||isNaN(i))throw new Error("c and s must not be NaN.");if(!isFinite(s))throw new Error("c must be finite.");if(!isFinite(i))throw new Error("s must be finite.");if(a<=0||n<=0)throw new Error("incx and incy must be positive.");if(!u&&!(e instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!f&&!(o instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(u!==f)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(r<=0)return u?{}:{x:e,y:o};if(e.length<(r-1)*a+1)throw new Error("x does not have enough elements for the given n and incx.");if(o.length<(r-1)*n+1)throw new Error("y does not have enough elements for the given n and incy.");let c=await A(t,"srot"),p=u?e._buf:v(e,"srot-x",!0),y=f?o._buf:v(o,"srot-y",!0),l=R([{value:r,type:"u32"},{value:s,type:"f32"},{value:i,type:"f32"},{value:a,type:"u32"},{value:n,type:"u32"}],"srot-params"),k=B(c.getBindGroupLayout(0),[p,y,l]),{commandEncoder:x,ts:S}=P(c,k,M(r)),d=u?null:h(x,p),b=f?null:h(x,y);E(x);let g=await G(S);if(u&&f)return w(l),g!==void 0?{gpuTimeMs:g}:{};let[W,U]=await Promise.all([_(d,Float32Array),_(b,Float32Array)]);return w(p,y,l,d,b),g!==void 0?{x:W,y:U,gpuTimeMs:g}:{x:W,y:U}}async function $r(t,r,e,a,o,n,s){let i=e instanceof m,u=o instanceof m;if(!(t instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(a)||!Number.isInteger(n))throw new Error("n, incx, and incy must be integers.");if(!(s instanceof Float32Array)||s.length!==5)throw new Error("param must be a Float32Array of length 5.");if(a<=0||n<=0)throw new Error("incx and incy must be positive.");if(!i&&!(e instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!u&&!(o instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(i!==u)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(r<=0||s[0]===-2)return i?{}:{x:e,y:o};if(e.length<(r-1)*a+1)throw new Error("x does not have enough elements for the given n and incx.");if(o.length<(r-1)*n+1)throw new Error("y does not have enough elements for the given n and incy.");let f=await A(t,"srotm"),c=i?e._buf:v(e,"srotm-x",!0),p=u?o._buf:v(o,"srotm-y",!0),y=v(s,"srotm-param",!1),l=R([{value:r,type:"u32"},{value:a,type:"u32"},{value:n,type:"u32"}],"srotm-params"),k=B(f.getBindGroupLayout(0),[c,p,y,l]),{commandEncoder:x,ts:S}=P(f,k,M(r)),d=i?null:h(x,c),b=u?null:h(x,p);E(x);let g=await G(S);if(i&&u)return w(y,l),g!==void 0?{gpuTimeMs:g}:{};let[W,U]=await Promise.all([_(d,Float32Array),_(b,Float32Array)]);return w(c,p,y,l,d,b),g!==void 0?{x:W,y:U,gpuTimeMs:g}:{x:W,y:U}}return Zr(we);})();
+`});var ue,se=I(()=>{ue=`// sgemv_n: y = alpha * A * x + beta * y  (A is m\xD7n row-major, no-transpose)
+//
+// One workgroup per output row, with a grid-stride outer loop so the shader
+// still covers all rows when m exceeds maxComputeWorkgroupsPerDimension.
+// Threads stride through A[row, :] and x with coalesced reads (consecutive
+// threads \u2192 consecutive addresses). Four independent accumulators let the GPU
+// pipeline memory requests across iterations (ILP=4), hiding the
+// global-memory latency.
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read>       x: array<f32>;
+@group(0) @binding(2) var<storage, read_write> y: array<f32>;
+
+struct Params {
+  m:     u32,
+  n:     u32,
+  alpha: f32,
+  beta:  f32,
+  incx:  u32,
+  incy:  u32,
+  lda:   u32,
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+var<workgroup> scratch: array<f32, 64>;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  // Grid-stride loop: each workgroup handles ceil(m / nwg.x) rows.
+  for (var row = wgid.x; row < params.m; row += nwg.x) {
+    let row_base = row * params.lda;
+    var acc0: f32 = 0.0;
+    var acc1: f32 = 0.0;
+    var acc2: f32 = 0.0;
+    var acc3: f32 = 0.0;
+
+    // 4-unrolled loop: each iteration issues 4 independent loads for A and x.
+    // The accumulators are independent so the GPU can overlap the memory
+    // requests rather than serialising them behind a dependency chain.
+    let n4_floor = (params.n / (4u * WGS)) * (4u * WGS);
+    for (var j: u32 = lid.x; j < n4_floor; j += 4u * WGS) {
+      acc0 += A[row_base + j            ] * x[ j             * params.incx];
+      acc1 += A[row_base + j +     WGS  ] * x[(j +     WGS)  * params.incx];
+      acc2 += A[row_base + j + 2u * WGS ] * x[(j + 2u * WGS) * params.incx];
+      acc3 += A[row_base + j + 3u * WGS ] * x[(j + 3u * WGS) * params.incx];
+    }
+    // Scalar tail: at most 3*WGS elements left after the unrolled block.
+    for (var j: u32 = n4_floor + lid.x; j < params.n; j += WGS) {
+      acc0 += A[row_base + j] * x[j * params.incx];
+    }
+
+    // Parallel reduction: 64 \u2192 32 \u2192 16 \u2192 8 \u2192 4 \u2192 2 \u2192 1
+    scratch[lid.x] = acc0 + acc1 + acc2 + acc3;
+    workgroupBarrier();
+    for (var stride = WGS >> 1u; stride > 0u; stride >>= 1u) {
+      if lid.x < stride {
+        scratch[lid.x] += scratch[lid.x + stride];
+      }
+      workgroupBarrier();
+    }
+
+    if lid.x == 0u {
+      let yi = row * params.incy;
+      y[yi] = params.alpha * scratch[0] + params.beta * y[yi];
+    }
+    // All 64 threads must agree before the next row reuses scratch[].
+    workgroupBarrier();
+  }
+}
+`});var fe,le=I(()=>{fe=`// sgemv_t: y = alpha * A^T * x + beta * y  (A is m\xD7n row-major, transposed)
+// each thread owns one column of A \u2192 one element of y (length n)
+// tiles over x (length m) using shared memory; four independent accumulators
+// let the GPU pipeline A reads across j within each tile (ILP=4)
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read>       x: array<f32>;
+@group(0) @binding(2) var<storage, read_write> y: array<f32>;
+
+struct Params {
+  m:     u32,
+  n:     u32,
+  alpha: f32,
+  beta:  f32,
+  incx:  u32,
+  incy:  u32,
+  lda:   u32,
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+var<workgroup> x_tile: array<f32, 64>;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(global_invocation_id) gid: vec3u,
+  @builtin(local_invocation_id)  lid: vec3u,
+) {
+  // each thread owns column col of A \u2192 output y[col]
+  let col     = gid.x;
+  // tile over x (length m, the rows of A)
+  let m_floor = (params.m / WGS) * WGS;
+  var acc0: f32 = 0.0;
+  var acc1: f32 = 0.0;
+  var acc2: f32 = 0.0;
+  var acc3: f32 = 0.0;
+
+  for (var base = 0u; base < m_floor; base += WGS) {
+    // cooperative load: all 64 threads fill x_tile with x[base..base+WGS]
+    x_tile[lid.x] = x[(base + lid.x) * params.incx];
+    workgroupBarrier();
+
+    // 4-unrolled inner loop: 4 independent A reads let the GPU pipeline
+    // global-memory requests within each tile. WGS=64 divides by 4 exactly.
+    if (col < params.n) {
+      for (var j = 0u; j < WGS; j += 4u) {
+        acc0 += A[(base + j    ) * params.lda + col] * x_tile[j    ];
+        acc1 += A[(base + j + 1) * params.lda + col] * x_tile[j + 1];
+        acc2 += A[(base + j + 2) * params.lda + col] * x_tile[j + 2];
+        acc3 += A[(base + j + 3) * params.lda + col] * x_tile[j + 3];
+      }
+    }
+    workgroupBarrier();
+  }
+
+  if (col < params.n) {
+    // remainder: m not divisible by WGS \u2014 short loop, single accumulator fine
+    for (var k = m_floor; k < params.m; k++) {
+      acc0 += A[k * params.lda + col] * x[k * params.incx];
+    }
+    let yi = col * params.incy;
+    y[yi] = params.alpha * (acc0 + acc1 + acc2 + acc3) + params.beta * y[yi];
+  }
+}
+`});var me,ce=I(()=>{me=`// ssymv: y = alpha * A * x + beta * y
+// A is n\xD7n symmetric, lower (uplo=0) or upper (uplo=1) triangle stored.
+// The logical matrix is fully dense (symmetric), so each row's dot product
+// sums over all n columns; entries on the unstored side of the diagonal are
+// fetched from their mirror position (A[i,j] == A[j,i]).
+// One workgroup per row, grid-stride outer loop.
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read>       x: array<f32>;
+@group(0) @binding(2) var<storage, read_write> y: array<f32>;
+
+struct Params {
+  n:     u32,
+  alpha: f32,
+  beta:  f32,
+  incx:  u32,
+  incy:  u32,
+  lda:   u32,
+  uplo:  u32,  // 0 = lower, 1 = upper
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+var<workgroup> scratch: array<f32, 64>;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  for (var i = wgid.x; i < params.n; i += nwg.x) {
+    var acc = 0.0f;
+
+    // y[i] = \u03A3_j A[i,j] * x[j]
+    for (var j = lid.x; j < params.n; j += WGS) {
+      var aVal: f32;
+      if params.uplo == 0u {
+        // Lower: A[i,j] stored at A[i*lda+j] for j \u2264 i, mirrored from A[j*lda+i] otherwise
+        if j <= i {
+          aVal = A[i * params.lda + j];
+        } else {
+          aVal = A[j * params.lda + i];
+        }
+      } else {
+        // Upper: A[i,j] stored at A[i*lda+j] for j \u2265 i, mirrored from A[j*lda+i] otherwise
+        if j >= i {
+          aVal = A[i * params.lda + j];
+        } else {
+          aVal = A[j * params.lda + i];
+        }
+      }
+      acc += aVal * x[j * params.incx];
+    }
+
+    // Parallel reduction: 64 \u2192 1
+    scratch[lid.x] = acc;
+    workgroupBarrier();
+    for (var stride = WGS >> 1u; stride > 0u; stride >>= 1u) {
+      if lid.x < stride { scratch[lid.x] += scratch[lid.x + stride]; }
+      workgroupBarrier();
+    }
+
+    if lid.x == 0u {
+      y[i * params.incy] = params.alpha * scratch[0] + params.beta * y[i * params.incy];
+    }
+  }
+}
+`});var pe,de=I(()=>{pe=`// strmv: y = op(A) * x
+// A is n\xD7n triangular, lower (uplo=0) or upper (uplo=1) triangle stored.
+// op(A) is A (trans=0) or A^T (trans=1).
+// diag=1 (unit) treats the diagonal as 1 without reading A's diagonal values.
+// One workgroup per row, grid-stride outer loop.
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read>       x: array<f32>;
+@group(0) @binding(2) var<storage, read_write> y: array<f32>;
+
+struct Params {
+  n:     u32,
+  incx:  u32,
+  incy:  u32,
+  lda:   u32,
+  trans: u32,  // 0 = no-transpose, 1 = transpose
+  uplo:  u32,  // 0 = lower, 1 = upper
+  diag:  u32,  // 0 = non-unit, 1 = unit
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+var<workgroup> scratch: array<f32, 64>;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  for (var i = wgid.x; i < params.n; i += nwg.x) {
+    var acc = 0.0f;
+
+    if params.trans == 0u {
+      // No-transpose: y[i] = \u03A3_j A[i,j] * x[j]
+      if params.uplo == 0u {
+        // Lower: A[i,j] stored at A[i*lda+j] for j \u2264 i
+        for (var j = lid.x; j <= i; j += WGS) {
+          var aVal: f32;
+          // unit diagonal: use 1 instead of A's actual diagonal value
+          if params.diag == 1u && j == i {
+            aVal = 1.0;
+          } else if ( j <= i ) {
+            aVal = A[i * params.lda + j];
+          }
+          acc += aVal * x[j * params.incx];
+        }
+      } else {
+        // Upper: A[i,j] stored at A[i*lda+j] for j \u2265 i
+        for (var j = i + lid.x; j < params.n; j += WGS) {
+          var aVal: f32;
+          // unit diagonal: use 1 instead of A's actual diagonal value
+          if params.diag == 1u && j == i {
+            aVal = 1.0;
+          } else if ( j >= i ) {
+            aVal = A[i * params.lda + j];
+          }
+          acc += aVal * x[j * params.incx];
+        }
+      }
+    } else {
+      // Transpose: y[i] = \u03A3_j A[j,i] * x[j]
+      if params.uplo == 0u {
+        // Lower: A[j,i] stored at A[j*lda+i] for j \u2265 i
+        for (var j = i + lid.x; j < params.n; j += WGS) {
+          var aVal: f32;
+          // unit diagonal: use 1 instead of A's actual diagonal value
+          if params.diag == 1u && j == i {
+            aVal = 1.0;
+          } else if ( j >= i ) {
+            aVal = A[j * params.lda + i];
+          }
+          acc += aVal * x[j * params.incx];
+        }
+      } else {
+        // Upper: A[j,i] stored at A[j*lda+i] for j \u2264 i
+        for (var j = lid.x; j <= i; j += WGS) {
+          var aVal: f32;
+          // unit diagonal: use 1 instead of A's actual diagonal value
+          if params.diag == 1u && j == i {
+            aVal = 1.0;
+          } else if ( j <= i ) {
+            aVal = A[j * params.lda + i];
+          }
+          acc += aVal * x[j * params.incx];
+        }
+      }
+    }
+
+    // Parallel reduction: 64 \u2192 1
+    scratch[lid.x] = acc;
+    workgroupBarrier();
+    for (var stride = WGS >> 1u; stride > 0u; stride >>= 1u) {
+      if lid.x < stride { scratch[lid.x] += scratch[lid.x + stride]; }
+      workgroupBarrier();
+    }
+
+    if lid.x == 0u {
+      y[ i * params.incy ] = scratch[0];
+    }
+  }
+}
+`});var we,ge=I(()=>{we=`// sger: A := alpha * x * y^T + A  (rank-1 update, A is m\xD7n general/dense)
+
+@group(0) @binding(0) var<storage, read>       x: array<f32>;
+@group(0) @binding(1) var<storage, read>       y: array<f32>;
+@group(0) @binding(2) var<storage, read_write> A: array<f32>;
+
+struct Params {
+  m:     u32,
+  n:     u32,
+  alpha: f32,
+  incx:  u32,
+  incy:  u32,
+  lda:   u32,
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  for (var row = wgid.x; row < params.m; row += nwg.x) {
+    let xi = params.alpha * x[row * params.incx];
+    let row_base = row * params.lda;
+
+    // 4-unrolled loop: each iteration issues 4 independent A/y accesses.
+    let n4_floor = (params.n / (4u * WGS)) * (4u * WGS);
+    for (var col: u32 = lid.x; col < n4_floor; col += 4u * WGS) {
+      let idx0 = row_base + col;
+      let idx1 = row_base + col + WGS;
+      let idx2 = row_base + col + 2u * WGS;
+      let idx3 = row_base + col + 3u * WGS;
+      A[idx0] = xi * y[ col            * params.incy] + A[idx0];
+      A[idx1] = xi * y[(col +     WGS) * params.incy] + A[idx1];
+      A[idx2] = xi * y[(col + 2u * WGS) * params.incy] + A[idx2];
+      A[idx3] = xi * y[(col + 3u * WGS) * params.incy] + A[idx3];
+    }
+    // Scalar tail: at most 3*WGS elements left after the unrolled block.
+    for (var col: u32 = n4_floor + lid.x; col < params.n; col += WGS) {
+      let idx = row_base + col;
+      A[idx] = xi * y[col * params.incy] + A[idx];
+    }
+  }
+}
+`});var he,be=I(()=>{he=`// ssyr: A := alpha * x * x^T + A  (symmetric rank-1 update)
+// A is n\xD7n symmetric; only the triangle specified by uplo is referenced/updated,
+// the other triangle is implied by symmetry (not touched).
+
+@group(0) @binding(0) var<storage, read>       x: array<f32>;
+@group(0) @binding(1) var<storage, read_write> A: array<f32>;
+
+struct Params {
+  n:     u32,
+  alpha: f32,
+  incx:  u32,
+  lda:   u32,
+  uplo:  u32,  // 0 = lower, 1 = upper
+}
+
+@group(0) @binding(2) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  for (var row = wgid.x; row < params.n; row += nwg.x) {
+    let xi = params.alpha * x[row * params.incx];
+    let row_base = row * params.lda;
+
+    // Stored-triangle column range for this row: lower [0,row], upper [row,n).
+    var colStart: u32;
+    var colEnd: u32;
+    if params.uplo == 1u {
+      colStart = row;
+      colEnd = params.n;
+    } else {
+      colStart = 0u;
+      colEnd = row + 1u;
+    }
+
+    // 4-unrolled loop over the stored range.
+    let rangeLen = colEnd - colStart;
+    let n4_floor = colStart + (rangeLen / (4u * WGS)) * (4u * WGS);
+    for (var col: u32 = colStart + lid.x; col < n4_floor; col += 4u * WGS) {
+      let idx0 = row_base + col;
+      let idx1 = row_base + col + WGS;
+      let idx2 = row_base + col + 2u * WGS;
+      let idx3 = row_base + col + 3u * WGS;
+      A[idx0] = xi * x[ col             * params.incx] + A[idx0];
+      A[idx1] = xi * x[(col +     WGS)  * params.incx] + A[idx1];
+      A[idx2] = xi * x[(col + 2u * WGS) * params.incx] + A[idx2];
+      A[idx3] = xi * x[(col + 3u * WGS) * params.incx] + A[idx3];
+    }
+    // Scalar tail: at most 3*WGS elements left after the unrolled block.
+    for (var col: u32 = n4_floor + lid.x; col < colEnd; col += WGS) {
+      let idx = row_base + col;
+      A[idx] = xi * x[col * params.incx] + A[idx];
+    }
+  }
+}
+`});var ve,xe=I(()=>{ve=`// ssyr2: A := alpha * x * y^T + alpha * y * x^T + A  (symmetric rank-2 update)
+// A is n\xD7n symmetric; only the triangle specified by uplo is referenced/updated,
+// the other triangle is implied by symmetry (not touched).
+
+@group(0) @binding(0) var<storage, read>       x: array<f32>;
+@group(0) @binding(1) var<storage, read>       y: array<f32>;
+@group(0) @binding(2) var<storage, read_write> A: array<f32>;
+
+struct Params {
+  n:     u32,
+  alpha: f32,
+  incx:  u32,
+  incy:  u32,
+  lda:   u32,
+  uplo:  u32,  // 0 = lower, 1 = upper
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  for (var row = wgid.x; row < params.n; row += nwg.x) {
+    let xi = params.alpha * x[row * params.incx];
+    let yi = params.alpha * y[row * params.incy];
+    let row_base = row * params.lda;
+
+    // Stored-triangle column range for this row: lower [0,row], upper [row,n).
+    var colStart: u32;
+    var colEnd: u32;
+    if params.uplo == 1u {
+      colStart = row;
+      colEnd = params.n;
+    } else {
+      colStart = 0u;
+      colEnd = row + 1u;
+    }
+
+    // 4-unrolled loop over the stored range.
+    let rangeLen = colEnd - colStart;
+    let n4_floor = colStart + (rangeLen / (4u * WGS)) * (4u * WGS);
+    for (var col: u32 = colStart + lid.x; col < n4_floor; col += 4u * WGS) {
+      let idx0 = row_base + col;
+      let idx1 = row_base + col + WGS;
+      let idx2 = row_base + col + 2u * WGS;
+      let idx3 = row_base + col + 3u * WGS;
+      A[idx0] = xi * y[ col             * params.incy] + yi * x[ col             * params.incx] + A[idx0];
+      A[idx1] = xi * y[(col +     WGS)  * params.incy] + yi * x[(col +     WGS)  * params.incx] + A[idx1];
+      A[idx2] = xi * y[(col + 2u * WGS) * params.incy] + yi * x[(col + 2u * WGS) * params.incx] + A[idx2];
+      A[idx3] = xi * y[(col + 3u * WGS) * params.incy] + yi * x[(col + 3u * WGS) * params.incx] + A[idx3];
+    }
+    // Scalar tail: at most 3*WGS elements left after the unrolled block.
+    for (var col: u32 = n4_floor + lid.x; col < colEnd; col += WGS) {
+      let idx = row_base + col;
+      A[idx] = xi * y[col * params.incy] + yi * x[col * params.incx] + A[idx];
+    }
+  }
+}
+`});var _e,ye=I(()=>{_e=`// f64add: adds two doubles, each packed as a [main, aux] pair (main: f32
+// value, aux: raw u32 bits \u2014 see src/util/f64pack.mjs; decode()/encode()
+// below are the WGSL mirror of that file's packedToFields()/fieldsToPacked()),
+// producing the sum as another [main, aux] pair.
+//
+// Implements IEEE-754 binary64 addition (align, add/subtract significands,
+// normalize, round-to-nearest-even) using only u32 bitwise/integer
+// arithmetic \u2014 WGSL has no 64-bit integer type or arbitrary-precision
+// integers, so each operand's 53-bit significand is carried as a two-word
+// (hi, lo) pair, widened by 3 bits at the bottom to hold guard/round/sticky
+// information while aligning exponents.
+
+const EXP_ALL_ONES: u32 = 0x7ffu;
+const BIAS: i32 = 1023;
+const QUIET_NAN_MANTISSA_HI: u32 = 1u << 19u; // bit51 of the 52-bit mantissa -> canonical quiet NaN
+
+struct Fields {
+  sign: u32,
+  rawExp: u32,
+  mantissaHi: u32, // 20 bits
+  lo: u32,         // 32 bits
+}
+
+// A packed [main, aux] result \u2014 aux stays a raw u32; it must never be stored
+// as an array<f32>/treated as a real float (bit pattern can land on a NaN/
+// Infinity exponent for perfectly ordinary doubles \u2014 an f32-typed storage
+// slot canonicalizes/corrupts that on any round-trip). See f64pack.mjs's
+// comment above fieldsToPacked, and dasum.wgsl's xAux/partialsAux bindings.
+struct Packed {
+  main: f32,
+  aux:  u32,
+}
+
+// Mirrors packedToFields() in f64pack.mjs.
+fn decode(mainBits: u32, auxBits: u32) -> Fields {
+  let sign = mainBits >> 31u;
+  let expMain = (mainBits >> 23u) & 0xffu;
+  let mantMain = mainBits & 0x7fffffu;
+
+  let auxSign = auxBits >> 31u;
+  let auxExp8 = (auxBits >> 23u) & 0xffu;
+  let auxMant23 = auxBits & 0x7fffffu;
+
+  let expExtra = (auxSign << 2u) | (auxExp8 >> 6u);
+  let mantExtra29 = ((auxExp8 & 0x3fu) << 23u) | auxMant23;
+
+  let rawExp = (expMain << 3u) | expExtra;
+  let mantissaHi = mantMain >> 3u;
+  let mantTop3 = mantMain & 0x7u;
+  let lo = (mantTop3 << 29u) | mantExtra29;
+
+  return Fields(sign, rawExp, mantissaHi, lo);
+}
+
+// Mirrors fieldsToPacked() in f64pack.mjs.
+fn encode(sign: u32, rawExp: u32, mantissaHi: u32, lo: u32) -> Packed {
+  let expMain = rawExp >> 3u;
+  let expExtra = rawExp & 0x7u;
+
+  let mantTop3 = lo >> 29u;
+  let mantMain = (mantissaHi << 3u) | mantTop3;
+  let mantExtra29 = lo & 0x1fffffffu;
+
+  let mainBits = (sign << 31u) | (expMain << 23u) | mantMain;
+
+  let auxSign = (expExtra >> 2u) & 0x1u;
+  let auxExpTop2 = expExtra & 0x3u;
+  let auxExpBot6 = mantExtra29 >> 23u;
+  let auxMant23 = mantExtra29 & 0x7fffffu;
+  let auxExp8 = (auxExpTop2 << 6u) | auxExpBot6;
+
+  let auxBits = (auxSign << 31u) | (auxExp8 << 23u) | auxMant23;
+
+  return Packed(bitcast<f32>(mainBits), auxBits);
+}
+
+struct Pair { hi: u32, lo: u32 }
+struct Shifted { hi: u32, lo: u32, sticky: u32 }
+
+// Two-word right shift by 0..64+ bits, folding every shifted-out 1 bit into
+// a returned sticky flag \u2014 used only for the (potentially huge) exponent
+// alignment shift, where exact bits can't all be kept.
+fn shr_sticky(hi: u32, lo: u32, n: u32) -> Shifted {
+  if (n == 0u) {
+    return Shifted(hi, lo, 0u);
+  }
+  if (n >= 64u) {
+    return Shifted(0u, 0u, select(0u, 1u, hi != 0u || lo != 0u));
+  }
+  if (n < 32u) {
+    let stickyBits = lo & ((1u << n) - 1u);
+    let newLo = (lo >> n) | (hi << (32u - n));
+    let newHi = hi >> n;
+    return Shifted(newHi, newLo, select(0u, 1u, stickyBits != 0u));
+  }
+  if (n == 32u) {
+    return Shifted(0u, hi, select(0u, 1u, lo != 0u));
+  }
+  let m = n - 32u;
+  let stickyBits = lo | (hi & ((1u << m) - 1u));
+  let newLo = hi >> m;
+  return Shifted(0u, newLo, select(0u, 1u, stickyBits != 0u));
+}
+
+// Two-word left shift by 0..63 bits \u2014 used only to renormalize after
+// cancellation, by an amount that exactly matches the leading-zero count,
+// so nothing meaningful is ever lost off the top.
+fn shl(hi: u32, lo: u32, n: u32) -> Pair {
+  if (n == 0u) {
+    return Pair(hi, lo);
+  }
+  if (n < 32u) {
+    let newHi = (hi << n) | (lo >> (32u - n));
+    let newLo = lo << n;
+    return Pair(newHi, newLo);
+  }
+  if (n == 32u) {
+    return Pair(lo, 0u);
+  }
+  let m = n - 32u;
+  return Pair(lo << m, 0u);
+}
+
+fn add64(aHi: u32, aLo: u32, bHi: u32, bLo: u32) -> Pair {
+  let sumLo = aLo + bLo;
+  let carry = select(0u, 1u, sumLo < aLo); // wrapped around -> there was a carry
+  let sumHi = aHi + bHi + carry;
+  return Pair(sumHi, sumLo);
+}
+
+// Assumes (aHi:aLo) >= (bHi:bLo) \u2014 callers guarantee this so no sign handling is needed.
+fn sub64(aHi: u32, aLo: u32, bHi: u32, bLo: u32) -> Pair {
+  let borrow = select(0u, 1u, aLo < bLo);
+  let diffLo = aLo - bLo;
+  let diffHi = aHi - bHi - borrow;
+  return Pair(diffHi, diffLo);
+}
+
+fn ge64(aHi: u32, aLo: u32, bHi: u32, bLo: u32) -> bool {
+  return aHi > bHi || (aHi == bHi && aLo >= bLo);
+}
+
+// The actual IEEE-754 addition, returning decoded Fields rather than an
+// encoded Packed pair \u2014 lets a caller that's accumulating many values in a
+// row (e.g. dasum.wgsl's per-thread reduction loop) keep the running total
+// in Fields form the whole time, only encoding once at the very end, instead
+// of paying a decode+encode round-trip on every single addition. computeSum
+// (below) is the Packed-in/Packed-out convenience wrapper around this.
+fn addFields(a: Fields, b: Fields) -> Fields {
+  let aIsNaN = a.rawExp == EXP_ALL_ONES && (a.mantissaHi != 0u || a.lo != 0u);
+  let bIsNaN = b.rawExp == EXP_ALL_ONES && (b.mantissaHi != 0u || b.lo != 0u);
+  if (aIsNaN || bIsNaN) {
+    return Fields(0u, EXP_ALL_ONES, QUIET_NAN_MANTISSA_HI, 0u);
+  }
+
+  let aIsInf = a.rawExp == EXP_ALL_ONES; // mantissa==0 here since NaN is excluded above
+  let bIsInf = b.rawExp == EXP_ALL_ONES;
+  if (aIsInf && bIsInf) {
+    if (a.sign != b.sign) {
+      return Fields(0u, EXP_ALL_ONES, QUIET_NAN_MANTISSA_HI, 0u);
+    }
+    return Fields(a.sign, EXP_ALL_ONES, 0u, 0u);
+  }
+  if (aIsInf) { return Fields(a.sign, EXP_ALL_ONES, 0u, 0u); }
+  if (bIsInf) { return Fields(b.sign, EXP_ALL_ONES, 0u, 0u); }
+
+  let aIsZero = a.rawExp == 0u && a.mantissaHi == 0u && a.lo == 0u;
+  let bIsZero = b.rawExp == 0u && b.mantissaHi == 0u && b.lo == 0u;
+  if (aIsZero && bIsZero) {
+    return Fields(a.sign & b.sign, 0u, 0u, 0u);
+  }
+  if (aIsZero) { return Fields(b.sign, b.rawExp, b.mantissaHi, b.lo); }
+  if (bIsZero) { return Fields(a.sign, a.rawExp, a.mantissaHi, a.lo); }
+
+  // Effective (unbiased) exponent \u2014 subnormals share the smallest normal
+  // exponent for alignment purposes and have no implicit leading 1.
+  var expA = i32(a.rawExp) - BIAS;
+  if (a.rawExp == 0u) { expA = 1 - BIAS; }
+  var expB = i32(b.rawExp) - BIAS;
+  if (b.rawExp == 0u) { expB = 1 - BIAS; }
+
+  let implicitA = select(0u, 1u, a.rawExp != 0u);
+  let implicitB = select(0u, 1u, b.rawExp != 0u);
+
+  // Widen each 53-bit significand (implicit + 52-bit mantissa) by 3 zero
+  // bits at the bottom \u2014 room for guard/round/sticky once alignment shifts happen.
+  let sigHiA = (implicitA << 23u) | (a.mantissaHi << 3u) | (a.lo >> 29u);
+  let sigLoA = a.lo << 3u;
+  let sigHiB = (implicitB << 23u) | (b.mantissaHi << 3u) | (b.lo >> 29u);
+  let sigLoB = b.lo << 3u;
+
+  // P = the operand with the larger exponent (Q = the other); on a tie, P =
+  // whichever has the larger significand \u2014 keeps subtraction below always
+  // non-negative without needing signed magnitudes.
+  var signP: u32; var expP: i32; var sigHiP: u32; var sigLoP: u32;
+  var signQ: u32; var expQ: i32; var sigHiQ: u32; var sigLoQ: u32;
+  if (expA > expB || (expA == expB && ge64(sigHiA, sigLoA, sigHiB, sigLoB))) {
+    signP = a.sign; expP = expA; sigHiP = sigHiA; sigLoP = sigLoA;
+    signQ = b.sign; expQ = expB; sigHiQ = sigHiB; sigLoQ = sigLoB;
+  } else {
+    signP = b.sign; expP = expB; sigHiP = sigHiB; sigLoP = sigLoB;
+    signQ = a.sign; expQ = expA; sigHiQ = sigHiA; sigLoQ = sigLoA;
+  }
+
+  let diff = u32(expP - expQ);
+  let shiftedQ = shr_sticky(sigHiQ, sigLoQ, diff);
+  let alignedHiQ = shiftedQ.hi;
+  let alignedLoQ = shiftedQ.lo | shiftedQ.sticky; // fold sticky into bit0
+
+  var sumHi: u32; var sumLo: u32;
+  if (signP == signQ) {
+    let s = add64(sigHiP, sigLoP, alignedHiQ, alignedLoQ);
+    sumHi = s.hi; sumLo = s.lo;
+  } else {
+    let s = sub64(sigHiP, sigLoP, alignedHiQ, alignedLoQ); // P >= Q(aligned) by construction
+    sumHi = s.hi; sumLo = s.lo;
+  }
+
+  if (sumHi == 0u && sumLo == 0u) {
+    return Fields(0u, 0u, 0u, 0u); // exact cancellation -> +0
+  }
+
+  // commonExp2: per-bit scale of sumLo's bit0 in the widened representation.
+  let commonExp2 = expP - 55;
+
+  var leadPos: i32;
+  if (sumHi != 0u) {
+    leadPos = 32 + i32(31u - countLeadingZeros(sumHi));
+  } else {
+    leadPos = i32(31u - countLeadingZeros(sumLo));
+  }
+  let tentativeExp = leadPos + commonExp2;
+  var targetLSBScale = tentativeExp - 52;
+  if (tentativeExp < -1022) { targetLSBScale = -1074; }
+  let shiftAmt = targetLSBScale - commonExp2;
+
+  var keepHi: u32; var keepLo: u32;
+  if (shiftAmt <= 0) {
+    let sh = shl(sumHi, sumLo, u32(-shiftAmt)); // exact \u2014 cancellation only, never loses bits
+    keepHi = sh.hi; keepLo = sh.lo;
+  } else {
+    // Only reached without cancellation (same-sign add, or a tied-exponent
+    // subtract with no shrinkage) \u2014 shiftAmt here is always exactly 3 or 4,
+    // so the dropped bits are fully known from sumLo directly (no sticky
+    // approximation needed, unlike the Q-alignment shift above).
+    let n = u32(shiftAmt);
+    let remainder = sumLo & ((1u << n) - 1u);
+    let halfway = 1u << (n - 1u);
+    let sh = shr_sticky(sumHi, sumLo, n);
+    keepHi = sh.hi; keepLo = sh.lo;
+    if (remainder > halfway || (remainder == halfway && (keepLo & 1u) != 0u)) {
+      let inc = add64(keepHi, keepLo, 0u, 1u);
+      keepHi = inc.hi; keepLo = inc.lo;
+    }
+  }
+
+  var resultExpBase = targetLSBScale;
+  if ((keepHi & (1u << 21u)) != 0u) { // rounding carried past the 53-bit budget
+    let sh = shr_sticky(keepHi, keepLo, 1u); // dropped bit is guaranteed 0 here
+    keepHi = sh.hi; keepLo = sh.lo;
+    resultExpBase = resultExpBase + 1;
+  }
+
+  let resultSign = signP;
+  if ((keepHi & (1u << 20u)) != 0u) { // normal-shaped result
+    let unbiasedExp = 52 + resultExpBase;
+    let rawExpFinal = unbiasedExp + BIAS;
+    if (rawExpFinal >= 2047) {
+      return Fields(resultSign, EXP_ALL_ONES, 0u, 0u); // overflow -> Infinity
+    }
+    return Fields(resultSign, u32(rawExpFinal), keepHi & 0xfffffu, keepLo);
+  }
+  return Fields(resultSign, 0u, keepHi & 0xfffffu, keepLo); // subnormal result
+}
+
+// Packed-in/Packed-out convenience wrapper around addFields \u2014 encodes once,
+// after the math, rather than addFields itself needing to know about Packed.
+fn computeSum(a: Fields, b: Fields) -> Packed {
+  let f = addFields(a, b);
+  return encode(f.sign, f.rawExp, f.mantissaHi, f.lo);
+}
+`});var Ge,Ee=I(()=>{Ge=`// dasum: result = sum(|x[i]|)
+// pass 1 dispatches exactly 2 * WGS workgroups; pass 2 uses reduction/sumF64.wgsl.
+// Same structure as sasum.wgsl \u2014 every value is now a [main, aux] pair
+// (see src/util/f64pack.mjs) and every \`+\`/\`+=\` is computeSum via addPair
+// instead of plain f32 addition. Concatenated after f64add.wgsl by
+// getPipeline (WGSL has no #include), reusing its decode/encode/computeSum/
+// addFields and Packed struct \u2014 f64add.wgsl declares no bindings and no entry
+// point of its own (just helper functions), so bindings here start at 0 and
+// the entry point is simply \`dasum_main\`.
+//
+// xAux/partialsAux are array<u32>, not array<f32> \u2014 aux's bits must never
+// pass through an f32-typed storage slot (NaN-bit-pattern corruption risk,
+// see f64pack.mjs and the Packed struct comment above decode()/encode() in
+// f64add.wgsl); Packed (from f64add.wgsl) keeps aux as u32 in registers/
+// workgroup memory too.
+//
+// Per-thread accumulation (acc0..acc3) stays in DECODED Fields form for the
+// entire strided loop below, via addFields \u2014 not re-encoded to Packed and
+// re-decoded on every single element like a naive version would. Only the
+// freshly-loaded x[idx] needs decoding each iteration (unavoidable, it's new
+// data every time); the running total never leaves Fields form until the
+// four accumulators are combined and encoded exactly once, right before
+// writing into workgroup-shared \`tile\`. The cross-thread reduction tree
+// after that still goes through Packed per level (unavoidable \u2014 each level
+// combines values that live in different threads' registers via shared
+// memory), but that's a fixed 6 levels regardless of n, unlike the strided
+// loop above whose iteration count scales with n.
+
+@group(0) @binding(0) var<storage, read>       xMain:        array<f32>;
+@group(0) @binding(1) var<storage, read>       xAux:         array<u32>;
+@group(0) @binding(2) var<storage, read_write> partialsMain: array<f32>;
+@group(0) @binding(3) var<storage, read_write> partialsAux:  array<u32>;
+@group(0) @binding(4) var<uniform>             params:       Params;
+
+struct Params {
+  n:     u32,
+  x_inc: u32,
+}
+
+const WGS: u32 = 64;
+
+var<workgroup> tile: array<Packed, 64>;
+
+// a + b, where a/b are [main, aux] pairs \u2014 computeSum takes decoded Fields.
+// Only used for the cross-thread reduction tree below; the per-thread
+// strided loop uses addFields directly instead (see module comment).
+fn addPair(a: Packed, b: Packed) -> Packed {
+  return computeSum(decode(bitcast<u32>(a.main), a.aux), decode(bitcast<u32>(b.main), b.aux));
+}
+
+// |x| for a packed double is abs(main) with aux untouched \u2014 only main's
+// sign bit carries the double's sign (see fieldsToPacked() in f64pack.mjs).
+// Returns decoded Fields directly (not Packed) for the per-thread loop.
+fn absFields(idx: u32) -> Fields {
+  return decode(bitcast<u32>(abs(xMain[idx])), xAux[idx]);
+}
+
+@compute @workgroup_size(64)
+fn dasum_main(
+  @builtin(global_invocation_id) gid:    vec3u,
+  @builtin(local_invocation_id)  lid:    vec3u,
+  @builtin(workgroup_id)         wgid:   vec3u,
+  @builtin(num_workgroups)       num_wg: vec3u,
+) {
+  var acc0: Fields = Fields(0u, 0u, 0u, 0u);
+  var acc1: Fields = Fields(0u, 0u, 0u, 0u);
+  var acc2: Fields = Fields(0u, 0u, 0u, 0u);
+  var acc3: Fields = Fields(0u, 0u, 0u, 0u);
+
+  let stride   = num_wg.x * WGS;
+  let n4_floor = (params.n / (4u * stride)) * (4u * stride);
+
+  for (var id = gid.x; id < n4_floor; id += 4u * stride) {
+    acc0 = addFields(acc0, absFields( id                * params.x_inc));
+    acc1 = addFields(acc1, absFields((id +      stride) * params.x_inc));
+    acc2 = addFields(acc2, absFields((id + 2u * stride) * params.x_inc));
+    acc3 = addFields(acc3, absFields((id + 3u * stride) * params.x_inc));
+  }
+  for (var id = n4_floor + gid.x; id < params.n; id += stride) {
+    acc0 = addFields(acc0, absFields(id * params.x_inc));
+  }
+
+  // Combine the 4 per-thread accumulators in Fields form too \u2014 still no
+  // encode/decode needed, since none of them have touched Packed yet.
+  let combined = addFields(addFields(acc0, acc1), addFields(acc2, acc3));
+  tile[lid.x] = encode(combined.sign, combined.rawExp, combined.mantissaHi, combined.lo);
+  workgroupBarrier();
+
+  for (var s = WGS / 2u; s > 0u; s >>= 1u) {
+    if (lid.x < s) { tile[lid.x] = addPair(tile[lid.x], tile[lid.x + s]); }
+    workgroupBarrier();
+  }
+
+  if (lid.x == 0u) {
+    partialsMain[wgid.x] = tile[0].main;
+    partialsAux[wgid.x] = tile[0].aux;
+  }
+}
+`});var Be,Ae=I(()=>{Be=`// strsv_invert_block: computes ONE column (workgroup_id.x) of ONE block's
+// (workgroup_id.y) explicit inverse, via the same one-row-at-a-time
+// substitution as strsv_block.wgsl, but solving against a unit basis vector
+// e_col instead of the real right-hand side, and writing to a dense
+// (BLOCK_SIZE x BLOCK_SIZE, row-major) scratch buffer per block instead of
+// mutating x. Dispatched once for the whole matrix (2D: BLOCK_SIZE columns x
+// numBlocks), fully in parallel -- unlike the sequential per-block main
+// loop in strsv.mjs, no block's inverse depends on any other block or on x.
+//
+// A triangular block's inverse is itself triangular: forward (effectively-
+// lower, e.g. no-trans+lower) blocks have inverse column col nonzero only
+// for row>=col, solved in increasing row order; backward (effectively-
+// upper) blocks have it nonzero only for row<=col, solved in decreasing
+// order. Rows outside a column's nonzero range are written as literal 0 \u2014
+// strsv_apply_inverse.wgsl's dense matvec depends on that, not just on
+// those entries being mathematically implied zero.
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read_write> Ainv: array<f32>;
+
+struct Params {
+  n:     u32,
+  lda:   u32,
+  trans: u32,  // 0 = no-transpose, 1 = transpose
+  uplo:  u32,  // 0 = lower, 1 = upper
+  diag:  u32,  // 0 = non-unit, 1 = unit
+}
+
+@group(0) @binding(2) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+const BLOCK_SIZE: u32 = 64u;
+var<workgroup> scratch: array<f32, 64>;
+
+fn readA(i: u32, j: u32) -> f32 {
+  if params.trans == 0u {
+    return A[i * params.lda + j];
+  } else {
+    return A[j * params.lda + i];
+  }
+}
+
+@compute @workgroup_size(64)
+fn strsv_invert_block_main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+) {
+  let col = wgid.x;
+  let blockIndex = wgid.y;
+  let blockStart = blockIndex * BLOCK_SIZE;
+  var blockEnd = blockStart + BLOCK_SIZE;
+  if (blockEnd > params.n) { blockEnd = params.n; }
+  let blockLen = blockEnd - blockStart;
+
+  if (col >= blockLen) { return; }
+
+  let ainvBase = blockIndex * BLOCK_SIZE * BLOCK_SIZE;
+  let forward = (params.trans == 0u) == (params.uplo == 0u);
+
+  if forward {
+    for (var r = lid.x; r < col; r += WGS) {
+      Ainv[ainvBase + r * BLOCK_SIZE + col] = 0.0;
+    }
+  } else {
+    for (var r = col + 1u + lid.x; r < blockLen; r += WGS) {
+      Ainv[ainvBase + r * BLOCK_SIZE + col] = 0.0;
+    }
+  }
+  storageBarrier();
+  workgroupBarrier();
+
+  let numSteps = select(col + 1u, blockLen - col, forward);
+  for (var step = 0u; step < numSteps; step++) {
+    let localRow = select(col - step, col + step, forward);
+    let i = blockStart + localRow;
+
+    var acc = 0.0f;
+    if forward {
+      for (var lj = col + lid.x; lj < localRow; lj += WGS) {
+        acc += readA(i, blockStart + lj) * Ainv[ainvBase + lj * BLOCK_SIZE + col];
+      }
+    } else {
+      for (var lj = localRow + 1u + lid.x; lj <= col; lj += WGS) {
+        acc += readA(i, blockStart + lj) * Ainv[ainvBase + lj * BLOCK_SIZE + col];
+      }
+    }
+
+    scratch[lid.x] = acc;
+    workgroupBarrier();
+    for (var stride = WGS >> 1u; stride > 0u; stride >>= 1u) {
+      if lid.x < stride { scratch[lid.x] += scratch[lid.x + stride]; }
+      workgroupBarrier();
+    }
+
+    if lid.x == 0u {
+      let e = select(0.0, 1.0, localRow == col);
+      let rhs = e - scratch[0];
+      var val: f32;
+      if params.diag == 1u {
+        val = rhs;
+      } else {
+        val = rhs / A[i * params.lda + i];
+      }
+      Ainv[ainvBase + localRow * BLOCK_SIZE + col] = val;
+    }
+    storageBarrier();
+    workgroupBarrier();
+  }
+}
+`});var Pe,ke=I(()=>{Pe=`// strsv_apply_inverse: given a precomputed block inverse (from
+// strsv_invert_block.wgsl), computes this block's solution as a dense
+// matrix-vector multiply against the block's current remainder in x \u2014
+// replacing what the old strsv_block.wgsl did via a genuinely sequential,
+// barrier-per-row substitution.
+//
+// All blockLen rows are computed in parallel within a single workgroup: the
+// remainder is loaded into workgroup-shared memory once, then each thread
+// independently computes one full row's dot product from that shared copy.
+// No further synchronization is needed after the load \u2014 every thread only
+// reads shared memory from then on (never written again within this call)
+// and writes a distinct element of x, so there's no cross-thread hazard to
+// guard against.
+
+@group(0) @binding(0) var<storage, read>       Ainv: array<f32>;
+@group(0) @binding(1) var<storage, read_write> x: array<f32>;
+
+struct Params {
+  incx:       u32,
+  blockIndex: u32,
+  blockStart: u32,
+  blockEnd:   u32,
+}
+
+@group(0) @binding(2) var<uniform> params: Params;
+
+const BLOCK_SIZE: u32 = 64u;
+var<workgroup> xLocal: array<f32, 64>;
+
+@compute @workgroup_size(64)
+fn strsv_apply_inverse_main(@builtin(local_invocation_id) lid: vec3u) {
+  let blockLen = params.blockEnd - params.blockStart;
+
+  if (lid.x < blockLen) {
+    xLocal[lid.x] = x[(params.blockStart + lid.x) * params.incx];
+  }
+  workgroupBarrier();
+
+  if (lid.x >= blockLen) { return; }
+
+  let ainvBase = params.blockIndex * BLOCK_SIZE * BLOCK_SIZE;
+  var acc = 0.0f;
+  for (var j = 0u; j < blockLen; j++) {
+    acc += Ainv[ainvBase + lid.x * BLOCK_SIZE + j] * xLocal[j];
+  }
+  x[(params.blockStart + lid.x) * params.incx] = acc;
+}
+`});var Fe,Se=I(()=>{Fe=`// strsv_update: subtracts a solved block's contribution from every
+// remaining row in parallel (one workgroup per row, like strmv.wgsl) \u2014
+// this is what turns strsv's O(n) sequential stages into O(n/blockSize).
+// No diag/masking needed: this region never touches the diagonal.
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read_write> x: array<f32>;
+
+struct Params {
+  n:          u32,
+  incx:       u32,
+  lda:        u32,
+  trans:      u32,  // 0 = no-transpose, 1 = transpose
+  uplo:       u32,  // 0 = lower, 1 = upper
+  blockStart: u32,
+  blockEnd:   u32,  // exclusive
+}
+
+@group(0) @binding(2) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+var<workgroup> scratch: array<f32, 64>;
+
+@compute @workgroup_size(64)
+fn strsv_update_main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  // forward: remaining rows are [blockEnd,n); backward: [0,blockStart).
+  let forward = (params.trans == 0u) == (params.uplo == 0u);
+
+  var rangeStart: u32;
+  var rangeEnd: u32;
+
+  if forward {
+    rangeStart = params.blockEnd;
+    rangeEnd = params.n;
+  } else {
+    rangeStart = 0u;
+    rangeEnd = params.blockStart;
+  }
+  
+  if (rangeStart >= rangeEnd) { return; }
+  let count = rangeEnd - rangeStart;
+
+  for (var idx = wgid.x; idx < count; idx += nwg.x) {
+    let i = rangeStart + idx;
+
+    // No-trans reads A[i,j]; transpose reads A[j,i] \u2014 uplo only sets the range above.
+    var acc = 0.0f;
+    if params.trans == 0u {
+      for (var j = params.blockStart + lid.x; j < params.blockEnd; j += WGS) {
+        acc += A[i * params.lda + j] * x[j * params.incx];
+      }
+    } else {
+      for (var j = params.blockStart + lid.x; j < params.blockEnd; j += WGS) {
+        acc += A[j * params.lda + i] * x[j * params.incx];
+      }
+    }
+
+    // Parallel reduction: 64 \u2192 1
+    scratch[lid.x] = acc;
+    workgroupBarrier();
+    for (var stride = WGS >> 1u; stride > 0u; stride >>= 1u) {
+      if lid.x < stride { scratch[lid.x] += scratch[lid.x + stride]; }
+      workgroupBarrier();
+    }
+
+    if lid.x == 0u {
+      x[i * params.incx] -= scratch[0];
+    }
+    workgroupBarrier();
+  }
+}
+`});var je={};yr(je,{shaderSources:()=>Kt});var Kt,Le=I(()=>{Ir();Ur();Vr();Hr();Cr();zr();qr();Kr();$r();Jr();ee();ae();ie();se();le();ce();de();ge();be();xe();ye();Ee();Ae();ke();Se();Kt={"reduction/argmax":Mr,"reduction/sum":Tr,"reduction/sumF64":Rr,sscal:Dr,sswap:Or,saxpy:Qr,scopy:Zr,sdot:Xr,sasum:Yr,snrm2:re,srot:te,srotm:oe,isamax:ne,sgemv_n:ue,sgemv_t:fe,ssymv:me,strmv:pe,sger:we,ssyr:he,ssyr2:ve,f64add:_e,dasum:Ge,strsv_invert_block:Be,strsv_apply_inverse:Pe,strsv_update:Fe}});var ra={};yr(ra,{GpuMatrix:()=>H,GpuVector:()=>x,cleanup:()=>Pr,dasum:()=>De,gpuName:()=>Sr,init:()=>kr,isamax:()=>ze,randomFloat32Array:()=>Nr,randomFloat64Array:()=>Wr,sasum:()=>He,saxpy:()=>Me,scopy:()=>Ue,sdot:()=>Ve,sgemv:()=>Ze,sger:()=>rt,snrm2:()=>Oe,srot:()=>Qe,srotm:()=>qe,sscal:()=>We,sswap:()=>Ie,ssymv:()=>Ke,ssyr:()=>et,ssyr2:()=>tt,strmv:()=>Xe,strsv:()=>Je});function Er(a,r){return r?a.features.has("timestamp-query")?{requiredFeatures:["timestamp-query"]}:(console.warn("timestamp-query not supported on this device \u2014 benchmark mode disabled."),{}):{}}function Gr(){if(!Ar())return{querySet:null,passDescriptor:void 0};let r=V().createQuerySet({type:"timestamp",count:2});return{querySet:r,passDescriptor:{timestampWrites:{querySet:r,beginningOfPassWriteIndex:0,endOfPassWriteIndex:1}}}}function cr(a,r){if(!r)return null;let e=V(),o=e.createBuffer({label:"timestamp-resolve",size:16,usage:GPUBufferUsage.QUERY_RESOLVE|GPUBufferUsage.COPY_SRC});a.resolveQuerySet(r,0,2,o,0);let t=e.createBuffer({label:"timestamp-readback",size:16,usage:GPUBufferUsage.COPY_DST|GPUBufferUsage.MAP_READ});return a.copyBufferToBuffer(o,0,t,0,16),{tsReadBuffer:t,resolveBuffer:o,querySet:r}}async function P(a){if(!a)return;let{tsReadBuffer:r,resolveBuffer:e,querySet:o}=a;await r.mapAsync(GPUMapMode.READ);let t=new BigInt64Array(r.getMappedRange().slice());return r.unmap(),r.destroy(),e.destroy(),o.destroy(),Math.max(0,Number(t[1]-t[0]))/1e6}var Z=null,J=null,Br=null,dr=!1;async function kr({powerPreference:a="high-performance",benchmark:r=!1}={}){if(Z)return Z;let e;if(typeof window>"u"){let{create:i,globals:n}=await import("webgpu");Object.assign(globalThis,n),e=i([]),Br=e}else e=navigator.gpu;if(!e)throw new Error("WebGPU not supported in this environment.");if(J=await e.requestAdapter({powerPreference:a})??await e.requestAdapter(),!J)throw new Error("No WebGPU adapter found.");dr=r;let t=[...Er(J,r).requiredFeatures??[]];return Z=await J.requestDevice({requiredFeatures:t}),Z.addEventListener("uncapturederror",i=>{console.error("Uncaptured GPU error:",i.error.message)}),Z}function Pr(){Z&&(Z.destroy(),Z=null),J=null,Br=null,dr=!1}function Sr(){if(!J)throw new Error("WebGPU adapter not initialized \u2014 call init() first.");let{device:a,description:r}=J.info;return{description:r||"unknown",device:a||"unknown"}}function Ar(){return dr}function V(){if(!Z)throw new Error("WebGPU device not initialized \u2014 call init() first.");return Z}function d(...a){a.flat().forEach(r=>r.destroy())}function b(a,r="blas-input",e=!1){let o=V(),t=o.limits.maxStorageBufferBindingSize,i=a.byteLength;if(i>t)throw new Error(`Buffer size ${i} bytes exceeds device limit of ${t} bytes.`);let n=e?GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_SRC:GPUBufferUsage.STORAGE,u=o.createBuffer({label:r,size:i,usage:n,mappedAtCreation:!0}),s=a.constructor;return new s(u.getMappedRange()).set(a),u.unmap(),u}function D(a,r="blas-storage"){return V().createBuffer({label:r,size:a,usage:GPUBufferUsage.STORAGE})}function q(a,r="blas-result"){return V().createBuffer({label:r,size:a,usage:GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_SRC})}function E(a,r){let o=V().createBuffer({label:"blas-readback",size:r.size,usage:GPUBufferUsage.COPY_DST|GPUBufferUsage.MAP_READ});return a.copyBufferToBuffer(r,0,o,0,r.size),o}function N(a,r="blas-params"){let e=V(),o=a.length*4,t=Math.ceil(o/16)*16,i=new ArrayBuffer(t),n=new DataView(i);a.forEach(({value:s,type:l},f)=>{let c=f*4;if(l==="u32")n.setUint32(c,s,!0);else if(l==="i32")n.setInt32(c,s,!0);else if(l==="f32")n.setFloat32(c,s,!0);else throw new Error(`Unknown param type "${l}". Use "f32", "u32", or "i32".`)});let u=e.createBuffer({label:r,size:t,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});return e.queue.writeBuffer(u,0,i),u}async function _(a,r=Float32Array){try{await a.mapAsync(GPUMapMode.READ);let e=new r(a.getMappedRange().slice());return a.unmap(),e}finally{a.destroy()}}var bt=new ArrayBuffer(8),er=new DataView(bt),Fr=new ArrayBuffer(4),jr=new Uint32Array(Fr),Lr=new Float32Array(Fr);function ht(a){return jr[0]=a>>>0,Lr[0]}function xt(a){return Lr[0]=a,jr[0]}function vt(a,r,e,o){let t=r>>>3,i=r&7,n=o>>>29,u=e<<3|n,s=o&536870911,l=a<<31|t<<23|u,f=i>>>2&1,c=i&3,p=s>>>23,m=s&8388607,g=c<<6|p,w=(f<<31|g<<23|m)>>>0;return[ht(l),w]}function yt(a,r){let e=xt(a);r=r>>>0;let o=e>>>31,t=e>>>23&255,i=e&8388607,n=r>>>31,u=r>>>23&255,s=r&8388607,l=n<<2|u>>>6,f=(u&63)<<23|s,c=t<<3|l,p=i>>>3,g=((i&7)<<29|f)>>>0;return{sign:o,rawExp:c,mantissaHi:p,lo:g}}var _t=2040;function mr(a){er.setFloat64(0,a,!1);let r=er.getUint32(0,!1),e=er.getUint32(4,!1),o=r>>>31,t=r>>>20&2047,i=r&1048575;if(t>=_t)throw new RangeError(`packF64: |${a}| is too large to pack safely (must be finite with magnitude below ~1.4e306); main's bit pattern would itself be NaN/Infinity-shaped and get silently corrupted by any real float32 round-trip`);return vt(o,t,i,e)}function tr(a,r){let{sign:e,rawExp:o,mantissaHi:t,lo:i}=yt(a,r),n=(e<<31|o<<20|t)>>>0;return er.setUint32(0,n,!1),er.setUint32(4,i,!1),er.getFloat64(0,!1)}var x=class a{constructor(r,e,o=Float32Array,t=null){this._buf=r,this._auxBuf=t,this.length=e,this.dtype=o}static from(r){if(r instanceof Float64Array){let o=new Float32Array(r.length),t=new Uint32Array(r.length);for(let u=0;u<r.length;u++){let s=mr(r[u]);o[u]=s[0],t[u]=s[1]}let i=b(o,"gpu-vector-f64-main",!0),n=b(t,"gpu-vector-f64-aux",!0);return new a(i,r.length,Float64Array,n)}if(!(r instanceof Float32Array))throw new Error("GpuVector.from expects a Float32Array or Float64Array.");let e=b(r,"gpu-vector",!0);return new a(e,r.length,r.constructor)}async read(){let r=V(),e=r.createCommandEncoder(),o=E(e,this._buf);if(r.queue.submit([e.finish()]),!this._auxBuf)return _(o,this.dtype);let t=r.createCommandEncoder(),i=E(t,this._auxBuf);r.queue.submit([t.finish()]);let[n,u]=await Promise.all([_(o,Float32Array),_(i,Uint32Array)]),s=new Float64Array(this.length);for(let l=0;l<this.length;l++)s[l]=tr(n[l],u[l]);return s}destroy(){this._buf.destroy(),this._auxBuf&&this._auxBuf.destroy()}};var H=class a{constructor(r,e,o,t,i=null,n="row-major"){this._buf=r,this._auxBuf=i,this.rows=e,this.cols=o,this.lda=t,this.layout=n}static from(r,e,o,t,i="row-major"){if(i!=="row-major"&&i!=="column-major")throw new Error("layout must be 'row-major' or 'column-major'.");let n=i==="row-major";if(t===void 0&&(t=n?o:e),!(r instanceof Float32Array)&&!(r instanceof Float64Array))throw new Error("GpuMatrix.from expects a Float32Array or Float64Array.");if(!Number.isInteger(e)||e<=0)throw new Error("rows must be a positive integer.");if(!Number.isInteger(o)||o<=0)throw new Error("cols must be a positive integer.");let u=n?o:e;if(!Number.isInteger(t)||t<u)throw new Error(`lda must be an integer >= ${n?"cols":"rows"}.`);let s=n?e:o;if(r.length<s*t)throw new Error("data does not have enough elements for the given rows, cols, and lda.");if(r instanceof Float64Array){let f=s*t,c=new Float32Array(f),p=new Uint32Array(f);for(let w=0;w<f;w++){let y=mr(r[w]);c[w]=y[0],p[w]=y[1]}let m=b(c,"gpu-matrix-f64-main",!0),g=b(p,"gpu-matrix-f64-aux",!0);return new a(m,e,o,t,g,i)}let l=b(r.subarray(0,s*t),"gpu-matrix",!0);return new a(l,e,o,t,null,i)}async read(){let r=V(),e=r.createCommandEncoder(),o=E(e,this._buf);r.queue.submit([e.finish()]);let t=this.layout!=="column-major",i=t?this.rows:this.cols,n=t?this.cols:this.rows;if(this._auxBuf){let l=r.createCommandEncoder(),f=E(l,this._auxBuf);r.queue.submit([l.finish()]);let[c,p]=await Promise.all([_(o,Float32Array),_(f,Uint32Array)]),m=new Float64Array(i*this.lda);for(let w=0;w<m.length;w++)m[w]=tr(c[w],p[w]);if(this.lda===n)return m;let g=new Float64Array(i*n);for(let w=0;w<i;w++)g.set(m.subarray(w*this.lda,w*this.lda+n),w*n);return g}let u=await _(o,Float32Array);if(this.lda===n)return u;let s=new Float32Array(i*n);for(let l=0;l<i;l++)s.set(u.subarray(l*this.lda,l*this.lda+n),l*n);return s}destroy(){this._buf.destroy(),this._auxBuf&&this._auxBuf.destroy()}};function Nr(a,r=-1,e=1){let o=new Float32Array(a);for(let t=0;t<a;t++)o[t]=r+Math.random()*(e-r);return o}function Wr(a,r=-1,e=1){let o=new Float64Array(a);for(let t=0;t<a;t++)o[t]=r+Math.random()*(e-r);return o}function A(a,r,e=0){let o=V(),t=r.map((i,n)=>({binding:e+n,resource:i instanceof GPUBuffer?{buffer:i}:i}));return o.createBindGroup({layout:a,entries:t})}var Et=new WeakMap;function S(a){V().queue.submit([a.finish()])}function pr(){let a=V(),{querySet:r,passDescriptor:e}=Gr();return{commandEncoder:a.createCommandEncoder(),querySet:r,passDescriptor:e}}function ir(a,r,e,o,t){let i=a.beginComputePass(t);i.setPipeline(r),i.setBindGroup(0,e),typeof o=="number"?i.dispatchWorkgroups(o):i.dispatchWorkgroups(o.x,o.y),i.end(),Et.set(a,i)}function L(a,r,e){let{commandEncoder:o,querySet:t,passDescriptor:i}=pr();ir(o,a,r,e,i);let n=cr(o,t);return{commandEncoder:o,ts:n}}var Yt={},gr=new WeakMap;async function B(a,r,e="main"){gr.has(a)||gr.set(a,new Map);let o=gr.get(a),t=Array.isArray(r)?r:[r],i=`${t.join("+")}::${e}`;return o.has(i)||o.set(i,await $t(t,e)),o.get(i)}async function Xt(a){if(typeof process>"u"||!process.versions?.node){let{shaderSources:r}=await Promise.resolve().then(()=>(Le(),je)),e=r[a];if(!e)throw new Error(`Shader "${a}" not found in browser bundle.`);return e}else{let{readFileSync:r}=await import("fs"),{fileURLToPath:e}=await import("url"),{dirname:o,join:t}=await import("path"),i=o(e(Yt.url));return r(t(i,`../shaders/${a}.wgsl`),"utf8")}}async function $t(a,r="main"){let e=V(),o=a.join("+"),t=(await Promise.all(a.map(Xt))).join(`
+`),i=e.createShaderModule({label:o,code:t}),u=(await i.getCompilationInfo()).messages.filter(f=>f.type==="error");if(u.length>0)throw new Error(`Shader "${o}" compilation failed:
+${u.map(f=>`  line ${f.lineNum}: ${f.message}`).join(`
+`)}`);let s=r==="main"?{module:i}:{module:i,entryPoint:r},l=e.createComputePipeline({label:o,layout:"auto",compute:s});return l._shaderModule=i,l}var Jt=64,Ne=8;function C(a,r){let e=V().limits.maxComputeWorkgroupsPerDimension;return r===void 0?Math.min(Math.ceil(a/Jt),e):{x:Math.min(Math.ceil(r/Ne),e),y:Math.min(Math.ceil(a/Ne),e)}}async function We(a,r,e,o,t){let i=o instanceof x;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(t))throw new Error("n and incx must be integers.");if(typeof e!="number")throw new Error("alpha must be a number.");if(Number.isNaN(e))throw new Error("alpha must not be NaN.");if(!Number.isFinite(e))throw new Error("alpha must be finite.");if(t<=0)throw new Error("incx must be positive.");if(!(o instanceof Float32Array)&&!(o instanceof x))throw new Error("x must be a Float32Array or GpuVector.");if(r<=0)return i?{}:o;if(o.length<(r-1)*t+1)throw new Error("x does not have enough elements for the given n and incx.");let n=await B(a,"sscal"),u=null,s=null,l=null;try{u=i?o._buf:b(o,"sscal-x",!0),s=N([{value:r,type:"u32"},{value:e,type:"f32"},{value:t,type:"u32"}],"sscal-params");let f=A(n.getBindGroupLayout(0),[u,s]),{commandEncoder:c,ts:p}=L(n,f,C(r));l=i?null:E(c,u),S(c);let m=await P(p);if(i)return m!==void 0?{gpuTimeMs:m}:{};let g=await _(l,Float32Array);return l=null,m!==void 0?{x:g,gpuTimeMs:m}:g}finally{!i&&u&&d(u),s&&d(s),l&&d(l)}}async function Ie(a,r,e,o,t,i){let n=e instanceof x,u=t instanceof x;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(o)||!Number.isInteger(i))throw new Error("n, incx, and incy must be integers.");if(o<=0||i<=0)throw new Error("incx and incy must be positive.");if(!(e instanceof Float32Array)&&!(e instanceof x))throw new Error("x must be a Float32Array or GpuVector.");if(!(t instanceof Float32Array)&&!(t instanceof x))throw new Error("y must be a Float32Array or GpuVector.");if(e.constructor!==t.constructor)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(r<=0)return n?{}:{x:e,y:t};if(e.length<(r-1)*o+1)throw new Error("x does not have enough elements for the given n and incx.");if(t.length<(r-1)*i+1)throw new Error("y does not have enough elements for the given n and incy.");let s=await B(a,"sswap"),l=null,f=null,c=null,p=null,m=null;try{l=n?e._buf:b(e,"sswap-x",!0),f=u?t._buf:b(t,"sswap-y",!0),c=N([{value:r,type:"u32"},{value:o,type:"u32"},{value:i,type:"u32"}],"sswap-params");let g=A(s.getBindGroupLayout(0),[l,f,c]),{commandEncoder:w,ts:y}=L(s,g,C(r));p=n?null:E(w,l),m=u?null:E(w,f),S(w);let h=await P(y);if(n&&u)return h!==void 0?{gpuTimeMs:h}:{};let G=await _(p,Float32Array);p=null;let v=await _(m,Float32Array);return m=null,h!==void 0?{x:G,y:v,gpuTimeMs:h}:{x:G,y:v}}finally{!n&&l&&d(l),!u&&f&&d(f),c&&d(c),p&&d(p),m&&d(m)}}async function Me(a,r,e,o,t,i,n){let u=o instanceof x,s=i instanceof x;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(t)||!Number.isInteger(n))throw new Error("n, incx, and incy must be integers.");if(typeof e!="number")throw new Error("alpha must be a number.");if(Number.isNaN(e))throw new Error("alpha must not be NaN.");if(!Number.isFinite(e))throw new Error("alpha must be finite.");if(t<=0||n<=0)throw new Error("incx and incy must be positive.");if(!u&&!(o instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!s&&!(i instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(u!==s)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(r<=0)return s?{}:{y:i};if(o.length<(r-1)*t+1)throw new Error("x does not have enough elements for the given n and incx.");if(i.length<(r-1)*n+1)throw new Error("y does not have enough elements for the given n and incy.");let l=await B(a,"saxpy"),f=null,c=null,p=null,m=null;try{f=u?o._buf:b(o,"saxpy-x",!1),c=s?i._buf:b(i,"saxpy-y",!0),p=N([{value:r,type:"u32"},{value:e,type:"f32"},{value:t,type:"u32"},{value:n,type:"u32"}],"saxpy-params");let g=A(l.getBindGroupLayout(0),[f,c,p]),{commandEncoder:w,ts:y}=L(l,g,C(r));m=s?null:E(w,c),S(w);let h=await P(y);if(s&&u)return h!==void 0?{gpuTimeMs:h}:{};let G=await _(m,Float32Array);return m=null,h!==void 0?{y:G,gpuTimeMs:h}:{y:G}}finally{!u&&f&&d(f),!s&&c&&d(c),p&&d(p),m&&d(m)}}async function Ue(a,r,e,o,t,i){let n=e instanceof x,u=t instanceof x;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(o)||!Number.isInteger(i))throw new Error("n, incx, and incy must be integers.");if(o<=0||i<=0)throw new Error("incx and incy must be positive.");if(!n&&!(e instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!u&&!(t instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(n!==u)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(r<=0)return u?{}:{y:t};if(e.length<(r-1)*o+1)throw new Error("x does not have enough elements for the given n and incx.");if(t.length<(r-1)*i+1)throw new Error("y does not have enough elements for the given n and incy.");let s=await B(a,"scopy"),l=null,f=null,c=null,p=null;try{l=n?e._buf:b(e,"scopy-x",!1),f=u?t._buf:b(t,"scopy-y",!0),c=N([{value:r,type:"u32"},{value:o,type:"u32"},{value:i,type:"u32"}],"scopy-params");let m=A(s.getBindGroupLayout(0),[l,f,c]),{commandEncoder:g,ts:w}=L(s,m,C(r));p=u?null:E(g,f),S(g);let y=await P(w);if(u&&n)return y!==void 0?{gpuTimeMs:y}:{};let h=await _(p,Float32Array);return p=null,y!==void 0?{y:h,gpuTimeMs:y}:{y:h}}finally{!n&&l&&d(l),!u&&f&&d(f),c&&d(c),p&&d(p)}}var Te=64;async function Ve(a,r,e,o,t,i){let n=e instanceof x,u=t instanceof x;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(o)||!Number.isInteger(i))throw new Error("n, incx, and incy must be integers.");if(o<=0||i<=0)throw new Error("incx and incy must be positive.");if(!n&&!(e instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!u&&!(t instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(n!==u)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(r<=0)return{dot:0};if(e.length<(r-1)*o+1)throw new Error("x does not have enough elements for the given n and incx.");if(t.length<(r-1)*i+1)throw new Error("y does not have enough elements for the given n and incy.");let s=await B(a,"sdot"),l=await B(a,"reduction/sum"),f=null,c=null,p=null,m=null,g=null,w=null;try{f=n?e._buf:b(e,"sdot-x",!1),c=u?t._buf:b(t,"sdot-y",!1),p=D(2*Te*4,"sdot-partials"),m=q(4,"sdot-result"),g=N([{value:r,type:"u32"},{value:o,type:"u32"},{value:i,type:"u32"}],"sdot-params");let y=A(s.getBindGroupLayout(0),[f,c,p,g]),{commandEncoder:h,ts:G}=L(s,y,2*Te);S(h);let v=A(l.getBindGroupLayout(0),[p,m]),{commandEncoder:F,ts:k}=L(l,v,1);w=E(F,m),S(F);let j=_(w,Float32Array);w=null;let[W,M,U]=await Promise.all([P(G),P(k),j]);return W!==void 0&&M!==void 0?{dot:U[0],gpuTimeMs:W+M}:{dot:U[0]}}finally{!n&&f&&d(f),!u&&c&&d(c),p&&d(p),m&&d(m),g&&d(g),w&&d(w)}}var Re=64;async function He(a,r,e,o){let t=e instanceof x;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(o))throw new Error("n and incx must be integers.");if(o<=0)throw new Error("incx must be positive.");if(!t&&!(e instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(r<=0)return{asum:0};if(e.length<(r-1)*o+1)throw new Error("x does not have enough elements for the given n and incx.");let i=await B(a,"sasum"),n=await B(a,"reduction/sum"),u=null,s=null,l=null,f=null,c=null;try{u=t?e._buf:b(e,"sasum-x",!1),s=D(2*Re*4,"sasum-partials"),l=q(4,"sasum-result"),f=N([{value:r,type:"u32"},{value:o,type:"u32"}],"sasum-params");let p=A(i.getBindGroupLayout(0),[u,s,f]),{commandEncoder:m,ts:g}=L(i,p,2*Re);S(m);let w=A(n.getBindGroupLayout(0),[s,l]),{commandEncoder:y,ts:h}=L(n,w,1);c=E(y,l),S(y);let G=_(c,Float32Array);c=null;let[v,F,k]=await Promise.all([P(g),P(h),G]);return v!==void 0&&F!==void 0?{asum:k[0],gpuTimeMs:v+F}:{asum:k[0]}}finally{!t&&u&&d(u),s&&d(s),l&&d(l),f&&d(f),c&&d(c)}}var wr=64;async function De(a,r,e,o){let t=e instanceof x;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(o))throw new Error("n and incx must be integers.");if(o<=0)throw new Error("incx must be positive.");if(!t&&!(e instanceof Float64Array))throw new Error("x must be a Float64Array or GpuVector.");if(t&&e.dtype!==Float64Array)throw new Error("x must be a Float64Array-backed GpuVector.");if(r<=0)return{asum:0};if(e.length<(r-1)*o+1)throw new Error("x does not have enough elements for the given n and incx.");let i=await B(a,["f64add","dasum"]),n=await B(a,["f64add","reduction/sumF64"]),u=null,s=null,l=null,f=null,c=null,p=null,m=null,g=null;try{u=t?e:x.from(e),s=D(2*wr*4,"dasum-partialsMain"),l=D(2*wr*4,"dasum-partialsAux"),f=q(4,"dasum-result-main"),c=q(4,"dasum-result-aux"),p=N([{value:r,type:"u32"},{value:o,type:"u32"}],"dasum-params");let w=A(i.getBindGroupLayout(0),[u._buf,u._auxBuf,s,l,p]),{commandEncoder:y,ts:h}=L(i,w,2*wr);S(y);let G=A(n.getBindGroupLayout(0),[s,l,f,c]),{commandEncoder:v,ts:F}=L(n,G,1);m=E(v,f),g=E(v,c),S(v);let k=_(m,Float32Array),j=_(g,Uint32Array);m=null,g=null;let[W,M,U,T]=await Promise.all([P(h),P(F),k,j]),R=tr(U[0],T[0]);return W!==void 0&&M!==void 0?{asum:R,gpuTimeMs:W+M}:{asum:R}}finally{!t&&u&&u.destroy(),s&&d(s),l&&d(l),f&&d(f),c&&d(c),p&&d(p),m&&d(m),g&&d(g)}}var Ce=64;async function Oe(a,r,e,o){let t=e instanceof x;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(o))throw new Error("n and incx must be integers.");if(o<=0)throw new Error("incx must be positive.");if(!t&&!(e instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(r<=0)return{nrm2:0};if(e.length<(r-1)*o+1)throw new Error("x does not have enough elements for the given n and incx.");let i=await B(a,"snrm2"),n=await B(a,"reduction/sum"),u=null,s=null,l=null,f=null,c=null;try{u=t?e._buf:b(e,"snrm2-x",!1),s=D(2*Ce*4,"snrm2-partials"),l=q(4,"snrm2-result"),f=N([{value:r,type:"u32"},{value:o,type:"u32"}],"snrm2-params");let p=A(i.getBindGroupLayout(0),[u,s,f]),{commandEncoder:m,ts:g}=L(i,p,2*Ce);S(m);let w=A(n.getBindGroupLayout(0),[s,l]),{commandEncoder:y,ts:h}=L(n,w,1);c=E(y,l),S(y);let G=_(c,Float32Array);c=null;let[v,F,k]=await Promise.all([P(g),P(h),G]),j=Math.sqrt(k[0]);return v!==void 0&&F!==void 0?{nrm2:j,gpuTimeMs:v+F}:{nrm2:j}}finally{!t&&u&&d(u),s&&d(s),l&&d(l),f&&d(f),c&&d(c)}}var br=64;async function ze(a,r,e,o){let t=e instanceof x;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(o))throw new Error("n and incx must be integers.");if(o<=0)throw new Error("incx must be positive.");if(!t&&!(e instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(r<=0)return{index:0};if(e.length<(r-1)*o+1)throw new Error("x does not have enough elements for the given n and incx.");let i=await B(a,"isamax"),n=await B(a,"reduction/argmax"),u=null,s=null,l=null,f=null,c=null,p=null;try{u=t?e._buf:b(e,"isamax-x",!1),s=D(2*br*4,"isamax-partials-val"),l=D(2*br*4,"isamax-partials-idx"),f=q(4,"isamax-result"),c=N([{value:r,type:"u32"},{value:o,type:"u32"}],"isamax-params");let m=A(i.getBindGroupLayout(0),[u,s,l,c]),{commandEncoder:g,ts:w}=L(i,m,2*br);S(g);let y=A(n.getBindGroupLayout(0),[s,l,f]),{commandEncoder:h,ts:G}=L(n,y,1);p=E(h,f),S(h);let v=_(p,Uint32Array);p=null;let[F,k,j]=await Promise.all([P(w),P(G),v]),W=j[0];return F!==void 0&&k!==void 0?{index:W,gpuTimeMs:F+k}:{index:W}}finally{!t&&u&&d(u),s&&d(s),l&&d(l),f&&d(f),c&&d(c),p&&d(p)}}async function Qe(a,r,e,o,t,i,n,u){let s=e instanceof x,l=t instanceof x;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(o)||!Number.isInteger(i))throw new Error("n, incx, and incy must be integers.");if(typeof n!="number")throw new Error("c must be a number.");if(typeof u!="number")throw new Error("s must be a number.");if(Number.isNaN(n)||Number.isNaN(u))throw new Error("c and s must not be NaN.");if(!Number.isFinite(n))throw new Error("c must be finite.");if(!Number.isFinite(u))throw new Error("s must be finite.");if(o<=0||i<=0)throw new Error("incx and incy must be positive.");if(!s&&!(e instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!l&&!(t instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(s!==l)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(r<=0)return s?{}:{x:e,y:t};if(e.length<(r-1)*o+1)throw new Error("x does not have enough elements for the given n and incx.");if(t.length<(r-1)*i+1)throw new Error("y does not have enough elements for the given n and incy.");let f=await B(a,"srot"),c=null,p=null,m=null,g=null,w=null;try{c=s?e._buf:b(e,"srot-x",!0),p=l?t._buf:b(t,"srot-y",!0),m=N([{value:r,type:"u32"},{value:n,type:"f32"},{value:u,type:"f32"},{value:o,type:"u32"},{value:i,type:"u32"}],"srot-params");let y=A(f.getBindGroupLayout(0),[c,p,m]),{commandEncoder:h,ts:G}=L(f,y,C(r));g=s?null:E(h,c),w=l?null:E(h,p),S(h);let v=await P(G);if(s&&l)return v!==void 0?{gpuTimeMs:v}:{};let F=_(g,Float32Array),k=_(w,Float32Array);g=null,w=null;let[j,W]=await Promise.all([F,k]);return v!==void 0?{x:j,y:W,gpuTimeMs:v}:{x:j,y:W}}finally{!s&&c&&d(c),!l&&p&&d(p),m&&d(m),g&&d(g),w&&d(w)}}async function qe(a,r,e,o,t,i,n){let u=e instanceof x,s=t instanceof x;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(!Number.isInteger(r)||!Number.isInteger(o)||!Number.isInteger(i))throw new Error("n, incx, and incy must be integers.");if(!(n instanceof Float32Array)||n.length!==5)throw new Error("param must be a Float32Array of length 5.");if(o<=0||i<=0)throw new Error("incx and incy must be positive.");if(!u&&!(e instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!s&&!(t instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(u!==s)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(r<=0||n[0]===-2)return u?{}:{x:e,y:t};if(e.length<(r-1)*o+1)throw new Error("x does not have enough elements for the given n and incx.");if(t.length<(r-1)*i+1)throw new Error("y does not have enough elements for the given n and incy.");let l=await B(a,"srotm"),f=null,c=null,p=null,m=null,g=null,w=null;try{f=u?e._buf:b(e,"srotm-x",!0),c=s?t._buf:b(t,"srotm-y",!0),p=b(n,"srotm-param",!1),m=N([{value:r,type:"u32"},{value:o,type:"u32"},{value:i,type:"u32"}],"srotm-params");let y=A(l.getBindGroupLayout(0),[f,c,p,m]),{commandEncoder:h,ts:G}=L(l,y,C(r));g=u?null:E(h,f),w=s?null:E(h,c),S(h);let v=await P(G);if(u&&s)return v!==void 0?{gpuTimeMs:v}:{};let F=_(g,Float32Array),k=_(w,Float32Array);g=null,w=null;let[j,W]=await Promise.all([F,k]);return v!==void 0?{x:j,y:W,gpuTimeMs:v}:{x:j,y:W}}finally{!u&&f&&d(f),!s&&c&&d(c),p&&d(p),m&&d(m),g&&d(g),w&&d(w)}}async function Ze(a,r,e,o,t,i,n,u,s,l,f,c,p="row-major"){let m=i instanceof H,g=u instanceof x,w=f instanceof x;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(r!=="no-transpose"&&r!=="transpose")throw new Error("trans must be 'no-transpose' or 'transpose'.");if(p!=="row-major"&&p!=="column-major")throw new Error("layout must be 'row-major' or 'column-major'.");if(typeof t!="number")throw new Error("alpha must be a number.");if(Number.isNaN(t))throw new Error("alpha must not be NaN.");if(!Number.isFinite(t))throw new Error("alpha must be finite.");if(typeof l!="number")throw new Error("beta must be a number.");if(Number.isNaN(l))throw new Error("beta must not be NaN.");if(!Number.isFinite(l))throw new Error("beta must be finite.");if(!Number.isInteger(e)||!Number.isInteger(o)||!Number.isInteger(s)||!Number.isInteger(c)||!Number.isInteger(n))throw new Error("m, n, incx, incy, and lda must be integers.");if(s<=0||c<=0)throw new Error("incx and incy must be positive.");if(!m&&!(i instanceof Float32Array))throw new Error("A must be a Float32Array or GpuMatrix.");if(!g&&!(u instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!w&&!(f instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(g!==w)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(g&&!m)throw new Error("A must be a GpuMatrix when x and y are GpuVectors.");if(g&&u._buf===f._buf)throw new Error("x and y must not reference the same GPU buffer when both are GpuVectors.");if(m&&n!==i.lda)throw new Error("lda must match A.lda when A is a GpuMatrix.");if(m&&(i.rows<e||i.cols<o))throw new Error("A is too small for the given m and n.");if(e<0||o<0)throw new Error("m and n must be non-negative.");if(e===0||o===0)return w?{}:{y:f};(m?i.layout:p)==="column-major"&&([e,o]=[o,e],r=r==="no-transpose"?"transpose":"no-transpose");let h=r==="no-transpose",G=h?o:e,v=h?e:o;if(n<o)throw new Error("lda must be >= n.");if(!m&&i.length<(e-1)*n+o)throw new Error("A does not have enough elements for the given m, n, and lda.");if(u.length<(G-1)*s+1)throw new Error("x does not have enough elements for the given dimensions and incx.");if(f.length<(v-1)*c+1)throw new Error("y does not have enough elements for the given dimensions and incy.");let k=await B(a,h?"sgemv_n":"sgemv_t"),j=m?i._buf:b(i,"sgemv-A",!1),W=g?u._buf:b(u,"sgemv-x",!1),M=w?f._buf:b(f,"sgemv-y",!0),U=N([{value:e,type:"u32"},{value:o,type:"u32"},{value:t,type:"f32"},{value:l,type:"f32"},{value:s,type:"u32"},{value:c,type:"u32"},{value:n,type:"u32"}],"sgemv-params");try{let T=A(k.getBindGroupLayout(0),[j,W,M,U]),R=h?Math.min(e,a.limits.maxComputeWorkgroupsPerDimension):C(v),{commandEncoder:z,ts:Y}=L(k,T,R),Q=w?null:E(z,M);S(z);let O=await P(Y);if(w)return O!==void 0?{gpuTimeMs:O}:{};let nr=await _(Q,Float32Array);return O!==void 0?{y:nr,gpuTimeMs:O}:{y:nr}}finally{m||d(j),g||d(W),w||d(M),d(U)}}async function Ke(a,r,e,o,t,i,n,u,s,l,f,c="row-major"){let p=n instanceof x,m=l instanceof x,g=t instanceof H;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(r!=="lower"&&r!=="upper")throw new Error("uplo must be 'lower' or 'upper'.");if(c!=="row-major"&&c!=="column-major")throw new Error("layout must be 'row-major' or 'column-major'.");if(!Number.isInteger(e)||!Number.isInteger(u)||!Number.isInteger(f)||!Number.isInteger(i))throw new Error("n, incx, incy, and lda must be integers.");if(typeof o!="number")throw new Error("alpha must be a number.");if(Number.isNaN(o))throw new Error("alpha must not be NaN.");if(!Number.isFinite(o))throw new Error("alpha must be finite.");if(typeof s!="number")throw new Error("beta must be a number.");if(Number.isNaN(s))throw new Error("beta must not be NaN.");if(!Number.isFinite(s))throw new Error("beta must be finite.");if(u<=0||f<=0)throw new Error("incx and incy must be positive.");if(i<e)throw new Error("lda must be >= n.");if(!g&&!(t instanceof Float32Array))throw new Error("A must be a Float32Array or GpuMatrix.");if(!p&&!(n instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!m&&!(l instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(p!==m)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(p&&!g)throw new Error("A must be a GpuMatrix when x and y are GpuVectors.");if(p&&n._buf===l._buf)throw new Error("x and y must not reference the same GPU buffer when both are GpuVectors.");if(g&&i!==t.lda)throw new Error("lda must match A.lda when A is a GpuMatrix.");if(g&&(t.rows<e||t.cols<e))throw new Error("A is too small for the given n.");if(e<0)throw new Error("n must be non-negative.");if(e===0)return m?{}:{y:l};if(!g&&t.length<(e-1)*i+e)throw new Error("A does not have enough elements for the given n and lda.");if(n.length<(e-1)*u+1)throw new Error("x does not have enough elements for the given n and incx.");if(l.length<(e-1)*f+1)throw new Error("y does not have enough elements for the given n and incy.");let y=(g?t.layout:c)==="column-major"?r==="upper":r==="lower",h=await B(a,"ssymv"),G=null,v=null,F=null,k=null;try{G=g?t._buf:b(t,"ssymv-A",!1),v=p?n._buf:b(n,"ssymv-x",!1),F=m?l._buf:b(l,"ssymv-y",!0),k=N([{value:e,type:"u32"},{value:o,type:"f32"},{value:s,type:"f32"},{value:u,type:"u32"},{value:f,type:"u32"},{value:i,type:"u32"},{value:y?0:1,type:"u32"}],"ssymv-params");let j=A(h.getBindGroupLayout(0),[G,v,F,k]),W=Math.min(e,a.limits.maxComputeWorkgroupsPerDimension),{commandEncoder:M,ts:U}=L(h,j,W),T=m?null:E(M,F);S(M);let R=await P(U);if(m)return R!==void 0?{gpuTimeMs:R}:{};let z=await _(T,Float32Array);return R!==void 0?{y:z,gpuTimeMs:R}:{y:z}}finally{!g&&G&&d(G),!p&&v&&d(v),!m&&F&&d(F),k&&d(k)}}async function Xe(a,r,e,o,t,i,n,u,s,l,f,c="row-major"){let p=u instanceof x,m=l instanceof x,g=i instanceof H,w=o==="unit";if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(r!=="lower"&&r!=="upper")throw new Error("uplo must be 'lower' or 'upper'.");if(e!=="no-transpose"&&e!=="transpose")throw new Error("trans must be 'no-transpose' or 'transpose'.");if(!w&&o!=="non-unit")throw new Error("diag must be 'unit' or 'non-unit'.");if(c!=="row-major"&&c!=="column-major")throw new Error("layout must be 'row-major' or 'column-major'.");if(!Number.isInteger(t)||!Number.isInteger(s)||!Number.isInteger(f)||!Number.isInteger(n))throw new Error("n, incx, incy, and lda must be integers.");if(s<=0||f<=0)throw new Error("incx and incy must be positive.");if(n<t)throw new Error("lda must be >= n.");if(!g&&!(i instanceof Float32Array))throw new Error("A must be a Float32Array or GpuMatrix.");if(!p&&!(u instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!m&&!(l instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(p!==m)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(p&&u._buf===l._buf)throw new Error("x and y must not reference the same GPU buffer when both are GpuVectors.");if(p&&!g)throw new Error("A must be a GpuMatrix when x and y are GpuVectors.");if(g&&m&&i._buf===l._buf)throw new Error("A and y must not reference the same GPU buffer.");if(g&&n!==i.lda)throw new Error("lda must match A.lda when A is a GpuMatrix.");if(g&&(i.rows<t||i.cols<t))throw new Error("A is too small for the given n.");if(t<0)throw new Error("n must be non-negative.");if(t===0)return m?{}:{y:l};if(!g&&i.length<(t-1)*n+t)throw new Error("A does not have enough elements for the given n and lda.");if(u.length<(t-1)*s+1)throw new Error("x does not have enough elements for the given n and incx.");if(l.length<(t-1)*f+1)throw new Error("y does not have enough elements for the given n and incy.");let h=(g?i.layout:c)==="column-major",G=h?r==="upper":r==="lower",v=h?e==="transpose":e==="no-transpose",F=await B(a,"strmv"),k=null,j=null,W=null,M=null;try{k=g?i._buf:b(i,"strmv-A",!1),j=p?u._buf:b(u,"strmv-x",!1),W=m?l._buf:b(l,"strmv-y",!0),M=N([{value:t,type:"u32"},{value:s,type:"u32"},{value:f,type:"u32"},{value:n,type:"u32"},{value:v?0:1,type:"u32"},{value:G?0:1,type:"u32"},{value:w?1:0,type:"u32"}],"strmv-params");let U=A(F.getBindGroupLayout(0),[k,j,W,M]),T=Math.min(t,a.limits.maxComputeWorkgroupsPerDimension),{commandEncoder:R,ts:z}=L(F,U,T),Y=m?null:E(R,W);S(R);let Q=await P(z);if(m)return Q!==void 0?{gpuTimeMs:Q}:{};let O=await _(Y,Float32Array);return Q!==void 0?{y:O,gpuTimeMs:Q}:{y:O}}finally{!g&&k&&d(k),!p&&j&&d(j),!m&&W&&d(W),M&&d(M)}}var K=64;function $e(a,r,e){let o=new ArrayBuffer(a*r),t=new DataView(o);for(let i=0;i<a;i++){let n=e(i),u=i*r;n.forEach((s,l)=>t.setUint32(u+l*4,s,!0))}return o}function Ye(a,r,e){let o=a.createBuffer({label:e,size:r.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});return a.queue.writeBuffer(o,0,r),o}async function Je(a,r,e,o,t,i,n,u,s,l="row-major"){let f=u instanceof x,c=i instanceof H,p=o==="unit";if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(r!=="lower"&&r!=="upper")throw new Error("uplo must be 'lower' or 'upper'.");if(e!=="no-transpose"&&e!=="transpose")throw new Error("trans must be 'no-transpose' or 'transpose'.");if(!p&&o!=="non-unit")throw new Error("diag must be 'unit' or 'non-unit'.");if(l!=="row-major"&&l!=="column-major")throw new Error("layout must be 'row-major' or 'column-major'.");if(!Number.isInteger(t)||!Number.isInteger(s)||!Number.isInteger(n))throw new Error("n, incx, and lda must be integers.");if(s<=0)throw new Error("incx must be positive.");if(n<t)throw new Error("lda must be >= n.");if(!c&&!(i instanceof Float32Array))throw new Error("A must be a Float32Array or GpuMatrix.");if(!f&&!(u instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(f&&!c)throw new Error("A must be a GpuMatrix when x is a GpuVector.");if(c&&n!==i.lda)throw new Error("lda must match A.lda when A is a GpuMatrix.");if(c&&(i.rows<t||i.cols<t))throw new Error("A is too small for the given n.");if(t<0)throw new Error("n must be non-negative.");if(t===0)return f?{}:{x:u};if(!c&&i.length<(t-1)*n+t)throw new Error("A does not have enough elements for the given n and lda.");if(u.length<(t-1)*s+1)throw new Error("x does not have enough elements for the given n and incx.");let g=(c?i.layout:l)==="column-major",w=g?r==="upper":r==="lower",y=g?e==="transpose":e==="no-transpose",h=await B(a,"strsv_invert_block"),G=await B(a,"strsv_apply_inverse"),v=await B(a,"strsv_update"),F=y===w,k=[];for(let O=0;O<t;O+=K)k.push(O);F||k.reverse();let j=k.length,W=a.limits.maxComputeWorkgroupsPerDimension,M=a.limits.minUniformBufferOffsetAlignment,U=null,T=null,R=null,z=null,Y=null,Q=null;try{U=c?i._buf:b(i,"strsv-A",!1),T=f?u._buf:b(u,"strsv-x",!0),R=D(j*K*K*4,"strsv-Ainv");let O=$e(j,M,X=>{let $=X*K,or=Math.min($+K,t);return[s,X,$,or]});z=Ye(a,O,"strsv-apply-params");let nr=$e(j,M,X=>{let $=X*K,or=Math.min($+K,t);return[t,s,n,y?0:1,w?0:1,$,or]});Y=Ye(a,nr,"strsv-update-params");let{commandEncoder:rr,querySet:ar}=pr();Q=N([{value:t,type:"u32"},{value:n,type:"u32"},{value:y?0:1,type:"u32"},{value:w?0:1,type:"u32"},{value:p?1:0,type:"u32"}],"strsv-invert-params");let at=A(h.getBindGroupLayout(0),[U,R,Q]);ir(rr,h,at,{x:K,y:j},ar?{timestampWrites:{querySet:ar,beginningOfPassWriteIndex:0}}:void 0);for(let X=0;X<k.length;X++){let $=k[X],or=Math.min($+K,t),nt=$/K,st=X===k.length-1,xr=nt*M,ut=A(G.getBindGroupLayout(0),[R,T,{buffer:z,offset:xr,size:16}]);ir(rr,G,ut,1,st&&ar?{timestampWrites:{querySet:ar,endOfPassWriteIndex:1}}:void 0);let vr=F?t-or:$;if(vr===0)continue;let lt=A(v.getBindGroupLayout(0),[U,T,{buffer:Y,offset:xr,size:32}]),ft=Math.min(vr,W);ir(rr,v,lt,ft)}let ot=cr(rr,ar),it=f?null:E(rr,T);S(rr);let sr=await P(ot);if(f)return sr!==void 0?{gpuTimeMs:sr}:{};let hr=await _(it,Float32Array);return sr!==void 0?{x:hr,gpuTimeMs:sr}:{x:hr}}finally{!c&&U&&d(U),!f&&T&&d(T),R&&d(R),z&&d(z),Y&&d(Y),Q&&d(Q)}}async function rt(a,r,e,o,t,i,n,u,s,l,f="row-major"){let c=s instanceof H;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(f!=="row-major"&&f!=="column-major")throw new Error("layout must be 'row-major' or 'column-major'.");if(typeof o!="number")throw new Error("alpha must be a number.");if(Number.isNaN(o))throw new Error("alpha must not be NaN.");if(!Number.isFinite(o))throw new Error("alpha must be finite.");if(!Number.isInteger(r)||!Number.isInteger(e)||!Number.isInteger(i)||!Number.isInteger(u)||!Number.isInteger(l))throw new Error("m, n, incx, incy, and lda must be integers.");if(i<=0||u<=0)throw new Error("incx and incy must be positive.");if(!c&&!(s instanceof Float32Array))throw new Error("A must be a Float32Array or GpuMatrix.");if(c&&l!==s.lda)throw new Error("lda must match A.lda when A is a GpuMatrix.");if(c&&(s.rows<r||s.cols<e))throw new Error("A is too small for the given m and n.");(c?s.layout:f)==="column-major"&&([r,e]=[e,r],[t,n]=[n,t],[i,u]=[u,i]);let m=t instanceof x,g=n instanceof x;if(l<e)throw new Error("lda must be >= n.");if(!m&&!(t instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!g&&!(n instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(m!==g)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(m&&!c)throw new Error("A must be a GpuMatrix when x and y are GpuVectors.");if(c&&m&&s._buf===t._buf)throw new Error("A and x must not reference the same GPU buffer.");if(c&&g&&s._buf===n._buf)throw new Error("A and y must not reference the same GPU buffer.");if(r<0||e<0)throw new Error("m and n must be non-negative.");if(r===0||e===0)return c?{}:{A:s};if(!c&&s.length<(r-1)*l+e)throw new Error("A does not have enough elements for the given m, n, and lda.");if(t.length<(r-1)*i+1)throw new Error("x does not have enough elements for the given m and incx.");if(n.length<(e-1)*u+1)throw new Error("y does not have enough elements for the given n and incy.");let w=await B(a,"sger"),y=null,h=null,G=null,v=null;try{y=m?t._buf:b(t,"sger-x",!1),h=g?n._buf:b(n,"sger-y",!1),G=c?s._buf:b(s,"sger-A",!0),v=N([{value:r,type:"u32"},{value:e,type:"u32"},{value:o,type:"f32"},{value:i,type:"u32"},{value:u,type:"u32"},{value:l,type:"u32"}],"sger-params");let F=A(w.getBindGroupLayout(0),[y,h,G,v]),k=Math.min(r,a.limits.maxComputeWorkgroupsPerDimension),{commandEncoder:j,ts:W}=L(w,F,k),M=c?null:E(j,G);S(j);let U=await P(W);if(c)return U!==void 0?{gpuTimeMs:U}:{};let T=await _(M,Float32Array);return U!==void 0?{A:T,gpuTimeMs:U}:{A:T}}finally{!m&&y&&d(y),!g&&h&&d(h),!c&&G&&d(G),v&&d(v)}}async function et(a,r,e,o,t,i,n,u,s="row-major"){let l=t instanceof x,f=n instanceof H;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(r!=="lower"&&r!=="upper")throw new Error("uplo must be 'lower' or 'upper'.");if(s!=="row-major"&&s!=="column-major")throw new Error("layout must be 'row-major' or 'column-major'.");if(!Number.isInteger(e)||!Number.isInteger(i)||!Number.isInteger(u))throw new Error("n, incx, and lda must be integers.");if(typeof o!="number")throw new Error("alpha must be a number.");if(Number.isNaN(o))throw new Error("alpha must not be NaN.");if(!Number.isFinite(o))throw new Error("alpha must be finite.");if(i<=0)throw new Error("incx must be positive.");if(u<e)throw new Error("lda must be >= n.");if(!f&&!(n instanceof Float32Array))throw new Error("A must be a Float32Array or GpuMatrix.");if(!l&&!(t instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(l&&!f)throw new Error("A must be a GpuMatrix when x is a GpuVector.");if(f&&l&&n._buf===t._buf)throw new Error("A and x must not reference the same GPU buffer.");if(f&&u!==n.lda)throw new Error("lda must match A.lda when A is a GpuMatrix.");if(f&&(n.rows<e||n.cols<e))throw new Error("A is too small for the given n.");if(e<0)throw new Error("n must be non-negative.");if(e===0)return f?{}:{A:n};if(!f&&n.length<(e-1)*u+e)throw new Error("A does not have enough elements for the given n and lda.");if(t.length<(e-1)*i+1)throw new Error("x does not have enough elements for the given n and incx.");let p=(f?n.layout:s)==="column-major"?r==="upper":r==="lower",m=await B(a,"ssyr"),g=null,w=null,y=null;try{g=l?t._buf:b(t,"ssyr-x",!1),w=f?n._buf:b(n,"ssyr-A",!0),y=N([{value:e,type:"u32"},{value:o,type:"f32"},{value:i,type:"u32"},{value:u,type:"u32"},{value:p?0:1,type:"u32"}],"ssyr-params");let h=A(m.getBindGroupLayout(0),[g,w,y]),G=Math.min(e,a.limits.maxComputeWorkgroupsPerDimension),{commandEncoder:v,ts:F}=L(m,h,G),k=f?null:E(v,w);S(v);let j=await P(F);if(f)return j!==void 0?{gpuTimeMs:j}:{};let W=await _(k,Float32Array);return j!==void 0?{A:W,gpuTimeMs:j}:{A:W}}finally{!l&&g&&d(g),!f&&w&&d(w),y&&d(y)}}async function tt(a,r,e,o,t,i,n,u,s,l,f="row-major"){let c=t instanceof x,p=n instanceof x,m=s instanceof H;if(!(a instanceof GPUDevice))throw new Error("device must be a GPUDevice.");if(r!=="lower"&&r!=="upper")throw new Error("uplo must be 'lower' or 'upper'.");if(f!=="row-major"&&f!=="column-major")throw new Error("layout must be 'row-major' or 'column-major'.");if(!Number.isInteger(e)||!Number.isInteger(i)||!Number.isInteger(u)||!Number.isInteger(l))throw new Error("n, incx, incy, and lda must be integers.");if(typeof o!="number")throw new Error("alpha must be a number.");if(Number.isNaN(o))throw new Error("alpha must not be NaN.");if(!Number.isFinite(o))throw new Error("alpha must be finite.");if(i<=0||u<=0)throw new Error("incx and incy must be positive.");if(l<e)throw new Error("lda must be >= n.");if(!m&&!(s instanceof Float32Array))throw new Error("A must be a Float32Array or GpuMatrix.");if(!c&&!(t instanceof Float32Array))throw new Error("x must be a Float32Array or GpuVector.");if(!p&&!(n instanceof Float32Array))throw new Error("y must be a Float32Array or GpuVector.");if(c!==p)throw new Error("x and y must be the same type (both Float32Array or both GpuVector).");if(c&&!m)throw new Error("A must be a GpuMatrix when x and y are GpuVectors.");if(m&&c&&s._buf===t._buf)throw new Error("A and x must not reference the same GPU buffer.");if(m&&p&&s._buf===n._buf)throw new Error("A and y must not reference the same GPU buffer.");if(c&&t._buf===n._buf)throw new Error("x and y must not reference the same GPU buffer when both are GpuVectors.");if(m&&l!==s.lda)throw new Error("lda must match A.lda when A is a GpuMatrix.");if(m&&(s.rows<e||s.cols<e))throw new Error("A is too small for the given n.");if(e<0)throw new Error("n must be non-negative.");if(e===0)return m?{}:{A:s};if(!m&&s.length<(e-1)*l+e)throw new Error("A does not have enough elements for the given n and lda.");if(t.length<(e-1)*i+1)throw new Error("x does not have enough elements for the given n and incx.");if(n.length<(e-1)*u+1)throw new Error("y does not have enough elements for the given n and incy.");let w=(m?s.layout:f)==="column-major"?r==="upper":r==="lower",y=await B(a,"ssyr2"),h=null,G=null,v=null,F=null;try{h=c?t._buf:b(t,"ssyr2-x",!1),G=p?n._buf:b(n,"ssyr2-y",!1),v=m?s._buf:b(s,"ssyr2-A",!0),F=N([{value:e,type:"u32"},{value:o,type:"f32"},{value:i,type:"u32"},{value:u,type:"u32"},{value:l,type:"u32"},{value:w?0:1,type:"u32"}],"ssyr2-params");let k=A(y.getBindGroupLayout(0),[h,G,v,F]),j=Math.min(e,a.limits.maxComputeWorkgroupsPerDimension),{commandEncoder:W,ts:M}=L(y,k,j),U=m?null:E(W,v);S(W);let T=await P(M);if(m)return T!==void 0?{gpuTimeMs:T}:{};let R=await _(U,Float32Array);return T!==void 0?{A:R,gpuTimeMs:T}:{A:R}}finally{!c&&h&&d(h),!p&&G&&d(G),!m&&v&&d(v),F&&d(F)}}return wt(ra);})();