volvoxai 0.1.0

package/dist/volvoxai.min.js

@@ -0,0 +1,1848 @@
+var cs=Object.defineProperty;var k=(p,t,r)=>()=>{if(r)throw r[0];try{return p&&(t=p(p=0)),t}catch(e){throw r=[e],e}};var fs=(p,t)=>{for(var r in t)cs(p,r,{get:t[r],enumerable:!0})};var Jt,Qt=k(()=>{Jt=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+            @group(0) @binding(1) var<storage, read> weight_f32 : array<f32>;
+            @group(0) @binding(2) var<storage, read> dummyScale : array<f32>;
+            @group(0) @binding(3) var<storage, read> bias : array<f32>;
+            @group(0) @binding(4) var<storage, read_write> output : array<f32>;
+
+            struct Params {
+                seq_len : u32,
+                d_in : u32,
+                d_out : u32,
+            }
+            @group(0) @binding(5) var<uniform> params : Params;
+
+            @compute @workgroup_size(64, 1, 1)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let row = global_id.y;
+                let col = global_id.x;
+                
+                if (row >= params.seq_len || col >= params.d_out) { return; }
+                
+                var sum : f32 = 0.0;
+                
+                for (var k = 0u; k < params.d_in; k = k + 1u) {
+                    let in_val = input[row * params.d_in + k];
+                    let w_val = weight_f32[col * params.d_in + k];
+                    sum = sum + in_val * w_val;
+                }
+                
+                let b_val = bias[col];
+                // dummyScale is passed just to keep bindings consistent but not used here.
+                
+                output[row * params.d_out + col] = sum + b_val;
+            }
+`});var te,Zt=k(()=>{te=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+            @group(0) @binding(1) var<storage, read> weight_int8_packed : array<u32>;
+            @group(0) @binding(2) var<storage, read> weight_scales : array<f32>;
+            @group(0) @binding(3) var<storage, read> bias : array<f32>;
+            @group(0) @binding(4) var<storage, read_write> output : array<f32>;
+
+            struct Params {
+                seq_len : u32,
+                d_in : u32,
+                d_out : u32,
+            }
+            @group(0) @binding(5) var<uniform> params : Params;
+
+            // Unpack one signed 8-bit integer from a 32-bit packed block
+            fn unpack_i8(packed: u32, byte_idx: u32) -> f32 {
+                let val_i32 = extractBits(i32(packed), byte_idx * 8u, 8u);
+                return f32(val_i32);
+            }
+
+            @compute @workgroup_size(64, 1, 1)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let row = global_id.y;
+                let col = global_id.x;
+                
+                if (row >= params.seq_len || col >= params.d_out) { return; }
+                
+                var sum : f32 = 0.0;
+                let d_in_4 = params.d_in / 4u;
+                
+                for (var i = 0u; i < d_in_4; i = i + 1u) {
+                    let w_packed = weight_int8_packed[col * d_in_4 + i];
+                    let in_base = row * params.d_in + i * 4u;
+                    
+                    sum = sum + input[in_base + 0u] * f32(extractBits(i32(w_packed), 0u, 8u));
+                    sum = sum + input[in_base + 1u] * f32(extractBits(i32(w_packed), 8u, 8u));
+                    sum = sum + input[in_base + 2u] * f32(extractBits(i32(w_packed), 16u, 8u));
+                    sum = sum + input[in_base + 3u] * f32(extractBits(i32(w_packed), 24u, 8u));
+                }
+                
+                let scale = weight_scales[col];
+                output[row * params.d_out + col] = (sum * scale) + bias[col];
+            }
+`});var ae,ee=k(()=>{ae=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+@group(0) @binding(1) var<storage, read> weight : array<f32>;
+@group(0) @binding(2) var<storage, read> bias : array<f32>;
+@group(0) @binding(3) var<storage, read_write> output : array<f32>;
+
+struct Params {
+    n : u32,
+    in_h : u32,
+    in_w : u32,
+    in_c : u32,
+    out_c : u32,
+    out_h : u32,
+    out_w : u32,
+    kh : u32,
+    kw : u32,
+    sy : u32,
+    sx : u32,
+    pt : u32,
+    pl : u32,
+    groups : u32,
+    relu : u32,
+    dy : u32,
+    dx : u32,
+}
+@group(0) @binding(4) var<uniform> params : Params;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let z = gid.z;
+    let nb = z / params.out_c;
+    let oc = z - nb * params.out_c;
+    if (nb >= params.n || ox >= params.out_w || oy >= params.out_h) { return; }
+
+    var sum = 0.0;
+    if (params.groups == params.in_c) {
+        let mult = params.out_c / params.in_c;
+        let ic = oc / mult;
+        let m = oc - ic * mult;
+        for (var yy = 0u; yy < params.kh; yy = yy + 1u) {
+            let iy = i32(oy * params.sy + yy * params.dy) - i32(params.pt);
+            if (iy < 0 || iy >= i32(params.in_h)) { continue; }
+            for (var xx = 0u; xx < params.kw; xx = xx + 1u) {
+                let ix = i32(ox * params.sx + xx * params.dx) - i32(params.pl);
+                if (ix < 0 || ix >= i32(params.in_w)) { continue; }
+                let ii = ((nb * params.in_h + u32(iy)) * params.in_w + u32(ix)) * params.in_c + ic;
+                let wi = (((yy * params.kw + xx) * params.in_c + ic) * mult) + m;
+                sum = sum + input[ii] * weight[wi];
+            }
+        }
+    } else {
+        let out_per_g = params.out_c / params.groups;
+        let in_per_g = params.in_c / params.groups;
+        let g = oc / out_per_g;
+        let ic0 = g * in_per_g;
+        for (var icl = 0u; icl < in_per_g; icl = icl + 1u) {
+            let ic = ic0 + icl;
+            for (var yy = 0u; yy < params.kh; yy = yy + 1u) {
+                let iy = i32(oy * params.sy + yy * params.dy) - i32(params.pt);
+                if (iy < 0 || iy >= i32(params.in_h)) { continue; }
+                for (var xx = 0u; xx < params.kw; xx = xx + 1u) {
+                    let ix = i32(ox * params.sx + xx * params.dx) - i32(params.pl);
+                    if (ix < 0 || ix >= i32(params.in_w)) { continue; }
+                    let ii = ((nb * params.in_h + u32(iy)) * params.in_w + u32(ix)) * params.in_c + ic;
+                    let wi = (((yy * params.kw + xx) * params.in_c + ic) * params.out_c) + oc;
+                    sum = sum + input[ii] * weight[wi];
+                }
+            }
+        }
+    }
+
+    var v = sum + bias[oc];
+    if (params.relu == 1u) {
+        v = max(v, 0.0);
+    } else if (params.relu >= 2u) {
+        v = min(max(v, 0.0), 6.0);
+    }
+    output[((nb * params.out_h + oy) * params.out_w + ox) * params.out_c + oc] = v;
+}
+`});var re,se=k(()=>{re=`@group(0) @binding(0) var<storage, read> input : array<vec4<f32>>;
+@group(0) @binding(1) var<storage, read> weight : array<vec4<f32>>;
+@group(0) @binding(2) var<storage, read> bias : array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read_write> output : array<vec4<f32>>;
+
+struct Params {
+    n : u32,
+    in_h : u32,
+    in_w : u32,
+    in_c : u32,
+    out_c : u32,
+    out_h : u32,
+    out_w : u32,
+    kh : u32,
+    kw : u32,
+    sy : u32,
+    sx : u32,
+    pt : u32,
+    pl : u32,
+    groups : u32,
+    relu : u32,
+    dy : u32,
+    dx : u32,
+}
+@group(0) @binding(4) var<uniform> params : Params;
+
+fn apply_relu4(v_in : vec4<f32>) -> vec4<f32> {
+    var v = v_in;
+    if (params.relu == 1u) {
+        v = max(v, vec4<f32>(0.0));
+    } else if (params.relu >= 2u) {
+        v = min(max(v, vec4<f32>(0.0)), vec4<f32>(6.0));
+    }
+    return v;
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let c8_count = (params.out_c + 7u) / 8u;
+    let nb = gid.z / c8_count;
+    let ch0 = (gid.z - nb * c8_count) * 8u;
+    if (nb >= params.n || ox >= params.out_w || oy >= params.out_h || ch0 >= params.out_c) { return; }
+
+    var sum0 = vec4<f32>(0.0);
+    var sum1 = vec4<f32>(0.0);
+
+    for (var yy = 0u; yy < params.kh; yy = yy + 1u) {
+        let iy = i32(oy * params.sy + yy * params.dy) - i32(params.pt);
+        if (iy < 0 || iy >= i32(params.in_h)) { continue; }
+        for (var xx = 0u; xx < params.kw; xx = xx + 1u) {
+            let ix = i32(ox * params.sx + xx * params.dx) - i32(params.pl);
+            if (ix < 0 || ix >= i32(params.in_w)) { continue; }
+            let input_base = (((nb * params.in_h + u32(iy)) * params.in_w + u32(ix)) * params.in_c + ch0) / 4u;
+            let weight_base = (((yy * params.kw + xx) * params.in_c) + ch0) / 4u;
+            sum0 = sum0 + input[input_base] * weight[weight_base];
+            sum1 = sum1 + input[input_base + 1u] * weight[weight_base + 1u];
+        }
+    }
+
+    let output_base = (((nb * params.out_h + oy) * params.out_w + ox) * params.out_c + ch0) / 4u;
+    let bias_base = ch0 / 4u;
+    output[output_base] = apply_relu4(sum0 + bias[bias_base]);
+    output[output_base + 1u] = apply_relu4(sum1 + bias[bias_base + 1u]);
+}
+`});var ue,ie=k(()=>{ue=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+@group(0) @binding(1) var<storage, read> weight : array<vec4<f32>>;
+@group(0) @binding(2) var<storage, read> bias : array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read_write> output : array<vec4<f32>>;
+
+struct Params {
+    n : u32,
+    in_h : u32,
+    in_w : u32,
+    in_c : u32,
+    out_c : u32,
+    out_h : u32,
+    out_w : u32,
+    kh : u32,
+    kw : u32,
+    sy : u32,
+    sx : u32,
+    pt : u32,
+    pl : u32,
+    groups : u32,
+    relu : u32,
+    dy : u32,
+    dx : u32,
+}
+@group(0) @binding(4) var<uniform> params : Params;
+
+fn apply_relu4(v_in : vec4<f32>) -> vec4<f32> {
+    var v = v_in;
+    if (params.relu == 1u) {
+        v = max(v, vec4<f32>(0.0));
+    } else if (params.relu >= 2u) {
+        v = min(max(v, vec4<f32>(0.0)), vec4<f32>(6.0));
+    }
+    return v;
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let oc16_count = (params.out_c + 15u) / 16u;
+    let nb = gid.z / oc16_count;
+    let oc0 = (gid.z - nb * oc16_count) * 16u;
+    if (nb >= params.n || ox >= params.out_w || oy >= params.out_h || oc0 >= params.out_c) { return; }
+
+    var sum0 = vec4<f32>(0.0);
+    var sum1 = vec4<f32>(0.0);
+    var sum2 = vec4<f32>(0.0);
+    var sum3 = vec4<f32>(0.0);
+
+    let input_base = ((nb * params.in_h + oy) * params.in_w + ox) * params.in_c;
+    for (var ic = 0u; ic < params.in_c; ic = ic + 1u) {
+        let x = input[input_base + ic];
+        let wbase = (ic * params.out_c + oc0) / 4u;
+        sum0 = sum0 + x * weight[wbase];
+        sum1 = sum1 + x * weight[wbase + 1u];
+        sum2 = sum2 + x * weight[wbase + 2u];
+        sum3 = sum3 + x * weight[wbase + 3u];
+    }
+
+    let output_base = (((nb * params.out_h + oy) * params.out_w + ox) * params.out_c + oc0) / 4u;
+    let bias_base = oc0 / 4u;
+    output[output_base] = apply_relu4(sum0 + bias[bias_base]);
+    output[output_base + 1u] = apply_relu4(sum1 + bias[bias_base + 1u]);
+    output[output_base + 2u] = apply_relu4(sum2 + bias[bias_base + 2u]);
+    output[output_base + 3u] = apply_relu4(sum3 + bias[bias_base + 3u]);
+}
+`});var ne,oe=k(()=>{ne=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+@group(0) @binding(1) var<storage, read> weight : array<vec4<f32>>;
+@group(0) @binding(2) var<storage, read> bias : array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read_write> output : array<vec4<f32>>;
+
+struct Params {
+    n : u32,
+    in_h : u32,
+    in_w : u32,
+    in_c : u32,
+    out_c : u32,
+    out_h : u32,
+    out_w : u32,
+    kh : u32,
+    kw : u32,
+    sy : u32,
+    sx : u32,
+    pt : u32,
+    pl : u32,
+    groups : u32,
+    relu : u32,
+    dy : u32,
+    dx : u32,
+}
+@group(0) @binding(4) var<uniform> params : Params;
+
+const TILE_C : u32 = 64u;
+var<workgroup> tile_weight : array<vec4<f32>, 256>;
+
+fn apply_relu4(v_in : vec4<f32>) -> vec4<f32> {
+    var v = v_in;
+    if (params.relu == 1u) {
+        v = max(v, vec4<f32>(0.0));
+    } else if (params.relu >= 2u) {
+        v = min(max(v, vec4<f32>(0.0)), vec4<f32>(6.0));
+    }
+    return v;
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>,
+        @builtin(local_invocation_id) lid3 : vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let oc16_count = params.out_c / 16u;
+    let nb = gid.z / oc16_count;
+    let oc0 = (gid.z - nb * oc16_count) * 16u;
+    let lid = lid3.y * 8u + lid3.x;
+    let in_bounds = nb < params.n && ox < params.out_w && oy < params.out_h;
+
+    var sum0 = vec4<f32>(0.0);
+    var sum1 = vec4<f32>(0.0);
+    var sum2 = vec4<f32>(0.0);
+    var sum3 = vec4<f32>(0.0);
+    let input_base = ((nb * params.in_h + oy) * params.in_w + ox) * params.in_c;
+
+    for (var tile_start = 0u; tile_start < params.in_c; tile_start = tile_start + TILE_C) {
+        let tile_count = min(TILE_C, params.in_c - tile_start);
+        for (var wi = lid; wi < tile_count * 4u; wi = wi + 64u) {
+            let ic = tile_start + wi / 4u;
+            let oc_vec = wi - (wi / 4u) * 4u;
+            tile_weight[wi] = weight[(ic * params.out_c + oc0) / 4u + oc_vec];
+        }
+        workgroupBarrier();
+
+        if (in_bounds) {
+            for (var ti = 0u; ti < tile_count; ti = ti + 1u) {
+                let x = input[input_base + tile_start + ti];
+                let wbase = ti * 4u;
+                sum0 = sum0 + x * tile_weight[wbase];
+                sum1 = sum1 + x * tile_weight[wbase + 1u];
+                sum2 = sum2 + x * tile_weight[wbase + 2u];
+                sum3 = sum3 + x * tile_weight[wbase + 3u];
+            }
+        }
+        workgroupBarrier();
+    }
+
+    if (!in_bounds) { return; }
+    let output_base = (((nb * params.out_h + oy) * params.out_w + ox) * params.out_c + oc0) / 4u;
+    let bias_base = oc0 / 4u;
+    output[output_base] = apply_relu4(sum0 + bias[bias_base]);
+    output[output_base + 1u] = apply_relu4(sum1 + bias[bias_base + 1u]);
+    output[output_base + 2u] = apply_relu4(sum2 + bias[bias_base + 2u]);
+    output[output_base + 3u] = apply_relu4(sum3 + bias[bias_base + 3u]);
+}
+`});var ce,pe=k(()=>{ce=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+@group(0) @binding(1) var<storage, read> weight : array<vec2<f32>>;
+@group(0) @binding(2) var<storage, read> bias : array<vec2<f32>>;
+@group(0) @binding(3) var<storage, read_write> output : array<vec2<f32>>;
+
+struct Params {
+    n : u32,
+    in_h : u32,
+    in_w : u32,
+    in_c : u32,
+    out_c : u32,
+    out_h : u32,
+    out_w : u32,
+    kh : u32,
+    kw : u32,
+    sy : u32,
+    sx : u32,
+    pt : u32,
+    pl : u32,
+    groups : u32,
+    relu : u32,
+    dy : u32,
+    dx : u32,
+}
+@group(0) @binding(4) var<uniform> params : Params;
+
+fn apply_relu2(v_in : vec2<f32>) -> vec2<f32> {
+    var v = v_in;
+    if (params.relu == 1u) {
+        v = max(v, vec2<f32>(0.0));
+    } else if (params.relu >= 2u) {
+        v = min(max(v, vec2<f32>(0.0)), vec2<f32>(6.0));
+    }
+    return v;
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let oc8_count = (params.out_c + 7u) / 8u;
+    let nb = gid.z / oc8_count;
+    let oc0 = (gid.z - nb * oc8_count) * 8u;
+    if (nb >= params.n || ox >= params.out_w || oy >= params.out_h || oc0 >= params.out_c) { return; }
+
+    let has1 = oc0 + 2u < params.out_c;
+    let has2 = oc0 + 4u < params.out_c;
+    let has3 = oc0 + 6u < params.out_c;
+    var sum0 = vec2<f32>(0.0);
+    var sum1 = vec2<f32>(0.0);
+    var sum2 = vec2<f32>(0.0);
+    var sum3 = vec2<f32>(0.0);
+
+    let input_base = ((nb * params.in_h + oy) * params.in_w + ox) * params.in_c;
+    for (var ic = 0u; ic < params.in_c; ic = ic + 1u) {
+        let x = input[input_base + ic];
+        let wbase = (ic * params.out_c + oc0) / 2u;
+        sum0 = sum0 + x * weight[wbase];
+        if (has1) { sum1 = sum1 + x * weight[wbase + 1u]; }
+        if (has2) { sum2 = sum2 + x * weight[wbase + 2u]; }
+        if (has3) { sum3 = sum3 + x * weight[wbase + 3u]; }
+    }
+
+    let output_base = (((nb * params.out_h + oy) * params.out_w + ox) * params.out_c + oc0) / 2u;
+    let bias_base = oc0 / 2u;
+    output[output_base] = apply_relu2(sum0 + bias[bias_base]);
+    if (has1) { output[output_base + 1u] = apply_relu2(sum1 + bias[bias_base + 1u]); }
+    if (has2) { output[output_base + 2u] = apply_relu2(sum2 + bias[bias_base + 2u]); }
+    if (has3) { output[output_base + 3u] = apply_relu2(sum3 + bias[bias_base + 3u]); }
+}
+`});var le,fe=k(()=>{le=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+@group(0) @binding(1) var<storage, read> weight : array<vec4<f32>>;
+@group(0) @binding(2) var<storage, read> bias : array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read_write> output : array<vec4<f32>>;
+
+struct Params {
+    n : u32,
+    in_h : u32,
+    in_w : u32,
+    in_c : u32,
+    out_c : u32,
+    out_h : u32,
+    out_w : u32,
+    kh : u32,
+    kw : u32,
+    sy : u32,
+    sx : u32,
+    pt : u32,
+    pl : u32,
+    groups : u32,
+    relu : u32,
+    dy : u32,
+    dx : u32,
+}
+@group(0) @binding(4) var<uniform> params : Params;
+
+fn apply_relu4(v_in : vec4<f32>) -> vec4<f32> {
+    var v = v_in;
+    if (params.relu == 1u) {
+        v = max(v, vec4<f32>(0.0));
+    } else if (params.relu >= 2u) {
+        v = min(max(v, vec4<f32>(0.0)), vec4<f32>(6.0));
+    }
+    return v;
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let oc8_count = (params.out_c + 7u) / 8u;
+    let nb = gid.z / oc8_count;
+    let oc0 = (gid.z - nb * oc8_count) * 8u;
+    if (nb >= params.n || ox >= params.out_w || oy >= params.out_h || oc0 >= params.out_c) { return; }
+
+    var sum0 = vec4<f32>(0.0);
+    var sum1 = vec4<f32>(0.0);
+    let input_base = ((nb * params.in_h + oy) * params.in_w + ox) * params.in_c;
+    let has_second = oc0 + 4u < params.out_c;
+    for (var ic = 0u; ic < params.in_c; ic = ic + 1u) {
+        let x = input[input_base + ic];
+        let wbase = (ic * params.out_c + oc0) / 4u;
+        sum0 = sum0 + x * weight[wbase];
+        if (has_second) {
+            sum1 = sum1 + x * weight[wbase + 1u];
+        }
+    }
+
+    let output_base = (((nb * params.out_h + oy) * params.out_w + ox) * params.out_c + oc0) / 4u;
+    let bias_base = oc0 / 4u;
+    output[output_base] = apply_relu4(sum0 + bias[bias_base]);
+    if (has_second) {
+        output[output_base + 1u] = apply_relu4(sum1 + bias[bias_base + 1u]);
+    }
+}
+`});var _e,me=k(()=>{_e=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+@group(0) @binding(1) var<storage, read> weight : array<vec4<f32>>;
+@group(0) @binding(2) var<storage, read> bias : array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read_write> output : array<vec4<f32>>;
+
+struct Params {
+    n : u32,
+    in_h : u32,
+    in_w : u32,
+    in_c : u32,
+    out_c : u32,
+    out_h : u32,
+    out_w : u32,
+    kh : u32,
+    kw : u32,
+    sy : u32,
+    sx : u32,
+    pt : u32,
+    pl : u32,
+    groups : u32,
+    relu : u32,
+    dy : u32,
+    dx : u32,
+}
+@group(0) @binding(4) var<uniform> params : Params;
+
+fn apply_relu4(v_in : vec4<f32>) -> vec4<f32> {
+    var v = v_in;
+    if (params.relu == 1u) {
+        v = max(v, vec4<f32>(0.0));
+    } else if (params.relu >= 2u) {
+        v = min(max(v, vec4<f32>(0.0)), vec4<f32>(6.0));
+    }
+    return v;
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let oc16_count = params.out_c / 16u;
+    let nb = gid.z / oc16_count;
+    let oc0 = (gid.z - nb * oc16_count) * 16u;
+    if (nb >= params.n || ox >= params.out_w || oy >= params.out_h) { return; }
+
+    var sum0 = vec4<f32>(0.0);
+    var sum1 = vec4<f32>(0.0);
+    var sum2 = vec4<f32>(0.0);
+    var sum3 = vec4<f32>(0.0);
+    for (var yy = 0u; yy < params.kh; yy = yy + 1u) {
+        let iy = i32(oy * params.sy + yy * params.dy) - i32(params.pt);
+        if (iy < 0 || iy >= i32(params.in_h)) { continue; }
+        for (var xx = 0u; xx < params.kw; xx = xx + 1u) {
+            let ix = i32(ox * params.sx + xx * params.dx) - i32(params.pl);
+            if (ix < 0 || ix >= i32(params.in_w)) { continue; }
+            let input_base = ((nb * params.in_h + u32(iy)) * params.in_w + u32(ix)) * 3u;
+            let weight_base = (((yy * params.kw + xx) * 3u) * params.out_c + oc0) / 4u;
+            for (var ic = 0u; ic < 3u; ic = ic + 1u) {
+                let x = input[input_base + ic];
+                let wbase = weight_base + ic * (params.out_c / 4u);
+                sum0 = sum0 + x * weight[wbase];
+                sum1 = sum1 + x * weight[wbase + 1u];
+                sum2 = sum2 + x * weight[wbase + 2u];
+                sum3 = sum3 + x * weight[wbase + 3u];
+            }
+        }
+    }
+
+    let output_base = (((nb * params.out_h + oy) * params.out_w + ox) * params.out_c + oc0) / 4u;
+    let bias_base = oc0 / 4u;
+    output[output_base] = apply_relu4(sum0 + bias[bias_base]);
+    output[output_base + 1u] = apply_relu4(sum1 + bias[bias_base + 1u]);
+    output[output_base + 2u] = apply_relu4(sum2 + bias[bias_base + 2u]);
+    output[output_base + 3u] = apply_relu4(sum3 + bias[bias_base + 3u]);
+}
+`});var ge,de=k(()=>{ge=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+            @group(0) @binding(1) var<storage, read> weight : array<f32>;
+            @group(0) @binding(2) var<storage, read> bias : array<f32>;
+            @group(0) @binding(3) var<storage, read_write> output : array<f32>;
+            
+            struct Params { rows : u32, d_model : u32 }
+            @group(0) @binding(4) var<uniform> params : Params;
+
+            @compute @workgroup_size(64)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let row = global_id.x;
+                if (row >= params.rows) { return; }
+                let d_model = params.d_model;
+                let offset = row * d_model;
+                
+                var sum : f32 = 0.0;
+                var sq_sum : f32 = 0.0;
+                
+                for (var i = 0u; i < d_model; i = i + 1u) {
+                    let val = input[offset + i];
+                    sum = sum + val;
+                    sq_sum = sq_sum + (val * val);
+                }
+                
+                let mean = sum / f32(d_model);
+                let variance = (sq_sum / f32(d_model)) - (mean * mean);
+                let inv_std = inverseSqrt(variance + 1e-5);
+                
+                for (var i = 0u; i < d_model; i = i + 1u) {
+                    let norm_val = (input[offset + i] - mean) * inv_std;
+                    output[offset + i] = norm_val * weight[i] + bias[i];
+                }
+            }
+`});var be,he=k(()=>{be=`@group(0) @binding(0) var<storage, read> a : array<f32>;
+        @group(0) @binding(1) var<storage, read> b : array<f32>;
+        @group(0) @binding(2) var<storage, read_write> output : array<f32>;
+        
+        struct Params { size : u32, is_b_scalar : u32, b_size : u32, a_size: u32, is_a_scalar: u32 }
+        @group(0) @binding(3) var<uniform> params : Params;
+        
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            
+            var a_val : f32 = 0.0;
+            if (params.is_a_scalar == 1u) {
+                a_val = a[0];
+            } else if (params.a_size < params.size && params.a_size > 0u) {
+                a_val = a[idx % params.a_size];
+            } else {
+                a_val = a[idx];
+            }
+            
+            var b_val : f32 = 0.0;
+            if (params.is_b_scalar == 1u) {
+                b_val = b[0];
+            } else if (params.b_size < params.size && params.b_size > 0u) {
+                b_val = b[idx % params.b_size];
+            } else {
+                b_val = b[idx];
+            }
+            
+            var out_val : f32 = 0.0;
+            undefined
+            output[idx] = out_val;
+        }
+`});var xe,ve=k(()=>{xe=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { size : u32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            let x = input[idx];
+            var out_val = x;
+            undefined
+            output[idx] = out_val;
+        }
+`});var we,ye=k(()=>{we=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+@group(0) @binding(1) var<storage, read_write> output : array<f32>;
+
+struct Params {
+    n : u32,
+    h : u32,
+    w : u32,
+    c : u32,
+    out_h : u32,
+    out_w : u32,
+    mode : u32,
+}
+@group(0) @binding(2) var<uniform> params : Params;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let z = gid.z;
+    let nb = z / params.c;
+    let ch = z - nb * params.c;
+    if (nb >= params.n || ox >= params.out_w || oy >= params.out_h) { return; }
+
+    if (params.mode == 0u) {
+        let iy = (oy * params.h) / params.out_h;
+        let ix = (ox * params.w) / params.out_w;
+        output[((nb * params.out_h + oy) * params.out_w + ox) * params.c + ch] =
+            input[((nb * params.h + iy) * params.w + ix) * params.c + ch];
+        return;
+    }
+
+    let scale_y = f32(params.h) / f32(params.out_h);
+    let scale_x = f32(params.w) / f32(params.out_w);
+    var fy = (f32(oy) + 0.5) * scale_y - 0.5;
+    var fx = (f32(ox) + 0.5) * scale_x - 0.5;
+    if (fy < 0.0) { fy = 0.0; }
+    if (fx < 0.0) { fx = 0.0; }
+    let y0 = u32(fy);
+    let x0 = u32(fx);
+    let y1 = min(y0 + 1u, params.h - 1u);
+    let x1 = min(x0 + 1u, params.w - 1u);
+    let dy = fy - f32(y0);
+    let dx = fx - f32(x0);
+    let base = nb * params.h * params.w * params.c;
+    let v00 = input[base + (y0 * params.w + x0) * params.c + ch];
+    let v01 = input[base + (y0 * params.w + x1) * params.c + ch];
+    let v10 = input[base + (y1 * params.w + x0) * params.c + ch];
+    let v11 = input[base + (y1 * params.w + x1) * params.c + ch];
+    let val = v00 * (1.0 - dy) * (1.0 - dx) + v01 * (1.0 - dy) * dx +
+              v10 * dy * (1.0 - dx) + v11 * dy * dx;
+    output[((nb * params.out_h + oy) * params.out_w + ox) * params.c + ch] = val;
+}
+`});var ke,Be=k(()=>{ke=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+@group(0) @binding(1) var<storage, read_write> output : array<f32>;
+// General strided slice over 4 dims (leading dims are padded to 1). For each
+// output element the source coord along axis k is start[k] + out_coord * step[k].
+struct Params {
+  out_b: u32, out_c: u32, out_h: u32, out_w: u32,
+  in_c: u32, in_h: u32, in_w: u32,
+  s0: u32, s1: u32, s2: u32, s3: u32,
+  st0: u32, st1: u32, st2: u32, st3: u32,
+  total: u32
+}
+@group(0) @binding(2) var<uniform> p : Params;
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= p.total) { return; }
+  let ow = idx % p.out_w;
+  let oh = (idx / p.out_w) % p.out_h;
+  let oc = (idx / (p.out_w * p.out_h)) % p.out_c;
+  let ob = idx / (p.out_w * p.out_h * p.out_c);
+  let ib = p.s0 + ob * p.st0;
+  let ic = p.s1 + oc * p.st1;
+  let ih = p.s2 + oh * p.st2;
+  let iw = p.s3 + ow * p.st3;
+  output[idx] = input[((ib * p.in_c + ic) * p.in_h + ih) * p.in_w + iw];
+}
+`});var Pe,Se=k(()=>{Pe=`@group(0) @binding(0) var<storage, read> a : array<f32>;
+        @group(0) @binding(1) var<storage, read> b : array<f32>;
+        @group(0) @binding(2) var<storage, read_write> output : array<f32>;
+        
+        struct Params { size : u32, is_b_scalar : u32, b_size : u32, a_size: u32, is_a_scalar: u32 }
+        @group(0) @binding(3) var<uniform> params : Params;
+        
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            
+            var a_val : f32 = 0.0;
+            if (params.is_a_scalar == 1u) {
+                a_val = a[0];
+            } else if (params.a_size < params.size && params.a_size > 0u) {
+                a_val = a[idx % params.a_size];
+            } else {
+                a_val = a[idx];
+            }
+            
+            var b_val : f32 = 0.0;
+            if (params.is_b_scalar == 1u) {
+                b_val = b[0];
+            } else if (params.b_size < params.size && params.b_size > 0u) {
+                b_val = b[idx % params.b_size];
+            } else {
+                b_val = b[idx];
+            }
+            
+            var out_val : f32 = 0.0;
+            out_val = a_val - b_val;
+            output[idx] = out_val;
+        }
+`});var ze,Ue=k(()=>{ze=`@group(0) @binding(0) var<storage, read> a : array<f32>;
+        @group(0) @binding(1) var<storage, read> b : array<f32>;
+        @group(0) @binding(2) var<storage, read_write> output : array<f32>;
+        
+        struct Params { size : u32, is_b_scalar : u32, b_size : u32, a_size: u32, is_a_scalar: u32 }
+        @group(0) @binding(3) var<uniform> params : Params;
+        
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            
+            var a_val : f32 = 0.0;
+            if (params.is_a_scalar == 1u) {
+                a_val = a[0];
+            } else if (params.a_size < params.size && params.a_size > 0u) {
+                a_val = a[idx % params.a_size];
+            } else {
+                a_val = a[idx];
+            }
+            
+            var b_val : f32 = 0.0;
+            if (params.is_b_scalar == 1u) {
+                b_val = b[0];
+            } else if (params.b_size < params.size && params.b_size > 0u) {
+                b_val = b[idx % params.b_size];
+            } else {
+                b_val = b[idx];
+            }
+            
+            var out_val : f32 = 0.0;
+            out_val = a_val / b_val;
+            output[idx] = out_val;
+        }
+`});var Me,Te=k(()=>{Me=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { size : u32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            let x = input[idx];
+            var out_val = x;
+            out_val = x * (1.0 / (1.0 + exp(-x)));
+            output[idx] = out_val;
+        }
+`});var qe,Ae=k(()=>{qe=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { size : u32, alpha : f32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            let x = input[idx];
+            if (x > 0.0) { output[idx] = x; } else { output[idx] = x * params.alpha; }
+        }
+`});var De,Ce=k(()=>{De=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { size : u32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            let x = input[idx];
+            var out_val = x;
+            let e2x = exp(2.0 * x); out_val = (e2x - 1.0) / (e2x + 1.0);
+            output[idx] = out_val;
+        }
+`});var Le,Ge=k(()=>{Le=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { size : u32, min_v : f32, max_v : f32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            output[idx] = clamp(input[idx], params.min_v, params.max_v);
+        }
+`});var Ne,Ie=k(()=>{Ne=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read> weight : array<f32>;
+        @group(0) @binding(2) var<storage, read_write> output : array<f32>;
+        struct Params { seq_len : u32, d_model : u32, eps : f32 }
+        @group(0) @binding(3) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let s = global_id.x;
+            if (s >= params.seq_len) { return; }
+            var var_val = 0.0;
+            let offset = s * params.d_model;
+            for (var d = 0u; d < params.d_model; d = d + 1u) {
+                let v = input[offset + d];
+                var_val = var_val + v * v;
+            }
+            var_val = var_val / f32(params.d_model);
+            let inv_std = 1.0 / sqrt(var_val + params.eps);
+            for (var d = 0u; d < params.d_model; d = d + 1u) {
+                output[offset + d] = input[offset + d] * inv_std * weight[d];
+            }
+        }
+`});var Re,Oe=k(()=>{Re=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { b : u32, d : u32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let i = global_id.x;
+            if (i >= params.b) { return; }
+            let offset = i * params.d;
+            var max_val = -100000.0;
+            for (var j = 0u; j < params.d; j = j + 1u) {
+                if (input[offset + j] > max_val) { max_val = input[offset + j]; }
+            }
+            var sum = 0.0;
+            for (var j = 0u; j < params.d; j = j + 1u) {
+                let e = exp(input[offset + j] - max_val);
+                output[offset + j] = e;
+                sum = sum + e;
+            }
+            for (var j = 0u; j < params.d; j = j + 1u) {
+                output[offset + j] = output[offset + j] / sum;
+            }
+        }
+`});var Ee,Fe=k(()=>{Ee=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read> weight : array<f32>;
+        @group(0) @binding(2) var<storage, read_write> output : array<f32>;
+        struct Params { size : u32, c : u32 }
+        @group(0) @binding(3) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            let c_idx = idx % params.c;
+            let alpha = weight[c_idx];
+            let v = input[idx];
+            if (v > 0.0) { output[idx] = v; } else { output[idx] = v * alpha; }
+        }
+`});var je,We=k(()=>{je=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { b : u32, d : u32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let i = global_id.x;
+            if (i >= params.b) { return; }
+            let offset = i * params.d;
+            var max_val = -100000.0;
+            for (var j = 0u; j < params.d; j = j + 1u) {
+                if (input[offset + j] > max_val) { max_val = input[offset + j]; }
+            }
+            var sum = 0.0;
+            for (var j = 0u; j < params.d; j = j + 1u) {
+                sum = sum + exp(input[offset + j] - max_val);
+            }
+            let logSum = log(sum);
+            for (var j = 0u; j < params.d; j = j + 1u) {
+                output[offset + j] = (input[offset + j] - max_val) - logSum;
+            }
+        }
+`});var $e,Ye=k(()=>{$e=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+@group(0) @binding(1) var<storage, read_write> output : array<f32>;
+// Reduce over the last (innermost) axis: \`b\` rows of length \`d\` -> \`b\` outputs.
+// \`inv\` scales the sum: 1.0 for ReduceSum, 1.0/d for ReduceMean.
+struct Params { b : u32, d : u32, inv : f32 }
+@group(0) @binding(2) var<uniform> p : Params;
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+  let i = gid.x;
+  if (i >= p.b) { return; }
+  let offset = i * p.d;
+  var sum = 0.0;
+  for (var j = 0u; j < p.d; j = j + 1u) {
+    sum = sum + input[offset + j];
+  }
+  output[i] = sum * p.inv;
+}
+`});var He,Ve=k(()=>{He=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { b: u32, in_h: u32, in_w: u32, c: u32, out_h: u32, out_w: u32, kh: u32, kw: u32, sh: u32, sw: u32, ph: u32, pw: u32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(8, 8, 1)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let x = global_id.x; let y = global_id.y; let z = global_id.z;
+            let b = z / params.c;
+            let c = z - b * params.c;
+            if (x >= params.out_w || y >= params.out_h || b >= params.b) { return; }
+            var sum = 0.0; var count = 0u;
+            for (var ky = 0u; ky < params.kh; ky = ky + 1u) {
+                for (var kx = 0u; kx < params.kw; kx = kx + 1u) {
+                    let in_y = i32(y * params.sh) - i32(params.ph) + i32(ky);
+                    let in_x = i32(x * params.sw) - i32(params.pw) + i32(kx);
+                    if (in_y >= 0 && in_y < i32(params.in_h) && in_x >= 0 && in_x < i32(params.in_w)) {
+                        sum = sum + input[((b * params.in_h + u32(in_y)) * params.in_w + u32(in_x)) * params.c + c];
+                        count = count + 1u;
+                    }
+                }
+            }
+            if (count == 0u) { count = 1u; }
+            output[((b * params.out_h + y) * params.out_w + x) * params.c + c] = sum / f32(count);
+        }
+`});var Xe,Ke=k(()=>{Xe=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+@group(0) @binding(1) var<storage, read> indices : array<f32>;
+@group(0) @binding(2) var<storage, read_write> output : array<f32>;
+// Gather along axis 0: output[i, ...] = input[indices[i], ...]. \`row_size\` is the
+// number of contiguous elements per gathered row (product of input dims after
+// axis 0); \`num_idx\` is the number of indices. total = num_idx * row_size.
+struct Params { row_size : u32, num_idx : u32, total : u32 }
+@group(0) @binding(3) var<uniform> p : Params;
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= p.total) { return; }
+  let k = idx % p.row_size;
+  let i = idx / p.row_size;
+  let row = u32(indices[i]);
+  output[idx] = input[row * p.row_size + k];
+}
+`});var Je,Qe=k(()=>{Je=`@group(0) @binding(0) var<storage, read> cond : array<f32>;
+        @group(0) @binding(1) var<storage, read> a : array<f32>;
+        @group(0) @binding(2) var<storage, read> b : array<f32>;
+        @group(0) @binding(3) var<storage, read_write> output : array<f32>;
+        struct Params { size : u32 }
+        @group(0) @binding(4) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            if (cond[idx] != 0.0) { output[idx] = a[idx]; } else { output[idx] = b[idx]; }
+        }
+`});var ta,Ze=k(()=>{ta=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read> scale : array<f32>;
+        @group(0) @binding(2) var<storage, read> zero_point : array<f32>;
+        @group(0) @binding(3) var<storage, read_write> output : array<f32>;
+        struct Params { size : u32, has_zp : u32 }
+        @group(0) @binding(4) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            var zp = 0.0;
+            if (params.has_zp == 1u) { zp = zero_point[0]; }
+            output[idx] = (input[idx] - zp) * scale[0];
+        }
+`});var aa,ea=k(()=>{aa=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { in_b: u32, in_h: u32, in_w: u32, in_c: u32, out_b: u32, out_h: u32, out_w: u32, out_c: u32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            let total = params.out_b * params.out_h * params.out_w * params.out_c;
+            if (idx >= total) { return; }
+            let oc = idx % params.out_c;
+            let ow = (idx / params.out_c) % params.out_w;
+            let oh = (idx / (params.out_c * params.out_w)) % params.out_h;
+            let ob = idx / (params.out_c * params.out_w * params.out_h);
+            let ib = ob % params.in_b;
+            let ih = oh % params.in_h; let iw = ow % params.in_w;
+            let ic = oc % params.in_c;
+            output[idx] = input[((ib * params.in_h + ih) * params.in_w + iw) * params.in_c + ic];
+        }
+`});var ra,sa=k(()=>{ra=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { b: u32, in_h: u32, in_w: u32, c: u32, out_h: u32, out_w: u32, pt: u32, pl: u32, val: f32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            let total = params.b * params.out_h * params.out_w * params.c;
+            if (idx >= total) { return; }
+            let c = idx % params.c;
+            let x = (idx / params.c) % params.out_w;
+            let y = (idx / (params.c * params.out_w)) % params.out_h;
+            let b = idx / (params.c * params.out_w * params.out_h);
+            if (y >= params.pt && y < params.pt + params.in_h && x >= params.pl && x < params.pl + params.in_w) {
+                output[idx] = input[((b * params.in_h + (y - params.pt)) * params.in_w + (x - params.pl)) * params.c + c];
+            } else {
+                output[idx] = params.val;
+            }
+        }
+`});var ua,ia=k(()=>{ua=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read> weight : array<f32>;
+        @group(0) @binding(2) var<storage, read> bias : array<f32>;
+        @group(0) @binding(3) var<storage, read_write> output : array<f32>;
+        struct Params { b: u32, in_h: u32, in_w: u32, in_c: u32, out_h: u32, out_w: u32, out_c: u32, kh: u32, kw: u32, sh: u32, sw: u32, ph: u32, pw: u32, has_bias: u32 }
+        @group(0) @binding(4) var<uniform> params : Params;
+        @compute @workgroup_size(8, 8, 1)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let x = global_id.x; let y = global_id.y; let batch_c = global_id.z;
+            if (x >= params.out_w || y >= params.out_h || batch_c >= (params.b * params.out_c)) { return; }
+            let ob = batch_c / params.out_c;
+            let oc = batch_c % params.out_c;
+            var sum = 0.0;
+            if (params.has_bias == 1u) { sum = bias[oc]; }
+            for (var ic = 0u; ic < params.in_c; ic = ic + 1u) {
+                for (var ky = 0u; ky < params.kh; ky = ky + 1u) {
+                    for (var kx = 0u; kx < params.kw; kx = kx + 1u) {
+                        let oy_shifted = i32(y) + i32(params.ph) - i32(ky);
+                        let ox_shifted = i32(x) + i32(params.pw) - i32(kx);
+                        if (oy_shifted % i32(params.sh) == 0 && ox_shifted % i32(params.sw) == 0) {
+                            let iy = oy_shifted / i32(params.sh);
+                            let ix = ox_shifted / i32(params.sw);
+                            if (iy >= 0 && iy < i32(params.in_h) && ix >= 0 && ix < i32(params.in_w)) {
+                                let in_val = input[((ob * params.in_h + u32(iy)) * params.in_w + u32(ix)) * params.in_c + ic];
+                                let w_val = weight[ic * (params.out_c * params.kh * params.kw) + oc * (params.kh * params.kw) + ky * params.kw + kx];
+                                sum = sum + in_val * w_val;
+                            }
+                        }
+                    }
+                }
+            }
+            output[((ob * params.out_h + y) * params.out_w + x) * params.out_c + oc] = sum;
+        }
+`});var na,oa=k(()=>{na=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { size : u32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            let x = input[idx];
+            var out_val = x;
+            if (x > 0.0) { out_val = x; } else { out_val = 0.0; }
+            output[idx] = out_val;
+        }
+`});var ca,pa=k(()=>{ca=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { size : u32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            let x = input[idx];
+            var out_val = x;
+            out_val = 1.0 / (1.0 + exp(-x));
+            output[idx] = out_val;
+        }
+`});var la,fa=k(()=>{la=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { size : u32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            let x = input[idx];
+            var out_val = x;
+            var v = x + 3.0; if (v < 0.0) { v = 0.0; } if (v > 6.0) { v = 6.0; } out_val = x * v / 6.0;
+            output[idx] = out_val;
+        }
+`});var _a,ma=k(()=>{_a=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { size : u32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            let x = input[idx];
+            var out_val = x;
+            var v = x + 3.0; if (v < 0.0) { v = 0.0; } if (v > 6.0) { v = 6.0; } out_val = v / 6.0;
+            output[idx] = out_val;
+        }
+`});var ga,da=k(()=>{ga=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { size : u32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            if (idx >= params.size) { return; }
+            let x = input[idx];
+            var out_val = x;
+            out_val = x;
+            output[idx] = out_val;
+        }
+`});var ba,ha=k(()=>{ba=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read> weight : array<f32>;
+        @group(0) @binding(2) var<storage, read> bias : array<f32>;
+        @group(0) @binding(3) var<storage, read> running_mean : array<f32>;
+        @group(0) @binding(4) var<storage, read> running_var : array<f32>;
+        @group(0) @binding(5) var<storage, read_write> output : array<f32>;
+        struct Params { b : u32, c : u32, h : u32, w : u32, eps : f32 }
+        @group(0) @binding(6) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+            let idx = global_id.x;
+            let total = params.b * params.c * params.h * params.w;
+            if (idx >= total) { return; }
+            let c = idx % params.c;
+            let mean = running_mean[c];
+            let var_val = running_var[c];
+            let gamma = weight[c];
+            let beta = bias[c];
+            let inv_std = 1.0 / sqrt(var_val + params.eps);
+            output[idx] = (input[idx] - mean) * inv_std * gamma + beta;
+        }
+`});var xa,va=k(()=>{xa=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+@group(0) @binding(1) var<storage, read_write> output : array<f32>;
+struct Params { size : u32 }
+@group(0) @binding(2) var<uniform> params : Params;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+    let idx = global_id.x;
+    if (idx >= params.size) { return; }
+    let x = input[idx];
+    let cdf = 0.5 * (1.0 + tanh(0.7978845608 * (x + 0.044715 * x * x * x)));
+    output[idx] = x * cdf;
+}
+`});var wa,ya=k(()=>{wa=`@group(0) @binding(0) var<storage, read> a : array<f32>;
+            @group(0) @binding(1) var<storage, read> b : array<f32>;
+            @group(0) @binding(2) var<storage, read_write> output : array<f32>;
+            
+            struct Params { size : u32 }
+            @group(0) @binding(3) var<uniform> params : Params;
+            
+            @compute @workgroup_size(64)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let idx = global_id.x;
+                if (idx >= params.size) { return; }
+                output[idx] = a[idx] + b[idx];
+            }
+`});var ka,Ba=k(()=>{ka=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+@group(0) @binding(1) var<storage, read_write> output : array<f32>;
+
+struct Params {
+    n : u32,
+    h : u32,
+    w : u32,
+    c : u32,
+}
+@group(0) @binding(2) var<uniform> params : Params;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let z = gid.z;
+    let nb = z / params.c;
+    let ch = z - nb * params.c;
+    let out_h = params.h * 2u;
+    let out_w = params.w * 2u;
+    if (nb >= params.n || ox >= out_w || oy >= out_h) { return; }
+    output[((nb * out_h + oy) * out_w + ox) * params.c + ch] =
+        input[((nb * params.h + (oy / 2u)) * params.w + (ox / 2u)) * params.c + ch];
+}
+`});var Pa,Sa=k(()=>{Pa=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { size : u32, offset : u32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+            let i = gid.x;
+            if (i >= params.size) { return; }
+            output[params.offset + i] = input[i];
+        }
+`});var za,Ua=k(()=>{za=`@group(0) @binding(0) var<storage, read> a : array<f32>;
+            @group(0) @binding(1) var<storage, read> b : array<f32>;
+            @group(0) @binding(2) var<storage, read_write> output : array<f32>;
+            
+            struct Params { a_size : u32, b_size : u32 }
+            @group(0) @binding(3) var<uniform> params : Params;
+            
+            @compute @workgroup_size(64)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let idx = global_id.x;
+                if (idx < params.a_size) {
+                    output[idx] = a[idx];
+                } else if (idx < params.a_size + params.b_size) {
+                    output[idx] = b[idx - params.a_size];
+                }
+            }
+`});var Ma,Ta=k(()=>{Ma=`@group(0) @binding(0) var<storage, read> a : array<f32>;
+        @group(0) @binding(1) var<storage, read> b : array<f32>;
+        @group(0) @binding(2) var<storage, read_write> output : array<f32>;
+        @group(0) @binding(3) var<storage, read> md : array<u32>;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+            let idx = gid.x;
+            let total = md[0];
+            if (idx >= total) { return; }
+            let rank = md[1];
+            var rem = idx;
+            var a_idx = 0u;
+            var b_idx = 0u;
+            for (var d = 0u; d < rank; d = d + 1u) {
+                let os = md[2u + d];
+                let coord = rem / os;
+                rem = rem - coord * os;
+                a_idx = a_idx + coord * md[2u + rank + d];
+                b_idx = b_idx + coord * md[2u + 2u * rank + d];
+            }
+            let av = a[a_idx];
+            let bv = b[b_idx];
+            var out_val = 0.0;
+            //__BINOP__
+            output[idx] = out_val;
+        }
+`});var qa,Aa=k(()=>{qa=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        @group(0) @binding(2) var<storage, read> md : array<u32>;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+            let idx = gid.x;
+            let total = md[0];
+            if (idx >= total) { return; }
+            let rank = md[1];
+            var rem = idx;
+            var in_idx = 0u;
+            for (var d = 0u; d < rank; d = d + 1u) {
+                let os = md[2u + d];
+                let coord = rem / os;
+                rem = rem - coord * os;
+                in_idx = in_idx + coord * md[2u + rank + d];
+            }
+            output[idx] = input[in_idx];
+        }
+`});var Da,Ca=k(()=>{Da=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+        @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+        struct Params { total : u32, inner : u32, split_size : u32, axis_in : u32, offset : u32 }
+        @group(0) @binding(2) var<uniform> params : Params;
+        @compute @workgroup_size(64)
+        fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+            let i = gid.x;
+            if (i >= params.total) { return; }
+            let inner_idx = i % params.inner;
+            let s = (i / params.inner) % params.split_size;
+            let outer_idx = i / (params.split_size * params.inner);
+            let in_idx = outer_idx * (params.axis_in * params.inner)
+                       + (params.offset + s) * params.inner + inner_idx;
+            output[i] = input[in_idx];
+        }
+`});var La,Ga=k(()=>{La=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+            @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+            
+            struct Params { in_h : u32, in_w : u32, in_c : u32 }
+            @group(0) @binding(2) var<uniform> params : Params;
+            
+            @compute @workgroup_size(64)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let y = global_id.x;
+                let c = global_id.y;
+                
+                if (y >= params.in_h || c >= params.in_c) { return; }
+                
+                var max_val = -1e38;
+                var sum_val = 0.0;
+                
+                for (var x = 0u; x < params.in_w; x = x + 1u) {
+                    let val = input[(y * params.in_w + x) * params.in_c + c];
+                    if (val > max_val) { max_val = val; }
+                    sum_val = sum_val + val;
+                }
+                
+                let out_max_idx = c * params.in_h + y;
+                let out_mean_idx = (c + params.in_c) * params.in_h + y;
+                
+                output[out_max_idx] = max_val;
+                output[out_mean_idx] = sum_val / f32(params.in_w);
+            }
+`});var Na,Ia=k(()=>{Na=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+            @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+            
+            struct Params { in_h : u32, in_w : u32, in_c : u32 }
+            @group(0) @binding(2) var<uniform> params : Params;
+            
+            @compute @workgroup_size(64)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let x = global_id.x;
+                let c = global_id.y;
+                
+                if (x >= params.in_w || c >= params.in_c) { return; }
+                
+                var max_val = -1e38;
+                var sum_val = 0.0;
+                
+                for (var y = 0u; y < params.in_h; y = y + 1u) {
+                    let val = input[(y * params.in_w + x) * params.in_c + c];
+                    if (val > max_val) { max_val = val; }
+                    sum_val = sum_val + val;
+                }
+                
+                let out_max_idx = c * params.in_w + x;
+                let out_mean_idx = (c + params.in_c) * params.in_w + x;
+                
+                output[out_max_idx] = max_val;
+                output[out_mean_idx] = sum_val / f32(params.in_h);
+            }
+`});var Ra,Oa=k(()=>{Ra=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+@group(0) @binding(1) var<storage, read_write> output : array<f32>;
+
+struct Params { n : u32, h : u32, w : u32, c : u32 }
+@group(0) @binding(2) var<uniform> params : Params;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    let ch = gid.x;
+    let nb = gid.y;
+    if (nb >= params.n || ch >= params.c) { return; }
+    var sum = 0.0;
+    for (var y = 0u; y < params.h; y = y + 1u) {
+        for (var x = 0u; x < params.w; x = x + 1u) {
+            sum = sum + input[((nb * params.h + y) * params.w + x) * params.c + ch];
+        }
+    }
+    output[nb * params.c + ch] = sum / f32(params.h * params.w);
+}
+`});var Ea,Fa=k(()=>{Ea=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+            @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+
+            struct Params { in_h : u32, in_w : u32, in_c : u32 }
+            @group(0) @binding(2) var<uniform> params : Params;
+
+            @compute @workgroup_size(64)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let x = global_id.x;
+                let c = global_id.y;
+                if (x >= params.in_w || c >= params.in_c) { return; }
+
+                var sum_val = 0.0;
+                for (var y = 0u; y < params.in_h; y = y + 1u) {
+                    sum_val = sum_val + input[(y * params.in_w + x) * params.in_c + c];
+                }
+                output[c * params.in_w + x] = sum_val / f32(params.in_h);
+            }
+`});var ja,Wa=k(()=>{ja=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+@group(0) @binding(1) var<storage, read_write> output : array<f32>;
+
+struct Params {
+    h : u32,
+    w : u32,
+    c : u32,
+    out_h : u32,
+    out_w : u32,
+    ky : u32,
+    kx : u32,
+    sy : u32,
+    sx : u32,
+    py : u32,
+    px : u32,
+}
+@group(0) @binding(2) var<uniform> params : Params;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let ch = gid.z;
+    if (ox >= params.out_w || oy >= params.out_h || ch >= params.c) { return; }
+
+    var best = -3.402823466e38;
+    for (var yy = 0u; yy < params.ky; yy = yy + 1u) {
+        let iy = i32(oy * params.sy + yy) - i32(params.py);
+        if (iy < 0 || iy >= i32(params.h)) { continue; }
+        for (var xx = 0u; xx < params.kx; xx = xx + 1u) {
+            let ix = i32(ox * params.sx + xx) - i32(params.px);
+            if (ix < 0 || ix >= i32(params.w)) { continue; }
+            best = max(best, input[(u32(iy) * params.w + u32(ix)) * params.c + ch]);
+        }
+    }
+    output[(oy * params.out_w + ox) * params.c + ch] = best;
+}
+`});var $a,Ya=k(()=>{$a=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+            @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+            
+            struct Params { in_c : u32, in_l : u32, out_l : u32 }
+            @group(0) @binding(2) var<uniform> params : Params;
+            
+            @compute @workgroup_size(64)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let i = global_id.x;
+                let c = global_id.y;
+                
+                if (i >= params.out_l || c >= params.in_c) { return; }
+                
+                let scale = f32(params.in_l) / f32(params.out_l);
+                var src = (f32(i) + 0.5) * scale - 0.5;
+                if (src < 0.0) { src = 0.0; }
+                if (src > f32(params.in_l - 1u)) { src = f32(params.in_l - 1u); }
+                
+                let lo = u32(src);
+                var hi = lo + 1u;
+                if (hi >= params.in_l) { hi = params.in_l - 1u; }
+                let t = src - f32(lo);
+                
+                let in_base = c * params.in_l;
+                let out_base = c * params.out_l;
+                
+                output[out_base + i] = input[in_base + lo] * (1.0 - t) + input[in_base + hi] * t;
+            }
+`});var Ha,Va=k(()=>{Ha=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+            @group(0) @binding(1) var<storage, read> weight : array<f32>;
+            @group(0) @binding(2) var<storage, read> bias : array<f32>;
+            @group(0) @binding(3) var<storage, read_write> output : array<f32>;
+            
+            struct Params {
+                in_c : u32, in_l : u32,
+                out_c : u32, k : u32,
+                stride : u32, pad : u32, relu : u32
+            }
+            @group(0) @binding(4) var<uniform> params : Params;
+            
+            @compute @workgroup_size(64)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let x = global_id.x;
+                let oc = global_id.y;
+                let out_l = (params.in_l + 2u * params.pad - params.k) / params.stride + 1u;
+                
+                if (x >= out_l || oc >= params.out_c) { return; }
+                
+                var sum = bias[oc];
+                let w_base = oc * params.in_c * params.k;
+                
+                for (var ic = 0u; ic < params.in_c; ic = ic + 1u) {
+                    let in_base = ic * params.in_l;
+                    let w_ic_base = w_base + ic * params.k;
+                    for (var k = 0u; k < params.k; k = k + 1u) {
+                        let in_x = i32(x * params.stride + k) - i32(params.pad);
+                        if (in_x >= 0 && in_x < i32(params.in_l)) {
+                            sum = sum + input[in_base + u32(in_x)] * weight[w_ic_base + k];
+                        }
+                    }
+                }
+                
+                if (params.relu == 1u && sum < 0.0) { sum = 0.0; }
+                output[oc * out_l + x] = sum;
+            }
+`});var Xa,Ka=k(()=>{Xa=`@group(0) @binding(0) var<storage, read> input : array<f32>;
+            @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+            
+            struct Params { in_h : u32, in_w : u32, in_c : u32 }
+            @group(0) @binding(2) var<uniform> params : Params;
+            
+            @compute @workgroup_size(64)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let x = global_id.x;
+                let c = global_id.y;
+                
+                if (x >= params.in_w || c >= params.in_c) { return; }
+                
+                var max_val = -1e38;
+                for (var y = 0u; y < params.in_h; y = y + 1u) {
+                    let val = input[(y * params.in_w + x) * params.in_c + c];
+                    if (val > max_val) { max_val = val; }
+                }
+                
+                var denom = 0.0;
+                var weighted = 0.0;
+                for (var y = 0u; y < params.in_h; y = y + 1u) {
+                    let val = input[(y * params.in_w + x) * params.in_c + c];
+                    let ev = exp(val - max_val);
+                    denom = denom + ev;
+                    weighted = weighted + ev * (f32(y) + 0.5) / f32(params.in_h);
+                }
+                
+                var out_val = 0.0;
+                if (denom > 0.0) { out_val = weighted / denom; }
+                output[c * params.in_w + x] = out_val;
+            }
+`});var Ja,Qa=k(()=>{Ja=`@group(0) @binding(0) var<storage, read> tokens : array<f32>;
+            @group(0) @binding(1) var<storage, read> weight : array<f32>;
+            @group(0) @binding(2) var<storage, read_write> output : array<f32>;
+            
+            struct Params { seq_len : u32, d_model : u32 }
+            @group(0) @binding(3) var<uniform> params : Params;
+
+            @compute @workgroup_size(64)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let token_idx = global_id.x;
+                if (token_idx >= params.seq_len) { return; }
+                
+                let d_model = params.d_model;
+                let token_id = u32(tokens[token_idx]);   // ids arrive as f32 (see CPU/WASM tiers)
+
+                let in_offset = token_id * d_model;
+                let out_offset = token_idx * d_model;
+                
+                for (var i = 0u; i < d_model; i = i + 1u) {
+                    output[out_offset + i] = weight[in_offset + i];
+                }
+            }
+`});var ts,Za=k(()=>{ts=`@group(0) @binding(0) var<storage, read> qkv : array<f32>;
+            @group(0) @binding(1) var<storage, read_write> output : array<f32>;
+            
+            struct Params {
+                seq_len : u32,
+                d_model : u32,
+                num_heads : u32,
+                head_dim : u32,
+                scale : f32,
+            }
+            @group(0) @binding(2) var<uniform> params : Params;
+            
+            @compute @workgroup_size(64, 1, 1)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let q_idx = global_id.x; 
+                let h_idx = global_id.y; 
+                
+                if (q_idx >= params.seq_len || h_idx >= params.num_heads) { return; }
+                
+                let head_dim = params.head_dim;
+                let d_model = params.d_model;
+                
+                var max_logit : f32 = -1e38;
+                
+                // Cache Q for this head and this q_idx
+                var q_cache : array<f32, 64>; // max head_dim 64
+                for (var d = 0u; d < head_dim; d = d + 1u) {
+                    q_cache[d] = qkv[q_idx * (d_model * 3u) + (h_idx * head_dim) + d];
+                }
+                
+                // Pass 1: find max
+                for (var k_idx = 0u; k_idx <= q_idx; k_idx = k_idx + 1u) {
+                    var score : f32 = 0.0;
+                    for (var d = 0u; d < head_dim; d = d + 1u) {
+                        let k_val = qkv[k_idx * (d_model * 3u) + d_model + (h_idx * head_dim) + d];
+                        score = score + (q_cache[d] * k_val);
+                    }
+                    score = score * params.scale;
+                    if (score > max_logit) { max_logit = score; }
+                }
+                
+                // Pass 2: sum exp
+                var sum_exp : f32 = 0.0;
+                for (var k_idx = 0u; k_idx <= q_idx; k_idx = k_idx + 1u) {
+                    var score : f32 = 0.0;
+                    for (var d = 0u; d < head_dim; d = d + 1u) {
+                        let k_val = qkv[k_idx * (d_model * 3u) + d_model + (h_idx * head_dim) + d];
+                        score = score + (q_cache[d] * k_val);
+                    }
+                    score = score * params.scale;
+                    sum_exp = sum_exp + exp(score - max_logit);
+                }
+                
+                // Pass 3: output
+                for (var d = 0u; d < head_dim; d = d + 1u) {
+                    var out_val : f32 = 0.0;
+                    for (var k_idx = 0u; k_idx <= q_idx; k_idx = k_idx + 1u) {
+                        var score : f32 = 0.0;
+                        for (var kd = 0u; kd < head_dim; kd = kd + 1u) {
+                            let k_val = qkv[k_idx * (d_model * 3u) + d_model + (h_idx * head_dim) + kd];
+                            score = score + (q_cache[kd] * k_val);
+                        }
+                        score = score * params.scale;
+                        
+                        let w = exp(score - max_logit) / sum_exp;
+                        let v_val = qkv[k_idx * (d_model * 3u) + d_model * 2u + (h_idx * head_dim) + d];
+                        out_val = out_val + (w * v_val);
+                    }
+                    output[q_idx * d_model + (h_idx * head_dim) + d] = out_val;
+                }
+            }
+`});var as,es=k(()=>{as=`@group(0) @binding(0) var<storage, read> q_in : array<f32>;
+            @group(0) @binding(1) var<storage, read> k_in : array<f32>;
+            @group(0) @binding(2) var<storage, read> v_in : array<f32>;
+            @group(0) @binding(3) var<storage, read_write> output : array<f32>;
+            
+            struct Params {
+                seq_len_q : u32,
+                seq_len_kv : u32,
+                d_model : u32,
+                num_heads : u32,
+                head_dim : u32,
+                scale : f32,
+            }
+            @group(0) @binding(4) var<uniform> params : Params;
+            
+            @compute @workgroup_size(64, 1, 1)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let q_idx = global_id.x; 
+                let h_idx = global_id.y; 
+                
+                if (q_idx >= params.seq_len_q || h_idx >= params.num_heads) { return; }
+                
+                let head_dim = params.head_dim;
+                let d_model = params.d_model;
+                
+                // Cache Q for this head and this q_idx
+                var q_cache : array<f32, 64>; // max head_dim 64
+                for (var d = 0u; d < head_dim; d = d + 1u) {
+                    q_cache[d] = q_in[q_idx * d_model + (h_idx * head_dim) + d];
+                }
+                
+                var max_logit : f32 = -1e38;
+                
+                // Pass 1: find max
+                for (var k_idx = 0u; k_idx < params.seq_len_kv; k_idx = k_idx + 1u) {
+                    var score : f32 = 0.0;
+                    for (var d = 0u; d < head_dim; d = d + 1u) {
+                        let k_val = k_in[k_idx * d_model + (h_idx * head_dim) + d];
+                        score = score + (q_cache[d] * k_val);
+                    }
+                    score = score * params.scale;
+                    if (score > max_logit) { max_logit = score; }
+                }
+                
+                // Pass 2: sum exp
+                var sum_exp : f32 = 0.0;
+                for (var k_idx = 0u; k_idx < params.seq_len_kv; k_idx = k_idx + 1u) {
+                    var score : f32 = 0.0;
+                    for (var d = 0u; d < head_dim; d = d + 1u) {
+                        let k_val = k_in[k_idx * d_model + (h_idx * head_dim) + d];
+                        score = score + (q_cache[d] * k_val);
+                    }
+                    score = score * params.scale;
+                    sum_exp = sum_exp + exp(score - max_logit);
+                }
+                
+                // Pass 3: output
+                for (var d = 0u; d < head_dim; d = d + 1u) {
+                    var out_val : f32 = 0.0;
+                    for (var k_idx = 0u; k_idx < params.seq_len_kv; k_idx = k_idx + 1u) {
+                        var score : f32 = 0.0;
+                        for (var kd = 0u; kd < head_dim; kd = kd + 1u) {
+                            let k_val = k_in[k_idx * d_model + (h_idx * head_dim) + kd];
+                            score = score + (q_cache[kd] * k_val);
+                        }
+                        score = score * params.scale;
+                        
+                        let w = exp(score - max_logit) / sum_exp;
+                        let v_val = v_in[k_idx * d_model + (h_idx * head_dim) + d];
+                        out_val = out_val + (w * v_val);
+                    }
+                    output[q_idx * d_model + (h_idx * head_dim) + d] = out_val;
+                }
+            }
+`});var rs,ss=k(()=>{rs=`@group(0) @binding(0) var<storage, read> q_in : array<f32>;
+            @group(0) @binding(1) var<storage, read> kv_in : array<f32>;
+            @group(0) @binding(2) var<storage, read> weight_int8_packed : array<u32>;
+            @group(0) @binding(3) var<storage, read> w_scale : array<f32>;
+            @group(0) @binding(4) var<storage, read> bias : array<f32>;
+            @group(0) @binding(5) var<storage, read_write> output : array<f32>;
+            
+            struct Params {
+                seq_len_q : u32,
+                seq_len_kv : u32,
+                d_model : u32,
+                num_heads : u32,
+                head_dim : u32,
+                scale_factor : f32,
+                has_scale : u32,
+                has_bias : u32,
+            }
+            @group(0) @binding(6) var<uniform> params : Params;
+            
+            @compute @workgroup_size(64, 1, 1)
+            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {
+                let q_idx = global_id.x; 
+                let h_idx = global_id.y; 
+                
+                if (q_idx >= params.seq_len_q || h_idx >= params.num_heads) { return; }
+                
+                let head_dim = params.head_dim;
+                let d_model = params.d_model;
+                let d_model_4 = d_model / 4u;
+                
+                // Cache Q for this head and this q_idx
+                var q_cache : array<f32, 64>; // max head_dim 64
+                for (var d = 0u; d < head_dim; d = d + 1u) {
+                    var sum = 0.0;
+                    let out_col = h_idx * head_dim + d;
+                    for (var i = 0u; i < d_model_4; i = i + 1u) {
+                        let w_packed = weight_int8_packed[out_col * d_model_4 + i];
+                        let in_base = q_idx * d_model + i * 4u;
+                        sum = sum + q_in[in_base + 0u] * f32(extractBits(i32(w_packed), 0u, 8u));
+                        sum = sum + q_in[in_base + 1u] * f32(extractBits(i32(w_packed), 8u, 8u));
+                        sum = sum + q_in[in_base + 2u] * f32(extractBits(i32(w_packed), 16u, 8u));
+                        sum = sum + q_in[in_base + 3u] * f32(extractBits(i32(w_packed), 24u, 8u));
+                    }
+                    if (params.has_scale > 0u) { sum = sum * w_scale[out_col]; }
+                    if (params.has_bias > 0u) { sum = sum + bias[out_col]; }
+                    q_cache[d] = sum;
+                }
+                
+                var max_logit : f32 = -1e38;
+                
+                // Pass 1: find max
+                for (var k_idx = 0u; k_idx < params.seq_len_kv; k_idx = k_idx + 1u) {
+                    var score : f32 = 0.0;
+                    for (var d = 0u; d < head_dim; d = d + 1u) {
+                        var k_val = 0.0;
+                        let out_col = d_model + h_idx * head_dim + d;
+                        for (var i = 0u; i < d_model_4; i = i + 1u) {
+                            let w_packed = weight_int8_packed[out_col * d_model_4 + i];
+                            let in_base = k_idx * d_model + i * 4u;
+                            k_val = k_val + kv_in[in_base + 0u] * f32(extractBits(i32(w_packed), 0u, 8u));
+                            k_val = k_val + kv_in[in_base + 1u] * f32(extractBits(i32(w_packed), 8u, 8u));
+                            k_val = k_val + kv_in[in_base + 2u] * f32(extractBits(i32(w_packed), 16u, 8u));
+                            k_val = k_val + kv_in[in_base + 3u] * f32(extractBits(i32(w_packed), 24u, 8u));
+                        }
+                        if (params.has_scale > 0u) { k_val = k_val * w_scale[out_col]; }
+                        if (params.has_bias > 0u) { k_val = k_val + bias[out_col]; }
+                        
+                        score = score + (q_cache[d] * k_val);
+                    }
+                    score = score * params.scale_factor;
+                    if (score > max_logit) { max_logit = score; }
+                }
+                
+                // Pass 2: sum exp
+                var sum_exp : f32 = 0.0;
+                for (var k_idx = 0u; k_idx < params.seq_len_kv; k_idx = k_idx + 1u) {
+                    var score : f32 = 0.0;
+                    for (var d = 0u; d < head_dim; d = d + 1u) {
+                        var k_val = 0.0;
+                        let out_col = d_model + h_idx * head_dim + d;
+                        for (var i = 0u; i < d_model_4; i = i + 1u) {
+                            let w_packed = weight_int8_packed[out_col * d_model_4 + i];
+                            let in_base = k_idx * d_model + i * 4u;
+                            k_val = k_val + kv_in[in_base + 0u] * f32(extractBits(i32(w_packed), 0u, 8u));
+                            k_val = k_val + kv_in[in_base + 1u] * f32(extractBits(i32(w_packed), 8u, 8u));
+                            k_val = k_val + kv_in[in_base + 2u] * f32(extractBits(i32(w_packed), 16u, 8u));
+                            k_val = k_val + kv_in[in_base + 3u] * f32(extractBits(i32(w_packed), 24u, 8u));
+                        }
+                        if (params.has_scale > 0u) { k_val = k_val * w_scale[out_col]; }
+                        if (params.has_bias > 0u) { k_val = k_val + bias[out_col]; }
+                        
+                        score = score + (q_cache[d] * k_val);
+                    }
+                    score = score * params.scale_factor;
+                    sum_exp = sum_exp + exp(score - max_logit);
+                }
+                
+                // Pass 3: output
+                for (var d = 0u; d < head_dim; d = d + 1u) {
+                    var out_val : f32 = 0.0;
+                    for (var k_idx = 0u; k_idx < params.seq_len_kv; k_idx = k_idx + 1u) {
+                        var score : f32 = 0.0;
+                        for (var kd = 0u; kd < head_dim; kd = kd + 1u) {
+                            var k_val = 0.0;
+                            let out_col = d_model + h_idx * head_dim + kd;
+                            for (var i = 0u; i < d_model_4; i = i + 1u) {
+                                let w_packed = weight_int8_packed[out_col * d_model_4 + i];
+                                let in_base = k_idx * d_model + i * 4u;
+                                k_val = k_val + kv_in[in_base + 0u] * f32(extractBits(i32(w_packed), 0u, 8u));
+                                k_val = k_val + kv_in[in_base + 1u] * f32(extractBits(i32(w_packed), 8u, 8u));
+                                k_val = k_val + kv_in[in_base + 2u] * f32(extractBits(i32(w_packed), 16u, 8u));
+                                k_val = k_val + kv_in[in_base + 3u] * f32(extractBits(i32(w_packed), 24u, 8u));
+                            }
+                            if (params.has_scale > 0u) { k_val = k_val * w_scale[out_col]; }
+                            if (params.has_bias > 0u) { k_val = k_val + bias[out_col]; }
+                            
+                            score = score + (q_cache[kd] * k_val);
+                        }
+                        score = score * params.scale_factor;
+                        
+                        let w = exp(score - max_logit) / sum_exp;
+                        
+                        var v_val = 0.0;
+                        let v_col = d_model * 2u + h_idx * head_dim + d;
+                        for (var i = 0u; i < d_model_4; i = i + 1u) {
+                            let w_packed = weight_int8_packed[v_col * d_model_4 + i];
+                            let in_base = k_idx * d_model + i * 4u;
+                            v_val = v_val + kv_in[in_base + 0u] * f32(extractBits(i32(w_packed), 0u, 8u));
+                            v_val = v_val + kv_in[in_base + 1u] * f32(extractBits(i32(w_packed), 8u, 8u));
+                            v_val = v_val + kv_in[in_base + 2u] * f32(extractBits(i32(w_packed), 16u, 8u));
+                            v_val = v_val + kv_in[in_base + 3u] * f32(extractBits(i32(w_packed), 24u, 8u));
+                        }
+                        if (params.has_scale > 0u) { v_val = v_val * w_scale[v_col]; }
+                        if (params.has_bias > 0u) { v_val = v_val + bias[v_col]; }
+                        
+                        out_val = out_val + (w * v_val);
+                    }
+                    output[q_idx * d_model + (h_idx * head_dim) + d] = out_val;
+                }
+            }
+`});var is={};fs(is,{ShaderLibrary:()=>Q});var Q,us=k(()=>{Qt();Zt();ee();se();ie();oe();pe();fe();me();de();he();ve();ye();Be();Se();Ue();Te();Ae();Ce();Ge();Ie();Oe();Fe();We();Ye();Ve();Ke();Qe();Ze();ea();sa();ia();oa();pa();fa();ma();da();ha();va();ya();Ba();Sa();Ua();Ta();Aa();Ca();Ga();Ia();Oa();Fa();Wa();Ya();Va();Ka();Qa();Za();es();ss();Q=class{static getLinearF32Shader(){return Jt}static getLinearInt8Shader(){return te}static getConv2DShader(){return ae}static getConv2DDepthwise8Shader(){return re}static getConv2DPointwise16Shader(){return ue}static getConv2DPointwise16TileShader(){return ne}static getConv2DPointwise8Vec2Shader(){return ce}static getConv2DPointwise8Vec4Shader(){return le}static getConv2DRegularC3Out16Shader(){return _e}static getLayerNormShader(){return ge}static getBinaryBroadcastShader(){return be}static getElementwiseShader(){return xe}static getResizeShader(){return we}static getSliceShader(){return ke}static getSubShader(){return Pe}static getDivShader(){return ze}static getSiLUShader(){return Me}static getLeakyReLUShader(){return qe}static getTanhShader(){return De}static getClipShader(){return Le}static getRMSNormShader(){return Ne}static getSoftmaxShader(){return Re}static getPReLUShader(){return Ee}static getLogSoftmaxShader(){return je}static getReduceShader(){return $e}static getAveragePool2DShader(){return He}static getGatherShader(){return Xe}static getWhereShader(){return Je}static getDequantizeLinearShader(){return ta}static getExpandShader(){return aa}static getPadShader(){return ra}static getConvTranspose2DShader(){return ua}static getReLUShader(){return na}static getSigmoidShader(){return ca}static getHardSwishShader(){return la}static getHardSigmoidShader(){return _a}static getCopyShader(){return ga}static getBatchNorm2DShader(){return ba}static getGELUShader(){return xa}static getAddShader(){return wa}static getUpsample2xShader(){return ka}static getConcatCopyShader(){return Pa}static getConcat2Shader(){return za}static getBroadcastBinaryShader(t="out_val = av + bv;"){return Ma.replace("//__BINOP__",t)}static getGeneralTransposeShader(){return qa}static getSplitShader(){return Da}static getProfileYShader(){return La}static getProfileXShader(){return Na}static getGlobalAveragePoolShader(){return Ra}static getMeanHeightShader(){return Ea}static getMaxPool2DShader(){return ja}static getInterp1DShader(){return $a}static getConv1DShader(){return Ha}static getSpatialSoftargmaxYShader(){return Xa}static getEmbeddingShader(){return Ja}static getSDPAShader(){return ts}static getCrossSDPAShader(){return as}static getCrossAttentionShader(){return rs}}});var W=class{constructor(t,r,e="float32",c=!1){this.name=t,this.shape=r,this.dtype=e,this.isWeight=c,this.gpuBuffer=null,this.sizeBytes=this._calculateByteSize()}_calculateByteSize(){let t=this.shape.reduce((r,e)=>r*e,1);return this.dtype==="float32"||this.dtype==="int32"?t*4:this.dtype==="int8"||this.dtype==="uint8"?t:t*4}};function C(p,t){if(Array.isArray(p))return[p[0],p[1]??p[0]];let r=p??t;return[r,r]}var j=class{constructor(){this.nodes=[],this.tensors=new Map}addInput(t,r,e="float32"){let c=new W(t,r,e,!1);return this.tensors.set(t,c),c}addWeight(t,r,e="float32"){let c=new W(t,r,e,!0);return this.tensors.set(t,c),c}addOp(t,r,e,c={}){let s={};for(let[m,a]of Object.entries(e)){let u=`${t}_${this.nodes.length}_out_${m}`,i=new W(u,a,"float32",!1);this.tensors.set(u,i),s[m]=i}let n={id:this.nodes.length,opType:t,inputs:r,outputs:s,params:c};return this.nodes.push(n),s}};function J(p){let t=(p.inputs.input||p.inputs.x).buffer,r=(p.inputs.slope||p.inputs.weight).buffer,e=p.outputs.out.buffer,c=(p.inputs.input||p.inputs.x).shape||[],s=c.length===4?c[3]:r.length;for(let n=0;n<e.length;n++){let m=r.length===s?r[n%s]:r[n%r.length];e[n]=t[n]<0?t[n]*m:t[n]}}function Z(p){let t=p.inputs.input.buffer,r=p.outputs.out.buffer;if(t.length===1)for(let e=0;e<r.length;e++)r[e]=t[0];else if(t.length===r.length)r.set(t);else{let e=f=>[1,1,1,1].slice(0,4-f.length).concat(f),[c,s,n,m]=e(p.inputs.input.shape),[a,u,i,o]=e(p.outputs.out.shape);for(let f=0;f<a;f++)for(let l=0;l<u;l++)for(let _=0;_<i;_++)for(let d=0;d<o;d++){let g=((f%c*s+l%s)*n+_%n)*m+d%m,b=((f*u+l)*i+_)*o+d;r[b]=t[g]}}}function tt(p){let t=p.inputs.input.buffer,r=p.inputs.scale.buffer[0],e=p.inputs.zero_point?p.inputs.zero_point.buffer[0]:0,c=p.outputs.out.buffer;for(let s=0;s<c.length;s++)c[s]=(t[s]-e)*r}function et(p){let t=p.inputs.input.buffer,r=p.outputs.out.buffer;for(let e=0;e<r.length;e++)r[e]=Math.tanh(t[e])}function at(p){let t=p.inputs.input||p.inputs.x,r=p.inputs.weight,e=p.outputs.out.buffer,c=t.shape.length===2?t.shape:[1,t.buffer.length],s=c[0],n=c[1],m=p.params.eps||1e-5;for(let a=0;a<s;a++){let u=0;for(let o=0;o<n;o++)u+=t.buffer[a*n+o]*t.buffer[a*n+o];let i=Math.sqrt(u/n+m);for(let o=0;o<n;o++)e[a*n+o]=t.buffer[a*n+o]/i*r.buffer[o]}}function st(p){let t=p.inputs.input.buffer,r=p.outputs.out.buffer;for(let e=0;e<r.length;e++){let c=t[e];r[e]=c/(1+Math.exp(-c))}}function rt(p){let t=p.inputs.a.buffer,r=p.inputs.b.buffer,e=p.outputs.out.buffer,c=e.length;if(r.length===1)for(let s=0;s<c;s++)e[s]=t[s]-r[0];else for(let s=0;s<c;s++)e[s]=t[s]-r[s]}function it(p){let t=p.inputs.input||p.inputs.x,r=p.outputs.out.buffer,e=t.shape.length===2?t.shape:[1,t.buffer.length],c=e[0],s=e[1];for(let n=0;n<c;n++){let m=-1/0;for(let i=0;i<s;i++)m=Math.max(m,t.buffer[n*s+i]);let a=0;for(let i=0;i<s;i++)a+=Math.exp(t.buffer[n*s+i]-m);let u=Math.log(a);for(let i=0;i<s;i++)r[n*s+i]=t.buffer[n*s+i]-m-u}}function ut(p){let t=p.inputs.input||p.inputs.x,r=p.outputs.out.buffer,e=t.shape.length===2?t.shape:[1,t.buffer.length],c=e[0],s=e[1];for(let n=0;n<c;n++){let m=-1/0;for(let u=0;u<s;u++)m=Math.max(m,t.buffer[n*s+u]);let a=0;for(let u=0;u<s;u++){let i=Math.exp(t.buffer[n*s+u]-m);r[n*s+u]=i,a+=i}for(let u=0;u<s;u++)r[n*s+u]/=a}}function ot(p){let t=p.inputs.cond||p.inputs.condition,r=p.inputs.x||p.inputs.a,e=p.inputs.y||p.inputs.b,c=p.outputs.out.buffer,s=t.buffer,n=r.buffer,m=e.buffer,a=c.length;for(let u=0;u<a;u++)c[u]=s[u]!==0?n[u]:m[u]}function nt(p){let t=p.inputs.input||p.inputs.data,r=p.outputs.out.buffer,e=p.params.pads||[],c=p.params.value||0,s=0,n=0,m=0,a=0;e.length===8?(s=e[1],m=e[2],n=e[5],a=e[6]):e.length===4&&(s=e[0],m=e[1],n=e[2],a=e[3]);let u=t.shape.length===4?t.shape:[1,t.shape[0]||1,t.shape[1]||1,1],[i,o,f,l]=u,_=o+s+n,d=f+m+a;for(let g=0;g<r.length;g++)r[g]=c;for(let g=0;g<i;g++)for(let b=0;b<o;b++)for(let h=0;h<f;h++)for(let v=0;v<l;v++){let x=((g*o+b)*f+h)*l+v,y=((g*_+(b+s))*d+(h+m))*l+v;r[y]=t.buffer[x]}}function pt(p){let t=p.inputs.input||p.inputs.x,r=t.buffer,e=p.outputs.out.buffer,[c,s,n,m]=t.shape,[a,u,i,o]=p.outputs.out.shape,f=p.params.kernel[0],l=p.params.kernel[1],_=p.params.stride?p.params.stride[0]:1,d=p.params.stride?p.params.stride[1]:1,g=p.params.padding?p.params.padding[0]:0,b=p.params.padding?p.params.padding[1]:0;for(let h=0;h<c;h++)for(let v=0;v<u;v++)for(let x=0;x<i;x++)for(let y=0;y<m;y++){let w=0,P=0;for(let z=0;z<f;z++)for(let M=0;M<l;M++){let q=v*_-g+z,T=x*d-b+M;if(q>=0&&q<s&&T>=0&&T<n){let A=((h*s+q)*n+T)*m+y;w+=r[A],P++}}let B=((h*u+v)*i+x)*o+y;e[B]=P>0?w/P:0}}function ct(p){let t=p.inputs.input||p.inputs.data,r=p.outputs.out.buffer,e=p.params.starts||[0,0,0,0],c=p.params.steps||[1,1,1,1],s=p.params.axes||[0,1,2,3],n=[1,1,1,1].slice(0,4-t.shape.length).concat(t.shape),m=[1,1,1,1].slice(0,4-p.outputs.out.shape.length).concat(p.outputs.out.shape),a=[0,0,0,0],u=[1,1,1,1];for(let o=0;o<s.length;o++){let f=s[o];f<0&&(f+=t.shape.length),f+=4-t.shape.length,a[f]=e[o]<0?e[o]+n[f]:e[o],u[f]=c[o]}let i=0;for(let o=0;o<m[0];o++)for(let f=0;f<m[1];f++)for(let l=0;l<m[2];l++)for(let _=0;_<m[3];_++){let d=a[0]+o*u[0],g=a[1]+f*u[1],b=a[2]+l*u[2],h=a[3]+_*u[3],v=d*(n[1]*n[2]*n[3])+g*(n[2]*n[3])+b*n[3]+h;r[i++]=t.buffer[v]}}function ft(p){let t=p.inputs.input||p.inputs.x,r=p.inputs.weight,e=p.inputs.bias,c=t.buffer,s=r.buffer,n=e?e.buffer:null,m=p.outputs.out.buffer,[a,u,i,o]=t.shape,[f,l,_,d]=p.outputs.out.shape,g=p.params.kernel[0],b=p.params.kernel[1],h=p.params.stride?p.params.stride[0]:1,v=p.params.stride?p.params.stride[1]:1,x=p.params.padding?p.params.padding[0]:0,y=p.params.padding?p.params.padding[1]:0;for(let w=0;w<m.length;w++)m[w]=n?n[w%d]:0;for(let w=0;w<a;w++)for(let P=0;P<o;P++)for(let B=0;B<u;B++)for(let z=0;z<i;z++){let M=c[((w*u+B)*i+z)*o+P];for(let q=0;q<d;q++)for(let T=0;T<g;T++)for(let A=0;A<b;A++){let D=B*h-x+T,G=z*v-y+A;if(D>=0&&D<l&&G>=0&&G<_){let L=s[P*(d*g*b)+q*(g*b)+T*b+A];m[((w*l+D)*_+G)*d+q]+=M*L}}}}function lt(p){let t=p.inputs.input||p.inputs.data,r=t.buffer,e=p.outputs.out.buffer,c=t.shape.length===2?t.shape:[1,t.buffer.length],s=c[0],n=c[1];for(let m=0;m<s;m++){let a=0;for(let u=0;u<n;u++)a+=r[m*n+u];e[m]=a}}function mt(p){let t=p.inputs.input||p.inputs.data,r=t.buffer,e=p.outputs.out.buffer,c=t.shape.length===2?t.shape:[1,t.buffer.length],s=c[0],n=c[1];for(let m=0;m<s;m++){let a=0;for(let u=0;u<n;u++)a+=r[m*n+u];e[m]=a/n}}function _t(p){let t=p.inputs.input||p.inputs.x,r=p.inputs.weight||p.inputs.scale,e=p.inputs.bias||p.inputs.b,c=p.inputs.running_mean||p.inputs.mean,s=p.inputs.running_var||p.inputs.var,n=p.outputs.out.buffer,[m,a,u,i]=t.shape,o=p.params.eps||1e-5;for(let f=0;f<m;f++)for(let l=0;l<i;l++){let _=r.buffer[l],d=e?e.buffer[l]:0,g=c.buffer[l],b=s.buffer[l];for(let h=0;h<a;h++)for(let v=0;v<u;v++){let x=((f*a+h)*u+v)*i+l,y=t.buffer[x];n[x]=(y-g)/Math.sqrt(b+o)*_+d}}}function dt(p){let t=p.inputs.a,r=p.inputs.b,e=p.outputs.out,c=t.buffer,s=r.buffer,n=e.buffer;if(s.length===1)for(let m=0;m<c.length;m++)n[m]=c[m]/s[0];else for(let m=0;m<c.length;m++)n[m]=c[m]/s[m%s.length]}function gt(p){let t=p.inputs.boxes,r=p.inputs.scores,e=p.outputs.out,c=0;p.inputs.max_output_boxes_per_class&&(c=p.inputs.max_output_boxes_per_class.buffer[0]);let s=.5;p.inputs.iou_threshold&&(s=p.inputs.iou_threshold.buffer[0]);let n=0;p.inputs.score_threshold&&(n=p.inputs.score_threshold.buffer[0]);let m=t.shape[0],a=t.shape[1],u=r.shape[1],i=0;for(let o=0;o<m;o++)for(let f=0;f<u;f++){let l=[];for(let d=0;d<a;d++){let g=r.buffer[o*(u*a)+f*a+d];if(g>=n){let b=t.buffer[o*(a*4)+d*4+0],h=t.buffer[o*(a*4)+d*4+1],v=t.buffer[o*(a*4)+d*4+2],x=t.buffer[o*(a*4)+d*4+3];l.push({s:d,score:g,y1:b,x1:h,y2:v,x2:x})}}l.sort((d,g)=>g.score-d.score);let _=[];for(let d=0;d<l.length&&_.length<c;d++){let g=l[d],b=!0;for(let h=0;h<_.length;h++){let v=_[h],x=Math.max(g.x1,v.x1),y=Math.max(g.y1,v.y1),w=Math.min(g.x2,v.x2),P=Math.min(g.y2,v.y2),B=Math.max(0,w-x),z=Math.max(0,P-y),M=B*z,q=(g.x2-g.x1)*(g.y2-g.y1),T=(v.x2-v.x1)*(v.y2-v.y1);if(M/(q+T-M)>s){b=!1;break}}b&&(_.push(g),i<e.buffer.length/3&&(e.buffer[i*3+0]=o,e.buffer[i*3+1]=f,e.buffer[i*3+2]=g.s,i++))}}for(;i<e.buffer.length/3;)e.buffer[i*3+0]=-1,e.buffer[i*3+1]=-1,e.buffer[i*3+2]=-1,i++}function ht(p){let t=p.inputs.input,r=p.inputs.indices,e=p.outputs.out,c=p.params.axis||0;c<0&&(c+=t.shape.length);let s=t.shape,n=e.shape,m=r.shape,a=new Array(s.length),u=1;for(let f=s.length-1;f>=0;f--)a[f]=u,u*=s[f];let i=new Array(n.length);u=1;for(let f=n.length-1;f>=0;f--)i[f]=u,u*=n[f];let o=new Array(m.length);u=1;for(let f=m.length-1;f>=0;f--)o[f]=u,u*=m[f];for(let f=0;f<e.buffer.length;f++){let l=f,_=new Array(n.length);for(let h=0;h<n.length;h++)_[h]=Math.floor(l/i[h]),l%=i[h];let d=0;for(let h=0;h<m.length;h++)d+=_[c+h]*o[h];let g=r.buffer[d];if(g<0){e.buffer[f]=-1;continue}let b=0;for(let h=0;h<c;h++)b+=_[h]*a[h];b+=g*a[c];for(let h=c+1;h<s.length;h++)b+=_[h-1+m.length]*a[h];e.buffer[f]=t.buffer[b]}}function bt(p){let t=p.inputs.input||p.inputs.data,r=p.inputs.indices,e=p.outputs.out,c=t.buffer,s=r.buffer,n=e.buffer,m=t.shape,a=r.shape,u=p.params.axis!==void 0?p.params.axis:0;u<0&&(u+=m.length);let i=new Array(m.length);{let _=1;for(let d=m.length-1;d>=0;d--)i[d]=_,_*=m[d]}let o=new Array(a.length);{let _=1;for(let d=a.length-1;d>=0;d--)o[d]=_,_*=a[d]}let f=a.length,l=new Array(f);for(let _=0;_<n.length;_++){let d=_;for(let h=0;h<f;h++)l[h]=Math.floor(d/o[h]),d%=o[h];let g=s[_]|0;g<0&&(g+=m[u]);let b=0;for(let h=0;h<f;h++)b+=(h===u?g:l[h])*i[h];n[_]=c[b]}}function vt(p){let t=p.inputs.q.buffer,r=p.inputs.kv.buffer,e=p.inputs.weight.buffer,c=p.inputs.scale?p.inputs.scale.buffer:null,s=p.inputs.bias?p.inputs.bias.buffer:null,n=p.outputs.out.buffer,m=p.inputs.q.shape[1],a=p.inputs.kv.shape[1],u=p.outputs.out.shape[2],i=p.params.heads||8,o=u/i,f=1/Math.sqrt(o);for(let l=0;l<i;l++)for(let _=0;_<m;_++){let d=new Float32Array(o);for(let v=0;v<o;v++){let x=0,y=l*o+v;for(let w=0;w<u;w++)x+=t[_*u+w]*e[y*u+w];c&&(x*=c[y]),s&&(x+=s[y]),d[v]=x}let g=new Float32Array(a),b=-1/0;for(let v=0;v<a;v++){let x=0;for(let y=0;y<o;y++){let w=0,P=u+l*o+y;for(let B=0;B<u;B++)w+=r[v*u+B]*e[P*u+B];c&&(w*=c[P]),s&&(w+=s[P]),x+=d[y]*w}x*=f,g[v]=x,x>b&&(b=x)}let h=0;for(let v=0;v<a;v++){let x=Math.exp(g[v]-b);g[v]=x,h+=x}for(let v=0;v<o;v++){let x=0;for(let y=0;y<a;y++){let w=g[y]/h,P=0,B=u*2+l*o+v;for(let z=0;z<u;z++)P+=r[y*u+z]*e[B*u+z];c&&(P*=c[B]),s&&(P+=s[B]),x+=w*P}n[_*u+l*o+v]=x}}}function xt(p){let t=p.inputs.input,r=p.outputs.out,e=t.buffer,c=r.buffer,s=t.shape[1],n=t.shape[2],m=t.shape[3];for(let a=0;a<m;a++){let u=a*n;for(let i=0;i<n;i++){let o=-1/0;for(let _=0;_<s;_++){let d=e[(_*n+i)*m+a];d>o&&(o=d)}let f=0,l=0;for(let _=0;_<s;_++){let d=Math.exp(e[(_*n+i)*m+a]-o);f+=d,l+=d*((_+.5)/s)}c[u+i]=f>0?l/f:0}}}function yt(p){let t=p.inputs.input,r=t.buffer,e=t.shape,c=p.outputs.out.buffer,s=p.params.perm||[...Array(e.length).keys()].reverse(),n=new Array(e.length),m=1;for(let o=e.length-1;o>=0;o--)n[o]=m,m*=e[o];let a=s.map(o=>e[o]),u=new Array(a.length);m=1;for(let o=a.length-1;o>=0;o--)u[o]=m,m*=a[o];let i=r.length;for(let o=0;o<i;o++){let f=0,l=o;for(let _=0;_<a.length;_++){let d=Math.floor(l/u[_]);l%=u[_],f+=d*n[s[_]]}c[o]=r[f]}}function wt(p){let t=p.inputs.q.buffer,r=p.inputs.k.buffer,e=p.inputs.v.buffer,c=p.outputs.out.buffer,s=p.inputs.q.shape[1],n=p.inputs.k.shape[1],m=p.outputs.out.shape[p.outputs.out.shape.length-1],a=p.params.heads||8,u=m/a,i=1/Math.sqrt(u);for(let o=0;o<a;o++)for(let f=0;f<s;f++){let l=new Float32Array(n),_=-1/0;for(let g=0;g<n;g++){let b=0;for(let h=0;h<u;h++)b+=t[f*m+o*u+h]*r[g*m+o*u+h];b*=i,l[g]=b,b>_&&(_=b)}let d=0;for(let g=0;g<n;g++){let b=Math.exp(l[g]-_);l[g]=b,d+=b}for(let g=0;g<u;g++){let b=0;for(let h=0;h<n;h++)b+=l[h]/d*e[h*m+o*u+g];c[f*m+o*u+g]=b}}}function Bt(p){let t=p.inputs.input,r=p.outputs.out,[,e,c,s]=t.shape,n=t.buffer,m=r.buffer;for(let a=0;a<s;a++)for(let u=0;u<c;u++){let i=0;for(let o=0;o<e;o++)i+=n[(o*c+u)*s+a];m[a*c+u]=i/e}}function kt(p){let t=p.inputs.input,r=p.outputs.out,[e,c,s,n]=t.shape,m=p.params.kernel[0],a=p.params.kernel[1],u=p.params.stride[0],i=p.params.stride[1],o=p.params.padding?p.params.padding[0]:0,f=p.params.padding?p.params.padding[1]:0,l=r.shape[1],_=r.shape[2],d=t.buffer,g=r.buffer;for(let b=0;b<e;b++)for(let h=0;h<l;h++)for(let v=0;v<_;v++)for(let x=0;x<n;x++){let y=-1/0;for(let w=0;w<m;w++)for(let P=0;P<a;P++){let B=h*u+w-o,z=v*i+P-f;if(B>=0&&B<c&&z>=0&&z<s){let M=d[((b*c+B)*s+z)*n+x];M>y&&(y=M)}}g[((b*l+h)*_+v)*n+x]=y}}function St(p){let t=p.inputs.input,r=p.outputs.out,[e,c]=t.shape.slice(1),s=p.params.size,n=t.buffer,m=r.buffer,a=c/s;for(let u=0;u<e;u++)for(let i=0;i<s;i++){let o=(i+.5)*a-.5;o<0&&(o=0),o>c-1&&(o=c-1);let f=Math.floor(o),l=f+1<c?f+1:f,_=o-f,d=n[u*c+f],g=n[u*c+l];m[u*s+i]=d+_*(g-d)}}function Pt(p){let t=p.inputs.input,r=p.outputs.out,[,e,c,s]=t.shape,n=t.buffer,m=r.buffer;for(let a=0;a<s;a++)for(let u=0;u<c;u++){let i=-1/0,o=0;for(let f=0;f<e;f++){let l=n[(f*c+u)*s+a];l>i&&(i=l),o+=l}m[a*c+u]=i,m[(s+a)*c+u]=o/e}}function Ut(p){let t=p.inputs.input,r=p.outputs.out,[,e,c,s]=t.shape,n=t.buffer,m=r.buffer;for(let a=0;a<s;a++)for(let u=0;u<e;u++){let i=-1/0,o=0;for(let f=0;f<c;f++){let l=n[(u*c+f)*s+a];l>i&&(i=l),o+=l}m[a*e+u]=i,m[(s+a)*e+u]=o/c}}function zt(p){let t=p.outputs.out.buffer,r=0,e=Object.entries(p.inputs).sort(([c],[s])=>{let n=/^input(\d+)$/.exec(c),m=/^input(\d+)$/.exec(s);return n&&m?Number(n[1])-Number(m[1]):c.localeCompare(s)});for(let[,c]of e)t.set(c.buffer,r),r+=c.buffer.length}function Tt(p){let t=p.inputs.input,r=p.outputs.out,[e,c,s,n]=t.shape,m=t.buffer,a=r.buffer;for(let u=0;u<e;u++)for(let i=0;i<c;i++)for(let o=0;o<s;o++)for(let f=0;f<n;f++){let l=m[((u*c+i)*s+o)*n+f],_=i*2,d=o*2;a[((u*c*2+_)*s*2+d)*n+f]=l,a[((u*c*2+_)*s*2+d+1)*n+f]=l,a[((u*c*2+_+1)*s*2+d)*n+f]=l,a[((u*c*2+_+1)*s*2+d+1)*n+f]=l}}function Mt(p){let t=p.inputs.qkv.buffer,r=p.outputs.out.buffer,e=p.inputs.qkv.shape[1],c=p.outputs.out.shape[2],s=p.params.heads||8,n=c/s,m=p.params.scale!==void 0?p.params.scale:1/Math.sqrt(n);for(let a=0;a<s;a++)for(let u=0;u<e;u++){let i=new Float32Array(e),o=-1/0;for(let l=0;l<=u;l++){let _=0;for(let d=0;d<n;d++){let g=t[u*(c*3)+a*n+d],b=t[l*(c*3)+c+a*n+d];_+=g*b}_*=m,i[l]=_,_>o&&(o=_)}let f=0;for(let l=0;l<=u;l++){let _=Math.exp(i[l]-o);i[l]=_,f+=_}for(let l=0;l<n;l++){let _=0;for(let d=0;d<=u;d++){let g=i[d]/f,b=t[d*(c*3)+c*2+a*n+l];_+=g*b}r[u*c+a*n+l]=_}}}function At(p){let t=p.inputs.input.buffer,r=p.inputs.weight.buffer,e=p.outputs.out.buffer,c=p.outputs.out.shape[p.outputs.out.shape.length-1],s=t.length;for(let n=0;n<s;n++){let m=t[n];for(let a=0;a<c;a++)e[n*c+a]=r[m*c+a]}}function qt(p){let t=p.inputs.a,r=p.inputs.b,e=p.outputs.out.buffer,c=t.buffer,s=r.buffer,n=t.shape,m=r.shape;if(c.length<s.length){let u=c;c=s,s=u;let i=n;n=m,m=i}let a=c.length;if(s.length===1)for(let u=0;u<a;u++)e[u]=c[u]*s[0];else if(s.length===a)for(let u=0;u<a;u++)e[u]=c[u]*s[u];else if(n.length===4&&s.length===n[3]){let u=n[3];for(let i=0;i<a;i++)e[i]=c[i]*s[i%u]}else if(n.length===4&&m.length===4&&m[0]===1&&m[1]===1&&m[2]===1&&m[3]===n[3]){let u=n[3];for(let i=0;i<a;i++)e[i]=c[i]*s[i%u]}else console.warn("[VolvoxAI CPU] Executing Mul is not fully implemented yet for shapes",t.shape,r.shape)}function Ct(p){let t=p.inputs.a,r=p.inputs.b,e=p.outputs.out.buffer,c=t.buffer,s=r.buffer,n=t.shape,m=r.shape;if(c.length<s.length){let u=c;c=s,s=u;let i=n;n=m,m=i}let a=c.length;if(s.length===1)for(let u=0;u<a;u++)e[u]=c[u]+s[0];else if(s.length===a)for(let u=0;u<a;u++)e[u]=c[u]+s[u];else if(n.length===4&&s.length===n[3]){let u=n[3];for(let i=0;i<a;i++)e[i]=c[i]+s[i%u]}else if(n.length===4&&m.length===4&&m[0]===1&&m[1]===1&&m[2]===1&&m[3]===n[3]){let u=n[3];for(let i=0;i<a;i++)e[i]=c[i]+s[i%u]}else console.warn("[VolvoxAI CPU] Executing Add is not fully implemented yet for shapes",t.shape,r.shape)}function Dt(p){let t=p.inputs.input,r=p.outputs.out,e=t.shape[0],c=t.shape[1],s=t.shape[2],n=t.shape[3],m=c*s;for(let a=0;a<e;a++)for(let u=0;u<n;u++){let i=0;for(let o=0;o<m;o++){let f=Math.floor(o/s),l=o-f*s;i+=t.buffer[((a*c+f)*s+l)*n+u]}r.buffer[a*n+u]=i/m}}function Gt(p){let t=p.inputs.input,r=p.outputs.out,e=p.params.min!==void 0?p.params.min:-1/0,c=p.params.max!==void 0?p.params.max:1/0;p.inputs.min&&(e=p.inputs.min.buffer[0]),p.inputs.max&&(c=p.inputs.max.buffer[0]);for(let s=0;s<t.buffer.length;s++){let n=t.buffer[s];n<e&&(n=e),n>c&&(n=c),r.buffer[s]=n}}function Lt(p){let t=p.inputs.input;p.outputs.out.buffer.set(t.buffer)}function It(p){let t=p.inputs.input,r=t.buffer,e=t.shape,c=p.params.axis||0;c<0&&(c+=e.length);let s=Object.keys(p.outputs).sort(),n=s.length,m=e[c]/n,a=1;for(let o=0;o<c;o++)a*=e[o];let u=1;for(let o=c+1;o<e.length;o++)u*=e[o];let i=m*u;for(let o=0;o<n;o++){let f=p.outputs[s[o]].buffer;for(let l=0;l<a;l++){let _=(l*e[c]+o*m)*u,d=l*i;f.set(r.subarray(_,_+i),d)}}}function Nt(p){let t=p.inputs.input,r=p.outputs.out,[e,c,s,n]=t.shape,[,m,a]=r.shape,u=t.buffer,i=r.buffer;if(p.opType==="ResizeNearest2D"||p.params.mode==="nearest"){for(let l=0;l<e;l++)for(let _=0;_<m;_++){let d=Math.floor(_*c/m);d>=c&&(d=c-1);for(let g=0;g<a;g++){let b=Math.floor(g*s/a);b>=s&&(b=s-1);for(let h=0;h<n;h++)i[((l*m+_)*a+g)*n+h]=u[((l*c+d)*s+b)*n+h]}}return}let o=c/m,f=s/a;for(let l=0;l<e;l++)for(let _=0;_<m;_++){let d=(_+.5)*o-.5;d<0&&(d=0);let g=Math.min(c-1,Math.floor(d)),b=Math.min(c-1,g+1),h=d-g;for(let v=0;v<a;v++){let x=(v+.5)*f-.5;x<0&&(x=0);let y=Math.min(s-1,Math.floor(x)),w=Math.min(s-1,y+1),P=x-y;for(let B=0;B<n;B++){let z=u[((l*c+g)*s+y)*n+B],M=u[((l*c+g)*s+w)*n+B],q=u[((l*c+b)*s+y)*n+B],T=u[((l*c+b)*s+w)*n+B];i[((l*m+_)*a+v)*n+B]=z*(1-h)*(1-P)+M*(1-h)*P+q*h*(1-P)+T*h*P}}}}function Ot(p){let t=p.inputs.input.buffer,r=p.outputs.out.buffer;for(let e=0;e<t.length;e++)r[e]=1/(1+Math.exp(-t[e]))}function Rt(p){let t=p.inputs.input.buffer,r=p.outputs.out.buffer;for(let e=0;e<t.length;e++){let s=t[e]+3;s<0?s=0:s>6&&(s=6),r[e]=s/6}}function Ft(p){let t=p.inputs.input.buffer,r=p.outputs.out.buffer;for(let e=0;e<t.length;e++){let c=t[e],s=c+3;s<0?s=0:s>6&&(s=6),r[e]=c*s/6}}function Et(p){let t=p.inputs.input.buffer,r=p.outputs.out.buffer;for(let e=0;e<t.length;e++)r[e]=t[e]>0?t[e]:0}function Wt(p){let t=p.inputs.input.buffer,r=p.outputs.out.buffer,e=p.params.alpha!==void 0?p.params.alpha:.01;for(let c=0;c<t.length;c++){let s=t[c];r[c]=s>0?s:e*s}}function jt(p){let t=p.inputs.input.buffer,r=p.outputs.out.buffer;for(let e=0;e<t.length;e++){let c=t[e];r[e]=.5*c*(1+Math.tanh(.7978845608*(c+.044715*c*c*c)))}}function Yt(p){let t=p.inputs.input.buffer,r=p.inputs.weight.buffer,e=p.inputs.bias.buffer,c=p.outputs.out.buffer,s=p.params.d_model,n=p.inputs.input.shape.slice(0,-1).reduce((m,a)=>m*a,1);for(let m=0;m<n;m++){let a=m*s,u=0,i=0;for(let _=0;_<s;_++){let d=t[a+_];u+=d,i+=d*d}let o=u/s,f=i/s-o*o,l=1/Math.sqrt(f+1e-5);for(let _=0;_<s;_++){let d=(t[a+_]-o)*l;c[a+_]=d*r[_]+e[_]}}}function $t(p){let t=p.inputs.input,r=p.inputs.weight,e=p.inputs.bias?p.inputs.bias.buffer:null,c=p.outputs.out,[s,n,m,a]=t.shape,[u,i]=r.shape,o=c.shape[3],f=c.shape[1],l=c.shape[2],[_,d]=C(p.params.stride,1),[g,b]=C(p.params.padding,0),h=p.params.pads||[g,b,g,b],[v,x]=C(p.params.dilation,1),y=t.buffer,w=r.buffer,P=c.buffer,B=p.params.groups||1,z=o/B,M=r.shape[2];for(let q=0;q<s;q++)for(let T=0;T<f;T++)for(let A=0;A<l;A++)for(let D=0;D<o;D++){let G=0;if(B===a){let L=o/a,O=Math.floor(D/L),I=D-O*L;for(let E=0;E<u;E++)for(let N=0;N<i;N++){let R=T*_+E*v-h[0],F=A*d+N*x-h[1];if(R>=0&&R<n&&F>=0&&F<m){let Y=((q*n+R)*m+F)*a+O,X=((E*i+N)*a+O)*L+I;G+=y[Y]*w[X]}}}else{let O=Math.floor(D/z)*M;for(let I=0;I<M;I++){let E=O+I;for(let N=0;N<u;N++)for(let R=0;R<i;R++){let F=T*_+N*v-h[0],Y=A*d+R*x-h[1];if(F>=0&&F<n&&Y>=0&&Y<m){let X=((q*n+F)*m+Y)*a+E,ps=((N*i+R)*M+I)*o+D;G+=y[X]*w[ps]}}}}e&&(G+=e[D]),p.params.relu===1&&G<0?G=0:p.params.relu>=2&&(G=Math.min(Math.max(G,0),6)),P[((q*f+T)*l+A)*o+D]=G}}function Vt(p){let t=p.inputs.input,r=p.inputs.weight,e=p.inputs.bias?p.inputs.bias.buffer:null,c=p.outputs.out,[s,n]=t.shape.slice(1),[m,a,u]=r.shape,i=c.shape[2],o=C(p.params.stride,1)[0],f=C(p.params.padding,0)[0],l=p.params.relu,_=t.buffer,d=r.buffer,g=c.buffer;for(let b=0;b<m;b++)for(let h=0;h<i;h++){let v=e?e[b]:0;for(let x=0;x<s;x++)for(let y=0;y<u;y++){let w=h*o+y-f;if(w>=0&&w<n){let P=x*n+w,B=(b*s+x)*u+y;v+=_[P]*d[B]}}l&&v<0&&(v=0),g[b*i+h]=v}}function Ht(p){let t=p.inputs.input,r=p.inputs.weight,e=p.outputs.out,c=t.shape.slice(0,-1).reduce((d,g)=>d*g,1),s=t.shape[t.shape.length-1],n=e.shape[e.shape.length-1],m=t.buffer,a=r.buffer,u=e.buffer,i=p.inputs.scale?p.inputs.scale.buffer:null,o=p.inputs.bias?p.inputs.bias.buffer:null,f=r.shape.length>=2?r.shape[0]:n,l=r.shape.length>=2?r.shape[1]:s,_=i?!0:p.wLayout?p.wLayout==="dout":f===n&&l===s;for(let d=0;d<c;d++)for(let g=0;g<n;g++){let b=0;if(_)for(let h=0;h<s;h++)b+=m[d*s+h]*a[g*s+h];else for(let h=0;h<s;h++)b+=m[d*s+h]*a[h*n+g];i&&(b*=i[g]),o&&(b+=o[g]),u[d*n+g]=b}}function Kt(p){let t=p.inputs.input||p.inputs.data,r=p.outputs.out,e=t.buffer,c=r.buffer,s=p.params.to,n=s==="int32"||s==="int64"||s==="int8"||s===3||s===5||s===6||s===7,m=Math.min(e.length,c.length);if(n)for(let a=0;a<m;a++)c[a]=Math.trunc(e[a]);else c.set(e.subarray(0,m))}function Xt(p){let t=p.inputs.input||p.inputs.data,r=p.outputs.out,e=t.buffer,c=r.buffer,s=t.shape,n=p.params.axis!==void 0?p.params.axis:0;n<0&&(n+=s.length);let m=s[n],a=1;for(let o=n+1;o<s.length;o++)a*=s[o];let u=1;for(let o=0;o<n;o++)u*=s[o];let i=0;for(let o=0;o<u;o++)for(let f=0;f<a;f++){let l=o*m*a+f,_=e[l],d=0;for(let g=1;g<m;g++){let b=e[l+g*a];b>_&&(_=b,d=g)}c[i++]=d}}var S=class{constructor(){this.tensors=new Map,console.log("[VolvoxAI] CPU Fallback Engine ready.")}allocateGraph(t){this.graph=t;for(let[r,e]of t.tensors.entries())e.buffer||(e.dtype==="int8"?e.buffer=new Int8Array(e.sizeBytes):e.buffer=new Float32Array(e.sizeBytes/4))}async execute(t,r){let e=r?t:this.graph,c=r||t;for(let[n,m]of Object.entries(c)){let a=e.tensors.get(n);a&&a.buffer&&a.buffer.set(m)}for(let n of e.nodes)this._runNode(n);let s={};if(e.outputNames&&e.outputNames.length>0)for(let n of e.outputNames)s[n]=e.tensors.get(n).buffer;else{let n=e.nodes[e.nodes.length-1];for(let[m,a]of Object.entries(n.outputs))s[a.name]=e.tensors.get(a.name).buffer}return s}_runNode(t){switch(t.opType){case"MatMul":return this._cpuMatMul(t);case"LayerNorm":return this._cpuLayerNorm(t);case"RMSNorm":return this._cpuRMSNorm(t);case"Embedding":return this._cpuEmbedding(t);case"SDPA":return this._cpuSDPA(t);case"CrossSDPA":return this._cpuCrossSDPA(t);case"CrossAttention":return this._cpuCrossAttention(t);case"Conv2D":return this._cpuConv2D(t);case"Conv1D":return this._cpuConv1D(t);case"ConvTranspose2D":return this._cpuConvTranspose2D(t);case"MaxPool2D":return this._cpuMaxPool2D(t);case"AveragePool":case"AveragePool2D":return this._cpuAveragePool2D(t);case"GlobalAveragePool":return this._cpuGlobalAveragePool(t);case"BatchNorm2D":return this._cpuBatchNorm2D(t);case"ResizeNearest2D":case"Resize":return this._cpuResize(t);case"Upsample2x":case"UpsampleNearest2D":return this._cpuUpsample2x(t);case"Interp1D":case"InterpLinear1D":return this._cpuInterp1D(t);case"ReLU":return this._cpuReLU(t);case"LeakyReLU":return this._cpuLeakyReLU(t);case"PReLU":return this._cpuPReLU(t);case"GELU":return this._cpuGELU(t);case"SiLU":case"Swish":return this._cpuSiLU(t);case"Sigmoid":return this._cpuSigmoid(t);case"HardSwish":return this._cpuHardSwish(t);case"HardSigmoid":return this._cpuHardSigmoid(t);case"Tanh":return this._cpuTanh(t);case"Clip":return this._cpuClip(t);case"Add":return this._cpuAdd(t);case"Mul":return this._cpuMul(t);case"Sub":return this._cpuSub(t);case"Div":return this._cpuDiv(t);case"Softmax":return this._cpuSoftmax(t);case"LogSoftmax":return this._cpuLogSoftmax(t);case"ReduceSum":return this._cpuReduceSum(t);case"ReduceMean":return this._cpuReduceMean(t);case"ArgMax":return this._cpuArgMax(t);case"Transpose":return this._cpuTranspose(t);case"Concat":case"Concat2":return this._cpuConcat2(t);case"Split":return this._cpuSplit(t);case"Slice":return this._cpuSlice(t);case"Pad":return this._cpuPad(t);case"Expand":case"Broadcast":return this._cpuExpand(t);case"Gather":return this._cpuGather(t);case"GatherElements":return this._cpuGatherElements(t);case"Where":case"Mask":return this._cpuWhere(t);case"Cast":return this._cpuCast(t);case"DequantizeLinear":return this._cpuDequantizeLinear(t);case"NonMaxSuppression":return this._cpuNonMaxSuppression(t);case"SpatialSoftargmaxY":return this._cpuSpatialSoftargmaxY(t);case"ProfileX":return this._cpuProfileX(t);case"ProfileY":return this._cpuProfileY(t);case"MeanHeight":return this._cpuMeanHeight(t);case"Reshape":case"Flatten":case"Squeeze":case"Unsqueeze":case"Dropout":case"Identity":return this._cpuReshape(t);default:console.warn(`[VolvoxAI CPU] Executing ${t.opType} is not implemented; node ${t.id} skipped.`)}}};S.prototype._cpuWhere=ot;S.prototype._cpuPad=nt;S.prototype._cpuAveragePool2D=pt;S.prototype._cpuSlice=ct;S.prototype._cpuConvTranspose2D=ft;S.prototype._cpuReduceSum=lt;S.prototype._cpuReduceMean=mt;S.prototype._cpuBatchNorm2D=_t;S.prototype._cpuSoftmax=ut;S.prototype._cpuLogSoftmax=it;S.prototype._cpuSub=rt;S.prototype._cpuSiLU=st;S.prototype._cpuRMSNorm=at;S.prototype._cpuTanh=et;S.prototype._cpuDequantizeLinear=tt;S.prototype._cpuExpand=Z;S.prototype._cpuPReLU=J;S.prototype._cpuDiv=dt;S.prototype._cpuNonMaxSuppression=gt;S.prototype._cpuGather=ht;S.prototype._cpuGatherElements=bt;S.prototype._cpuCrossAttention=vt;S.prototype._cpuSpatialSoftargmaxY=xt;S.prototype._cpuTranspose=yt;S.prototype._cpuCrossSDPA=wt;S.prototype._cpuMeanHeight=Bt;S.prototype._cpuMaxPool2D=kt;S.prototype._cpuInterp1D=St;S.prototype._cpuProfileX=Pt;S.prototype._cpuProfileY=Ut;S.prototype._cpuConcat2=zt;S.prototype._cpuUpsample2x=Tt;S.prototype._cpuSDPA=Mt;S.prototype._cpuEmbedding=At;S.prototype._cpuMul=qt;S.prototype._cpuAdd=Ct;S.prototype._cpuGlobalAveragePool=Dt;S.prototype._cpuClip=Gt;S.prototype._cpuReshape=Lt;S.prototype._cpuSplit=It;S.prototype._cpuResize=Nt;S.prototype._cpuSigmoid=Ot;S.prototype._cpuHardSigmoid=Rt;S.prototype._cpuHardSwish=Ft;S.prototype._cpuReLU=Et;S.prototype._cpuLeakyReLU=Wt;S.prototype._cpuGELU=jt;S.prototype._cpuLayerNorm=Yt;S.prototype._cpuConv2D=$t;S.prototype._cpuConv1D=Vt;S.prototype._cpuMatMul=Ht;S.prototype._cpuCast=Kt;S.prototype._cpuArgMax=Xt;var $=class p extends S{constructor(t){super(),this.wasmModule=t,this.api=t.instance.exports,this.mem=this.api.memory,this.pointers=new Map,console.log("[VolvoxAI] WASM Engine ready (Tier 2 Fallback).")}static async init(t){try{let r;if(typeof process<"u"&&process.versions&&process.versions.node){let s=await import("fs"),n=t;n.startsWith("/")||(n="./"+n),r=s.readFileSync(n)}else{let s=await fetch(t);if(!s.ok)throw new Error("WASM file not found.");r=await s.arrayBuffer()}let e={expf:Math.exp,logf:Math.log,powf:Math.pow},c=await WebAssembly.instantiate(r,{env:e,math:e});return new p(c)}catch(r){return console.warn(`[VolvoxAI] Failed to load WASM from ${t}:`,r),null}}createGraph(){return new j}_alloc(t){if(!this.pointers.has(t.name)){let r=this.api.alloc_bytes(t.sizeBytes),e=r+t.sizeBytes,c=this.mem.buffer.byteLength;if(e>c){let n=Math.ceil((e-c)/65536);this.mem.grow(n)}this.pointers.set(t.name,r);let s=new Float32Array(this.mem.buffer,r,t.sizeBytes/4);if(t.isWeight&&t.buffer){let n=t.buffer,m=this._doutWeights&&this._doutWeights.get(t.name);if(m){let{din:i,dout:o}=m,f=new Float32Array(i*o);for(let l=0;l<o;l++)for(let _=0;_<i;_++)f[_*o+l]=n[l*i+_];n=f}let a=new Uint8Array(n.buffer,n.byteOffset,n.byteLength),u=Math.min(n.byteLength,t.sizeBytes);new Uint8Array(this.mem.buffer,r,u).set(a.subarray(0,u))}t.buffer=s}return this.pointers.get(t.name)}allocateGraph(t){return this.compile(t)}compile(t){console.log("[VolvoxAI WASM] Allocating graph tensors on WASM heap..."),this.api.reset_heap&&this.api.reset_heap(),this.pointers.clear(),this._doutWeights=new Map;for(let r of t.nodes)if((r.opType==="MatMul"||r.opType==="Linear"||r.opType==="Gemm")&&r.wLayout==="dout"&&r.inputs.weight&&!r.inputs.scale){let e=r.inputs.input.shape[r.inputs.input.shape.length-1],c=r.outputs.out.shape[r.outputs.out.shape.length-1];this._doutWeights.set(r.inputs.weight.name,{din:e,dout:c})}for(let[r,e]of t.tensors.entries())this._alloc(e);for(let[r,e]of t.tensors.entries()){let c=this.pointers.get(r);e.buffer=new Float32Array(this.mem.buffer,c,e.sizeBytes/4)}return this.graph=t,this}async execute(t){for(let[e,c]of Object.entries(t)){if(!this.graph.tensors.get(e))continue;let n=this.pointers.get(e);new Float32Array(this.mem.buffer,n,c.length).set(c)}for(let e of this.graph.nodes)try{let c=this.pointers.get(e.inputs.input?.name),s=this.pointers.get(e.outputs.out?.name),n=this.pointers.get(e.inputs.weight?.name),m=this.pointers.get(e.inputs.bias?.name);if(e.opType==="Conv2D"){let a=this.pointers.get(e.inputs.weight.name),u=e.inputs.bias?this.pointers.get(e.inputs.bias.name):0,i=e.inputs.input.shape,o=e.outputs.out.shape,f=e.inputs.weight.shape,[l,_]=C(e.params.stride,1),[d,g]=C(e.params.dilation,1),b=C(e.params.padding,0),h=e.params.pads||[b[0],b[1],b[0],b[1]],v=e.params.groups||1,x=e.params.relu?1:0;this.api.conv2d_f32(c,s,a,u,i[0],i[1],i[2],i[3],f[0],f[1],f[2],f[3],o[1],o[2],l,_,h[0],h[1],v,x,d,g)}else if(e.opType==="ConvTranspose2D"){let a=this.pointers.get(e.inputs.weight.name),u=e.inputs.bias?this.pointers.get(e.inputs.bias.name):0,[i,o,f,l]=e.inputs.input.shape,[_,d,g,b]=e.outputs.out.shape,h=e.params.kernel[0],v=e.params.kernel[1],x=e.params.stride?e.params.stride[0]:1,y=e.params.stride?e.params.stride[1]:1,w=e.params.padding?e.params.padding[0]:0,P=e.params.padding?e.params.padding[1]:0;this.api.conv_transpose2d_f32(c,a,u,s,i,o,f,l,d,g,b,h,v,x,y,w,P)}else if(e.opType==="ReduceSum"){let a=e.inputs.input?e.inputs.input.shape:e.inputs.data.shape,u=a.length===2?a:[1,e.inputs.input?e.inputs.input.buffer.length:e.inputs.data.buffer.length];this.api.reduce_sum_f32(c,s,u[0],u[1])}else if(e.opType==="ReduceMean"){let a=e.inputs.input?e.inputs.input.shape:e.inputs.data.shape,u=a.length===2?a:[1,e.inputs.input?e.inputs.input.buffer.length:e.inputs.data.buffer.length];this.api.reduce_mean_f32(c,s,u[0],u[1])}else if(e.opType==="MatMul"){let a=this.pointers.get(e.inputs.weight.name),u=e.inputs.bias?this.pointers.get(e.inputs.bias.name):0,i=e.inputs.input.shape[e.inputs.input.shape.length-1],o=e.outputs.out.shape[e.outputs.out.shape.length-1],f=e.inputs.input.shape.slice(0,-1).reduce((l,_)=>l*_,1);if(e.inputs.scale){let l=this.pointers.get(e.inputs.scale.name);this.api.matmul_int8_f32(c,a,l,u,s,f,i,o)}else this.api.matmul_f32(c,a,u,s,f,i,o)}else if(e.opType==="LayerNorm"){let a=e.inputs.input.shape.slice(0,-1).reduce((i,o)=>i*o,1),u=e.params.d_model;this.api.layernorm_f32(c,n,m,s,a,u,1e-5)}else if(e.opType==="SDPA"){let a=this.pointers.get(e.inputs.qkv.name),u=e.inputs.qkv.shape[1],i=e.outputs.out.shape[e.outputs.out.shape.length-1],o=e.params.heads||e.params.num_heads||8,f=e.params.head_dim||i/o,l=e.params.scale!==void 0?e.params.scale:1/Math.sqrt(f);this.api.sdpa_f32(a,s,u,i,o,f,l)}else if(e.opType==="CrossSDPA"){let a=this.pointers.get(e.inputs.q.name),u=this.pointers.get(e.inputs.k.name),i=this.pointers.get(e.inputs.v.name),o=e.inputs.q.shape[1],f=e.inputs.k.shape[1],l=e.outputs.out.shape[e.outputs.out.shape.length-1],_=e.params.heads||e.params.num_heads||8,d=e.params.head_dim||l/_;this.api.cross_sdpa_f32(a,u,i,s,o,f,l,_,d,1/Math.sqrt(d))}else if(e.opType==="Embedding"){let a=e.inputs.input.shape.reduce((i,o)=>i*o,1),u=e.outputs.out.shape[e.outputs.out.shape.length-1];this.api.embedding_f32(c,n,s,a,u)}else if(e.opType==="ReLU"){let u=e.inputs.input.shape.reduce((i,o)=>i*o,1);this.api.relu_f32(c,s,u)}else if(e.opType==="GELU"){let a=e.inputs.input.sizeBytes/4;this.api.gelu_f32(c,s,a)}else if(e.opType==="Add")this._cpuAdd(e);else if(e.opType==="Mul")this._cpuMul(e);else if(e.opType==="Conv1D"){let a=e.inputs.input.shape,u=e.inputs.weight.shape,[i]=C(e.params.stride,1),[o]=C(e.params.padding,0),f=e.params.groups||1,l=e.params.relu?1:0;this.api.conv1d_f32(c,s,n,m,a[1],a[2],u[0],u[1],u[2],i,o,f,l)}else if(e.opType==="UpsampleNearest2D"){let a=e.inputs.input.shape;this.api.upsample_nearest2x_f32(c,s,a[3],a[1],a[2])}else if(e.opType==="Concat"||e.opType==="Concat2")this._cpuConcat2(e);else if(e.opType==="ProfileY"){let a=e.inputs.input.shape;this.api.profile_y_f32(c,s,a[3],a[1],a[2])}else if(e.opType==="ProfileX"){let a=e.inputs.input.shape;this.api.profile_x_f32(c,s,a[3],a[1],a[2])}else if(e.opType==="InterpLinear1D"){let a=e.inputs.input.shape,u=e.params.size;this.api.interp1d_f32(c,s,a[1],a[2],u)}else if(e.opType==="SpatialSoftargmaxY"){let a=e.inputs.input.shape;this.api.spatial_softargmax_y_f32(c,s,a[3],a[1],a[2])}else if(e.opType==="Sigmoid"){let u=e.inputs.input.shape.reduce((i,o)=>i*o,1);this.api.sigmoid_f32(c,s,u)}else if(e.opType==="Clip"){let a=e.params.min!==void 0?e.params.min:-1e9,u=e.params.max!==void 0?e.params.max:1e9;if(e.inputs.min){let f=this.pointers.get(e.inputs.min.name);a=new Float32Array(this.mem.buffer,f,1)[0]}if(e.inputs.max){let f=this.pointers.get(e.inputs.max.name);u=new Float32Array(this.mem.buffer,f,1)[0]}let o=e.inputs.input.shape.reduce((f,l)=>f*l,1);this.api.clip_f32(c,s,o,a,u)}else if(e.opType==="HardSwish"){let u=e.inputs.input.shape.reduce((i,o)=>i*o,1);this.api.hardswish_f32(c,s,u)}else if(e.opType==="LeakyReLU"){let u=e.inputs.input.shape.reduce((o,f)=>o*f,1),i=e.params.alpha||.01;this.api.leakyrelu_f32?this.api.leakyrelu_f32(c,s,u,i):this._cpuLeakyReLU(e)}else if(e.opType==="PReLU")if(this.api.prelu_f32){let a=e.inputs.input.shape,u=this.pointers.get(e.inputs.weight.name);this.api.prelu_f32(c,u,s,a[0],a[1],a[2],a[3])}else this._cpuPReLU(e);else if(e.opType==="HardSigmoid"){let u=e.inputs.input.shape.reduce((i,o)=>i*o,1);this.api.hardsigmoid_f32(c,s,u)}else if(e.opType==="Reshape"){let u=e.inputs.input.shape.reduce((i,o)=>i*o,1);this.api.copy_f32(c,s,u)}else if(e.opType==="Transpose")this._cpuTranspose(e);else if(e.opType==="GlobalAveragePool"){let a=e.inputs.input.shape;this.api.global_average_pool_f32(c,s,a[0],a[1],a[2],a[3])}else if(e.opType==="BatchNorm2D"){let a=this.pointers.get(e.inputs.weight.name),u=this.pointers.get(e.inputs.bias.name),i=this.pointers.get(e.inputs.running_mean.name),o=this.pointers.get(e.inputs.running_var.name),[f,l,_,d]=e.inputs.input.shape,g=e.params.eps||1e-5;this.api.batch_norm2d_f32(c,a,u,i,o,s,f,l,_,d,g)}else if(e.opType==="ResizeNearest2D")this._cpuResize(e);else if(e.opType==="Resize"){let[a,u,i,o]=e.inputs.input.shape,[f,l,_]=e.outputs.out.shape;this.api.resize_bilinear_f32(c,s,a,u,i,o,l,_)}else if(e.opType==="Cast")this._cpuCast(e);else if(e.opType==="Slice"){let a=[1,1,1,1].slice(0,4-e.inputs.input.shape.length).concat(e.inputs.input.shape),u=[1,1,1,1].slice(0,4-e.outputs.out.shape.length).concat(e.outputs.out.shape),i=e.params.starts||[0,0,0,0],o=e.params.steps||[1,1,1,1],f=e.params.axes||[0,1,2,3],l=[0,0,0,0],_=[1,1,1,1];for(let d=0;d<f.length;d++){let g=f[d];g<0&&(g+=e.inputs.input.shape.length),g+=4-e.inputs.input.shape.length,l[g]=i[d]<0?i[d]+a[g]:i[d],_[g]=o[d]}this.api.slice_4d_f32(c,s,a[0],a[1],a[2],a[3],u[0],u[1],u[2],u[3],l[0],l[1],l[2],l[3],_[0],_[1],_[2],_[3])}else if(e.opType==="Split")this._cpuSplit(e);else if(e.opType==="Gather"){let a=[1,1,1,1].slice(0,4-e.inputs.input.shape.length).concat(e.inputs.input.shape),u=e.params.axis||0;u<0&&(u+=e.inputs.input.shape.length),u+=4-e.inputs.input.shape.length;let i=this.pointers.get(e.inputs.indices.name);this.api.gather_4d_f32(c,i,s,a[0],a[1],a[2],a[3],e.inputs.indices.sizeBytes/4,u)}else if(e.opType==="GatherElements")this._cpuGatherElements(e);else if(e.opType==="NonMaxSuppression")this._cpuNonMaxSuppression(e);else if(e.opType==="Where"||e.opType==="Mask"){let a=this.pointers.get(e.inputs.cond?e.inputs.cond.name:e.inputs.condition.name),u=this.pointers.get(e.inputs.x?e.inputs.x.name:e.inputs.a.name),i=this.pointers.get(e.inputs.y?e.inputs.y.name:e.inputs.b.name);this.api.where_f32(a,u,i,s,e.outputs.out.sizeBytes/4)}else if(e.opType==="Pad"){let a=e.params.pads,u=a.length===8?a[1]:a[0],i=a.length===8?a[2]:a[1],o=a.length===8?a[5]:a[2],f=a.length===8?a[6]:a[3],l=e.params.value||0,_=e.inputs.input?e.inputs.input.shape:e.inputs.data.shape,d=_.length===4?_:[1,_[0]||1,_[1]||1,1];this.api.pad_2d_f32(c,s,l,d[0],d[1],d[2],d[3],u,o,i,f)}else if(e.opType==="AveragePool2D"||e.opType==="AveragePool"){let[a,u,i,o]=(e.inputs.input||e.inputs.x).shape,[f,l,_]=e.outputs.out.shape,d=e.params.kernel[0],g=e.params.kernel[1],b=e.params.stride?e.params.stride[0]:1,h=e.params.stride?e.params.stride[1]:1,v=e.params.padding?e.params.padding[0]:0,x=e.params.padding?e.params.padding[1]:0;this.api.averagepool2d_f32(c,s,a,u,i,o,d,g,b,h,v,x,l,_)}else if(e.opType==="Div")this._cpuDiv(e);else if(e.opType==="MaxPool2D"){let a=e.inputs.input.shape,u=e.outputs.out.shape,i=e.params.kernel[0],o=e.params.kernel[1],f=e.params.stride[0],l=e.params.stride[1],_=e.params.padding?e.params.padding[0]:0,d=e.params.padding?e.params.padding[1]:0;this.api.maxpool2d_f32(c,s,a[1],a[2],a[3],u[1],u[2],i,o,f,l,_,d)}else if(e.opType==="MeanHeight"){let a=e.inputs.input.shape;this.api.mean_height_f32(c,s,a[3],a[1],a[2])}else e.opType==="Flatten"||e.opType==="Squeeze"||e.opType==="Unsqueeze"||e.opType==="Dropout"||e.opType==="Reshape"||e.opType==="Identity"?this._cpuReshape(e):super._runNode(e)}catch(c){throw console.error("[WasmEngine] Execution failed at node:",e,c),c}let r={};for(let e of this.graph.outputNames){let c=this.graph.tensors.get(e),s=this.pointers.get(e);r[e]=new Float32Array(this.mem.buffer,s,c.sizeBytes/4).slice()}return r}};var U,V=class{constructor(t,r){this.device=t,this.graph=r,this.pipelines=[],this.gpuBuffers=new Map,console.log("[VolvoxAI WebGPU] Starting Graph Compilation...")}async compile(){({ShaderLibrary:U}=await Promise.resolve().then(()=>(us(),is))),this._dinWeights=new Map;for(let t of this.graph.nodes)if((t.opType==="MatMul"||t.opType==="Linear"||t.opType==="Gemm")&&t.wLayout==="din"&&t.inputs.weight&&!t.inputs.scale){let r=t.inputs.input.shape[t.inputs.input.shape.length-1],e=t.outputs.out.shape[t.outputs.out.shape.length-1];this._dinWeights.set(t.inputs.weight.name,{din:r,dout:e})}this._allocateBuffers();for(let t of this.graph.nodes)await this._buildNodePipeline(t);console.log(`[VolvoxAI WebGPU] Compilation complete. Allocated ${this.gpuBuffers.size} VRAM buffers.`)}_allocateBuffers(){for(let[t,r]of this.graph.tensors.entries()){let e=GPUBufferUsage.STORAGE;this.graph.nodes.some(s=>Object.values(s.inputs).some(n=>n.name===t))&&(e|=GPUBufferUsage.COPY_DST),this.graph.nodes.some(s=>Object.values(s.outputs).some(n=>n.name===t))&&(e|=GPUBufferUsage.COPY_SRC),!r.isWeight&&!this.graph.nodes.some(s=>Object.values(s.outputs).some(n=>n.name===t))&&(e|=GPUBufferUsage.COPY_DST),r.isWeight&&r.buffer&&(e|=GPUBufferUsage.COPY_DST);let c=this.device.createBuffer({label:`Tensor_${t}`,size:Math.ceil(r.sizeBytes/4)*4,usage:e});if(r.gpuBuffer=c,this.gpuBuffers.set(t,c),r.isWeight&&r.buffer){let s=r.buffer,n=this._dinWeights&&this._dinWeights.get(t);if(n){let{din:u,dout:i}=n,o=new Float32Array(u*i);for(let f=0;f<u;f++)for(let l=0;l<i;l++)o[l*u+f]=r.buffer[f*i+l];s=o}let m=new Uint8Array(s.buffer,s.byteOffset,s.byteLength),a=Math.ceil(m.byteLength/4)*4;if(a===m.byteLength)this.device.queue.writeBuffer(c,0,m);else{let u=new Uint8Array(a);u.set(m),this.device.queue.writeBuffer(c,0,u)}}}}async _buildNodePipeline(t){let r="",e="",c=null,s=[],n=[1,1,1];if(t.opType==="Conv2D"){r=U.getConv2DShader();let i=t.inputs.input.gpuBuffer,o=t.inputs.weight.gpuBuffer,f=t.outputs.out.gpuBuffer,[l,_,d,g]=t.inputs.input.shape,[b,h]=t.inputs.weight.shape,v=t.outputs.out.shape[3],x=t.outputs.out.shape[1],y=t.outputs.out.shape[2],[w,P]=C(t.params.stride,1),[B,z]=C(t.params.padding,0),[M,q]=C(t.params.dilation,1),T=t.params.groups||1,A=Array.isArray(t.params.pads)?t.params.pads:[B,z,B,z],D=A.length>=4&&A[0]===0&&A[1]===0&&A[2]===0&&A[3]===0,G=t.params.weight_layout||(T===g?"HWCM":"HWIO");e=r,c=[Math.ceil(y/8),Math.ceil(x/8),l*v],T===1&&G==="HWIO"&&g===3&&(v&15)===0?(r=U.getConv2DRegularC3Out16Shader(),n=[Math.ceil(y/8),Math.ceil(x/8),l*(v/16)]):T===g&&G==="HWCM"&&v===g&&(v&7)===0?(r=U.getConv2DDepthwise8Shader(),n=[Math.ceil(y/8),Math.ceil(x/8),l*Math.ceil(v/8)]):T===1&&G==="HWIO"&&b===1&&h===1&&w===1&&P===1&&D&&M===1&&q===1&&x===_&&y===d&&((v&15)===0?(r=U.getConv2DPointwise16TileShader(),n=[Math.ceil(y/8),Math.ceil(x/8),l*(v/16)]):(v&3)===0?(r=U.getConv2DPointwise8Vec4Shader(),n=[Math.ceil(y/8),Math.ceil(x/8),l*Math.ceil(v/8)]):(v&1)===0&&(r=U.getConv2DPointwise8Vec2Shader(),n=[Math.ceil(y/8),Math.ceil(x/8),l*Math.ceil(v/8)]));let L=this.device.createBuffer({size:Math.ceil(v*4/4)*4,usage:GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST});t.inputs.bias&&this.device.queue.writeBuffer(L,0,t.inputs.bias.buffer);let O=new Uint32Array([l,_,d,g,v,x,y,b,h,w,P,B,z,T,t.params.relu||0,M,q]),I=this.device.createBuffer({size:Math.ceil(O.byteLength/16)*16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(I,0,O),s=[{binding:0,resource:{buffer:i}},{binding:1,resource:{buffer:o}},{binding:2,resource:{buffer:L}},{binding:3,resource:{buffer:f}},{binding:4,resource:{buffer:I}}],r===e&&(n=c)}else if(t.opType==="Conv1D"){r=U.getConv1DShader();let i=t.inputs.input.gpuBuffer,o=t.inputs.weight.gpuBuffer,f=t.outputs.out.gpuBuffer,l=this.device.createBuffer({size:Math.ceil(t.inputs.weight.shape[0]*4/4)*4||4,usage:GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST});t.inputs.bias&&this.device.queue.writeBuffer(l,0,t.inputs.bias.buffer);let _=new Uint32Array([t.inputs.input.shape[1],t.inputs.input.shape[2],t.outputs.out.shape[1],t.inputs.weight.shape[2],C(t.params.stride,1)[0],C(t.params.padding,0)[0],t.params.relu?1:0]),d=this.device.createBuffer({size:_.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(d,0,_),s=[{binding:0,resource:{buffer:i}},{binding:1,resource:{buffer:o}},{binding:2,resource:{buffer:l}},{binding:3,resource:{buffer:f}},{binding:4,resource:{buffer:d}}],n=[Math.ceil(t.outputs.out.shape[2]/64),t.outputs.out.shape[1],1]}else if(t.opType==="SpatialSoftargmaxY"){r=U.getSpatialSoftargmaxYShader();let i=t.inputs.input.gpuBuffer,o=t.outputs.out.gpuBuffer,f=new Uint32Array([t.inputs.input.shape[1],t.inputs.input.shape[2],t.inputs.input.shape[3]]),l=this.device.createBuffer({size:f.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(l,0,f),s=[{binding:0,resource:{buffer:i}},{binding:1,resource:{buffer:o}},{binding:2,resource:{buffer:l}}],n=[Math.ceil(t.inputs.input.shape[2]/64),t.inputs.input.shape[3],1]}else if(t.opType==="UpsampleNearest2D"){r=U.getUpsample2xShader();let i=t.inputs.input.gpuBuffer,o=t.outputs.out.gpuBuffer,f=new Uint32Array([t.inputs.input.shape[0],t.inputs.input.shape[1],t.inputs.input.shape[2],t.inputs.input.shape[3]]),l=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(l,0,f),s=[{binding:0,resource:{buffer:i}},{binding:1,resource:{buffer:o}},{binding:2,resource:{buffer:l}}],n=[Math.ceil(t.outputs.out.shape[2]/8),Math.ceil(t.outputs.out.shape[1]/8),t.outputs.out.shape[0]*t.outputs.out.shape[3]]}else if(t.opType==="Concat"){let i=this.device.createShaderModule({code:U.getConcatCopyShader()}),o=await this.device.createComputePipelineAsync({layout:"auto",compute:{module:i,entryPoint:"main"}}),f=0;for(let l of["input","a","b","c","d","e","f","g","h"]){let _=t.inputs[l];if(!_)continue;let d=_.sizeBytes/4,g=new Uint32Array([d,f]),b=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(b,0,g);let h=this.device.createBindGroup({layout:o.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:_.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:b}}]});this.pipelines.push({pipeline:o,bindGroup:h,workgroupCount:[Math.ceil(d/64),1,1],nodeName:`${t.id}_concat`}),f+=d}return}else if(t.opType==="ProfileY"){r=U.getProfileYShader();let i=t.inputs.input.gpuBuffer,o=t.outputs.out.gpuBuffer,f=new Uint32Array([t.inputs.input.shape[1],t.inputs.input.shape[2],t.inputs.input.shape[3]]),l=this.device.createBuffer({size:f.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(l,0,f),s=[{binding:0,resource:{buffer:i}},{binding:1,resource:{buffer:o}},{binding:2,resource:{buffer:l}}],n=[Math.ceil(t.inputs.input.shape[1]/64),t.inputs.input.shape[3],1]}else if(t.opType==="ProfileX"){r=U.getProfileXShader();let i=t.inputs.input.gpuBuffer,o=t.outputs.out.gpuBuffer,f=new Uint32Array([t.inputs.input.shape[1],t.inputs.input.shape[2],t.inputs.input.shape[3]]),l=this.device.createBuffer({size:f.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(l,0,f),s=[{binding:0,resource:{buffer:i}},{binding:1,resource:{buffer:o}},{binding:2,resource:{buffer:l}}],n=[Math.ceil(t.inputs.input.shape[2]/64),t.inputs.input.shape[3],1]}else if(t.opType==="InterpLinear1D"){r=U.getInterp1DShader();let i=t.inputs.input.gpuBuffer,o=t.outputs.out.gpuBuffer,f=new Uint32Array([t.inputs.input.shape[1],t.inputs.input.shape[2],t.params.size]),l=this.device.createBuffer({size:f.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(l,0,f),s=[{binding:0,resource:{buffer:i}},{binding:1,resource:{buffer:o}},{binding:2,resource:{buffer:l}}],n=[Math.ceil(t.params.size/64),t.inputs.input.shape[1],1]}else if(t.opType==="MatMul"){t.inputs.scale?r=U.getLinearInt8Shader():r=U.getLinearF32Shader();let i=this.device.createBuffer({size:4096,usage:GPUBufferUsage.STORAGE}),o=t.inputs.input.shape.slice(0,-1).reduce((b,h)=>b*h,1),f=t.inputs.input.shape[t.inputs.input.shape.length-1],l=t.outputs.out.shape[t.outputs.out.shape.length-1],_=new Uint32Array([o,f,l]),d=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(d,0,_);let g=t.inputs.bias?t.inputs.bias.gpuBuffer:i;s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.inputs.weight.gpuBuffer}},...t.inputs.scale?[{binding:2,resource:{buffer:t.inputs.scale.gpuBuffer}}]:[],{binding:3,resource:{buffer:g}},{binding:4,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:5,resource:{buffer:d}}],n=[Math.ceil(l/64),o,1]}else if(t.opType==="LayerNorm"){r=U.getLayerNormShader();let i=t.params.d_model,o=t.inputs.input.shape.slice(0,-1).reduce((_,d)=>_*d,1),f=new Uint32Array([o,i]),l=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(l,0,f),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.inputs.weight.gpuBuffer}},{binding:2,resource:{buffer:t.inputs.bias.gpuBuffer}},{binding:3,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:4,resource:{buffer:l}}],n=[Math.ceil(o/64),1,1]}else if(t.opType==="GELU"){r=U.getGELUShader();let i=t.outputs.out.shape.reduce((f,l)=>f*l,1),o=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(o,0,new Uint32Array([i])),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:o}}],n=[Math.ceil(i/64),1,1]}else if(t.opType==="Embedding"){r=U.getEmbeddingShader();let i=t.inputs.input.shape.reduce((_,d)=>_*d,1),o=t.outputs.out.shape[t.outputs.out.shape.length-1],f=new Uint32Array([i,o]),l=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(l,0,f),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.inputs.weight.gpuBuffer}},{binding:2,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:3,resource:{buffer:l}}],n=[Math.ceil(i/64),1,1]}else if(t.opType==="SDPA"){r=U.getSDPAShader();let i=t.inputs.qkv.shape[1],o=t.outputs.out.shape[2],f=t.params.heads||8,l=o/f,_=t.params.scale!==void 0?t.params.scale:1/Math.sqrt(l),d=new ArrayBuffer(20),g=new Uint32Array(d),b=new Float32Array(d);g[0]=i,g[1]=o,g[2]=f,g[3]=l,b[4]=_;let h=this.device.createBuffer({size:32,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(h,0,d),s=[{binding:0,resource:{buffer:t.inputs.qkv.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:h}}],n=[Math.ceil(i/64),f,1]}else if(t.opType==="CrossSDPA"){r=U.getCrossSDPAShader();let i=t.inputs.q.shape[1],o=t.inputs.k.shape[1],f=t.inputs.q.shape[2],l=t.params.heads||8,_=f/l,d=1/Math.sqrt(_),g=new ArrayBuffer(24),b=new Uint32Array(g),h=new Float32Array(g);b[0]=i,b[1]=o,b[2]=f,b[3]=l,b[4]=_,h[5]=d;let v=this.device.createBuffer({size:32,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(v,0,g),s=[{binding:0,resource:{buffer:t.inputs.q.gpuBuffer}},{binding:1,resource:{buffer:t.inputs.k.gpuBuffer}},{binding:2,resource:{buffer:t.inputs.v.gpuBuffer}},{binding:3,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:4,resource:{buffer:v}}],n=[Math.ceil(i/64),l,1]}else if(t.opType==="CrossAttention"){r=U.getCrossAttentionShader();let i=t.inputs.q.shape[1],o=t.inputs.kv.shape[1],f=t.outputs.out.shape[2],l=t.params.heads||8,_=f/l,d=1/Math.sqrt(_),g=new ArrayBuffer(32),b=new Uint32Array(g),h=new Float32Array(g);b[0]=i,b[1]=o,b[2]=f,b[3]=l,b[4]=_,h[5]=d,b[6]=t.inputs.scale?1:0,b[7]=t.inputs.bias?1:0;let v=this.device.createBuffer({size:32,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(v,0,g);let x=this.device.createBuffer({size:4096,usage:GPUBufferUsage.STORAGE}),y=this.device.createBuffer({size:4096,usage:GPUBufferUsage.STORAGE});s=[{binding:0,resource:{buffer:t.inputs.q.gpuBuffer}},{binding:1,resource:{buffer:t.inputs.kv.gpuBuffer}},{binding:2,resource:{buffer:t.inputs.weight.gpuBuffer}},{binding:3,resource:{buffer:t.inputs.scale?t.inputs.scale.gpuBuffer:x}},{binding:4,resource:{buffer:t.inputs.bias?t.inputs.bias.gpuBuffer:y}},{binding:5,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:6,resource:{buffer:v}}],n=[Math.ceil(i/64),l,1]}else if(t.opType==="MeanHeight"){r=U.getMeanHeightShader();let i=new Uint32Array([t.inputs.input.shape[1],t.inputs.input.shape[2],t.inputs.input.shape[3]]),o=this.device.createBuffer({size:Math.ceil(i.byteLength/16)*16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(o,0,i),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:o}}],n=[Math.ceil(t.inputs.input.shape[2]/64),t.inputs.input.shape[3],1]}else if(t.opType==="ReLU"||t.opType==="Sigmoid"||t.opType==="HardSwish"||t.opType==="HardSigmoid"||t.opType==="SiLU"||t.opType==="Swish"||t.opType==="Tanh"||t.opType==="Reshape"||t.opType==="Squeeze"||t.opType==="Unsqueeze"||t.opType==="Flatten"||t.opType==="Dropout"||t.opType==="Identity"){t.opType==="ReLU"?r=U.getReLUShader():t.opType==="Sigmoid"?r=U.getSigmoidShader():t.opType==="HardSwish"?r=U.getHardSwishShader():t.opType==="HardSigmoid"?r=U.getHardSigmoidShader():t.opType==="SiLU"||t.opType==="Swish"?r=U.getSiLUShader():t.opType==="Tanh"?r=U.getTanhShader():r=U.getCopyShader();let i=t.outputs.out.shape.reduce((l,_)=>l*_,1),o=new Uint32Array([i]),f=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(f,0,o),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:f}}],n=[Math.ceil(i/64),1,1]}else if(t.opType==="Add"||t.opType==="Mul"||t.opType==="Sub"||t.opType==="Div"){let i={Add:"out_val = av + bv;",Mul:"out_val = av * bv;",Sub:"out_val = av - bv;",Div:"out_val = av / bv;"}[t.opType];r=U.getBroadcastBinaryShader(i);let o=t.outputs.out.shape,f=o.length,l=y=>{let w=new Array(y.length),P=1;for(let B=y.length-1;B>=0;B--)w[B]=P,P*=y[B];return w},_=l(o),d=y=>{let w=new Array(f).fill(1);for(let B=0;B<y.length;B++)w[f-y.length+B]=y[B];let P=l(w);for(let B=0;B<f;B++)w[B]===1&&o[B]!==1&&(P[B]=0);return P},g=d(t.inputs.a.shape),b=d(t.inputs.b.shape),h=o.reduce((y,w)=>y*w,1),v=new Uint32Array(2+f*3);v[0]=h,v[1]=f;for(let y=0;y<f;y++)v[2+y]=_[y],v[2+f+y]=g[y],v[2+2*f+y]=b[y];let x=this.device.createBuffer({size:Math.ceil(v.byteLength/4)*4,usage:GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(x,0,v),s=[{binding:0,resource:{buffer:t.inputs.a.gpuBuffer}},{binding:1,resource:{buffer:t.inputs.b.gpuBuffer}},{binding:2,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:3,resource:{buffer:x}}],n=[Math.ceil(h/64),1,1]}else if(t.opType==="Transpose"){r=U.getGeneralTransposeShader();let i=t.inputs.input.shape,o=i.length,f=t.params.perm||[...Array(o).keys()].reverse(),l=new Array(o);{let v=1;for(let x=o-1;x>=0;x--)l[x]=v,v*=i[x]}let _=f.map(v=>i[v]),d=new Array(o);{let v=1;for(let x=o-1;x>=0;x--)d[x]=v,v*=_[x]}let g=i.reduce((v,x)=>v*x,1),b=new Uint32Array(2+o*2);b[0]=g,b[1]=o;for(let v=0;v<o;v++)b[2+v]=d[v],b[2+o+v]=l[f[v]];let h=this.device.createBuffer({size:Math.ceil(b.byteLength/4)*4,usage:GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(h,0,b),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:h}}],n=[Math.ceil(g/64),1,1]}else if(t.opType==="Softmax"||t.opType==="LogSoftmax"){r=t.opType==="Softmax"?U.getSoftmaxShader():U.getLogSoftmaxShader();let i=t.inputs.input.shape,o=i[i.length-1],f=i.reduce((d,g)=>d*g,1)/o;if(t.params.axis!==void 0){let d=t.params.axis;d<0&&(d+=i.length),d!==i.length-1&&console.warn(`[VolvoxAI WebGPU] ${t.opType} axis ${t.params.axis} != last; using last-axis.`)}let l=new Uint32Array([f,o]),_=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(_,0,l),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:_}}],n=[Math.ceil(f/64),1,1]}else if(t.opType==="LeakyReLU"){r=U.getLeakyReLUShader();let i=t.outputs.out.shape.reduce((_,d)=>_*d,1),o=t.params.alpha!==void 0?t.params.alpha:.01,f=new ArrayBuffer(16);new Uint32Array(f,0,1)[0]=i,new Float32Array(f,4,1)[0]=o;let l=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(l,0,f),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:l}}],n=[Math.ceil(i/64),1,1]}else if(t.opType==="PReLU"){r=U.getPReLUShader();let i=t.inputs.input.shape,o=i[i.length-1]||1,f=i.reduce((d,g)=>d*g,1),l=new Uint32Array([f,o]),_=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(_,0,l),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.inputs.weight.gpuBuffer}},{binding:2,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:3,resource:{buffer:_}}],n=[Math.ceil(f/64),1,1]}else if(t.opType==="RMSNorm"){r=U.getRMSNormShader();let i=t.inputs.input.shape,o=t.params.d_model||i[i.length-1],f=i.reduce((g,b)=>g*b,1)/o,l=t.params.eps!==void 0?t.params.eps:1e-6,_=new ArrayBuffer(16);new Uint32Array(_,0,2).set([f,o]),new Float32Array(_,8,1)[0]=l;let d=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(d,0,_),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.inputs.weight.gpuBuffer}},{binding:2,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:3,resource:{buffer:d}}],n=[Math.ceil(f/64),1,1]}else if(t.opType==="GlobalAveragePool"){r=U.getGlobalAveragePoolShader();let i=t.inputs.input.shape,o=i[0],f=i[1]||1,l=i[2]||1,_=i[3]||1,d=new Uint32Array([o,f,l,_]),g=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(g,0,d),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:g}}],n=[Math.ceil(_/64),o,1]}else if(t.opType==="BatchNorm2D"){r=U.getBatchNorm2DShader();let[i,o,f,l]=t.inputs.input.shape,_=t.params.eps!==void 0?t.params.eps:1e-5,d=new ArrayBuffer(32);new Uint32Array(d,0,4).set([i,l,o,f]),new Float32Array(d,16,1)[0]=_;let g=this.device.createBuffer({size:32,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(g,0,d),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.inputs.weight.gpuBuffer}},{binding:2,resource:{buffer:t.inputs.bias.gpuBuffer}},{binding:3,resource:{buffer:t.inputs.running_mean.gpuBuffer}},{binding:4,resource:{buffer:t.inputs.running_var.gpuBuffer}},{binding:5,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:6,resource:{buffer:g}}],n=[Math.ceil(i*l*o*f/64),1,1]}else if(t.opType==="Resize"||t.opType==="ResizeNearest2D"){r=U.getResizeShader();let[i,o,f,l]=t.inputs.input.shape,[,_,d]=t.outputs.out.shape,g=t.opType==="ResizeNearest2D"||t.params.mode==="nearest"?0:1,b=new Uint32Array([i,o,f,l,_,d,g,0]),h=this.device.createBuffer({size:32,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(h,0,b),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:h}}],n=[Math.ceil(d/8),Math.ceil(_/8),i*l]}else if(t.opType==="Split"){let i=t.inputs.input.shape,o=t.params.axis||0;o<0&&(o+=i.length);let f=Object.keys(t.outputs).sort(),l=f.length,_=i[o]/l,d=1;for(let h=o+1;h<i.length;h++)d*=i[h];let g=this.device.createShaderModule({code:U.getSplitShader()}),b=await this.device.createComputePipelineAsync({layout:"auto",compute:{module:g,entryPoint:"main"}});for(let h=0;h<l;h++){let v=t.outputs[f[h]],x=v.shape.reduce((B,z)=>B*z,1),y=new Uint32Array([x,d,_,i[o],h*_]),w=this.device.createBuffer({size:32,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(w,0,y);let P=this.device.createBindGroup({layout:b.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:v.gpuBuffer}},{binding:2,resource:{buffer:w}}]});this.pipelines.push({pipeline:b,bindGroup:P,workgroupCount:[Math.ceil(x/64),1,1],nodeName:`${t.id}_split${h}`})}return}else if(t.opType==="Clip"){r=U.getClipShader();let i=t.inputs.input.sizeBytes/4,o=t.params.min!==void 0?t.params.min:-1e9,f=t.params.max!==void 0?t.params.max:1e9;t.inputs.min&&(o=new Float32Array(t.inputs.min.buffer)[0]),t.inputs.max&&(f=new Float32Array(t.inputs.max.buffer)[0]);let l=new Float32Array([0,o,f,0]);new Uint32Array(l.buffer)[0]=i;let _=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(_,0,l),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:_}}],n=[Math.ceil(i/64),1,1]}else if(t.opType==="MaxPool2D"){r=U.getMaxPool2DShader();let[i,o]=C(t.params.kernel,1),[f,l]=C(t.params.stride,1),_=t.params.padding?t.params.padding[0]:0,d=t.params.padding?t.params.padding[1]:0,g=new Uint32Array([t.inputs.input.shape[1],t.inputs.input.shape[2],t.inputs.input.shape[3],t.outputs.out.shape[1],t.outputs.out.shape[2],i,o,f,l,_,d]),b=this.device.createBuffer({size:Math.ceil(g.byteLength/16)*16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(b,0,g),s=[{binding:0,resource:{buffer:t.inputs.input.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:b}}],n=[Math.ceil(t.outputs.out.shape[2]/8),Math.ceil(t.outputs.out.shape[1]/8),t.outputs.out.shape[3]]}else if(t.opType==="Cast"){r=U.getCopyShader();let i=t.inputs.input||t.inputs.data,o=t.outputs.out.shape.reduce((l,_)=>l*_,1),f=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(f,0,new Uint32Array([o])),s=[{binding:0,resource:{buffer:i.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:f}}],n=[Math.ceil(o/64),1,1]}else if(t.opType==="Where"||t.opType==="Mask"){r=U.getWhereShader();let i=t.inputs.cond||t.inputs.condition,o=t.inputs.x||t.inputs.a,f=t.inputs.y||t.inputs.b,l=t.outputs.out.shape.reduce((d,g)=>d*g,1),_=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(_,0,new Uint32Array([l])),s=[{binding:0,resource:{buffer:i.gpuBuffer}},{binding:1,resource:{buffer:o.gpuBuffer}},{binding:2,resource:{buffer:f.gpuBuffer}},{binding:3,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:4,resource:{buffer:_}}],n=[Math.ceil(l/64),1,1]}else if(t.opType==="DequantizeLinear"){r=U.getDequantizeLinearShader();let i=t.inputs.input||t.inputs.x,o=t.outputs.out.shape.reduce((d,g)=>d*g,1),f=t.inputs.zero_point?1:0,l=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(l,0,new Uint32Array([o,f]));let _=this.device.createBuffer({size:16,usage:GPUBufferUsage.STORAGE});s=[{binding:0,resource:{buffer:i.gpuBuffer}},{binding:1,resource:{buffer:t.inputs.scale.gpuBuffer}},{binding:2,resource:{buffer:f?t.inputs.zero_point.gpuBuffer:_}},{binding:3,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:4,resource:{buffer:l}}],n=[Math.ceil(o/64),1,1]}else if(t.opType==="Expand"||t.opType==="Broadcast"){r=U.getExpandShader();let i=t.inputs.input||t.inputs.data,o=w=>[1,1,1,1].slice(0,4-w.length).concat(w),[f,l,_,d]=o(i.shape),[g,b,h,v]=o(t.outputs.out.shape),x=new Uint32Array([f,l,_,d,g,b,h,v]),y=this.device.createBuffer({size:32,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(y,0,x),s=[{binding:0,resource:{buffer:i.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:y}}],n=[Math.ceil(g*b*h*v/64),1,1]}else if(t.opType==="Pad"){r=U.getPadShader();let i=t.inputs.input||t.inputs.data,o=t.params.pads||[],f=o.length===8?o[1]:o[0]||0,l=o.length===8?o[2]:o[1]||0,_=t.params.value||0,d=[1,1,1,1].slice(0,4-i.shape.length).concat(i.shape),g=[1,1,1,1].slice(0,4-t.outputs.out.shape.length).concat(t.outputs.out.shape),b=new ArrayBuffer(48),h=new Uint32Array(b),v=new Float32Array(b);h[0]=d[0],h[1]=d[1],h[2]=d[2],h[3]=d[3],h[4]=g[1],h[5]=g[2],h[6]=f,h[7]=l,v[8]=_;let x=this.device.createBuffer({size:48,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(x,0,b),s=[{binding:0,resource:{buffer:i.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:x}}],n=[Math.ceil(g[0]*g[1]*g[2]*g[3]/64),1,1]}else if(t.opType==="Slice"){r=U.getSliceShader();let i=t.inputs.input||t.inputs.data,o=t.params.starts||[0,0,0,0],f=t.params.steps||[1,1,1,1],l=t.params.axes||[0,1,2,3],_=[1,1,1,1].slice(0,4-i.shape.length).concat(i.shape),d=[1,1,1,1].slice(0,4-t.outputs.out.shape.length).concat(t.outputs.out.shape),g=[0,0,0,0],b=[1,1,1,1];for(let y=0;y<l.length;y++){let w=l[y];w<0&&(w+=i.shape.length),w+=4-i.shape.length,g[w]=o[y]<0?o[y]+_[w]:o[y],b[w]=f[y]}let h=d[0]*d[1]*d[2]*d[3],v=new Uint32Array([d[0],d[1],d[2],d[3],_[1],_[2],_[3],g[0],g[1],g[2],g[3],b[0],b[1],b[2],b[3],h]),x=this.device.createBuffer({size:64,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(x,0,v),s=[{binding:0,resource:{buffer:i.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:x}}],n=[Math.ceil(h/64),1,1]}else if(t.opType==="Gather"){let i=t.params.axis||0;if(i<0&&(i+=t.inputs.input.shape.length),i!==0){console.warn(`[VolvoxAI WebGPU] Gather axis ${i} not supported on GPU; node ${t.id} skipped (use WASM/CPU).`);return}r=U.getGatherShader();let o=t.inputs.input,f=o.shape.slice(1).reduce((d,g)=>d*g,1)||1,l=t.outputs.out.shape.reduce((d,g)=>d*g,1),_=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(_,0,new Uint32Array([f,l/f,l])),s=[{binding:0,resource:{buffer:o.gpuBuffer}},{binding:1,resource:{buffer:t.inputs.indices.gpuBuffer}},{binding:2,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:3,resource:{buffer:_}}],n=[Math.ceil(l/64),1,1]}else if(t.opType==="ReduceSum"||t.opType==="ReduceMean"){r=U.getReduceShader();let i=t.inputs.input||t.inputs.data,o=i.shape.length===2?i.shape:[1,i.shape.reduce((b,h)=>b*h,1)],f=o[0],l=o[1],_=t.opType==="ReduceMean"?1/l:1,d=new ArrayBuffer(16);new Uint32Array(d,0,2).set([f,l]),new Float32Array(d,8,1)[0]=_;let g=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(g,0,d),s=[{binding:0,resource:{buffer:i.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:g}}],n=[Math.ceil(f/64),1,1]}else if(t.opType==="AveragePool"||t.opType==="AveragePool2D"){r=U.getAveragePool2DShader();let i=t.inputs.input||t.inputs.x,[o,f,l,_]=i.shape,[,d,g]=t.outputs.out.shape,[b,h]=C(t.params.kernel,1),[v,x]=C(t.params.stride,1),y=t.params.padding?t.params.padding[0]:0,w=t.params.padding?t.params.padding[1]:0,P=new Uint32Array([o,f,l,_,d,g,b,h,v,x,y,w]),B=this.device.createBuffer({size:48,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(B,0,P),s=[{binding:0,resource:{buffer:i.gpuBuffer}},{binding:1,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:2,resource:{buffer:B}}],n=[Math.ceil(g/8),Math.ceil(d/8),o*_]}else if(t.opType==="ConvTranspose2D"){r=U.getConvTranspose2DShader();let i=t.inputs.input||t.inputs.x,[o,f,l,_]=i.shape,[,d,g,b]=t.outputs.out.shape,h=t.params.kernel[0],v=t.params.kernel[1],x=t.params.stride?t.params.stride[0]:1,y=t.params.stride?t.params.stride[1]:1,w=t.params.padding?t.params.padding[0]:0,P=t.params.padding?t.params.padding[1]:0,B=t.inputs.bias?1:0,z=new Uint32Array([o,f,l,_,d,g,b,h,v,x,y,w,P,B]),M=this.device.createBuffer({size:64,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});this.device.queue.writeBuffer(M,0,z);let q=this.device.createBuffer({size:16,usage:GPUBufferUsage.STORAGE});s=[{binding:0,resource:{buffer:i.gpuBuffer}},{binding:1,resource:{buffer:t.inputs.weight.gpuBuffer}},{binding:2,resource:{buffer:B?t.inputs.bias.gpuBuffer:q}},{binding:3,resource:{buffer:t.outputs.out.gpuBuffer}},{binding:4,resource:{buffer:M}}],n=[Math.ceil(g/8),Math.ceil(d/8),o*b]}else{console.warn(`[VolvoxAI WebGPU] Shader for ${t.opType} not implemented yet in Executor.`);return}if(!r){console.warn(`[VolvoxAI WebGPU] ${t.opType} has no native GPU shader; node ${t.id} skipped.`);return}(isNaN(n[0])||isNaN(n[1])||isNaN(n[2])||n[0]<=0||n[1]<=0||n[2]<=0)&&(console.error(`Invalid workgroupCount [${n}] for node ${t.id} (${t.opType})`),n=[1,1,1]);let m=this.device.createShaderModule({code:r}),a;try{a=await this.device.createComputePipelineAsync({layout:"auto",compute:{module:m,entryPoint:"main"}})}catch(i){if(!e||e===r||!c)throw i;console.warn(`[VolvoxAI WebGPU] Specialized shader for ${t.id} failed; falling back to generic Conv2D.`,i),r=e,n=c,m=this.device.createShaderModule({code:r}),a=await this.device.createComputePipelineAsync({layout:"auto",compute:{module:m,entryPoint:"main"}})}let u=this.device.createBindGroup({layout:a.getBindGroupLayout(0),entries:s});this.pipelines.push({pipeline:a,bindGroup:u,workgroupCount:n,nodeName:t.id})}async execute(t){for(let[n,m]of Object.entries(t)){let a=this.gpuBuffers.get(n);a&&this.device.queue.writeBuffer(a,0,m.buffer,m.byteOffset,m.byteLength)}let r=this.device.createCommandEncoder(),e=r.beginComputePass();for(let n=0;n<this.pipelines.length;n++){let m=this.pipelines[n];e.setPipeline(m.pipeline),e.setBindGroup(0,m.bindGroup),e.dispatchWorkgroups(m.workgroupCount[0],m.workgroupCount[1],m.workgroupCount[2]),(n+1)%20===0&&(e.end(),this.device.queue.submit([r.finish()]),r=this.device.createCommandEncoder(),e=r.beginComputePass())}e.end(),this.device.queue.submit([r.finish()]);let c=this.graph.nodes[this.graph.nodes.length-1],s=Object.keys(c.outputs)[0];return this.gpuBuffers.get(c.outputs[s].name)}async readBuffer(t,r){let e=this.device.createBuffer({size:r,usage:GPUBufferUsage.MAP_READ|GPUBufferUsage.COPY_DST}),c=this.device.createCommandEncoder();c.copyBufferToBuffer(t,0,e,0,r),this.device.queue.submit([c.finish()]),await e.mapAsync(GPUMapMode.READ);let s=new Float32Array(e.getMappedRange().slice(0));return e.unmap(),s}};var H=class p{static async load(t,r){let e;r.endsWith("_weights.safetensors")?e=r.replace("_weights.safetensors","_config.json"):e=r.replace(/\/[^\/]+$/,"/config.json"),console.log(`[VolvoxAI] Loading config from ${e}...`);let c=await fetch(e);if(!c.ok)throw new Error(`Failed to load config.json: ${c.statusText}`);let s=await c.json();console.log(`[VolvoxAI] Loading Safetensors model from ${r}...`);let n=await fetch(r);if(!n.ok)throw new Error(`Failed to load safetensors: ${n.statusText}`);let m=await n.arrayBuffer(),a=new DataView(m),u=Number(a.getBigUint64(0,!0)),i=new Uint8Array(m,8,u),o=new TextDecoder("utf-8").decode(i),f=JSON.parse(o),l=f.__metadata__||{},_=8+u,d=new Map;for(let[h,v]of Object.entries(f)){if(h==="__metadata__")continue;let x=v.dtype==="I8"?"int8":v.dtype==="U8"?"uint8":"float32",y=t.addWeight(h,v.shape,x),w=_+v.data_offsets[0],P=v.data_offsets[1]-v.data_offsets[0];x==="int8"?y.buffer=new Int8Array(m,w,P):x==="uint8"?y.buffer=new Uint8Array(m,w,P):v.dtype==="F16"?y.buffer=p._float16ToFloat32Array(m,w,P):y.buffer=new Float32Array(m,w,P/4),d.set(h,y)}if(s.inputs){let h=s.inputs;for(let[v,x]of Object.entries(h)){let y=t.addInput(v,x.shape,x.dtype||"float32");d.set(v,y)}}if(s.nodes)p._buildFromBlueprint(t,s,d);else if(s.model_type){if(typeof p.ModelBuilders>"u"||!p.ModelBuilders[s.model_type])throw new Error(`[VolvoxAI] Unsupported Hugging Face model_type: '${s.model_type}'. No builder registered.`);console.log(`[VolvoxAI] Building graph on the fly using model builder for '${s.model_type}'...`),p.ModelBuilders[s.model_type](t,s,d)}else throw new Error("[VolvoxAI] config.json must contain either 'nodes' (Volvox blueprint) or 'model_type' (Hugging Face).");p._dequantizeConvWeights(t),p._normalizeConvWeightsForImageLayout(t);let g=new Set;for(let h of t.nodes)for(let v of Object.values(h.inputs))v&&v.name&&g.add(v.name);let b=[];for(let h of t.nodes)for(let v of Object.values(h.outputs))v&&v.name&&!g.has(v.name)&&b.push(v.name);return t.outputNames=b,p._resolveMatMulLayouts(t),console.log("[VolvoxAI] Successfully assembled graph. Outputs:",b),t}static _resolveMatMulLayouts(t){let r=m=>m.opType==="MatMul"||m.opType==="Linear"||m.opType==="Gemm",e=m=>{let a=m.inputs.input?.shape?.[m.inputs.input.shape.length-1],u=Object.values(m.outputs)[0],i=u?.shape?.[u.shape.length-1];return[a,i]},c=0,s=0;for(let m of t.nodes){if(!r(m)||!m.inputs.weight||m.inputs.scale)continue;let a=m.inputs.weight.shape;if(!a||a.length<2)continue;let[u,i]=e(m);u!==i&&(a[0]===i&&a[1]===u?s++:a[0]===u&&a[1]===i&&c++)}let n=c>s?"din":"dout";for(let m of t.nodes){if(!r(m))continue;let a=m.inputs.weight?.shape,[u,i]=e(m);m.inputs.scale||a&&a.length>=2&&u!==i&&a[0]===i&&a[1]===u?m.wLayout="dout":a&&a.length>=2&&u!==i&&a[0]===u&&a[1]===i?m.wLayout="din":m.wLayout=n}}static _buildFromBlueprint(t,r,e){let c=r.nodes;for(let s of c){let n={};for(let[i,o]of Object.entries(s.inputs)){let f=e.get(o)||t.tensors.get(o);f||(console.warn(`[GraphLoader] Implicitly adding missing graph input '${o}' with shape [1, 3, 224, 224]`),f=t.addInput(o,[1,3,224,224],"float32"),e.set(o,f)),n[i]=f}let m=s.outputs_shape||{},a=s.opType||s.op,u=t.addOp(a,n,m,s.params||{});for(let[i,o]of Object.entries(s.outputs)){let f=u[i];f&&(f.name!==o&&(t.tensors.delete(f.name),f.name=o,t.tensors.set(o,f)),e.set(o,f))}}}static ModelBuilders={};static _float16ToFloat32Array(t,r,e){let c=e/2,s=new DataView(t,r,e),n=new Float32Array(c);for(let m=0;m<c;m++)n[m]=p._float16BitsToFloat32(s.getUint16(m*2,!0));return n}static _float16BitsToFloat32(t){let r=t&32768?-1:1,e=t>>10&31,c=t&1023;return e===0?c===0?r<0?-0:0:r*Math.pow(2,-14)*(c/1024):e===31?c?NaN:r*(1/0):r*Math.pow(2,e-15)*(1+c/1024)}static _dequantizeConvWeights(t){for(let r of t.nodes){if(r.opType!=="Conv2D"&&r.opType!=="Conv1D"&&r.opType!=="QConv2D")continue;let e=r.inputs.weight,c=r.inputs.scale||r.inputs.weight_scale;if(!c||!e||e.dtype!=="int8"||!e.buffer)continue;let s=r.inputs.weight_zero_point,n=e.shape[0],m=e.buffer.length/n,a=new Float32Array(e.buffer.length);for(let u=0;u<n;u++){let i=c.buffer[u],o=s&&s.buffer?s.buffer[s.buffer.length===1?0:u]:0,f=u*m;for(let l=0;l<m;l++)a[f+l]=(e.buffer[f+l]-o)*i}if(r.opType==="QConv2D"){let u=t.addWeight(`${e.name}__deq_${r.id}`,e.shape,"float32");u.buffer=a,u.sizeBytes=a.length*4,r.inputs.weight=u}else e.buffer=a,e.dtype="float32",e.sizeBytes=a.length*4;delete r.inputs.scale,delete r.inputs.weight_scale,delete r.inputs.weight_zero_point,r.opType==="QConv2D"&&(r.opType="Conv2D")}}static _normalizeConvWeightsForImageLayout(t){for(let r of t.nodes){if(r.opType!=="Conv2D")continue;let e=r.inputs.weight,c=r.inputs.input,s=r.outputs.out;if(!e||!e.buffer||!c||!s||e.shape.length!==4)continue;let n=r.params?.weight_layout||"HWIO";if(!(n==="HWIO"||n==="HWCM"))if(n==="OHWI"||n==="OIHW"){let[m,a,u,i]=e.shape,o=n==="OHWI"?a:u,f=n==="OHWI"?u:i,l=n==="OHWI"?i:a,_=e.buffer,d=new Float32Array(_.length);for(let g=0;g<m;g++)for(let b=0;b<o;b++)for(let h=0;h<f;h++)for(let v=0;v<l;v++)d[((b*f+h)*l+v)*m+g]=n==="OHWI"?_[((g*o+b)*f+h)*l+v]:_[((g*l+v)*o+b)*f+h];e.buffer=d,e.shape=[o,f,l,m],e.sizeBytes=d.length*4,r.params.weight_layout="HWIO"}else if(n==="1HWO"||n==="1HWM"){let[,m,a,u]=e.shape,i=c.shape[3],o=s.shape[3]/i;if(!Number.isInteger(o)||o<=0||i*o!==u)throw new Error(`[GraphLoader] Invalid depthwise Conv2D shape for node ${r.id}`);let f=e.buffer,l=new Float32Array(f.length);for(let _=0;_<m;_++)for(let d=0;d<a;d++)for(let g=0;g<i;g++)for(let b=0;b<o;b++)l[((_*a+d)*i+g)*o+b]=f[(_*a+d)*u+g*o+b];e.buffer=l,e.shape=[m,a,i,o],e.sizeBytes=l.length*4,r.params.weight_layout="HWCM"}else throw new Error(`[GraphLoader] Unsupported Conv2D weight_layout '${n}'. VolvoxAI uses NHWC/HWIO only.`)}}};var K=class{constructor(t){this.context=t,this.graph=null,this.compiledGraph=null,this.operands={},this.inputs=[],this.outputs=[]}async allocateGraph(t){this.graph=t,this.operands={},this.inputs=[],this.outputs=[];let r=new MLGraphBuilder(this.context),e=a=>{let u=a.length?a:[1];return{dataType:"float32",type:"float32",shape:u,dimensions:u}},c=new Set;for(let a of t.nodes)for(let u of Object.values(a.outputs))u&&u.name&&c.add(u.name);for(let a of t.tensors.values())a.isWeight&&a.buffer?(this.operands[a.name]=r.constant(e(a.shape),a.buffer),c.add(a.name)):c.has(a.name)||(this.inputs.push(a.name),this.operands[a.name]=r.input(a.name,e(a.shape)),c.add(a.name));let s=a=>((!a||!this.operands[a])&&(console.warn(`[WebNN] missing operand: ${a}`),this.operands[a]=r.constant(e([1]),new Float32Array([0]))),this.operands[a]),n=(a,u)=>a.inputs[u]?a.inputs[u].name:null;for(let a of t.nodes){let u=a.opType,i=Object.values(a.outputs)[0].name;try{if(u==="MatMul"||u==="Linear"||u==="Gemm"){let o=s(n(a,"input")||n(a,"a")),f=s(n(a,"weight")||n(a,"b")),l=a.wLayout==="dout"?r.gemm(o,f,{bTranspose:!0}):r.matmul(o,f);n(a,"bias")&&(l=r.add(l,s(n(a,"bias")))),this.operands[i]=l}else if(u==="Add")this.operands[i]=r.add(s(n(a,"a")||n(a,"input")),s(n(a,"b")));else if(u==="Mul")this.operands[i]=r.mul(s(n(a,"a")||n(a,"input")),s(n(a,"b")));else if(u==="ReLU")this.operands[i]=r.relu(s(n(a,"input")));else if(u==="GELU")this.operands[i]=r.gelu(s(n(a,"input")));else if(u==="SiLU"||u==="Swish"){let o=s(n(a,"input"));this.operands[i]=r.mul(o,r.sigmoid(o))}else if(u==="Sigmoid")this.operands[i]=r.sigmoid(s(n(a,"input")));else if(u==="Softmax")this.operands[i]=r.softmax(s(n(a,"input")));else if(u==="Reshape"||u==="Flatten"){let o=Object.values(a.outputs)[0].shape;this.operands[i]=r.reshape(s(n(a,"input")),o.length?o:[1])}else if(u==="LayerNorm"){let o=s(n(a,"input")),f=n(a,"weight")?s(n(a,"weight")):void 0,l=n(a,"bias")?s(n(a,"bias")):void 0,_=a.inputs.input.shape;this.operands[i]=r.layerNormalization(o,{axes:[_.length-1],scale:f,bias:l})}else if(u==="Conv2D")this.operands[i]=r.conv2d(s(n(a,"input")),s(n(a,"weight")),{bias:n(a,"bias")?s(n(a,"bias")):void 0,strides:a.params.stride,padding:a.params.padding,groups:a.params.groups||1});else if(u==="Embedding"){let o=r.cast(s(n(a,"input")),"int32");this.operands[i]=r.gather(s(n(a,"weight")),o,{axis:0})}else if(u==="SDPA"){let o=a.inputs.qkv,f=o.shape[1],l=Math.floor(o.shape[2]/3),_=a.params.heads||8,d=Math.floor(l/_),g=a.params.scale!==void 0?a.params.scale:1/Math.sqrt(d),b=r.reshape(s(n(a,"qkv")),[f,3*l]),h=r.slice(b,[0,0],[f,l]),v=r.slice(b,[0,l],[f,l]),x=r.slice(b,[0,2*l],[f,l]),y=A=>r.transpose(r.reshape(A,[f,_,d]),{permutation:[1,0,2]}),w=y(h),P=y(x),B=r.transpose(r.reshape(v,[f,_,d]),{permutation:[1,2,0]}),z=r.matmul(w,B);z=r.mul(z,r.constant(e([1]),new Float32Array([g])));let M=new Float32Array(f*f);for(let A=0;A<f;A++)for(let D=0;D<f;D++)M[A*f+D]=D<=A?0:-1e9;z=r.add(z,r.constant(e([f,f]),M));let q=r.softmax(z,2),T=r.matmul(q,P);T=r.transpose(T,{permutation:[1,0,2]}),this.operands[i]=r.reshape(T,[1,f,l])}else throw new Error(`Unsupported op in WebNNEngine: ${u}`)}catch(o){throw console.warn(`[WebNN] cannot map op ${u}: ${o.message}`),o}}let m={};for(let a of t.outputNames)this.operands[a]&&(m[a]=this.operands[a],this.outputs.push(a));return console.log("[WebNN] building graph, outputs:",this.outputs),this.compiledGraph=await r.build(m),console.log("[WebNN] graph compiled."),this}async execute(t){if(!this.compiledGraph)throw new Error("WebNN graph not compiled.");let r=this.context,e=a=>{let u=this.graph.tensors.get(a);return u?u.shape.reduce((i,o)=>i*o,1):1},c=a=>{let u=this.graph.tensors.get(a);return u&&u.shape.length?u.shape:[1]};if(typeof r.compute=="function"){let a={},u={};for(let i of this.inputs)a[i]=t[i]||new Float32Array(e(i));for(let i of this.outputs)u[i]=new Float32Array(e(i));return(await r.compute(this.compiledGraph,a,u)).outputs}let s={},n={};for(let a of this.inputs){let u=await r.createTensor({dataType:"float32",shape:c(a),dimensions:c(a),writable:!0});r.writeTensor(u,t[a]||new Float32Array(e(a))),s[a]=u}for(let a of this.outputs)n[a]=await r.createTensor({dataType:"float32",shape:c(a),dimensions:c(a),readable:!0});r.dispatch(this.compiledGraph,s,n);let m={};for(let a of this.outputs){let u=await r.readTensor(n[a]);m[a]=new Float32Array(u),n[a].destroy?.()}for(let a of this.inputs)s[a].destroy?.();return m}};var os=class p{constructor(){this.engines=[],this.weightsBaseUrl=null}static async init(t="auto",r="./volvoxai.wasm"){let e=new p,c={auto:["webnn","webgpu","wasm","cpu"],webnn:["webnn","wasm","cpu"],webgpu:["webgpu","wasm","cpu"],wasm:["wasm","cpu"],cpu:["cpu"]},s=new Set(["webnn","webgpu","wasm","cpu"]),n=Array.isArray(t),m=n?[...t]:c[t];if(!m||m.length===0)throw new Error(`[VolvoxAI] Invalid backend selection: ${JSON.stringify(t)}`);for(let u of m)if(!s.has(u))throw new Error(`[VolvoxAI] Unknown backend '${u}'. Use 'auto', 'webnn', 'webgpu', 'wasm', 'cpu', or an array of those backend names.`);let a=new Set;for(let u of m)if(!a.has(u))if(u==="webnn")if(typeof navigator<"u"&&navigator.ml)try{let i=await navigator.ml.createContext({deviceType:"npu"});console.log("[VolvoxAI] WebNN Engine (NPU) Initialized successfully."),e.engines.push({type:"webnn",engine:new K(i)}),a.add(u)}catch(i){console.warn("[VolvoxAI] WebNN initialization failed.",i.message)}else(n||t==="webnn")&&console.warn("[VolvoxAI] WebNN is not supported.");else if(u==="webgpu")if(typeof navigator<"u"&&navigator.gpu)try{let i=await navigator.gpu.requestAdapter();if(i){let o=await i.requestDevice();console.log("[VolvoxAI] WebGPU Engine Initialized successfully."),e.engines.push({type:"webgpu",device:o}),a.add(u)}else console.warn("[VolvoxAI] WebGPU adapter is not available.")}catch(i){console.warn("[VolvoxAI] WebGPU initialization failed.",i.message)}else(n||t==="webgpu")&&console.warn("[VolvoxAI] WebGPU is not supported.");else if(u==="wasm"){let i=await $.init(r);i?(console.log("[VolvoxAI] WASM Engine Initialized successfully."),e.engines.push({type:"wasm",engine:i}),a.add(u)):console.warn("[VolvoxAI] WASM initialization failed.")}else u==="cpu"&&(console.log("[VolvoxAI] Pure JS CPU Engine Initialized."),e.engines.push({type:"cpu",engine:new S}),a.add(u));if(e.engines.length===0)throw new Error(`[VolvoxAI] None of the requested backends initialized: ${m.join(", ")}`);return e}createGraph(){return new j}async loadGraph(t){let r=this.createGraph();return await H.load(r,t)}async compile(t,r){this.weightsBaseUrl=r,console.log(`[VolvoxAI] Compiling graph with ${t.nodes.length} nodes...`);for(let e of this.engines)try{if(e.type==="webgpu"){console.log("[VolvoxAI] Trying to allocate graph on WebGPU (Tier 2)...");let c=new V(e.device,t);return await c.compile(),console.log("[VolvoxAI] WebGPU Engine compiled successfully."),c}else return console.log(`[VolvoxAI] Trying to allocate graph on ${e.engine.constructor.name}...`),await e.engine.allocateGraph(t),console.log(`[VolvoxAI] ${e.engine.constructor.name} compiled successfully.`),e.engine}catch(c){console.warn(`[VolvoxAI] Compilation failed on ${e.type}. Falling back to next tier. Error: ${c.message}`)}throw new Error("[VolvoxAI] All engine tiers failed to compile the graph.")}};var ns=class{constructor(){this.vocabByText=new Map,this.vocabByLatin1=new Map,this.idToText=[],this.idToBytes=[],this.merges=new Map,this.mergeEnabled=!1,this.decoder=new TextDecoder("utf-8"),this.encoder=new TextEncoder,this.bpePattern=/'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+/gu}async load(t,r=null){try{/\.bin$/i.test(t)?await this.loadFromBinary(t):await this.loadFromJson(t),r&&await this.loadMerges(r)}catch(e){throw console.error("Tokenizer load error:",e),e}}resetVocab(){this.vocabByText.clear(),this.vocabByLatin1.clear(),this.idToText=[],this.idToBytes=[],this.merges.clear(),this.mergeEnabled=!1}async loadFromJson(t){let r=await fetch(t);if(!r.ok)throw new Error(`Failed to fetch vocab: ${r.statusText}`);let e=await r.json();this.resetVocab();for(let[c,s]of Object.entries(e)){let n=this.encoder.encode(c);this.vocabByText.set(c,s),this.vocabByLatin1.set(this.bytesToLatin1(n),s),this.idToText[s]=c,this.idToBytes[s]=n}console.log(`Loaded ${Object.keys(e).length} tokens from ${t}`)}async loadFromBinary(t){let r=await fetch(t);if(!r.ok)throw new Error(`Failed to fetch vocab.bin: ${r.statusText}`);let e=new Uint8Array(await r.arrayBuffer());if(e.length<4)throw new Error("Invalid vocab.bin");let c=new DataView(e.buffer,e.byteOffset,e.byteLength),s=c.getInt32(0,!0);this.resetVocab();let n=4;for(let m=0;m<s;m++){if(n+4>e.length)throw new Error(`vocab.bin truncated at token ${m}`);let a=c.getInt32(n,!0);if(n+=4,a<0||n+a>e.length)throw new Error(`vocab.bin malformed at token ${m}`);let u=e.slice(n,n+a);n+=a;let i=this.decoder.decode(u);this.vocabByText.set(i,m),this.vocabByLatin1.set(this.bytesToLatin1(u),m),this.idToText[m]=i,this.idToBytes[m]=u}console.log(`Loaded ${s} tokens from ${t}`)}async loadMerges(t){let r=await fetch(t);if(!r.ok)throw new Error(`Failed to fetch merges: ${r.statusText}`);let e=await r.text(),c=0;this.merges.clear();for(let s of e.split(/\r?\n/)){let n=s.trim();if(!n||n.startsWith("#"))continue;let m=n.split(/\s+/);if(m.length<2)continue;let a=this.normalizeMergeToken(m[0]),u=this.normalizeMergeToken(m[1]),i=this.findTokenByText(a),o=this.findTokenByText(u);if(i<0||o<0)continue;let f=`${this.idToText[i]}${this.idToText[o]}`,l=this.vocabByText.get(f);if(l===void 0)continue;let _=this.pairKey(i,o);this.merges.has(_)||this.merges.set(_,{rank:c++,mergedId:l})}this.mergeEnabled=this.merges.size>0,console.log(`Loaded ${this.merges.size} merge rules from ${t}`)}bytesToLatin1(t){let r="";for(let e=0;e<t.length;e++)r+=String.fromCharCode(t[e]);return r}utf8Len(t){return t<128?1:(t&224)===192?2:(t&240)===224?3:(t&248)===240?4:1}pairKey(t,r){return`${t},${r}`}normalizeMergeToken(t){return t.startsWith("\u0120")?` ${t.slice(1)}`:t}findTokenByText(t){let r=this.vocabByText.get(t);return r!==void 0?r:(r=this.vocabByLatin1.get(t),r===void 0?-1:r)}findTokenByBytes(t){let r=this.decoder.decode(t),e=this.vocabByText.get(r);return e!==void 0?e:(e=this.vocabByLatin1.get(this.bytesToLatin1(t)),e===void 0?-1:e)}decodeToken(t){let r=this.idToBytes[t];return r?this.decoder.decode(r).replace(/Ġ/g," "):""}decode(t){return t.map(r=>this.decodeToken(r)).join("")}encodeBpeWord(t,r){let e=this.encoder.encode(t);if(e.length===0||r<=0)return[];let c=[];for(let s=0;s<e.length;){let n=this.utf8Len(e[s]);s+n>e.length&&(n=e.length-s);let m=e.slice(s,s+n),a=this.findTokenByBytes(m);if(a>=0)c.push(a);else for(let u=0;u<n;u++){let i=this.findTokenByBytes(Uint8Array.of(e[s+u]));i>=0&&c.push(i)}s+=n}for(;c.length>1;){let s=-1,n=Number.MAX_SAFE_INTEGER,m=-1;for(let a=0;a<c.length-1;a++){let u=this.merges.get(this.pairKey(c[a],c[a+1]));u&&(u.rank>=n||u.mergedId<0||(s=a,n=u.rank,m=u.mergedId))}if(s<0)break;c[s]=m,c.splice(s+1,1)}return c.slice(0,r)}encodeGreedy(t,r){let e=this.encoder.encode(t),c=[],s=0;for(;s<e.length&&c.length<r;){let n=-1,m=0;for(let a=0;a<this.idToBytes.length;a++){let u=this.idToBytes[a];if(!u||u.length<=m||s+u.length>e.length)continue;let i=!0;for(let o=0;o<u.length;o++)if(e[s+o]!==u[o]){i=!1;break}i&&(n=a,m=u.length)}if(n<0){s++;continue}c.push(n),s+=m}return c}encode(t,r=256){if(r<=0)return[];if(this.vocabByText.size===0&&this.vocabByLatin1.size===0)return[];if(!this.mergeEnabled)return this.encodeGreedy(t,r);let e=[];for(let c of t.matchAll(this.bpePattern)){let s=c[0];if(!s||e.length>=r)continue;let n=r-e.length;if(n<=0)break;let m=this.encodeBpeWord(s,n);for(let a of m)e.push(a)}return e}};export{S as CPUEngine,j as Graph,V as GraphExecutor,H as GraphLoader,W as Tensor,ns as Tokenizer,os as VolvoxAI,$ as WasmEngine,C as _pair};