volvoxai 0.1.0

package/dist/v0.1.0/volvoxai.js

@@ -0,0 +1,4664 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// shaders/linearF32.wgsl
+var linearF32_default;
+var init_linearF32 = __esm({
+  "shaders/linearF32.wgsl"() {
+    linearF32_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n            @group(0) @binding(1) var<storage, read> weight_f32 : array<f32>;\n            @group(0) @binding(2) var<storage, read> dummyScale : array<f32>;\n            @group(0) @binding(3) var<storage, read> bias : array<f32>;\n            @group(0) @binding(4) var<storage, read_write> output : array<f32>;\n\n            struct Params {\n                seq_len : u32,\n                d_in : u32,\n                d_out : u32,\n            }\n            @group(0) @binding(5) var<uniform> params : Params;\n\n            @compute @workgroup_size(64, 1, 1)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let row = global_id.y;\n                let col = global_id.x;\n                \n                if (row >= params.seq_len || col >= params.d_out) { return; }\n                \n                var sum : f32 = 0.0;\n                \n                for (var k = 0u; k < params.d_in; k = k + 1u) {\n                    let in_val = input[row * params.d_in + k];\n                    let w_val = weight_f32[col * params.d_in + k];\n                    sum = sum + in_val * w_val;\n                }\n                \n                let b_val = bias[col];\n                // dummyScale is passed just to keep bindings consistent but not used here.\n                \n                output[row * params.d_out + col] = sum + b_val;\n            }\n";
+  }
+});
+
+// shaders/linearInt8.wgsl
+var linearInt8_default;
+var init_linearInt8 = __esm({
+  "shaders/linearInt8.wgsl"() {
+    linearInt8_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n            @group(0) @binding(1) var<storage, read> weight_int8_packed : array<u32>;\n            @group(0) @binding(2) var<storage, read> weight_scales : array<f32>;\n            @group(0) @binding(3) var<storage, read> bias : array<f32>;\n            @group(0) @binding(4) var<storage, read_write> output : array<f32>;\n\n            struct Params {\n                seq_len : u32,\n                d_in : u32,\n                d_out : u32,\n            }\n            @group(0) @binding(5) var<uniform> params : Params;\n\n            // Unpack one signed 8-bit integer from a 32-bit packed block\n            fn unpack_i8(packed: u32, byte_idx: u32) -> f32 {\n                let val_i32 = extractBits(i32(packed), byte_idx * 8u, 8u);\n                return f32(val_i32);\n            }\n\n            @compute @workgroup_size(64, 1, 1)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let row = global_id.y;\n                let col = global_id.x;\n                \n                if (row >= params.seq_len || col >= params.d_out) { return; }\n                \n                var sum : f32 = 0.0;\n                let d_in_4 = params.d_in / 4u;\n                \n                for (var i = 0u; i < d_in_4; i = i + 1u) {\n                    let w_packed = weight_int8_packed[col * d_in_4 + i];\n                    let in_base = row * params.d_in + i * 4u;\n                    \n                    sum = sum + input[in_base + 0u] * f32(extractBits(i32(w_packed), 0u, 8u));\n                    sum = sum + input[in_base + 1u] * f32(extractBits(i32(w_packed), 8u, 8u));\n                    sum = sum + input[in_base + 2u] * f32(extractBits(i32(w_packed), 16u, 8u));\n                    sum = sum + input[in_base + 3u] * f32(extractBits(i32(w_packed), 24u, 8u));\n                }\n                \n                let scale = weight_scales[col];\n                output[row * params.d_out + col] = (sum * scale) + bias[col];\n            }\n";
+  }
+});
+
+// shaders/conv2D.wgsl
+var conv2D_default;
+var init_conv2D = __esm({
+  "shaders/conv2D.wgsl"() {
+    conv2D_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n@group(0) @binding(1) var<storage, read> weight : array<f32>;\n@group(0) @binding(2) var<storage, read> bias : array<f32>;\n@group(0) @binding(3) var<storage, read_write> output : array<f32>;\n\nstruct Params {\n    n : u32,\n    in_h : u32,\n    in_w : u32,\n    in_c : u32,\n    out_c : u32,\n    out_h : u32,\n    out_w : u32,\n    kh : u32,\n    kw : u32,\n    sy : u32,\n    sx : u32,\n    pt : u32,\n    pl : u32,\n    groups : u32,\n    relu : u32,\n    dy : u32,\n    dx : u32,\n}\n@group(0) @binding(4) var<uniform> params : Params;\n\n@compute @workgroup_size(8, 8, 1)\nfn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n    let ox = gid.x;\n    let oy = gid.y;\n    let z = gid.z;\n    let nb = z / params.out_c;\n    let oc = z - nb * params.out_c;\n    if (nb >= params.n || ox >= params.out_w || oy >= params.out_h) { return; }\n\n    var sum = 0.0;\n    if (params.groups == params.in_c) {\n        let mult = params.out_c / params.in_c;\n        let ic = oc / mult;\n        let m = oc - ic * mult;\n        for (var yy = 0u; yy < params.kh; yy = yy + 1u) {\n            let iy = i32(oy * params.sy + yy * params.dy) - i32(params.pt);\n            if (iy < 0 || iy >= i32(params.in_h)) { continue; }\n            for (var xx = 0u; xx < params.kw; xx = xx + 1u) {\n                let ix = i32(ox * params.sx + xx * params.dx) - i32(params.pl);\n                if (ix < 0 || ix >= i32(params.in_w)) { continue; }\n                let ii = ((nb * params.in_h + u32(iy)) * params.in_w + u32(ix)) * params.in_c + ic;\n                let wi = (((yy * params.kw + xx) * params.in_c + ic) * mult) + m;\n                sum = sum + input[ii] * weight[wi];\n            }\n        }\n    } else {\n        let out_per_g = params.out_c / params.groups;\n        let in_per_g = params.in_c / params.groups;\n        let g = oc / out_per_g;\n        let ic0 = g * in_per_g;\n        for (var icl = 0u; icl < in_per_g; icl = icl + 1u) {\n            let ic = ic0 + icl;\n            for (var yy = 0u; yy < params.kh; yy = yy + 1u) {\n                let iy = i32(oy * params.sy + yy * params.dy) - i32(params.pt);\n                if (iy < 0 || iy >= i32(params.in_h)) { continue; }\n                for (var xx = 0u; xx < params.kw; xx = xx + 1u) {\n                    let ix = i32(ox * params.sx + xx * params.dx) - i32(params.pl);\n                    if (ix < 0 || ix >= i32(params.in_w)) { continue; }\n                    let ii = ((nb * params.in_h + u32(iy)) * params.in_w + u32(ix)) * params.in_c + ic;\n                    let wi = (((yy * params.kw + xx) * params.in_c + ic) * params.out_c) + oc;\n                    sum = sum + input[ii] * weight[wi];\n                }\n            }\n        }\n    }\n\n    var v = sum + bias[oc];\n    if (params.relu == 1u) {\n        v = max(v, 0.0);\n    } else if (params.relu >= 2u) {\n        v = min(max(v, 0.0), 6.0);\n    }\n    output[((nb * params.out_h + oy) * params.out_w + ox) * params.out_c + oc] = v;\n}\n";
+  }
+});
+
+// shaders/conv2DDepthwise8.wgsl
+var conv2DDepthwise8_default;
+var init_conv2DDepthwise8 = __esm({
+  "shaders/conv2DDepthwise8.wgsl"() {
+    conv2DDepthwise8_default = "@group(0) @binding(0) var<storage, read> input : array<vec4<f32>>;\n@group(0) @binding(1) var<storage, read> weight : array<vec4<f32>>;\n@group(0) @binding(2) var<storage, read> bias : array<vec4<f32>>;\n@group(0) @binding(3) var<storage, read_write> output : array<vec4<f32>>;\n\nstruct Params {\n    n : u32,\n    in_h : u32,\n    in_w : u32,\n    in_c : u32,\n    out_c : u32,\n    out_h : u32,\n    out_w : u32,\n    kh : u32,\n    kw : u32,\n    sy : u32,\n    sx : u32,\n    pt : u32,\n    pl : u32,\n    groups : u32,\n    relu : u32,\n    dy : u32,\n    dx : u32,\n}\n@group(0) @binding(4) var<uniform> params : Params;\n\nfn apply_relu4(v_in : vec4<f32>) -> vec4<f32> {\n    var v = v_in;\n    if (params.relu == 1u) {\n        v = max(v, vec4<f32>(0.0));\n    } else if (params.relu >= 2u) {\n        v = min(max(v, vec4<f32>(0.0)), vec4<f32>(6.0));\n    }\n    return v;\n}\n\n@compute @workgroup_size(8, 8, 1)\nfn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n    let ox = gid.x;\n    let oy = gid.y;\n    let c8_count = (params.out_c + 7u) / 8u;\n    let nb = gid.z / c8_count;\n    let ch0 = (gid.z - nb * c8_count) * 8u;\n    if (nb >= params.n || ox >= params.out_w || oy >= params.out_h || ch0 >= params.out_c) { return; }\n\n    var sum0 = vec4<f32>(0.0);\n    var sum1 = vec4<f32>(0.0);\n\n    for (var yy = 0u; yy < params.kh; yy = yy + 1u) {\n        let iy = i32(oy * params.sy + yy * params.dy) - i32(params.pt);\n        if (iy < 0 || iy >= i32(params.in_h)) { continue; }\n        for (var xx = 0u; xx < params.kw; xx = xx + 1u) {\n            let ix = i32(ox * params.sx + xx * params.dx) - i32(params.pl);\n            if (ix < 0 || ix >= i32(params.in_w)) { continue; }\n            let input_base = (((nb * params.in_h + u32(iy)) * params.in_w + u32(ix)) * params.in_c + ch0) / 4u;\n            let weight_base = (((yy * params.kw + xx) * params.in_c) + ch0) / 4u;\n            sum0 = sum0 + input[input_base] * weight[weight_base];\n            sum1 = sum1 + input[input_base + 1u] * weight[weight_base + 1u];\n        }\n    }\n\n    let output_base = (((nb * params.out_h + oy) * params.out_w + ox) * params.out_c + ch0) / 4u;\n    let bias_base = ch0 / 4u;\n    output[output_base] = apply_relu4(sum0 + bias[bias_base]);\n    output[output_base + 1u] = apply_relu4(sum1 + bias[bias_base + 1u]);\n}\n";
+  }
+});
+
+// shaders/conv2DPointwise16.wgsl
+var conv2DPointwise16_default;
+var init_conv2DPointwise16 = __esm({
+  "shaders/conv2DPointwise16.wgsl"() {
+    conv2DPointwise16_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n@group(0) @binding(1) var<storage, read> weight : array<vec4<f32>>;\n@group(0) @binding(2) var<storage, read> bias : array<vec4<f32>>;\n@group(0) @binding(3) var<storage, read_write> output : array<vec4<f32>>;\n\nstruct Params {\n    n : u32,\n    in_h : u32,\n    in_w : u32,\n    in_c : u32,\n    out_c : u32,\n    out_h : u32,\n    out_w : u32,\n    kh : u32,\n    kw : u32,\n    sy : u32,\n    sx : u32,\n    pt : u32,\n    pl : u32,\n    groups : u32,\n    relu : u32,\n    dy : u32,\n    dx : u32,\n}\n@group(0) @binding(4) var<uniform> params : Params;\n\nfn apply_relu4(v_in : vec4<f32>) -> vec4<f32> {\n    var v = v_in;\n    if (params.relu == 1u) {\n        v = max(v, vec4<f32>(0.0));\n    } else if (params.relu >= 2u) {\n        v = min(max(v, vec4<f32>(0.0)), vec4<f32>(6.0));\n    }\n    return v;\n}\n\n@compute @workgroup_size(8, 8, 1)\nfn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n    let ox = gid.x;\n    let oy = gid.y;\n    let oc16_count = (params.out_c + 15u) / 16u;\n    let nb = gid.z / oc16_count;\n    let oc0 = (gid.z - nb * oc16_count) * 16u;\n    if (nb >= params.n || ox >= params.out_w || oy >= params.out_h || oc0 >= params.out_c) { return; }\n\n    var sum0 = vec4<f32>(0.0);\n    var sum1 = vec4<f32>(0.0);\n    var sum2 = vec4<f32>(0.0);\n    var sum3 = vec4<f32>(0.0);\n\n    let input_base = ((nb * params.in_h + oy) * params.in_w + ox) * params.in_c;\n    for (var ic = 0u; ic < params.in_c; ic = ic + 1u) {\n        let x = input[input_base + ic];\n        let wbase = (ic * params.out_c + oc0) / 4u;\n        sum0 = sum0 + x * weight[wbase];\n        sum1 = sum1 + x * weight[wbase + 1u];\n        sum2 = sum2 + x * weight[wbase + 2u];\n        sum3 = sum3 + x * weight[wbase + 3u];\n    }\n\n    let output_base = (((nb * params.out_h + oy) * params.out_w + ox) * params.out_c + oc0) / 4u;\n    let bias_base = oc0 / 4u;\n    output[output_base] = apply_relu4(sum0 + bias[bias_base]);\n    output[output_base + 1u] = apply_relu4(sum1 + bias[bias_base + 1u]);\n    output[output_base + 2u] = apply_relu4(sum2 + bias[bias_base + 2u]);\n    output[output_base + 3u] = apply_relu4(sum3 + bias[bias_base + 3u]);\n}\n";
+  }
+});
+
+// shaders/conv2DPointwise16Tile.wgsl
+var conv2DPointwise16Tile_default;
+var init_conv2DPointwise16Tile = __esm({
+  "shaders/conv2DPointwise16Tile.wgsl"() {
+    conv2DPointwise16Tile_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n@group(0) @binding(1) var<storage, read> weight : array<vec4<f32>>;\n@group(0) @binding(2) var<storage, read> bias : array<vec4<f32>>;\n@group(0) @binding(3) var<storage, read_write> output : array<vec4<f32>>;\n\nstruct Params {\n    n : u32,\n    in_h : u32,\n    in_w : u32,\n    in_c : u32,\n    out_c : u32,\n    out_h : u32,\n    out_w : u32,\n    kh : u32,\n    kw : u32,\n    sy : u32,\n    sx : u32,\n    pt : u32,\n    pl : u32,\n    groups : u32,\n    relu : u32,\n    dy : u32,\n    dx : u32,\n}\n@group(0) @binding(4) var<uniform> params : Params;\n\nconst TILE_C : u32 = 64u;\nvar<workgroup> tile_weight : array<vec4<f32>, 256>;\n\nfn apply_relu4(v_in : vec4<f32>) -> vec4<f32> {\n    var v = v_in;\n    if (params.relu == 1u) {\n        v = max(v, vec4<f32>(0.0));\n    } else if (params.relu >= 2u) {\n        v = min(max(v, vec4<f32>(0.0)), vec4<f32>(6.0));\n    }\n    return v;\n}\n\n@compute @workgroup_size(8, 8, 1)\nfn main(@builtin(global_invocation_id) gid : vec3<u32>,\n        @builtin(local_invocation_id) lid3 : vec3<u32>) {\n    let ox = gid.x;\n    let oy = gid.y;\n    let oc16_count = params.out_c / 16u;\n    let nb = gid.z / oc16_count;\n    let oc0 = (gid.z - nb * oc16_count) * 16u;\n    let lid = lid3.y * 8u + lid3.x;\n    let in_bounds = nb < params.n && ox < params.out_w && oy < params.out_h;\n\n    var sum0 = vec4<f32>(0.0);\n    var sum1 = vec4<f32>(0.0);\n    var sum2 = vec4<f32>(0.0);\n    var sum3 = vec4<f32>(0.0);\n    let input_base = ((nb * params.in_h + oy) * params.in_w + ox) * params.in_c;\n\n    for (var tile_start = 0u; tile_start < params.in_c; tile_start = tile_start + TILE_C) {\n        let tile_count = min(TILE_C, params.in_c - tile_start);\n        for (var wi = lid; wi < tile_count * 4u; wi = wi + 64u) {\n            let ic = tile_start + wi / 4u;\n            let oc_vec = wi - (wi / 4u) * 4u;\n            tile_weight[wi] = weight[(ic * params.out_c + oc0) / 4u + oc_vec];\n        }\n        workgroupBarrier();\n\n        if (in_bounds) {\n            for (var ti = 0u; ti < tile_count; ti = ti + 1u) {\n                let x = input[input_base + tile_start + ti];\n                let wbase = ti * 4u;\n                sum0 = sum0 + x * tile_weight[wbase];\n                sum1 = sum1 + x * tile_weight[wbase + 1u];\n                sum2 = sum2 + x * tile_weight[wbase + 2u];\n                sum3 = sum3 + x * tile_weight[wbase + 3u];\n            }\n        }\n        workgroupBarrier();\n    }\n\n    if (!in_bounds) { return; }\n    let output_base = (((nb * params.out_h + oy) * params.out_w + ox) * params.out_c + oc0) / 4u;\n    let bias_base = oc0 / 4u;\n    output[output_base] = apply_relu4(sum0 + bias[bias_base]);\n    output[output_base + 1u] = apply_relu4(sum1 + bias[bias_base + 1u]);\n    output[output_base + 2u] = apply_relu4(sum2 + bias[bias_base + 2u]);\n    output[output_base + 3u] = apply_relu4(sum3 + bias[bias_base + 3u]);\n}\n";
+  }
+});
+
+// shaders/conv2DPointwise8Vec2.wgsl
+var conv2DPointwise8Vec2_default;
+var init_conv2DPointwise8Vec2 = __esm({
+  "shaders/conv2DPointwise8Vec2.wgsl"() {
+    conv2DPointwise8Vec2_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n@group(0) @binding(1) var<storage, read> weight : array<vec2<f32>>;\n@group(0) @binding(2) var<storage, read> bias : array<vec2<f32>>;\n@group(0) @binding(3) var<storage, read_write> output : array<vec2<f32>>;\n\nstruct Params {\n    n : u32,\n    in_h : u32,\n    in_w : u32,\n    in_c : u32,\n    out_c : u32,\n    out_h : u32,\n    out_w : u32,\n    kh : u32,\n    kw : u32,\n    sy : u32,\n    sx : u32,\n    pt : u32,\n    pl : u32,\n    groups : u32,\n    relu : u32,\n    dy : u32,\n    dx : u32,\n}\n@group(0) @binding(4) var<uniform> params : Params;\n\nfn apply_relu2(v_in : vec2<f32>) -> vec2<f32> {\n    var v = v_in;\n    if (params.relu == 1u) {\n        v = max(v, vec2<f32>(0.0));\n    } else if (params.relu >= 2u) {\n        v = min(max(v, vec2<f32>(0.0)), vec2<f32>(6.0));\n    }\n    return v;\n}\n\n@compute @workgroup_size(8, 8, 1)\nfn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n    let ox = gid.x;\n    let oy = gid.y;\n    let oc8_count = (params.out_c + 7u) / 8u;\n    let nb = gid.z / oc8_count;\n    let oc0 = (gid.z - nb * oc8_count) * 8u;\n    if (nb >= params.n || ox >= params.out_w || oy >= params.out_h || oc0 >= params.out_c) { return; }\n\n    let has1 = oc0 + 2u < params.out_c;\n    let has2 = oc0 + 4u < params.out_c;\n    let has3 = oc0 + 6u < params.out_c;\n    var sum0 = vec2<f32>(0.0);\n    var sum1 = vec2<f32>(0.0);\n    var sum2 = vec2<f32>(0.0);\n    var sum3 = vec2<f32>(0.0);\n\n    let input_base = ((nb * params.in_h + oy) * params.in_w + ox) * params.in_c;\n    for (var ic = 0u; ic < params.in_c; ic = ic + 1u) {\n        let x = input[input_base + ic];\n        let wbase = (ic * params.out_c + oc0) / 2u;\n        sum0 = sum0 + x * weight[wbase];\n        if (has1) { sum1 = sum1 + x * weight[wbase + 1u]; }\n        if (has2) { sum2 = sum2 + x * weight[wbase + 2u]; }\n        if (has3) { sum3 = sum3 + x * weight[wbase + 3u]; }\n    }\n\n    let output_base = (((nb * params.out_h + oy) * params.out_w + ox) * params.out_c + oc0) / 2u;\n    let bias_base = oc0 / 2u;\n    output[output_base] = apply_relu2(sum0 + bias[bias_base]);\n    if (has1) { output[output_base + 1u] = apply_relu2(sum1 + bias[bias_base + 1u]); }\n    if (has2) { output[output_base + 2u] = apply_relu2(sum2 + bias[bias_base + 2u]); }\n    if (has3) { output[output_base + 3u] = apply_relu2(sum3 + bias[bias_base + 3u]); }\n}\n";
+  }
+});
+
+// shaders/conv2DPointwise8Vec4.wgsl
+var conv2DPointwise8Vec4_default;
+var init_conv2DPointwise8Vec4 = __esm({
+  "shaders/conv2DPointwise8Vec4.wgsl"() {
+    conv2DPointwise8Vec4_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n@group(0) @binding(1) var<storage, read> weight : array<vec4<f32>>;\n@group(0) @binding(2) var<storage, read> bias : array<vec4<f32>>;\n@group(0) @binding(3) var<storage, read_write> output : array<vec4<f32>>;\n\nstruct Params {\n    n : u32,\n    in_h : u32,\n    in_w : u32,\n    in_c : u32,\n    out_c : u32,\n    out_h : u32,\n    out_w : u32,\n    kh : u32,\n    kw : u32,\n    sy : u32,\n    sx : u32,\n    pt : u32,\n    pl : u32,\n    groups : u32,\n    relu : u32,\n    dy : u32,\n    dx : u32,\n}\n@group(0) @binding(4) var<uniform> params : Params;\n\nfn apply_relu4(v_in : vec4<f32>) -> vec4<f32> {\n    var v = v_in;\n    if (params.relu == 1u) {\n        v = max(v, vec4<f32>(0.0));\n    } else if (params.relu >= 2u) {\n        v = min(max(v, vec4<f32>(0.0)), vec4<f32>(6.0));\n    }\n    return v;\n}\n\n@compute @workgroup_size(8, 8, 1)\nfn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n    let ox = gid.x;\n    let oy = gid.y;\n    let oc8_count = (params.out_c + 7u) / 8u;\n    let nb = gid.z / oc8_count;\n    let oc0 = (gid.z - nb * oc8_count) * 8u;\n    if (nb >= params.n || ox >= params.out_w || oy >= params.out_h || oc0 >= params.out_c) { return; }\n\n    var sum0 = vec4<f32>(0.0);\n    var sum1 = vec4<f32>(0.0);\n    let input_base = ((nb * params.in_h + oy) * params.in_w + ox) * params.in_c;\n    let has_second = oc0 + 4u < params.out_c;\n    for (var ic = 0u; ic < params.in_c; ic = ic + 1u) {\n        let x = input[input_base + ic];\n        let wbase = (ic * params.out_c + oc0) / 4u;\n        sum0 = sum0 + x * weight[wbase];\n        if (has_second) {\n            sum1 = sum1 + x * weight[wbase + 1u];\n        }\n    }\n\n    let output_base = (((nb * params.out_h + oy) * params.out_w + ox) * params.out_c + oc0) / 4u;\n    let bias_base = oc0 / 4u;\n    output[output_base] = apply_relu4(sum0 + bias[bias_base]);\n    if (has_second) {\n        output[output_base + 1u] = apply_relu4(sum1 + bias[bias_base + 1u]);\n    }\n}\n";
+  }
+});
+
+// shaders/conv2DRegularC3Out16.wgsl
+var conv2DRegularC3Out16_default;
+var init_conv2DRegularC3Out16 = __esm({
+  "shaders/conv2DRegularC3Out16.wgsl"() {
+    conv2DRegularC3Out16_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n@group(0) @binding(1) var<storage, read> weight : array<vec4<f32>>;\n@group(0) @binding(2) var<storage, read> bias : array<vec4<f32>>;\n@group(0) @binding(3) var<storage, read_write> output : array<vec4<f32>>;\n\nstruct Params {\n    n : u32,\n    in_h : u32,\n    in_w : u32,\n    in_c : u32,\n    out_c : u32,\n    out_h : u32,\n    out_w : u32,\n    kh : u32,\n    kw : u32,\n    sy : u32,\n    sx : u32,\n    pt : u32,\n    pl : u32,\n    groups : u32,\n    relu : u32,\n    dy : u32,\n    dx : u32,\n}\n@group(0) @binding(4) var<uniform> params : Params;\n\nfn apply_relu4(v_in : vec4<f32>) -> vec4<f32> {\n    var v = v_in;\n    if (params.relu == 1u) {\n        v = max(v, vec4<f32>(0.0));\n    } else if (params.relu >= 2u) {\n        v = min(max(v, vec4<f32>(0.0)), vec4<f32>(6.0));\n    }\n    return v;\n}\n\n@compute @workgroup_size(8, 8, 1)\nfn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n    let ox = gid.x;\n    let oy = gid.y;\n    let oc16_count = params.out_c / 16u;\n    let nb = gid.z / oc16_count;\n    let oc0 = (gid.z - nb * oc16_count) * 16u;\n    if (nb >= params.n || ox >= params.out_w || oy >= params.out_h) { return; }\n\n    var sum0 = vec4<f32>(0.0);\n    var sum1 = vec4<f32>(0.0);\n    var sum2 = vec4<f32>(0.0);\n    var sum3 = vec4<f32>(0.0);\n    for (var yy = 0u; yy < params.kh; yy = yy + 1u) {\n        let iy = i32(oy * params.sy + yy * params.dy) - i32(params.pt);\n        if (iy < 0 || iy >= i32(params.in_h)) { continue; }\n        for (var xx = 0u; xx < params.kw; xx = xx + 1u) {\n            let ix = i32(ox * params.sx + xx * params.dx) - i32(params.pl);\n            if (ix < 0 || ix >= i32(params.in_w)) { continue; }\n            let input_base = ((nb * params.in_h + u32(iy)) * params.in_w + u32(ix)) * 3u;\n            let weight_base = (((yy * params.kw + xx) * 3u) * params.out_c + oc0) / 4u;\n            for (var ic = 0u; ic < 3u; ic = ic + 1u) {\n                let x = input[input_base + ic];\n                let wbase = weight_base + ic * (params.out_c / 4u);\n                sum0 = sum0 + x * weight[wbase];\n                sum1 = sum1 + x * weight[wbase + 1u];\n                sum2 = sum2 + x * weight[wbase + 2u];\n                sum3 = sum3 + x * weight[wbase + 3u];\n            }\n        }\n    }\n\n    let output_base = (((nb * params.out_h + oy) * params.out_w + ox) * params.out_c + oc0) / 4u;\n    let bias_base = oc0 / 4u;\n    output[output_base] = apply_relu4(sum0 + bias[bias_base]);\n    output[output_base + 1u] = apply_relu4(sum1 + bias[bias_base + 1u]);\n    output[output_base + 2u] = apply_relu4(sum2 + bias[bias_base + 2u]);\n    output[output_base + 3u] = apply_relu4(sum3 + bias[bias_base + 3u]);\n}\n";
+  }
+});
+
+// shaders/layerNorm.wgsl
+var layerNorm_default;
+var init_layerNorm = __esm({
+  "shaders/layerNorm.wgsl"() {
+    layerNorm_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n            @group(0) @binding(1) var<storage, read> weight : array<f32>;\n            @group(0) @binding(2) var<storage, read> bias : array<f32>;\n            @group(0) @binding(3) var<storage, read_write> output : array<f32>;\n            \n            struct Params { rows : u32, d_model : u32 }\n            @group(0) @binding(4) var<uniform> params : Params;\n\n            @compute @workgroup_size(64)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let row = global_id.x;\n                if (row >= params.rows) { return; }\n                let d_model = params.d_model;\n                let offset = row * d_model;\n                \n                var sum : f32 = 0.0;\n                var sq_sum : f32 = 0.0;\n                \n                for (var i = 0u; i < d_model; i = i + 1u) {\n                    let val = input[offset + i];\n                    sum = sum + val;\n                    sq_sum = sq_sum + (val * val);\n                }\n                \n                let mean = sum / f32(d_model);\n                let variance = (sq_sum / f32(d_model)) - (mean * mean);\n                let inv_std = inverseSqrt(variance + 1e-5);\n                \n                for (var i = 0u; i < d_model; i = i + 1u) {\n                    let norm_val = (input[offset + i] - mean) * inv_std;\n                    output[offset + i] = norm_val * weight[i] + bias[i];\n                }\n            }\n";
+  }
+});
+
+// shaders/binaryBroadcast.wgsl
+var binaryBroadcast_default;
+var init_binaryBroadcast = __esm({
+  "shaders/binaryBroadcast.wgsl"() {
+    binaryBroadcast_default = "@group(0) @binding(0) var<storage, read> a : array<f32>;\n        @group(0) @binding(1) var<storage, read> b : array<f32>;\n        @group(0) @binding(2) var<storage, read_write> output : array<f32>;\n        \n        struct Params { size : u32, is_b_scalar : u32, b_size : u32, a_size: u32, is_a_scalar: u32 }\n        @group(0) @binding(3) var<uniform> params : Params;\n        \n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            \n            var a_val : f32 = 0.0;\n            if (params.is_a_scalar == 1u) {\n                a_val = a[0];\n            } else if (params.a_size < params.size && params.a_size > 0u) {\n                a_val = a[idx % params.a_size];\n            } else {\n                a_val = a[idx];\n            }\n            \n            var b_val : f32 = 0.0;\n            if (params.is_b_scalar == 1u) {\n                b_val = b[0];\n            } else if (params.b_size < params.size && params.b_size > 0u) {\n                b_val = b[idx % params.b_size];\n            } else {\n                b_val = b[idx];\n            }\n            \n            var out_val : f32 = 0.0;\n            undefined\n            output[idx] = out_val;\n        }\n";
+  }
+});
+
+// shaders/elementwise.wgsl
+var elementwise_default;
+var init_elementwise = __esm({
+  "shaders/elementwise.wgsl"() {
+    elementwise_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { size : u32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            let x = input[idx];\n            var out_val = x;\n            undefined\n            output[idx] = out_val;\n        }\n";
+  }
+});
+
+// shaders/resize.wgsl
+var resize_default;
+var init_resize = __esm({
+  "shaders/resize.wgsl"() {
+    resize_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n@group(0) @binding(1) var<storage, read_write> output : array<f32>;\n\nstruct Params {\n    n : u32,\n    h : u32,\n    w : u32,\n    c : u32,\n    out_h : u32,\n    out_w : u32,\n    mode : u32,\n}\n@group(0) @binding(2) var<uniform> params : Params;\n\n@compute @workgroup_size(8, 8, 1)\nfn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n    let ox = gid.x;\n    let oy = gid.y;\n    let z = gid.z;\n    let nb = z / params.c;\n    let ch = z - nb * params.c;\n    if (nb >= params.n || ox >= params.out_w || oy >= params.out_h) { return; }\n\n    if (params.mode == 0u) {\n        let iy = (oy * params.h) / params.out_h;\n        let ix = (ox * params.w) / params.out_w;\n        output[((nb * params.out_h + oy) * params.out_w + ox) * params.c + ch] =\n            input[((nb * params.h + iy) * params.w + ix) * params.c + ch];\n        return;\n    }\n\n    let scale_y = f32(params.h) / f32(params.out_h);\n    let scale_x = f32(params.w) / f32(params.out_w);\n    var fy = (f32(oy) + 0.5) * scale_y - 0.5;\n    var fx = (f32(ox) + 0.5) * scale_x - 0.5;\n    if (fy < 0.0) { fy = 0.0; }\n    if (fx < 0.0) { fx = 0.0; }\n    let y0 = u32(fy);\n    let x0 = u32(fx);\n    let y1 = min(y0 + 1u, params.h - 1u);\n    let x1 = min(x0 + 1u, params.w - 1u);\n    let dy = fy - f32(y0);\n    let dx = fx - f32(x0);\n    let base = nb * params.h * params.w * params.c;\n    let v00 = input[base + (y0 * params.w + x0) * params.c + ch];\n    let v01 = input[base + (y0 * params.w + x1) * params.c + ch];\n    let v10 = input[base + (y1 * params.w + x0) * params.c + ch];\n    let v11 = input[base + (y1 * params.w + x1) * params.c + ch];\n    let val = v00 * (1.0 - dy) * (1.0 - dx) + v01 * (1.0 - dy) * dx +\n              v10 * dy * (1.0 - dx) + v11 * dy * dx;\n    output[((nb * params.out_h + oy) * params.out_w + ox) * params.c + ch] = val;\n}\n";
+  }
+});
+
+// shaders/slice.wgsl
+var slice_default;
+var init_slice = __esm({
+  "shaders/slice.wgsl"() {
+    slice_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n@group(0) @binding(1) var<storage, read_write> output : array<f32>;\n// General strided slice over 4 dims (leading dims are padded to 1). For each\n// output element the source coord along axis k is start[k] + out_coord * step[k].\nstruct Params {\n  out_b: u32, out_c: u32, out_h: u32, out_w: u32,\n  in_c: u32, in_h: u32, in_w: u32,\n  s0: u32, s1: u32, s2: u32, s3: u32,\n  st0: u32, st1: u32, st2: u32, st3: u32,\n  total: u32\n}\n@group(0) @binding(2) var<uniform> p : Params;\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n  let idx = gid.x;\n  if (idx >= p.total) { return; }\n  let ow = idx % p.out_w;\n  let oh = (idx / p.out_w) % p.out_h;\n  let oc = (idx / (p.out_w * p.out_h)) % p.out_c;\n  let ob = idx / (p.out_w * p.out_h * p.out_c);\n  let ib = p.s0 + ob * p.st0;\n  let ic = p.s1 + oc * p.st1;\n  let ih = p.s2 + oh * p.st2;\n  let iw = p.s3 + ow * p.st3;\n  output[idx] = input[((ib * p.in_c + ic) * p.in_h + ih) * p.in_w + iw];\n}\n";
+  }
+});
+
+// shaders/sub.wgsl
+var sub_default;
+var init_sub = __esm({
+  "shaders/sub.wgsl"() {
+    sub_default = "@group(0) @binding(0) var<storage, read> a : array<f32>;\n        @group(0) @binding(1) var<storage, read> b : array<f32>;\n        @group(0) @binding(2) var<storage, read_write> output : array<f32>;\n        \n        struct Params { size : u32, is_b_scalar : u32, b_size : u32, a_size: u32, is_a_scalar: u32 }\n        @group(0) @binding(3) var<uniform> params : Params;\n        \n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            \n            var a_val : f32 = 0.0;\n            if (params.is_a_scalar == 1u) {\n                a_val = a[0];\n            } else if (params.a_size < params.size && params.a_size > 0u) {\n                a_val = a[idx % params.a_size];\n            } else {\n                a_val = a[idx];\n            }\n            \n            var b_val : f32 = 0.0;\n            if (params.is_b_scalar == 1u) {\n                b_val = b[0];\n            } else if (params.b_size < params.size && params.b_size > 0u) {\n                b_val = b[idx % params.b_size];\n            } else {\n                b_val = b[idx];\n            }\n            \n            var out_val : f32 = 0.0;\n            out_val = a_val - b_val;\n            output[idx] = out_val;\n        }\n";
+  }
+});
+
+// shaders/div.wgsl
+var div_default;
+var init_div = __esm({
+  "shaders/div.wgsl"() {
+    div_default = "@group(0) @binding(0) var<storage, read> a : array<f32>;\n        @group(0) @binding(1) var<storage, read> b : array<f32>;\n        @group(0) @binding(2) var<storage, read_write> output : array<f32>;\n        \n        struct Params { size : u32, is_b_scalar : u32, b_size : u32, a_size: u32, is_a_scalar: u32 }\n        @group(0) @binding(3) var<uniform> params : Params;\n        \n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            \n            var a_val : f32 = 0.0;\n            if (params.is_a_scalar == 1u) {\n                a_val = a[0];\n            } else if (params.a_size < params.size && params.a_size > 0u) {\n                a_val = a[idx % params.a_size];\n            } else {\n                a_val = a[idx];\n            }\n            \n            var b_val : f32 = 0.0;\n            if (params.is_b_scalar == 1u) {\n                b_val = b[0];\n            } else if (params.b_size < params.size && params.b_size > 0u) {\n                b_val = b[idx % params.b_size];\n            } else {\n                b_val = b[idx];\n            }\n            \n            var out_val : f32 = 0.0;\n            out_val = a_val / b_val;\n            output[idx] = out_val;\n        }\n";
+  }
+});
+
+// shaders/siLU.wgsl
+var siLU_default;
+var init_siLU = __esm({
+  "shaders/siLU.wgsl"() {
+    siLU_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { size : u32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            let x = input[idx];\n            var out_val = x;\n            out_val = x * (1.0 / (1.0 + exp(-x)));\n            output[idx] = out_val;\n        }\n";
+  }
+});
+
+// shaders/leakyReLU.wgsl
+var leakyReLU_default;
+var init_leakyReLU = __esm({
+  "shaders/leakyReLU.wgsl"() {
+    leakyReLU_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { size : u32, alpha : f32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            let x = input[idx];\n            if (x > 0.0) { output[idx] = x; } else { output[idx] = x * params.alpha; }\n        }\n";
+  }
+});
+
+// shaders/tanh.wgsl
+var tanh_default;
+var init_tanh = __esm({
+  "shaders/tanh.wgsl"() {
+    tanh_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { size : u32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            let x = input[idx];\n            var out_val = x;\n            let e2x = exp(2.0 * x); out_val = (e2x - 1.0) / (e2x + 1.0);\n            output[idx] = out_val;\n        }\n";
+  }
+});
+
+// shaders/clip.wgsl
+var clip_default;
+var init_clip = __esm({
+  "shaders/clip.wgsl"() {
+    clip_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { size : u32, min_v : f32, max_v : f32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            output[idx] = clamp(input[idx], params.min_v, params.max_v);\n        }\n";
+  }
+});
+
+// shaders/rMSNorm.wgsl
+var rMSNorm_default;
+var init_rMSNorm = __esm({
+  "shaders/rMSNorm.wgsl"() {
+    rMSNorm_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read> weight : array<f32>;\n        @group(0) @binding(2) var<storage, read_write> output : array<f32>;\n        struct Params { seq_len : u32, d_model : u32, eps : f32 }\n        @group(0) @binding(3) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let s = global_id.x;\n            if (s >= params.seq_len) { return; }\n            var var_val = 0.0;\n            let offset = s * params.d_model;\n            for (var d = 0u; d < params.d_model; d = d + 1u) {\n                let v = input[offset + d];\n                var_val = var_val + v * v;\n            }\n            var_val = var_val / f32(params.d_model);\n            let inv_std = 1.0 / sqrt(var_val + params.eps);\n            for (var d = 0u; d < params.d_model; d = d + 1u) {\n                output[offset + d] = input[offset + d] * inv_std * weight[d];\n            }\n        }\n";
+  }
+});
+
+// shaders/softmax.wgsl
+var softmax_default;
+var init_softmax = __esm({
+  "shaders/softmax.wgsl"() {
+    softmax_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { b : u32, d : u32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let i = global_id.x;\n            if (i >= params.b) { return; }\n            let offset = i * params.d;\n            var max_val = -100000.0;\n            for (var j = 0u; j < params.d; j = j + 1u) {\n                if (input[offset + j] > max_val) { max_val = input[offset + j]; }\n            }\n            var sum = 0.0;\n            for (var j = 0u; j < params.d; j = j + 1u) {\n                let e = exp(input[offset + j] - max_val);\n                output[offset + j] = e;\n                sum = sum + e;\n            }\n            for (var j = 0u; j < params.d; j = j + 1u) {\n                output[offset + j] = output[offset + j] / sum;\n            }\n        }\n";
+  }
+});
+
+// shaders/pReLU.wgsl
+var pReLU_default;
+var init_pReLU = __esm({
+  "shaders/pReLU.wgsl"() {
+    pReLU_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read> weight : array<f32>;\n        @group(0) @binding(2) var<storage, read_write> output : array<f32>;\n        struct Params { size : u32, c : u32 }\n        @group(0) @binding(3) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            let c_idx = idx % params.c;\n            let alpha = weight[c_idx];\n            let v = input[idx];\n            if (v > 0.0) { output[idx] = v; } else { output[idx] = v * alpha; }\n        }\n";
+  }
+});
+
+// shaders/logSoftmax.wgsl
+var logSoftmax_default;
+var init_logSoftmax = __esm({
+  "shaders/logSoftmax.wgsl"() {
+    logSoftmax_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { b : u32, d : u32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let i = global_id.x;\n            if (i >= params.b) { return; }\n            let offset = i * params.d;\n            var max_val = -100000.0;\n            for (var j = 0u; j < params.d; j = j + 1u) {\n                if (input[offset + j] > max_val) { max_val = input[offset + j]; }\n            }\n            var sum = 0.0;\n            for (var j = 0u; j < params.d; j = j + 1u) {\n                sum = sum + exp(input[offset + j] - max_val);\n            }\n            let logSum = log(sum);\n            for (var j = 0u; j < params.d; j = j + 1u) {\n                output[offset + j] = (input[offset + j] - max_val) - logSum;\n            }\n        }\n";
+  }
+});
+
+// shaders/reduce.wgsl
+var reduce_default;
+var init_reduce = __esm({
+  "shaders/reduce.wgsl"() {
+    reduce_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n@group(0) @binding(1) var<storage, read_write> output : array<f32>;\n// Reduce over the last (innermost) axis: `b` rows of length `d` -> `b` outputs.\n// `inv` scales the sum: 1.0 for ReduceSum, 1.0/d for ReduceMean.\nstruct Params { b : u32, d : u32, inv : f32 }\n@group(0) @binding(2) var<uniform> p : Params;\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n  let i = gid.x;\n  if (i >= p.b) { return; }\n  let offset = i * p.d;\n  var sum = 0.0;\n  for (var j = 0u; j < p.d; j = j + 1u) {\n    sum = sum + input[offset + j];\n  }\n  output[i] = sum * p.inv;\n}\n";
+  }
+});
+
+// shaders/averagePool2D.wgsl
+var averagePool2D_default;
+var init_averagePool2D = __esm({
+  "shaders/averagePool2D.wgsl"() {
+    averagePool2D_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        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 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(8, 8, 1)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let x = global_id.x; let y = global_id.y; let z = global_id.z;\n            let b = z / params.c;\n            let c = z - b * params.c;\n            if (x >= params.out_w || y >= params.out_h || b >= params.b) { return; }\n            var sum = 0.0; var count = 0u;\n            for (var ky = 0u; ky < params.kh; ky = ky + 1u) {\n                for (var kx = 0u; kx < params.kw; kx = kx + 1u) {\n                    let in_y = i32(y * params.sh) - i32(params.ph) + i32(ky);\n                    let in_x = i32(x * params.sw) - i32(params.pw) + i32(kx);\n                    if (in_y >= 0 && in_y < i32(params.in_h) && in_x >= 0 && in_x < i32(params.in_w)) {\n                        sum = sum + input[((b * params.in_h + u32(in_y)) * params.in_w + u32(in_x)) * params.c + c];\n                        count = count + 1u;\n                    }\n                }\n            }\n            if (count == 0u) { count = 1u; }\n            output[((b * params.out_h + y) * params.out_w + x) * params.c + c] = sum / f32(count);\n        }\n";
+  }
+});
+
+// shaders/gather.wgsl
+var gather_default;
+var init_gather = __esm({
+  "shaders/gather.wgsl"() {
+    gather_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n@group(0) @binding(1) var<storage, read> indices : array<f32>;\n@group(0) @binding(2) var<storage, read_write> output : array<f32>;\n// Gather along axis 0: output[i, ...] = input[indices[i], ...]. `row_size` is the\n// number of contiguous elements per gathered row (product of input dims after\n// axis 0); `num_idx` is the number of indices. total = num_idx * row_size.\nstruct Params { row_size : u32, num_idx : u32, total : u32 }\n@group(0) @binding(3) var<uniform> p : Params;\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n  let idx = gid.x;\n  if (idx >= p.total) { return; }\n  let k = idx % p.row_size;\n  let i = idx / p.row_size;\n  let row = u32(indices[i]);\n  output[idx] = input[row * p.row_size + k];\n}\n";
+  }
+});
+
+// shaders/where.wgsl
+var where_default;
+var init_where = __esm({
+  "shaders/where.wgsl"() {
+    where_default = "@group(0) @binding(0) var<storage, read> cond : array<f32>;\n        @group(0) @binding(1) var<storage, read> a : array<f32>;\n        @group(0) @binding(2) var<storage, read> b : array<f32>;\n        @group(0) @binding(3) var<storage, read_write> output : array<f32>;\n        struct Params { size : u32 }\n        @group(0) @binding(4) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            if (cond[idx] != 0.0) { output[idx] = a[idx]; } else { output[idx] = b[idx]; }\n        }\n";
+  }
+});
+
+// shaders/dequantizeLinear.wgsl
+var dequantizeLinear_default;
+var init_dequantizeLinear = __esm({
+  "shaders/dequantizeLinear.wgsl"() {
+    dequantizeLinear_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read> scale : array<f32>;\n        @group(0) @binding(2) var<storage, read> zero_point : array<f32>;\n        @group(0) @binding(3) var<storage, read_write> output : array<f32>;\n        struct Params { size : u32, has_zp : u32 }\n        @group(0) @binding(4) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            var zp = 0.0;\n            if (params.has_zp == 1u) { zp = zero_point[0]; }\n            output[idx] = (input[idx] - zp) * scale[0];\n        }\n";
+  }
+});
+
+// shaders/expand.wgsl
+var expand_default;
+var init_expand = __esm({
+  "shaders/expand.wgsl"() {
+    expand_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        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 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            let total = params.out_b * params.out_h * params.out_w * params.out_c;\n            if (idx >= total) { return; }\n            let oc = idx % params.out_c;\n            let ow = (idx / params.out_c) % params.out_w;\n            let oh = (idx / (params.out_c * params.out_w)) % params.out_h;\n            let ob = idx / (params.out_c * params.out_w * params.out_h);\n            let ib = ob % params.in_b;\n            let ih = oh % params.in_h; let iw = ow % params.in_w;\n            let ic = oc % params.in_c;\n            output[idx] = input[((ib * params.in_h + ih) * params.in_w + iw) * params.in_c + ic];\n        }\n";
+  }
+});
+
+// shaders/pad.wgsl
+var pad_default;
+var init_pad = __esm({
+  "shaders/pad.wgsl"() {
+    pad_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { b: u32, in_h: u32, in_w: u32, c: u32, out_h: u32, out_w: u32, pt: u32, pl: u32, val: f32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            let total = params.b * params.out_h * params.out_w * params.c;\n            if (idx >= total) { return; }\n            let c = idx % params.c;\n            let x = (idx / params.c) % params.out_w;\n            let y = (idx / (params.c * params.out_w)) % params.out_h;\n            let b = idx / (params.c * params.out_w * params.out_h);\n            if (y >= params.pt && y < params.pt + params.in_h && x >= params.pl && x < params.pl + params.in_w) {\n                output[idx] = input[((b * params.in_h + (y - params.pt)) * params.in_w + (x - params.pl)) * params.c + c];\n            } else {\n                output[idx] = params.val;\n            }\n        }\n";
+  }
+});
+
+// shaders/convTranspose2D.wgsl
+var convTranspose2D_default;
+var init_convTranspose2D = __esm({
+  "shaders/convTranspose2D.wgsl"() {
+    convTranspose2D_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read> weight : array<f32>;\n        @group(0) @binding(2) var<storage, read> bias : array<f32>;\n        @group(0) @binding(3) var<storage, read_write> output : array<f32>;\n        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 }\n        @group(0) @binding(4) var<uniform> params : Params;\n        @compute @workgroup_size(8, 8, 1)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let x = global_id.x; let y = global_id.y; let batch_c = global_id.z;\n            if (x >= params.out_w || y >= params.out_h || batch_c >= (params.b * params.out_c)) { return; }\n            let ob = batch_c / params.out_c;\n            let oc = batch_c % params.out_c;\n            var sum = 0.0;\n            if (params.has_bias == 1u) { sum = bias[oc]; }\n            for (var ic = 0u; ic < params.in_c; ic = ic + 1u) {\n                for (var ky = 0u; ky < params.kh; ky = ky + 1u) {\n                    for (var kx = 0u; kx < params.kw; kx = kx + 1u) {\n                        let oy_shifted = i32(y) + i32(params.ph) - i32(ky);\n                        let ox_shifted = i32(x) + i32(params.pw) - i32(kx);\n                        if (oy_shifted % i32(params.sh) == 0 && ox_shifted % i32(params.sw) == 0) {\n                            let iy = oy_shifted / i32(params.sh);\n                            let ix = ox_shifted / i32(params.sw);\n                            if (iy >= 0 && iy < i32(params.in_h) && ix >= 0 && ix < i32(params.in_w)) {\n                                let in_val = input[((ob * params.in_h + u32(iy)) * params.in_w + u32(ix)) * params.in_c + ic];\n                                let w_val = weight[ic * (params.out_c * params.kh * params.kw) + oc * (params.kh * params.kw) + ky * params.kw + kx];\n                                sum = sum + in_val * w_val;\n                            }\n                        }\n                    }\n                }\n            }\n            output[((ob * params.out_h + y) * params.out_w + x) * params.out_c + oc] = sum;\n        }\n";
+  }
+});
+
+// shaders/reLU.wgsl
+var reLU_default;
+var init_reLU = __esm({
+  "shaders/reLU.wgsl"() {
+    reLU_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { size : u32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            let x = input[idx];\n            var out_val = x;\n            if (x > 0.0) { out_val = x; } else { out_val = 0.0; }\n            output[idx] = out_val;\n        }\n";
+  }
+});
+
+// shaders/sigmoid.wgsl
+var sigmoid_default;
+var init_sigmoid = __esm({
+  "shaders/sigmoid.wgsl"() {
+    sigmoid_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { size : u32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            let x = input[idx];\n            var out_val = x;\n            out_val = 1.0 / (1.0 + exp(-x));\n            output[idx] = out_val;\n        }\n";
+  }
+});
+
+// shaders/hardSwish.wgsl
+var hardSwish_default;
+var init_hardSwish = __esm({
+  "shaders/hardSwish.wgsl"() {
+    hardSwish_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { size : u32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            let x = input[idx];\n            var out_val = x;\n            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;\n            output[idx] = out_val;\n        }\n";
+  }
+});
+
+// shaders/hardSigmoid.wgsl
+var hardSigmoid_default;
+var init_hardSigmoid = __esm({
+  "shaders/hardSigmoid.wgsl"() {
+    hardSigmoid_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { size : u32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            let x = input[idx];\n            var out_val = x;\n            var v = x + 3.0; if (v < 0.0) { v = 0.0; } if (v > 6.0) { v = 6.0; } out_val = v / 6.0;\n            output[idx] = out_val;\n        }\n";
+  }
+});
+
+// shaders/copy.wgsl
+var copy_default;
+var init_copy = __esm({
+  "shaders/copy.wgsl"() {
+    copy_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { size : u32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            if (idx >= params.size) { return; }\n            let x = input[idx];\n            var out_val = x;\n            out_val = x;\n            output[idx] = out_val;\n        }\n";
+  }
+});
+
+// shaders/batchNorm2D.wgsl
+var batchNorm2D_default;
+var init_batchNorm2D = __esm({
+  "shaders/batchNorm2D.wgsl"() {
+    batchNorm2D_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read> weight : array<f32>;\n        @group(0) @binding(2) var<storage, read> bias : array<f32>;\n        @group(0) @binding(3) var<storage, read> running_mean : array<f32>;\n        @group(0) @binding(4) var<storage, read> running_var : array<f32>;\n        @group(0) @binding(5) var<storage, read_write> output : array<f32>;\n        struct Params { b : u32, c : u32, h : u32, w : u32, eps : f32 }\n        @group(0) @binding(6) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n            let idx = global_id.x;\n            let total = params.b * params.c * params.h * params.w;\n            if (idx >= total) { return; }\n            let c = idx % params.c;\n            let mean = running_mean[c];\n            let var_val = running_var[c];\n            let gamma = weight[c];\n            let beta = bias[c];\n            let inv_std = 1.0 / sqrt(var_val + params.eps);\n            output[idx] = (input[idx] - mean) * inv_std * gamma + beta;\n        }\n";
+  }
+});
+
+// shaders/gELU.wgsl
+var gELU_default;
+var init_gELU = __esm({
+  "shaders/gELU.wgsl"() {
+    gELU_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n@group(0) @binding(1) var<storage, read_write> output : array<f32>;\nstruct Params { size : u32 }\n@group(0) @binding(2) var<uniform> params : Params;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n    let idx = global_id.x;\n    if (idx >= params.size) { return; }\n    let x = input[idx];\n    let cdf = 0.5 * (1.0 + tanh(0.7978845608 * (x + 0.044715 * x * x * x)));\n    output[idx] = x * cdf;\n}\n";
+  }
+});
+
+// shaders/add.wgsl
+var add_default;
+var init_add = __esm({
+  "shaders/add.wgsl"() {
+    add_default = "@group(0) @binding(0) var<storage, read> a : array<f32>;\n            @group(0) @binding(1) var<storage, read> b : array<f32>;\n            @group(0) @binding(2) var<storage, read_write> output : array<f32>;\n            \n            struct Params { size : u32 }\n            @group(0) @binding(3) var<uniform> params : Params;\n            \n            @compute @workgroup_size(64)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let idx = global_id.x;\n                if (idx >= params.size) { return; }\n                output[idx] = a[idx] + b[idx];\n            }\n";
+  }
+});
+
+// shaders/upsample2x.wgsl
+var upsample2x_default;
+var init_upsample2x = __esm({
+  "shaders/upsample2x.wgsl"() {
+    upsample2x_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n@group(0) @binding(1) var<storage, read_write> output : array<f32>;\n\nstruct Params {\n    n : u32,\n    h : u32,\n    w : u32,\n    c : u32,\n}\n@group(0) @binding(2) var<uniform> params : Params;\n\n@compute @workgroup_size(8, 8, 1)\nfn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n    let ox = gid.x;\n    let oy = gid.y;\n    let z = gid.z;\n    let nb = z / params.c;\n    let ch = z - nb * params.c;\n    let out_h = params.h * 2u;\n    let out_w = params.w * 2u;\n    if (nb >= params.n || ox >= out_w || oy >= out_h) { return; }\n    output[((nb * out_h + oy) * out_w + ox) * params.c + ch] =\n        input[((nb * params.h + (oy / 2u)) * params.w + (ox / 2u)) * params.c + ch];\n}\n";
+  }
+});
+
+// shaders/concatCopy.wgsl
+var concatCopy_default;
+var init_concatCopy = __esm({
+  "shaders/concatCopy.wgsl"() {
+    concatCopy_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { size : u32, offset : u32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n            let i = gid.x;\n            if (i >= params.size) { return; }\n            output[params.offset + i] = input[i];\n        }\n";
+  }
+});
+
+// shaders/concat2.wgsl
+var concat2_default;
+var init_concat2 = __esm({
+  "shaders/concat2.wgsl"() {
+    concat2_default = "@group(0) @binding(0) var<storage, read> a : array<f32>;\n            @group(0) @binding(1) var<storage, read> b : array<f32>;\n            @group(0) @binding(2) var<storage, read_write> output : array<f32>;\n            \n            struct Params { a_size : u32, b_size : u32 }\n            @group(0) @binding(3) var<uniform> params : Params;\n            \n            @compute @workgroup_size(64)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let idx = global_id.x;\n                if (idx < params.a_size) {\n                    output[idx] = a[idx];\n                } else if (idx < params.a_size + params.b_size) {\n                    output[idx] = b[idx - params.a_size];\n                }\n            }\n";
+  }
+});
+
+// shaders/broadcastBinary.wgsl
+var broadcastBinary_default;
+var init_broadcastBinary = __esm({
+  "shaders/broadcastBinary.wgsl"() {
+    broadcastBinary_default = "@group(0) @binding(0) var<storage, read> a : array<f32>;\n        @group(0) @binding(1) var<storage, read> b : array<f32>;\n        @group(0) @binding(2) var<storage, read_write> output : array<f32>;\n        @group(0) @binding(3) var<storage, read> md : array<u32>;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n            let idx = gid.x;\n            let total = md[0];\n            if (idx >= total) { return; }\n            let rank = md[1];\n            var rem = idx;\n            var a_idx = 0u;\n            var b_idx = 0u;\n            for (var d = 0u; d < rank; d = d + 1u) {\n                let os = md[2u + d];\n                let coord = rem / os;\n                rem = rem - coord * os;\n                a_idx = a_idx + coord * md[2u + rank + d];\n                b_idx = b_idx + coord * md[2u + 2u * rank + d];\n            }\n            let av = a[a_idx];\n            let bv = b[b_idx];\n            var out_val = 0.0;\n            //__BINOP__\n            output[idx] = out_val;\n        }\n";
+  }
+});
+
+// shaders/generalTranspose.wgsl
+var generalTranspose_default;
+var init_generalTranspose = __esm({
+  "shaders/generalTranspose.wgsl"() {
+    generalTranspose_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        @group(0) @binding(2) var<storage, read> md : array<u32>;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n            let idx = gid.x;\n            let total = md[0];\n            if (idx >= total) { return; }\n            let rank = md[1];\n            var rem = idx;\n            var in_idx = 0u;\n            for (var d = 0u; d < rank; d = d + 1u) {\n                let os = md[2u + d];\n                let coord = rem / os;\n                rem = rem - coord * os;\n                in_idx = in_idx + coord * md[2u + rank + d];\n            }\n            output[idx] = input[in_idx];\n        }\n";
+  }
+});
+
+// shaders/split.wgsl
+var split_default;
+var init_split = __esm({
+  "shaders/split.wgsl"() {
+    split_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n        @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n        struct Params { total : u32, inner : u32, split_size : u32, axis_in : u32, offset : u32 }\n        @group(0) @binding(2) var<uniform> params : Params;\n        @compute @workgroup_size(64)\n        fn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n            let i = gid.x;\n            if (i >= params.total) { return; }\n            let inner_idx = i % params.inner;\n            let s = (i / params.inner) % params.split_size;\n            let outer_idx = i / (params.split_size * params.inner);\n            let in_idx = outer_idx * (params.axis_in * params.inner)\n                       + (params.offset + s) * params.inner + inner_idx;\n            output[i] = input[in_idx];\n        }\n";
+  }
+});
+
+// shaders/profileY.wgsl
+var profileY_default;
+var init_profileY = __esm({
+  "shaders/profileY.wgsl"() {
+    profileY_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n            @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n            \n            struct Params { in_h : u32, in_w : u32, in_c : u32 }\n            @group(0) @binding(2) var<uniform> params : Params;\n            \n            @compute @workgroup_size(64)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let y = global_id.x;\n                let c = global_id.y;\n                \n                if (y >= params.in_h || c >= params.in_c) { return; }\n                \n                var max_val = -1e38;\n                var sum_val = 0.0;\n                \n                for (var x = 0u; x < params.in_w; x = x + 1u) {\n                    let val = input[(y * params.in_w + x) * params.in_c + c];\n                    if (val > max_val) { max_val = val; }\n                    sum_val = sum_val + val;\n                }\n                \n                let out_max_idx = c * params.in_h + y;\n                let out_mean_idx = (c + params.in_c) * params.in_h + y;\n                \n                output[out_max_idx] = max_val;\n                output[out_mean_idx] = sum_val / f32(params.in_w);\n            }\n";
+  }
+});
+
+// shaders/profileX.wgsl
+var profileX_default;
+var init_profileX = __esm({
+  "shaders/profileX.wgsl"() {
+    profileX_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n            @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n            \n            struct Params { in_h : u32, in_w : u32, in_c : u32 }\n            @group(0) @binding(2) var<uniform> params : Params;\n            \n            @compute @workgroup_size(64)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let x = global_id.x;\n                let c = global_id.y;\n                \n                if (x >= params.in_w || c >= params.in_c) { return; }\n                \n                var max_val = -1e38;\n                var sum_val = 0.0;\n                \n                for (var y = 0u; y < params.in_h; y = y + 1u) {\n                    let val = input[(y * params.in_w + x) * params.in_c + c];\n                    if (val > max_val) { max_val = val; }\n                    sum_val = sum_val + val;\n                }\n                \n                let out_max_idx = c * params.in_w + x;\n                let out_mean_idx = (c + params.in_c) * params.in_w + x;\n                \n                output[out_max_idx] = max_val;\n                output[out_mean_idx] = sum_val / f32(params.in_h);\n            }\n";
+  }
+});
+
+// shaders/globalAveragePool.wgsl
+var globalAveragePool_default;
+var init_globalAveragePool = __esm({
+  "shaders/globalAveragePool.wgsl"() {
+    globalAveragePool_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n@group(0) @binding(1) var<storage, read_write> output : array<f32>;\n\nstruct Params { n : u32, h : u32, w : u32, c : u32 }\n@group(0) @binding(2) var<uniform> params : Params;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n    let ch = gid.x;\n    let nb = gid.y;\n    if (nb >= params.n || ch >= params.c) { return; }\n    var sum = 0.0;\n    for (var y = 0u; y < params.h; y = y + 1u) {\n        for (var x = 0u; x < params.w; x = x + 1u) {\n            sum = sum + input[((nb * params.h + y) * params.w + x) * params.c + ch];\n        }\n    }\n    output[nb * params.c + ch] = sum / f32(params.h * params.w);\n}\n";
+  }
+});
+
+// shaders/meanHeight.wgsl
+var meanHeight_default;
+var init_meanHeight = __esm({
+  "shaders/meanHeight.wgsl"() {
+    meanHeight_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n            @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n\n            struct Params { in_h : u32, in_w : u32, in_c : u32 }\n            @group(0) @binding(2) var<uniform> params : Params;\n\n            @compute @workgroup_size(64)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let x = global_id.x;\n                let c = global_id.y;\n                if (x >= params.in_w || c >= params.in_c) { return; }\n\n                var sum_val = 0.0;\n                for (var y = 0u; y < params.in_h; y = y + 1u) {\n                    sum_val = sum_val + input[(y * params.in_w + x) * params.in_c + c];\n                }\n                output[c * params.in_w + x] = sum_val / f32(params.in_h);\n            }\n";
+  }
+});
+
+// shaders/maxPool2D.wgsl
+var maxPool2D_default;
+var init_maxPool2D = __esm({
+  "shaders/maxPool2D.wgsl"() {
+    maxPool2D_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n@group(0) @binding(1) var<storage, read_write> output : array<f32>;\n\nstruct Params {\n    h : u32,\n    w : u32,\n    c : u32,\n    out_h : u32,\n    out_w : u32,\n    ky : u32,\n    kx : u32,\n    sy : u32,\n    sx : u32,\n    py : u32,\n    px : u32,\n}\n@group(0) @binding(2) var<uniform> params : Params;\n\n@compute @workgroup_size(8, 8, 1)\nfn main(@builtin(global_invocation_id) gid : vec3<u32>) {\n    let ox = gid.x;\n    let oy = gid.y;\n    let ch = gid.z;\n    if (ox >= params.out_w || oy >= params.out_h || ch >= params.c) { return; }\n\n    var best = -3.402823466e38;\n    for (var yy = 0u; yy < params.ky; yy = yy + 1u) {\n        let iy = i32(oy * params.sy + yy) - i32(params.py);\n        if (iy < 0 || iy >= i32(params.h)) { continue; }\n        for (var xx = 0u; xx < params.kx; xx = xx + 1u) {\n            let ix = i32(ox * params.sx + xx) - i32(params.px);\n            if (ix < 0 || ix >= i32(params.w)) { continue; }\n            best = max(best, input[(u32(iy) * params.w + u32(ix)) * params.c + ch]);\n        }\n    }\n    output[(oy * params.out_w + ox) * params.c + ch] = best;\n}\n";
+  }
+});
+
+// shaders/interp1D.wgsl
+var interp1D_default;
+var init_interp1D = __esm({
+  "shaders/interp1D.wgsl"() {
+    interp1D_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n            @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n            \n            struct Params { in_c : u32, in_l : u32, out_l : u32 }\n            @group(0) @binding(2) var<uniform> params : Params;\n            \n            @compute @workgroup_size(64)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let i = global_id.x;\n                let c = global_id.y;\n                \n                if (i >= params.out_l || c >= params.in_c) { return; }\n                \n                let scale = f32(params.in_l) / f32(params.out_l);\n                var src = (f32(i) + 0.5) * scale - 0.5;\n                if (src < 0.0) { src = 0.0; }\n                if (src > f32(params.in_l - 1u)) { src = f32(params.in_l - 1u); }\n                \n                let lo = u32(src);\n                var hi = lo + 1u;\n                if (hi >= params.in_l) { hi = params.in_l - 1u; }\n                let t = src - f32(lo);\n                \n                let in_base = c * params.in_l;\n                let out_base = c * params.out_l;\n                \n                output[out_base + i] = input[in_base + lo] * (1.0 - t) + input[in_base + hi] * t;\n            }\n";
+  }
+});
+
+// shaders/conv1D.wgsl
+var conv1D_default;
+var init_conv1D = __esm({
+  "shaders/conv1D.wgsl"() {
+    conv1D_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n            @group(0) @binding(1) var<storage, read> weight : array<f32>;\n            @group(0) @binding(2) var<storage, read> bias : array<f32>;\n            @group(0) @binding(3) var<storage, read_write> output : array<f32>;\n            \n            struct Params {\n                in_c : u32, in_l : u32,\n                out_c : u32, k : u32,\n                stride : u32, pad : u32, relu : u32\n            }\n            @group(0) @binding(4) var<uniform> params : Params;\n            \n            @compute @workgroup_size(64)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let x = global_id.x;\n                let oc = global_id.y;\n                let out_l = (params.in_l + 2u * params.pad - params.k) / params.stride + 1u;\n                \n                if (x >= out_l || oc >= params.out_c) { return; }\n                \n                var sum = bias[oc];\n                let w_base = oc * params.in_c * params.k;\n                \n                for (var ic = 0u; ic < params.in_c; ic = ic + 1u) {\n                    let in_base = ic * params.in_l;\n                    let w_ic_base = w_base + ic * params.k;\n                    for (var k = 0u; k < params.k; k = k + 1u) {\n                        let in_x = i32(x * params.stride + k) - i32(params.pad);\n                        if (in_x >= 0 && in_x < i32(params.in_l)) {\n                            sum = sum + input[in_base + u32(in_x)] * weight[w_ic_base + k];\n                        }\n                    }\n                }\n                \n                if (params.relu == 1u && sum < 0.0) { sum = 0.0; }\n                output[oc * out_l + x] = sum;\n            }\n";
+  }
+});
+
+// shaders/spatialSoftargmaxY.wgsl
+var spatialSoftargmaxY_default;
+var init_spatialSoftargmaxY = __esm({
+  "shaders/spatialSoftargmaxY.wgsl"() {
+    spatialSoftargmaxY_default = "@group(0) @binding(0) var<storage, read> input : array<f32>;\n            @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n            \n            struct Params { in_h : u32, in_w : u32, in_c : u32 }\n            @group(0) @binding(2) var<uniform> params : Params;\n            \n            @compute @workgroup_size(64)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let x = global_id.x;\n                let c = global_id.y;\n                \n                if (x >= params.in_w || c >= params.in_c) { return; }\n                \n                var max_val = -1e38;\n                for (var y = 0u; y < params.in_h; y = y + 1u) {\n                    let val = input[(y * params.in_w + x) * params.in_c + c];\n                    if (val > max_val) { max_val = val; }\n                }\n                \n                var denom = 0.0;\n                var weighted = 0.0;\n                for (var y = 0u; y < params.in_h; y = y + 1u) {\n                    let val = input[(y * params.in_w + x) * params.in_c + c];\n                    let ev = exp(val - max_val);\n                    denom = denom + ev;\n                    weighted = weighted + ev * (f32(y) + 0.5) / f32(params.in_h);\n                }\n                \n                var out_val = 0.0;\n                if (denom > 0.0) { out_val = weighted / denom; }\n                output[c * params.in_w + x] = out_val;\n            }\n";
+  }
+});
+
+// shaders/embedding.wgsl
+var embedding_default;
+var init_embedding = __esm({
+  "shaders/embedding.wgsl"() {
+    embedding_default = "@group(0) @binding(0) var<storage, read> tokens : array<f32>;\n            @group(0) @binding(1) var<storage, read> weight : array<f32>;\n            @group(0) @binding(2) var<storage, read_write> output : array<f32>;\n            \n            struct Params { seq_len : u32, d_model : u32 }\n            @group(0) @binding(3) var<uniform> params : Params;\n\n            @compute @workgroup_size(64)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let token_idx = global_id.x;\n                if (token_idx >= params.seq_len) { return; }\n                \n                let d_model = params.d_model;\n                let token_id = u32(tokens[token_idx]);   // ids arrive as f32 (see CPU/WASM tiers)\n\n                let in_offset = token_id * d_model;\n                let out_offset = token_idx * d_model;\n                \n                for (var i = 0u; i < d_model; i = i + 1u) {\n                    output[out_offset + i] = weight[in_offset + i];\n                }\n            }\n";
+  }
+});
+
+// shaders/sDPA.wgsl
+var sDPA_default;
+var init_sDPA = __esm({
+  "shaders/sDPA.wgsl"() {
+    sDPA_default = "@group(0) @binding(0) var<storage, read> qkv : array<f32>;\n            @group(0) @binding(1) var<storage, read_write> output : array<f32>;\n            \n            struct Params {\n                seq_len : u32,\n                d_model : u32,\n                num_heads : u32,\n                head_dim : u32,\n                scale : f32,\n            }\n            @group(0) @binding(2) var<uniform> params : Params;\n            \n            @compute @workgroup_size(64, 1, 1)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let q_idx = global_id.x; \n                let h_idx = global_id.y; \n                \n                if (q_idx >= params.seq_len || h_idx >= params.num_heads) { return; }\n                \n                let head_dim = params.head_dim;\n                let d_model = params.d_model;\n                \n                var max_logit : f32 = -1e38;\n                \n                // Cache Q for this head and this q_idx\n                var q_cache : array<f32, 64>; // max head_dim 64\n                for (var d = 0u; d < head_dim; d = d + 1u) {\n                    q_cache[d] = qkv[q_idx * (d_model * 3u) + (h_idx * head_dim) + d];\n                }\n                \n                // Pass 1: find max\n                for (var k_idx = 0u; k_idx <= q_idx; k_idx = k_idx + 1u) {\n                    var score : f32 = 0.0;\n                    for (var d = 0u; d < head_dim; d = d + 1u) {\n                        let k_val = qkv[k_idx * (d_model * 3u) + d_model + (h_idx * head_dim) + d];\n                        score = score + (q_cache[d] * k_val);\n                    }\n                    score = score * params.scale;\n                    if (score > max_logit) { max_logit = score; }\n                }\n                \n                // Pass 2: sum exp\n                var sum_exp : f32 = 0.0;\n                for (var k_idx = 0u; k_idx <= q_idx; k_idx = k_idx + 1u) {\n                    var score : f32 = 0.0;\n                    for (var d = 0u; d < head_dim; d = d + 1u) {\n                        let k_val = qkv[k_idx * (d_model * 3u) + d_model + (h_idx * head_dim) + d];\n                        score = score + (q_cache[d] * k_val);\n                    }\n                    score = score * params.scale;\n                    sum_exp = sum_exp + exp(score - max_logit);\n                }\n                \n                // Pass 3: output\n                for (var d = 0u; d < head_dim; d = d + 1u) {\n                    var out_val : f32 = 0.0;\n                    for (var k_idx = 0u; k_idx <= q_idx; k_idx = k_idx + 1u) {\n                        var score : f32 = 0.0;\n                        for (var kd = 0u; kd < head_dim; kd = kd + 1u) {\n                            let k_val = qkv[k_idx * (d_model * 3u) + d_model + (h_idx * head_dim) + kd];\n                            score = score + (q_cache[kd] * k_val);\n                        }\n                        score = score * params.scale;\n                        \n                        let w = exp(score - max_logit) / sum_exp;\n                        let v_val = qkv[k_idx * (d_model * 3u) + d_model * 2u + (h_idx * head_dim) + d];\n                        out_val = out_val + (w * v_val);\n                    }\n                    output[q_idx * d_model + (h_idx * head_dim) + d] = out_val;\n                }\n            }\n";
+  }
+});
+
+// shaders/crossSDPA.wgsl
+var crossSDPA_default;
+var init_crossSDPA = __esm({
+  "shaders/crossSDPA.wgsl"() {
+    crossSDPA_default = "@group(0) @binding(0) var<storage, read> q_in : array<f32>;\n            @group(0) @binding(1) var<storage, read> k_in : array<f32>;\n            @group(0) @binding(2) var<storage, read> v_in : array<f32>;\n            @group(0) @binding(3) var<storage, read_write> output : array<f32>;\n            \n            struct Params {\n                seq_len_q : u32,\n                seq_len_kv : u32,\n                d_model : u32,\n                num_heads : u32,\n                head_dim : u32,\n                scale : f32,\n            }\n            @group(0) @binding(4) var<uniform> params : Params;\n            \n            @compute @workgroup_size(64, 1, 1)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let q_idx = global_id.x; \n                let h_idx = global_id.y; \n                \n                if (q_idx >= params.seq_len_q || h_idx >= params.num_heads) { return; }\n                \n                let head_dim = params.head_dim;\n                let d_model = params.d_model;\n                \n                // Cache Q for this head and this q_idx\n                var q_cache : array<f32, 64>; // max head_dim 64\n                for (var d = 0u; d < head_dim; d = d + 1u) {\n                    q_cache[d] = q_in[q_idx * d_model + (h_idx * head_dim) + d];\n                }\n                \n                var max_logit : f32 = -1e38;\n                \n                // Pass 1: find max\n                for (var k_idx = 0u; k_idx < params.seq_len_kv; k_idx = k_idx + 1u) {\n                    var score : f32 = 0.0;\n                    for (var d = 0u; d < head_dim; d = d + 1u) {\n                        let k_val = k_in[k_idx * d_model + (h_idx * head_dim) + d];\n                        score = score + (q_cache[d] * k_val);\n                    }\n                    score = score * params.scale;\n                    if (score > max_logit) { max_logit = score; }\n                }\n                \n                // Pass 2: sum exp\n                var sum_exp : f32 = 0.0;\n                for (var k_idx = 0u; k_idx < params.seq_len_kv; k_idx = k_idx + 1u) {\n                    var score : f32 = 0.0;\n                    for (var d = 0u; d < head_dim; d = d + 1u) {\n                        let k_val = k_in[k_idx * d_model + (h_idx * head_dim) + d];\n                        score = score + (q_cache[d] * k_val);\n                    }\n                    score = score * params.scale;\n                    sum_exp = sum_exp + exp(score - max_logit);\n                }\n                \n                // Pass 3: output\n                for (var d = 0u; d < head_dim; d = d + 1u) {\n                    var out_val : f32 = 0.0;\n                    for (var k_idx = 0u; k_idx < params.seq_len_kv; k_idx = k_idx + 1u) {\n                        var score : f32 = 0.0;\n                        for (var kd = 0u; kd < head_dim; kd = kd + 1u) {\n                            let k_val = k_in[k_idx * d_model + (h_idx * head_dim) + kd];\n                            score = score + (q_cache[kd] * k_val);\n                        }\n                        score = score * params.scale;\n                        \n                        let w = exp(score - max_logit) / sum_exp;\n                        let v_val = v_in[k_idx * d_model + (h_idx * head_dim) + d];\n                        out_val = out_val + (w * v_val);\n                    }\n                    output[q_idx * d_model + (h_idx * head_dim) + d] = out_val;\n                }\n            }\n";
+  }
+});
+
+// shaders/crossAttention.wgsl
+var crossAttention_default;
+var init_crossAttention = __esm({
+  "shaders/crossAttention.wgsl"() {
+    crossAttention_default = "@group(0) @binding(0) var<storage, read> q_in : array<f32>;\n            @group(0) @binding(1) var<storage, read> kv_in : array<f32>;\n            @group(0) @binding(2) var<storage, read> weight_int8_packed : array<u32>;\n            @group(0) @binding(3) var<storage, read> w_scale : array<f32>;\n            @group(0) @binding(4) var<storage, read> bias : array<f32>;\n            @group(0) @binding(5) var<storage, read_write> output : array<f32>;\n            \n            struct Params {\n                seq_len_q : u32,\n                seq_len_kv : u32,\n                d_model : u32,\n                num_heads : u32,\n                head_dim : u32,\n                scale_factor : f32,\n                has_scale : u32,\n                has_bias : u32,\n            }\n            @group(0) @binding(6) var<uniform> params : Params;\n            \n            @compute @workgroup_size(64, 1, 1)\n            fn main(@builtin(global_invocation_id) global_id : vec3<u32>) {\n                let q_idx = global_id.x; \n                let h_idx = global_id.y; \n                \n                if (q_idx >= params.seq_len_q || h_idx >= params.num_heads) { return; }\n                \n                let head_dim = params.head_dim;\n                let d_model = params.d_model;\n                let d_model_4 = d_model / 4u;\n                \n                // Cache Q for this head and this q_idx\n                var q_cache : array<f32, 64>; // max head_dim 64\n                for (var d = 0u; d < head_dim; d = d + 1u) {\n                    var sum = 0.0;\n                    let out_col = h_idx * head_dim + d;\n                    for (var i = 0u; i < d_model_4; i = i + 1u) {\n                        let w_packed = weight_int8_packed[out_col * d_model_4 + i];\n                        let in_base = q_idx * d_model + i * 4u;\n                        sum = sum + q_in[in_base + 0u] * f32(extractBits(i32(w_packed), 0u, 8u));\n                        sum = sum + q_in[in_base + 1u] * f32(extractBits(i32(w_packed), 8u, 8u));\n                        sum = sum + q_in[in_base + 2u] * f32(extractBits(i32(w_packed), 16u, 8u));\n                        sum = sum + q_in[in_base + 3u] * f32(extractBits(i32(w_packed), 24u, 8u));\n                    }\n                    if (params.has_scale > 0u) { sum = sum * w_scale[out_col]; }\n                    if (params.has_bias > 0u) { sum = sum + bias[out_col]; }\n                    q_cache[d] = sum;\n                }\n                \n                var max_logit : f32 = -1e38;\n                \n                // Pass 1: find max\n                for (var k_idx = 0u; k_idx < params.seq_len_kv; k_idx = k_idx + 1u) {\n                    var score : f32 = 0.0;\n                    for (var d = 0u; d < head_dim; d = d + 1u) {\n                        var k_val = 0.0;\n                        let out_col = d_model + h_idx * head_dim + d;\n                        for (var i = 0u; i < d_model_4; i = i + 1u) {\n                            let w_packed = weight_int8_packed[out_col * d_model_4 + i];\n                            let in_base = k_idx * d_model + i * 4u;\n                            k_val = k_val + kv_in[in_base + 0u] * f32(extractBits(i32(w_packed), 0u, 8u));\n                            k_val = k_val + kv_in[in_base + 1u] * f32(extractBits(i32(w_packed), 8u, 8u));\n                            k_val = k_val + kv_in[in_base + 2u] * f32(extractBits(i32(w_packed), 16u, 8u));\n                            k_val = k_val + kv_in[in_base + 3u] * f32(extractBits(i32(w_packed), 24u, 8u));\n                        }\n                        if (params.has_scale > 0u) { k_val = k_val * w_scale[out_col]; }\n                        if (params.has_bias > 0u) { k_val = k_val + bias[out_col]; }\n                        \n                        score = score + (q_cache[d] * k_val);\n                    }\n                    score = score * params.scale_factor;\n                    if (score > max_logit) { max_logit = score; }\n                }\n                \n                // Pass 2: sum exp\n                var sum_exp : f32 = 0.0;\n                for (var k_idx = 0u; k_idx < params.seq_len_kv; k_idx = k_idx + 1u) {\n                    var score : f32 = 0.0;\n                    for (var d = 0u; d < head_dim; d = d + 1u) {\n                        var k_val = 0.0;\n                        let out_col = d_model + h_idx * head_dim + d;\n                        for (var i = 0u; i < d_model_4; i = i + 1u) {\n                            let w_packed = weight_int8_packed[out_col * d_model_4 + i];\n                            let in_base = k_idx * d_model + i * 4u;\n                            k_val = k_val + kv_in[in_base + 0u] * f32(extractBits(i32(w_packed), 0u, 8u));\n                            k_val = k_val + kv_in[in_base + 1u] * f32(extractBits(i32(w_packed), 8u, 8u));\n                            k_val = k_val + kv_in[in_base + 2u] * f32(extractBits(i32(w_packed), 16u, 8u));\n                            k_val = k_val + kv_in[in_base + 3u] * f32(extractBits(i32(w_packed), 24u, 8u));\n                        }\n                        if (params.has_scale > 0u) { k_val = k_val * w_scale[out_col]; }\n                        if (params.has_bias > 0u) { k_val = k_val + bias[out_col]; }\n                        \n                        score = score + (q_cache[d] * k_val);\n                    }\n                    score = score * params.scale_factor;\n                    sum_exp = sum_exp + exp(score - max_logit);\n                }\n                \n                // Pass 3: output\n                for (var d = 0u; d < head_dim; d = d + 1u) {\n                    var out_val : f32 = 0.0;\n                    for (var k_idx = 0u; k_idx < params.seq_len_kv; k_idx = k_idx + 1u) {\n                        var score : f32 = 0.0;\n                        for (var kd = 0u; kd < head_dim; kd = kd + 1u) {\n                            var k_val = 0.0;\n                            let out_col = d_model + h_idx * head_dim + kd;\n                            for (var i = 0u; i < d_model_4; i = i + 1u) {\n                                let w_packed = weight_int8_packed[out_col * d_model_4 + i];\n                                let in_base = k_idx * d_model + i * 4u;\n                                k_val = k_val + kv_in[in_base + 0u] * f32(extractBits(i32(w_packed), 0u, 8u));\n                                k_val = k_val + kv_in[in_base + 1u] * f32(extractBits(i32(w_packed), 8u, 8u));\n                                k_val = k_val + kv_in[in_base + 2u] * f32(extractBits(i32(w_packed), 16u, 8u));\n                                k_val = k_val + kv_in[in_base + 3u] * f32(extractBits(i32(w_packed), 24u, 8u));\n                            }\n                            if (params.has_scale > 0u) { k_val = k_val * w_scale[out_col]; }\n                            if (params.has_bias > 0u) { k_val = k_val + bias[out_col]; }\n                            \n                            score = score + (q_cache[kd] * k_val);\n                        }\n                        score = score * params.scale_factor;\n                        \n                        let w = exp(score - max_logit) / sum_exp;\n                        \n                        var v_val = 0.0;\n                        let v_col = d_model * 2u + h_idx * head_dim + d;\n                        for (var i = 0u; i < d_model_4; i = i + 1u) {\n                            let w_packed = weight_int8_packed[v_col * d_model_4 + i];\n                            let in_base = k_idx * d_model + i * 4u;\n                            v_val = v_val + kv_in[in_base + 0u] * f32(extractBits(i32(w_packed), 0u, 8u));\n                            v_val = v_val + kv_in[in_base + 1u] * f32(extractBits(i32(w_packed), 8u, 8u));\n                            v_val = v_val + kv_in[in_base + 2u] * f32(extractBits(i32(w_packed), 16u, 8u));\n                            v_val = v_val + kv_in[in_base + 3u] * f32(extractBits(i32(w_packed), 24u, 8u));\n                        }\n                        if (params.has_scale > 0u) { v_val = v_val * w_scale[v_col]; }\n                        if (params.has_bias > 0u) { v_val = v_val + bias[v_col]; }\n                        \n                        out_val = out_val + (w * v_val);\n                    }\n                    output[q_idx * d_model + (h_idx * head_dim) + d] = out_val;\n                }\n            }\n";
+  }
+});
+
+// js/ShaderLibrary.js
+var ShaderLibrary_exports = {};
+__export(ShaderLibrary_exports, {
+  ShaderLibrary: () => ShaderLibrary
+});
+var ShaderLibrary;
+var init_ShaderLibrary = __esm({
+  "js/ShaderLibrary.js"() {
+    init_linearF32();
+    init_linearInt8();
+    init_conv2D();
+    init_conv2DDepthwise8();
+    init_conv2DPointwise16();
+    init_conv2DPointwise16Tile();
+    init_conv2DPointwise8Vec2();
+    init_conv2DPointwise8Vec4();
+    init_conv2DRegularC3Out16();
+    init_layerNorm();
+    init_binaryBroadcast();
+    init_elementwise();
+    init_resize();
+    init_slice();
+    init_sub();
+    init_div();
+    init_siLU();
+    init_leakyReLU();
+    init_tanh();
+    init_clip();
+    init_rMSNorm();
+    init_softmax();
+    init_pReLU();
+    init_logSoftmax();
+    init_reduce();
+    init_averagePool2D();
+    init_gather();
+    init_where();
+    init_dequantizeLinear();
+    init_expand();
+    init_pad();
+    init_convTranspose2D();
+    init_reLU();
+    init_sigmoid();
+    init_hardSwish();
+    init_hardSigmoid();
+    init_copy();
+    init_batchNorm2D();
+    init_gELU();
+    init_add();
+    init_upsample2x();
+    init_concatCopy();
+    init_concat2();
+    init_broadcastBinary();
+    init_generalTranspose();
+    init_split();
+    init_profileY();
+    init_profileX();
+    init_globalAveragePool();
+    init_meanHeight();
+    init_maxPool2D();
+    init_interp1D();
+    init_conv1D();
+    init_spatialSoftargmaxY();
+    init_embedding();
+    init_sDPA();
+    init_crossSDPA();
+    init_crossAttention();
+    ShaderLibrary = class {
+      static getLinearF32Shader() {
+        return linearF32_default;
+      }
+      static getLinearInt8Shader() {
+        return linearInt8_default;
+      }
+      static getConv2DShader() {
+        return conv2D_default;
+      }
+      static getConv2DDepthwise8Shader() {
+        return conv2DDepthwise8_default;
+      }
+      static getConv2DPointwise16Shader() {
+        return conv2DPointwise16_default;
+      }
+      static getConv2DPointwise16TileShader() {
+        return conv2DPointwise16Tile_default;
+      }
+      static getConv2DPointwise8Vec2Shader() {
+        return conv2DPointwise8Vec2_default;
+      }
+      static getConv2DPointwise8Vec4Shader() {
+        return conv2DPointwise8Vec4_default;
+      }
+      static getConv2DRegularC3Out16Shader() {
+        return conv2DRegularC3Out16_default;
+      }
+      static getLayerNormShader() {
+        return layerNorm_default;
+      }
+      static getBinaryBroadcastShader() {
+        return binaryBroadcast_default;
+      }
+      static getElementwiseShader() {
+        return elementwise_default;
+      }
+      static getResizeShader() {
+        return resize_default;
+      }
+      static getSliceShader() {
+        return slice_default;
+      }
+      static getSubShader() {
+        return sub_default;
+      }
+      static getDivShader() {
+        return div_default;
+      }
+      static getSiLUShader() {
+        return siLU_default;
+      }
+      static getLeakyReLUShader() {
+        return leakyReLU_default;
+      }
+      static getTanhShader() {
+        return tanh_default;
+      }
+      static getClipShader() {
+        return clip_default;
+      }
+      static getRMSNormShader() {
+        return rMSNorm_default;
+      }
+      static getSoftmaxShader() {
+        return softmax_default;
+      }
+      static getPReLUShader() {
+        return pReLU_default;
+      }
+      static getLogSoftmaxShader() {
+        return logSoftmax_default;
+      }
+      static getReduceShader() {
+        return reduce_default;
+      }
+      static getAveragePool2DShader() {
+        return averagePool2D_default;
+      }
+      static getGatherShader() {
+        return gather_default;
+      }
+      static getWhereShader() {
+        return where_default;
+      }
+      static getDequantizeLinearShader() {
+        return dequantizeLinear_default;
+      }
+      static getExpandShader() {
+        return expand_default;
+      }
+      static getPadShader() {
+        return pad_default;
+      }
+      static getConvTranspose2DShader() {
+        return convTranspose2D_default;
+      }
+      static getReLUShader() {
+        return reLU_default;
+      }
+      static getSigmoidShader() {
+        return sigmoid_default;
+      }
+      static getHardSwishShader() {
+        return hardSwish_default;
+      }
+      static getHardSigmoidShader() {
+        return hardSigmoid_default;
+      }
+      static getCopyShader() {
+        return copy_default;
+      }
+      static getBatchNorm2DShader() {
+        return batchNorm2D_default;
+      }
+      static getGELUShader() {
+        return gELU_default;
+      }
+      static getAddShader() {
+        return add_default;
+      }
+      static getUpsample2xShader() {
+        return upsample2x_default;
+      }
+      static getConcatCopyShader() {
+        return concatCopy_default;
+      }
+      static getConcat2Shader() {
+        return concat2_default;
+      }
+      static getBroadcastBinaryShader(binOp = "out_val = av + bv;") {
+        return broadcastBinary_default.replace("//__BINOP__", binOp);
+      }
+      static getGeneralTransposeShader() {
+        return generalTranspose_default;
+      }
+      static getSplitShader() {
+        return split_default;
+      }
+      static getProfileYShader() {
+        return profileY_default;
+      }
+      static getProfileXShader() {
+        return profileX_default;
+      }
+      static getGlobalAveragePoolShader() {
+        return globalAveragePool_default;
+      }
+      static getMeanHeightShader() {
+        return meanHeight_default;
+      }
+      static getMaxPool2DShader() {
+        return maxPool2D_default;
+      }
+      static getInterp1DShader() {
+        return interp1D_default;
+      }
+      static getConv1DShader() {
+        return conv1D_default;
+      }
+      static getSpatialSoftargmaxYShader() {
+        return spatialSoftargmaxY_default;
+      }
+      static getEmbeddingShader() {
+        return embedding_default;
+      }
+      static getSDPAShader() {
+        return sDPA_default;
+      }
+      static getCrossSDPAShader() {
+        return crossSDPA_default;
+      }
+      static getCrossAttentionShader() {
+        return crossAttention_default;
+      }
+    };
+  }
+});
+
+// js/Tensor.js
+var Tensor = class {
+  constructor(name, shape, dtype = "float32", isWeight = false) {
+    this.name = name;
+    this.shape = shape;
+    this.dtype = dtype;
+    this.isWeight = isWeight;
+    this.gpuBuffer = null;
+    this.sizeBytes = this._calculateByteSize();
+  }
+  _calculateByteSize() {
+    const elements = this.shape.reduce((a, b) => a * b, 1);
+    if (this.dtype === "float32" || this.dtype === "int32") return elements * 4;
+    if (this.dtype === "int8" || this.dtype === "uint8") return elements;
+    return elements * 4;
+  }
+};
+function _pair(v, def) {
+  if (Array.isArray(v)) return [v[0], v[1] ?? v[0]];
+  const s = v ?? def;
+  return [s, s];
+}
+
+// js/Graph.js
+var Graph = class {
+  constructor() {
+    this.nodes = [];
+    this.tensors = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Define an input tensor
+   */
+  addInput(name, shape, dtype = "float32") {
+    const tensor = new Tensor(name, shape, dtype, false);
+    this.tensors.set(name, tensor);
+    return tensor;
+  }
+  /**
+   * Define a weight tensor (learned parameter)
+   */
+  addWeight(name, shape, dtype = "float32") {
+    const tensor = new Tensor(name, shape, dtype, true);
+    this.tensors.set(name, tensor);
+    return tensor;
+  }
+  /**
+   * Add a computation operation to the graph
+   * @param {string} opType - e.g., 'MatMul', 'Conv2D', 'LayerNorm'
+   * @param {Object} inputs - Key-value pair of input names to Tensor objects
+   * @param {Object} outputs - Key-value pair of output names to Tensor shapes
+   * @param {Object} params - Uniform parameters for the shader (e.g., stride, kernel size)
+   */
+  addOp(opType, inputs, outputs, params = {}) {
+    const outTensors = {};
+    for (const [key, shape] of Object.entries(outputs)) {
+      const outName = `${opType}_${this.nodes.length}_out_${key}`;
+      const t = new Tensor(outName, shape, "float32", false);
+      this.tensors.set(outName, t);
+      outTensors[key] = t;
+    }
+    const node = {
+      id: this.nodes.length,
+      opType,
+      inputs,
+      outputs: outTensors,
+      params
+    };
+    this.nodes.push(node);
+    return outTensors;
+  }
+};
+
+// js/ops/pReLU.js
+function _cpuPReLU(node) {
+  const inBuf = (node.inputs.input || node.inputs.x).buffer;
+  const slope = (node.inputs.slope || node.inputs.weight).buffer;
+  const outBuf = node.outputs.out.buffer;
+  const shape = (node.inputs.input || node.inputs.x).shape || [];
+  const channels = shape.length === 4 ? shape[3] : slope.length;
+  for (let i = 0; i < outBuf.length; i++) {
+    const alpha = slope.length === channels ? slope[i % channels] : slope[i % slope.length];
+    outBuf[i] = inBuf[i] < 0 ? inBuf[i] * alpha : inBuf[i];
+  }
+}
+
+// js/ops/expand.js
+function _cpuExpand(node) {
+  const inBuf = node.inputs.input.buffer;
+  const outBuf = node.outputs.out.buffer;
+  if (inBuf.length === 1) {
+    for (let i = 0; i < outBuf.length; i++) outBuf[i] = inBuf[0];
+  } else if (inBuf.length === outBuf.length) {
+    outBuf.set(inBuf);
+  } else {
+    const pad4 = (sh) => [1, 1, 1, 1].slice(0, 4 - sh.length).concat(sh);
+    const [ib, ih, iw, ic] = pad4(node.inputs.input.shape);
+    const [ob, oh, ow, oc] = pad4(node.outputs.out.shape);
+    for (let b = 0; b < ob; b++) {
+      for (let y = 0; y < oh; y++) {
+        for (let x = 0; x < ow; x++) {
+          for (let c = 0; c < oc; c++) {
+            const src = ((b % ib * ih + y % ih) * iw + x % iw) * ic + c % ic;
+            const dst = ((b * oh + y) * ow + x) * oc + c;
+            outBuf[dst] = inBuf[src];
+          }
+        }
+      }
+    }
+  }
+}
+
+// js/ops/dequantizeLinear.js
+function _cpuDequantizeLinear(node) {
+  const inBuf = node.inputs.input.buffer;
+  const scale = node.inputs.scale.buffer[0];
+  const zp = node.inputs.zero_point ? node.inputs.zero_point.buffer[0] : 0;
+  const outBuf = node.outputs.out.buffer;
+  for (let i = 0; i < outBuf.length; i++) {
+    outBuf[i] = (inBuf[i] - zp) * scale;
+  }
+}
+
+// js/ops/tanh.js
+function _cpuTanh(node) {
+  const inBuf = node.inputs.input.buffer;
+  const outBuf = node.outputs.out.buffer;
+  for (let i = 0; i < outBuf.length; i++) {
+    outBuf[i] = Math.tanh(inBuf[i]);
+  }
+}
+
+// js/ops/rMSNorm.js
+function _cpuRMSNorm(node) {
+  const input = node.inputs.input || node.inputs.x;
+  const weight = node.inputs.weight;
+  const outBuf = node.outputs.out.buffer;
+  const in_shape = input.shape.length === 2 ? input.shape : [1, input.buffer.length];
+  const b = in_shape[0], d = in_shape[1];
+  const eps = node.params.eps || 1e-5;
+  for (let i = 0; i < b; i++) {
+    let sq_sum = 0;
+    for (let j = 0; j < d; j++) sq_sum += input.buffer[i * d + j] * input.buffer[i * d + j];
+    const rms = Math.sqrt(sq_sum / d + eps);
+    for (let j = 0; j < d; j++) outBuf[i * d + j] = input.buffer[i * d + j] / rms * weight.buffer[j];
+  }
+}
+
+// js/ops/siLU.js
+function _cpuSiLU(node) {
+  const inBuf = node.inputs.input.buffer;
+  const outBuf = node.outputs.out.buffer;
+  for (let i = 0; i < outBuf.length; i++) {
+    const x = inBuf[i];
+    outBuf[i] = x / (1 + Math.exp(-x));
+  }
+}
+
+// js/ops/sub.js
+function _cpuSub(node) {
+  const aBuf = node.inputs.a.buffer;
+  const bBuf = node.inputs.b.buffer;
+  const outBuf = node.outputs.out.buffer;
+  const elements = outBuf.length;
+  if (bBuf.length === 1) {
+    for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] - bBuf[0];
+  } else {
+    for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] - bBuf[i];
+  }
+}
+
+// js/ops/logSoftmax.js
+function _cpuLogSoftmax(node) {
+  const input = node.inputs.input || node.inputs.x;
+  const outBuf = node.outputs.out.buffer;
+  const in_shape = input.shape.length === 2 ? input.shape : [1, input.buffer.length];
+  const b = in_shape[0];
+  const d = in_shape[1];
+  for (let i = 0; i < b; i++) {
+    let max = -Infinity;
+    for (let j = 0; j < d; j++) max = Math.max(max, input.buffer[i * d + j]);
+    let sum = 0;
+    for (let j = 0; j < d; j++) sum += Math.exp(input.buffer[i * d + j] - max);
+    const logSum = Math.log(sum);
+    for (let j = 0; j < d; j++) outBuf[i * d + j] = input.buffer[i * d + j] - max - logSum;
+  }
+}
+
+// js/ops/softmax.js
+function _cpuSoftmax(node) {
+  const input = node.inputs.input || node.inputs.x;
+  const outBuf = node.outputs.out.buffer;
+  const in_shape = input.shape.length === 2 ? input.shape : [1, input.buffer.length];
+  const b = in_shape[0];
+  const d = in_shape[1];
+  for (let i = 0; i < b; i++) {
+    let max = -Infinity;
+    for (let j = 0; j < d; j++) max = Math.max(max, input.buffer[i * d + j]);
+    let sum = 0;
+    for (let j = 0; j < d; j++) {
+      const val = Math.exp(input.buffer[i * d + j] - max);
+      outBuf[i * d + j] = val;
+      sum += val;
+    }
+    for (let j = 0; j < d; j++) outBuf[i * d + j] /= sum;
+  }
+}
+
+// js/ops/where.js
+function _cpuWhere(node) {
+  const cond = node.inputs.cond || node.inputs.condition;
+  const a = node.inputs.x || node.inputs.a;
+  const b = node.inputs.y || node.inputs.b;
+  const outBuf = node.outputs.out.buffer;
+  const condBuf = cond.buffer;
+  const aBuf = a.buffer;
+  const bBuf = b.buffer;
+  const elements = outBuf.length;
+  for (let i = 0; i < elements; i++) {
+    outBuf[i] = condBuf[i] !== 0 ? aBuf[i] : bBuf[i];
+  }
+}
+
+// js/ops/pad.js
+function _cpuPad(node) {
+  const input = node.inputs.input || node.inputs.data;
+  const outBuf = node.outputs.out.buffer;
+  const pads = node.params.pads || [];
+  const val = node.params.value || 0;
+  let pt = 0, pb = 0, pl = 0, pr = 0;
+  if (pads.length === 8) {
+    pt = pads[1];
+    pl = pads[2];
+    pb = pads[5];
+    pr = pads[6];
+  } else if (pads.length === 4) {
+    pt = pads[0];
+    pl = pads[1];
+    pb = pads[2];
+    pr = pads[3];
+  }
+  const inShape = input.shape.length === 4 ? input.shape : [1, input.shape[0] || 1, input.shape[1] || 1, 1];
+  const [b, in_h, in_w, c] = inShape;
+  const out_h = in_h + pt + pb;
+  const out_w = in_w + pl + pr;
+  for (let i = 0; i < outBuf.length; i++) outBuf[i] = val;
+  for (let batch = 0; batch < b; batch++) {
+    for (let y = 0; y < in_h; y++) {
+      for (let x = 0; x < in_w; x++) {
+        for (let chan = 0; chan < c; chan++) {
+          const inIdx = ((batch * in_h + y) * in_w + x) * c + chan;
+          const outIdx = ((batch * out_h + (y + pt)) * out_w + (x + pl)) * c + chan;
+          outBuf[outIdx] = input.buffer[inIdx];
+        }
+      }
+    }
+  }
+}
+
+// js/ops/averagePool2D.js
+function _cpuAveragePool2D(node) {
+  const input = node.inputs.input || node.inputs.x;
+  const inBuf = input.buffer;
+  const outBuf = node.outputs.out.buffer;
+  const [b, in_h, in_w, c] = input.shape;
+  const [out_b, out_h, out_w, out_c] = node.outputs.out.shape;
+  const kh = node.params.kernel[0], kw = node.params.kernel[1];
+  const sh = node.params.stride ? node.params.stride[0] : 1;
+  const sw = node.params.stride ? node.params.stride[1] : 1;
+  const ph = node.params.padding ? node.params.padding[0] : 0;
+  const pw = node.params.padding ? node.params.padding[1] : 0;
+  for (let batch = 0; batch < b; batch++) {
+    for (let y = 0; y < out_h; y++) {
+      for (let x = 0; x < out_w; x++) {
+        for (let chan = 0; chan < c; chan++) {
+          let sum = 0;
+          let count = 0;
+          for (let ky = 0; ky < kh; ky++) {
+            for (let kx = 0; kx < kw; kx++) {
+              const in_y = y * sh - ph + ky;
+              const in_x = x * sw - pw + kx;
+              if (in_y >= 0 && in_y < in_h && in_x >= 0 && in_x < in_w) {
+                const inIdx = ((batch * in_h + in_y) * in_w + in_x) * c + chan;
+                sum += inBuf[inIdx];
+                count++;
+              }
+            }
+          }
+          const outIdx = ((batch * out_h + y) * out_w + x) * out_c + chan;
+          outBuf[outIdx] = count > 0 ? sum / count : 0;
+        }
+      }
+    }
+  }
+}
+
+// js/ops/slice.js
+function _cpuSlice(node) {
+  const input = node.inputs.input || node.inputs.data;
+  const outBuf = node.outputs.out.buffer;
+  const starts = node.params.starts || [0, 0, 0, 0];
+  const steps = node.params.steps || [1, 1, 1, 1];
+  const axes = node.params.axes || [0, 1, 2, 3];
+  const in_s = [1, 1, 1, 1].slice(0, 4 - input.shape.length).concat(input.shape);
+  const out_s = [1, 1, 1, 1].slice(0, 4 - node.outputs.out.shape.length).concat(node.outputs.out.shape);
+  const st = [0, 0, 0, 0];
+  const sp = [1, 1, 1, 1];
+  for (let i = 0; i < axes.length; i++) {
+    let ax = axes[i];
+    if (ax < 0) ax += input.shape.length;
+    ax += 4 - input.shape.length;
+    st[ax] = starts[i] < 0 ? starts[i] + in_s[ax] : starts[i];
+    sp[ax] = steps[i];
+  }
+  let outIdx = 0;
+  for (let i0 = 0; i0 < out_s[0]; i0++) {
+    for (let i1 = 0; i1 < out_s[1]; i1++) {
+      for (let i2 = 0; i2 < out_s[2]; i2++) {
+        for (let i3 = 0; i3 < out_s[3]; i3++) {
+          const src0 = st[0] + i0 * sp[0];
+          const src1 = st[1] + i1 * sp[1];
+          const src2 = st[2] + i2 * sp[2];
+          const src3 = st[3] + i3 * sp[3];
+          const inIdx = src0 * (in_s[1] * in_s[2] * in_s[3]) + src1 * (in_s[2] * in_s[3]) + src2 * in_s[3] + src3;
+          outBuf[outIdx++] = input.buffer[inIdx];
+        }
+      }
+    }
+  }
+}
+
+// js/ops/convTranspose2D.js
+function _cpuConvTranspose2D(node) {
+  const input = node.inputs.input || node.inputs.x;
+  const weight = node.inputs.weight;
+  const bias = node.inputs.bias;
+  const inBuf = input.buffer;
+  const wBuf = weight.buffer;
+  const bBuf = bias ? bias.buffer : null;
+  const outBuf = node.outputs.out.buffer;
+  const [b, in_h, in_w, in_c] = input.shape;
+  const [out_b, out_h, out_w, out_c] = node.outputs.out.shape;
+  const kh = node.params.kernel[0], kw = node.params.kernel[1];
+  const sh = node.params.stride ? node.params.stride[0] : 1;
+  const sw = node.params.stride ? node.params.stride[1] : 1;
+  const ph = node.params.padding ? node.params.padding[0] : 0;
+  const pw = node.params.padding ? node.params.padding[1] : 0;
+  for (let i = 0; i < outBuf.length; i++) {
+    outBuf[i] = bBuf ? bBuf[i % out_c] : 0;
+  }
+  for (let i_b = 0; i_b < b; i_b++) {
+    for (let i_ic = 0; i_ic < in_c; i_ic++) {
+      for (let iy = 0; iy < in_h; iy++) {
+        for (let ix = 0; ix < in_w; ix++) {
+          const in_val = inBuf[((i_b * in_h + iy) * in_w + ix) * in_c + i_ic];
+          for (let oc = 0; oc < out_c; oc++) {
+            for (let ky = 0; ky < kh; ky++) {
+              for (let kx = 0; kx < kw; kx++) {
+                const oy = iy * sh - ph + ky;
+                const ox = ix * sw - pw + kx;
+                if (oy >= 0 && oy < out_h && ox >= 0 && ox < out_w) {
+                  const w_val = wBuf[i_ic * (out_c * kh * kw) + oc * (kh * kw) + ky * kw + kx];
+                  outBuf[((i_b * out_h + oy) * out_w + ox) * out_c + oc] += in_val * w_val;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+// js/ops/reduceSum.js
+function _cpuReduceSum(node) {
+  const input = node.inputs.input || node.inputs.data;
+  const inBuf = input.buffer;
+  const outBuf = node.outputs.out.buffer;
+  const in_shape = input.shape.length === 2 ? input.shape : [1, input.buffer.length];
+  const b = in_shape[0];
+  const d = in_shape[1];
+  for (let i = 0; i < b; i++) {
+    let sum = 0;
+    for (let j = 0; j < d; j++) {
+      sum += inBuf[i * d + j];
+    }
+    outBuf[i] = sum;
+  }
+}
+
+// js/ops/reduceMean.js
+function _cpuReduceMean(node) {
+  const input = node.inputs.input || node.inputs.data;
+  const inBuf = input.buffer;
+  const outBuf = node.outputs.out.buffer;
+  const in_shape = input.shape.length === 2 ? input.shape : [1, input.buffer.length];
+  const b = in_shape[0];
+  const d = in_shape[1];
+  for (let i = 0; i < b; i++) {
+    let sum = 0;
+    for (let j = 0; j < d; j++) {
+      sum += inBuf[i * d + j];
+    }
+    outBuf[i] = sum / d;
+  }
+}
+
+// js/ops/batchNorm2D.js
+function _cpuBatchNorm2D(node) {
+  const input = node.inputs.input || node.inputs.x;
+  const weight = node.inputs.weight || node.inputs.scale;
+  const bias = node.inputs.bias || node.inputs.b;
+  const running_mean = node.inputs.running_mean || node.inputs.mean;
+  const running_var = node.inputs.running_var || node.inputs.var;
+  const outBuf = node.outputs.out.buffer;
+  const [b, h, w, c] = input.shape;
+  const eps = node.params.eps || 1e-5;
+  for (let batch = 0; batch < b; batch++) {
+    for (let chan = 0; chan < c; chan++) {
+      const w_val = weight.buffer[chan];
+      const b_val = bias ? bias.buffer[chan] : 0;
+      const rm_val = running_mean.buffer[chan];
+      const rv_val = running_var.buffer[chan];
+      for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) {
+          const idx = ((batch * h + y) * w + x) * c + chan;
+          const val = input.buffer[idx];
+          outBuf[idx] = (val - rm_val) / Math.sqrt(rv_val + eps) * w_val + b_val;
+        }
+      }
+    }
+  }
+}
+
+// js/ops/div.js
+function _cpuDiv(node) {
+  const a = node.inputs.a;
+  const b = node.inputs.b;
+  const out = node.outputs.out;
+  const aBuf = a.buffer;
+  const bBuf = b.buffer;
+  const outBuf = out.buffer;
+  if (bBuf.length === 1) {
+    for (let i = 0; i < aBuf.length; i++) outBuf[i] = aBuf[i] / bBuf[0];
+  } else {
+    for (let i = 0; i < aBuf.length; i++) outBuf[i] = aBuf[i] / bBuf[i % bBuf.length];
+  }
+}
+
+// js/ops/nonMaxSuppression.js
+function _cpuNonMaxSuppression(node) {
+  const boxes = node.inputs.boxes;
+  const scores = node.inputs.scores;
+  const out = node.outputs.out;
+  let max_output_boxes_per_class = 0;
+  if (node.inputs.max_output_boxes_per_class) max_output_boxes_per_class = node.inputs.max_output_boxes_per_class.buffer[0];
+  let iou_threshold = 0.5;
+  if (node.inputs.iou_threshold) iou_threshold = node.inputs.iou_threshold.buffer[0];
+  let score_threshold = 0;
+  if (node.inputs.score_threshold) score_threshold = node.inputs.score_threshold.buffer[0];
+  const num_batches = boxes.shape[0];
+  const spatial_dimension = boxes.shape[1];
+  const num_classes = scores.shape[1];
+  let outIdx = 0;
+  for (let b = 0; b < num_batches; b++) {
+    for (let c = 0; c < num_classes; c++) {
+      let candidates = [];
+      for (let s = 0; s < spatial_dimension; s++) {
+        const score = scores.buffer[b * (num_classes * spatial_dimension) + c * spatial_dimension + s];
+        if (score >= score_threshold) {
+          const y1 = boxes.buffer[b * (spatial_dimension * 4) + s * 4 + 0];
+          const x1 = boxes.buffer[b * (spatial_dimension * 4) + s * 4 + 1];
+          const y2 = boxes.buffer[b * (spatial_dimension * 4) + s * 4 + 2];
+          const x2 = boxes.buffer[b * (spatial_dimension * 4) + s * 4 + 3];
+          candidates.push({ s, score, y1, x1, y2, x2 });
+        }
+      }
+      candidates.sort((a, b_) => b_.score - a.score);
+      let selected = [];
+      for (let i = 0; i < candidates.length && selected.length < max_output_boxes_per_class; i++) {
+        const cand = candidates[i];
+        let keep = true;
+        for (let j = 0; j < selected.length; j++) {
+          const sel = selected[j];
+          const xx1 = Math.max(cand.x1, sel.x1);
+          const yy1 = Math.max(cand.y1, sel.y1);
+          const xx2 = Math.min(cand.x2, sel.x2);
+          const yy2 = Math.min(cand.y2, sel.y2);
+          const w = Math.max(0, xx2 - xx1);
+          const h = Math.max(0, yy2 - yy1);
+          const inter = w * h;
+          const areaCand = (cand.x2 - cand.x1) * (cand.y2 - cand.y1);
+          const areaSel = (sel.x2 - sel.x1) * (sel.y2 - sel.y1);
+          const iou = inter / (areaCand + areaSel - inter);
+          if (iou > iou_threshold) {
+            keep = false;
+            break;
+          }
+        }
+        if (keep) {
+          selected.push(cand);
+          if (outIdx < out.buffer.length / 3) {
+            out.buffer[outIdx * 3 + 0] = b;
+            out.buffer[outIdx * 3 + 1] = c;
+            out.buffer[outIdx * 3 + 2] = cand.s;
+            outIdx++;
+          }
+        }
+      }
+    }
+  }
+  while (outIdx < out.buffer.length / 3) {
+    out.buffer[outIdx * 3 + 0] = -1;
+    out.buffer[outIdx * 3 + 1] = -1;
+    out.buffer[outIdx * 3 + 2] = -1;
+    outIdx++;
+  }
+}
+
+// js/ops/gather.js
+function _cpuGather(node) {
+  const input = node.inputs.input;
+  const indices = node.inputs.indices;
+  const out = node.outputs.out;
+  let axis = node.params.axis || 0;
+  if (axis < 0) axis += input.shape.length;
+  const inShape = input.shape;
+  const outShape = out.shape;
+  const idxShape = indices.shape;
+  let inStrides = new Array(inShape.length);
+  let s = 1;
+  for (let i = inShape.length - 1; i >= 0; i--) {
+    inStrides[i] = s;
+    s *= inShape[i];
+  }
+  let outStrides = new Array(outShape.length);
+  s = 1;
+  for (let i = outShape.length - 1; i >= 0; i--) {
+    outStrides[i] = s;
+    s *= outShape[i];
+  }
+  let idxStrides = new Array(idxShape.length);
+  s = 1;
+  for (let i = idxShape.length - 1; i >= 0; i--) {
+    idxStrides[i] = s;
+    s *= idxShape[i];
+  }
+  for (let i = 0; i < out.buffer.length; i++) {
+    let temp = i;
+    let outCoords = new Array(outShape.length);
+    for (let d = 0; d < outShape.length; d++) {
+      outCoords[d] = Math.floor(temp / outStrides[d]);
+      temp %= outStrides[d];
+    }
+    let idxOffset = 0;
+    for (let d = 0; d < idxShape.length; d++) {
+      idxOffset += outCoords[axis + d] * idxStrides[d];
+    }
+    let gatherIdx = indices.buffer[idxOffset];
+    if (gatherIdx < 0) {
+      out.buffer[i] = -1;
+      continue;
+    }
+    let inOffset = 0;
+    for (let d = 0; d < axis; d++) {
+      inOffset += outCoords[d] * inStrides[d];
+    }
+    inOffset += gatherIdx * inStrides[axis];
+    for (let d = axis + 1; d < inShape.length; d++) {
+      inOffset += outCoords[d - 1 + idxShape.length] * inStrides[d];
+    }
+    out.buffer[i] = input.buffer[inOffset];
+  }
+}
+
+// js/ops/gatherElements.js
+function _cpuGatherElements(node) {
+  const data = node.inputs.input || node.inputs.data;
+  const indices = node.inputs.indices;
+  const out = node.outputs.out;
+  const dBuf = data.buffer;
+  const iBuf = indices.buffer;
+  const oBuf = out.buffer;
+  const dShape = data.shape;
+  const iShape = indices.shape;
+  let axis = node.params.axis !== void 0 ? node.params.axis : 0;
+  if (axis < 0) axis += dShape.length;
+  const dStrides = new Array(dShape.length);
+  {
+    let s = 1;
+    for (let k = dShape.length - 1; k >= 0; k--) {
+      dStrides[k] = s;
+      s *= dShape[k];
+    }
+  }
+  const iStrides = new Array(iShape.length);
+  {
+    let s = 1;
+    for (let k = iShape.length - 1; k >= 0; k--) {
+      iStrides[k] = s;
+      s *= iShape[k];
+    }
+  }
+  const rank = iShape.length;
+  const coord = new Array(rank);
+  for (let lin = 0; lin < oBuf.length; lin++) {
+    let rem = lin;
+    for (let k = 0; k < rank; k++) {
+      coord[k] = Math.floor(rem / iStrides[k]);
+      rem %= iStrides[k];
+    }
+    let idx = iBuf[lin] | 0;
+    if (idx < 0) idx += dShape[axis];
+    let off = 0;
+    for (let k = 0; k < rank; k++) off += (k === axis ? idx : coord[k]) * dStrides[k];
+    oBuf[lin] = dBuf[off];
+  }
+}
+
+// js/ops/crossAttention.js
+function _cpuCrossAttention(node) {
+  const q_in = node.inputs.q.buffer;
+  const kv_in = node.inputs.kv.buffer;
+  const wBuf = node.inputs.weight.buffer;
+  const scale = node.inputs.scale ? node.inputs.scale.buffer : null;
+  const bias = node.inputs.bias ? node.inputs.bias.buffer : null;
+  const outBuf = node.outputs.out.buffer;
+  const seq_len_q = node.inputs.q.shape[1];
+  const seq_len_kv = node.inputs.kv.shape[1];
+  const d_model = node.outputs.out.shape[2];
+  const num_heads = node.params.heads || 8;
+  const head_dim = d_model / num_heads;
+  const scale_factor = 1 / Math.sqrt(head_dim);
+  for (let h = 0; h < num_heads; h++) {
+    for (let q = 0; q < seq_len_q; q++) {
+      const q_proj = new Float32Array(head_dim);
+      for (let d = 0; d < head_dim; d++) {
+        let sum = 0;
+        const out_col = h * head_dim + d;
+        for (let i = 0; i < d_model; i++) {
+          sum += q_in[q * d_model + i] * wBuf[out_col * d_model + i];
+        }
+        if (scale) sum *= scale[out_col];
+        if (bias) sum += bias[out_col];
+        q_proj[d] = sum;
+      }
+      const logits = new Float32Array(seq_len_kv);
+      let max_logit = -Infinity;
+      for (let k = 0; k < seq_len_kv; k++) {
+        let score = 0;
+        for (let d = 0; d < head_dim; d++) {
+          let k_val = 0;
+          const out_col = d_model + h * head_dim + d;
+          for (let i = 0; i < d_model; i++) {
+            k_val += kv_in[k * d_model + i] * wBuf[out_col * d_model + i];
+          }
+          if (scale) k_val *= scale[out_col];
+          if (bias) k_val += bias[out_col];
+          score += q_proj[d] * k_val;
+        }
+        score *= scale_factor;
+        logits[k] = score;
+        if (score > max_logit) max_logit = score;
+      }
+      let sum_exp = 0;
+      for (let k = 0; k < seq_len_kv; k++) {
+        const exp_val = Math.exp(logits[k] - max_logit);
+        logits[k] = exp_val;
+        sum_exp += exp_val;
+      }
+      for (let d = 0; d < head_dim; d++) {
+        let out_val = 0;
+        for (let k = 0; k < seq_len_kv; k++) {
+          const w = logits[k] / sum_exp;
+          let v_val = 0;
+          const out_col = d_model * 2 + h * head_dim + d;
+          for (let i = 0; i < d_model; i++) {
+            v_val += kv_in[k * d_model + i] * wBuf[out_col * d_model + i];
+          }
+          if (scale) v_val *= scale[out_col];
+          if (bias) v_val += bias[out_col];
+          out_val += w * v_val;
+        }
+        outBuf[q * d_model + h * head_dim + d] = out_val;
+      }
+    }
+  }
+}
+
+// js/ops/spatialSoftargmaxY.js
+function _cpuSpatialSoftargmaxY(node) {
+  const input = node.inputs.input;
+  const output = node.outputs.out;
+  const inBuf = input.buffer;
+  const outBuf = output.buffer;
+  const h = input.shape[1];
+  const w = input.shape[2];
+  const c = input.shape[3];
+  for (let ch = 0; ch < c; ch++) {
+    const outBase = ch * w;
+    for (let x = 0; x < w; x++) {
+      let maxLogit = -Infinity;
+      for (let y = 0; y < h; y++) {
+        const v = inBuf[(y * w + x) * c + ch];
+        if (v > maxLogit) maxLogit = v;
+      }
+      let denom = 0;
+      let weighted = 0;
+      for (let y = 0; y < h; y++) {
+        const ev = Math.exp(inBuf[(y * w + x) * c + ch] - maxLogit);
+        denom += ev;
+        weighted += ev * ((y + 0.5) / h);
+      }
+      outBuf[outBase + x] = denom > 0 ? weighted / denom : 0;
+    }
+  }
+}
+
+// js/ops/transpose.js
+function _cpuTranspose(node) {
+  const input = node.inputs.input;
+  const inBuf = input.buffer;
+  const inShape = input.shape;
+  const outBuf = node.outputs.out.buffer;
+  const perm = node.params.perm || [...Array(inShape.length).keys()].reverse();
+  const inStrides = new Array(inShape.length);
+  let s = 1;
+  for (let i = inShape.length - 1; i >= 0; i--) {
+    inStrides[i] = s;
+    s *= inShape[i];
+  }
+  const outShape = perm.map((p) => inShape[p]);
+  const outStrides = new Array(outShape.length);
+  s = 1;
+  for (let i = outShape.length - 1; i >= 0; i--) {
+    outStrides[i] = s;
+    s *= outShape[i];
+  }
+  const elements = inBuf.length;
+  for (let i = 0; i < elements; i++) {
+    let inIdx = 0;
+    let temp = i;
+    for (let j = 0; j < outShape.length; j++) {
+      const outCoord = Math.floor(temp / outStrides[j]);
+      temp %= outStrides[j];
+      inIdx += outCoord * inStrides[perm[j]];
+    }
+    outBuf[i] = inBuf[inIdx];
+  }
+}
+
+// js/ops/crossSDPA.js
+function _cpuCrossSDPA(node) {
+  const q = node.inputs.q.buffer;
+  const k = node.inputs.k.buffer;
+  const v = node.inputs.v.buffer;
+  const outBuf = node.outputs.out.buffer;
+  const seqQ = node.inputs.q.shape[1];
+  const seqKV = node.inputs.k.shape[1];
+  const d_model = node.outputs.out.shape[node.outputs.out.shape.length - 1];
+  const heads = node.params.heads || 8;
+  const head_dim = d_model / heads;
+  const scale = 1 / Math.sqrt(head_dim);
+  for (let h = 0; h < heads; h++) {
+    for (let qi = 0; qi < seqQ; qi++) {
+      const logits = new Float32Array(seqKV);
+      let mx = -Infinity;
+      for (let ki = 0; ki < seqKV; ki++) {
+        let s = 0;
+        for (let d = 0; d < head_dim; d++) {
+          s += q[qi * d_model + h * head_dim + d] * k[ki * d_model + h * head_dim + d];
+        }
+        s *= scale;
+        logits[ki] = s;
+        if (s > mx) mx = s;
+      }
+      let sum = 0;
+      for (let ki = 0; ki < seqKV; ki++) {
+        const e = Math.exp(logits[ki] - mx);
+        logits[ki] = e;
+        sum += e;
+      }
+      for (let d = 0; d < head_dim; d++) {
+        let o = 0;
+        for (let ki = 0; ki < seqKV; ki++) {
+          o += logits[ki] / sum * v[ki * d_model + h * head_dim + d];
+        }
+        outBuf[qi * d_model + h * head_dim + d] = o;
+      }
+    }
+  }
+}
+
+// js/ops/meanHeight.js
+function _cpuMeanHeight(node) {
+  const input = node.inputs.input;
+  const output = node.outputs.out;
+  const [, h, w, c] = input.shape;
+  const inBuf = input.buffer;
+  const outBuf = output.buffer;
+  for (let ch = 0; ch < c; ch++) {
+    for (let x = 0; x < w; x++) {
+      let sum = 0;
+      for (let y = 0; y < h; y++) {
+        sum += inBuf[(y * w + x) * c + ch];
+      }
+      outBuf[ch * w + x] = sum / h;
+    }
+  }
+}
+
+// js/ops/maxPool2D.js
+function _cpuMaxPool2D(node) {
+  const input = node.inputs.input;
+  const output = node.outputs.out;
+  const [n, h, w, c] = input.shape;
+  const ky = node.params.kernel[0];
+  const kx = node.params.kernel[1];
+  const sy = node.params.stride[0];
+  const sx = node.params.stride[1];
+  const pad_y = node.params.padding ? node.params.padding[0] : 0;
+  const pad_x = node.params.padding ? node.params.padding[1] : 0;
+  const out_h = output.shape[1];
+  const out_w = output.shape[2];
+  const inBuf = input.buffer;
+  const outBuf = output.buffer;
+  for (let b = 0; b < n; b++) {
+    for (let oy = 0; oy < out_h; oy++) {
+      for (let ox = 0; ox < out_w; ox++) {
+        for (let ch = 0; ch < c; ch++) {
+          let best = -Infinity;
+          for (let dy = 0; dy < ky; dy++) {
+            for (let dx = 0; dx < kx; dx++) {
+              const ih = oy * sy + dy - pad_y;
+              const iw = ox * sx + dx - pad_x;
+              if (ih >= 0 && ih < h && iw >= 0 && iw < w) {
+                const v = inBuf[((b * h + ih) * w + iw) * c + ch];
+                if (v > best) best = v;
+              }
+            }
+          }
+          outBuf[((b * out_h + oy) * out_w + ox) * c + ch] = best;
+        }
+      }
+    }
+  }
+}
+
+// js/ops/interp1D.js
+function _cpuInterp1D(node) {
+  const input = node.inputs.input;
+  const output = node.outputs.out;
+  const [c, in_l] = input.shape.slice(1);
+  const out_l = node.params.size;
+  const inBuf = input.buffer;
+  const outBuf = output.buffer;
+  const scale = in_l / out_l;
+  for (let ch = 0; ch < c; ch++) {
+    for (let x = 0; x < out_l; x++) {
+      let pos = (x + 0.5) * scale - 0.5;
+      if (pos < 0) pos = 0;
+      if (pos > in_l - 1) pos = in_l - 1;
+      const x0 = Math.floor(pos);
+      const x1 = x0 + 1 < in_l ? x0 + 1 : x0;
+      const dx = pos - x0;
+      const v0 = inBuf[ch * in_l + x0];
+      const v1 = inBuf[ch * in_l + x1];
+      outBuf[ch * out_l + x] = v0 + dx * (v1 - v0);
+    }
+  }
+}
+
+// js/ops/profileX.js
+function _cpuProfileX(node) {
+  const input = node.inputs.input;
+  const output = node.outputs.out;
+  const [, h, w, c] = input.shape;
+  const inBuf = input.buffer;
+  const outBuf = output.buffer;
+  for (let ch = 0; ch < c; ch++) {
+    for (let x = 0; x < w; x++) {
+      let max_v = -Infinity;
+      let sum_v = 0;
+      for (let y = 0; y < h; y++) {
+        const v = inBuf[(y * w + x) * c + ch];
+        if (v > max_v) max_v = v;
+        sum_v += v;
+      }
+      outBuf[ch * w + x] = max_v;
+      outBuf[(c + ch) * w + x] = sum_v / h;
+    }
+  }
+}
+
+// js/ops/profileY.js
+function _cpuProfileY(node) {
+  const input = node.inputs.input;
+  const output = node.outputs.out;
+  const [, h, w, c] = input.shape;
+  const inBuf = input.buffer;
+  const outBuf = output.buffer;
+  for (let ch = 0; ch < c; ch++) {
+    for (let y = 0; y < h; y++) {
+      let max_v = -Infinity;
+      let sum_v = 0;
+      for (let x = 0; x < w; x++) {
+        const v = inBuf[(y * w + x) * c + ch];
+        if (v > max_v) max_v = v;
+        sum_v += v;
+      }
+      outBuf[ch * h + y] = max_v;
+      outBuf[(c + ch) * h + y] = sum_v / w;
+    }
+  }
+}
+
+// js/ops/concat2.js
+function _cpuConcat2(node) {
+  const outBuf = node.outputs.out.buffer;
+  let off = 0;
+  const entries = Object.entries(node.inputs).sort(([a], [b]) => {
+    const ai = /^input(\d+)$/.exec(a);
+    const bi = /^input(\d+)$/.exec(b);
+    if (ai && bi) return Number(ai[1]) - Number(bi[1]);
+    return a.localeCompare(b);
+  });
+  for (const [, t] of entries) {
+    outBuf.set(t.buffer, off);
+    off += t.buffer.length;
+  }
+}
+
+// js/ops/upsample2x.js
+function _cpuUpsample2x(node) {
+  const input = node.inputs.input;
+  const output = node.outputs.out;
+  const [n, h, w, c] = input.shape;
+  const inBuf = input.buffer;
+  const outBuf = output.buffer;
+  for (let b = 0; b < n; b++) {
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        for (let ch = 0; ch < c; ch++) {
+          const v = inBuf[((b * h + y) * w + x) * c + ch];
+          const oy = y * 2;
+          const ox = x * 2;
+          outBuf[((b * h * 2 + oy) * w * 2 + ox) * c + ch] = v;
+          outBuf[((b * h * 2 + oy) * w * 2 + ox + 1) * c + ch] = v;
+          outBuf[((b * h * 2 + oy + 1) * w * 2 + ox) * c + ch] = v;
+          outBuf[((b * h * 2 + oy + 1) * w * 2 + ox + 1) * c + ch] = v;
+        }
+      }
+    }
+  }
+}
+
+// js/ops/sDPA.js
+function _cpuSDPA(node) {
+  const qkv = node.inputs.qkv.buffer;
+  const outBuf = node.outputs.out.buffer;
+  const seq_len = node.inputs.qkv.shape[1];
+  const d_model = node.outputs.out.shape[2];
+  const num_heads = node.params.heads || 8;
+  const head_dim = d_model / num_heads;
+  const scale = node.params.scale !== void 0 ? node.params.scale : 1 / Math.sqrt(head_dim);
+  for (let h = 0; h < num_heads; h++) {
+    for (let q = 0; q < seq_len; q++) {
+      const logits = new Float32Array(seq_len);
+      let max_logit = -Infinity;
+      for (let k = 0; k <= q; k++) {
+        let score = 0;
+        for (let d = 0; d < head_dim; d++) {
+          const q_val = qkv[q * (d_model * 3) + h * head_dim + d];
+          const k_val = qkv[k * (d_model * 3) + d_model + h * head_dim + d];
+          score += q_val * k_val;
+        }
+        score *= scale;
+        logits[k] = score;
+        if (score > max_logit) max_logit = score;
+      }
+      let sum_exp = 0;
+      for (let k = 0; k <= q; k++) {
+        const exp_val = Math.exp(logits[k] - max_logit);
+        logits[k] = exp_val;
+        sum_exp += exp_val;
+      }
+      for (let d = 0; d < head_dim; d++) {
+        let out_val = 0;
+        for (let k = 0; k <= q; k++) {
+          const w = logits[k] / sum_exp;
+          const v_val = qkv[k * (d_model * 3) + d_model * 2 + h * head_dim + d];
+          out_val += w * v_val;
+        }
+        outBuf[q * d_model + h * head_dim + d] = out_val;
+      }
+    }
+  }
+}
+
+// js/ops/embedding.js
+function _cpuEmbedding(node) {
+  const tokens = node.inputs.input.buffer;
+  const wBuf = node.inputs.weight.buffer;
+  const outBuf = node.outputs.out.buffer;
+  const d_model = node.outputs.out.shape[node.outputs.out.shape.length - 1];
+  const seq_len = tokens.length;
+  for (let i = 0; i < seq_len; i++) {
+    const token_id = tokens[i];
+    for (let j = 0; j < d_model; j++) {
+      outBuf[i * d_model + j] = wBuf[token_id * d_model + j];
+    }
+  }
+}
+
+// js/ops/mul.js
+function _cpuMul(node) {
+  const a = node.inputs.a;
+  const b = node.inputs.b;
+  const outBuf = node.outputs.out.buffer;
+  let aBuf = a.buffer;
+  let bBuf = b.buffer;
+  let aShape = a.shape;
+  let bShape = b.shape;
+  if (aBuf.length < bBuf.length) {
+    let temp = aBuf;
+    aBuf = bBuf;
+    bBuf = temp;
+    let tempS = aShape;
+    aShape = bShape;
+    bShape = tempS;
+  }
+  const elements = aBuf.length;
+  if (bBuf.length === 1) {
+    for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] * bBuf[0];
+  } else if (bBuf.length === elements) {
+    for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] * bBuf[i];
+  } else if (aShape.length === 4 && bBuf.length === aShape[3]) {
+    const c = aShape[3];
+    for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] * bBuf[i % c];
+  } else if (aShape.length === 4 && bShape.length === 4 && bShape[0] === 1 && bShape[1] === 1 && bShape[2] === 1 && bShape[3] === aShape[3]) {
+    const c = aShape[3];
+    for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] * bBuf[i % c];
+  } else {
+    console.warn("[VolvoxAI CPU] Executing Mul is not fully implemented yet for shapes", a.shape, b.shape);
+  }
+}
+
+// js/ops/add.js
+function _cpuAdd(node) {
+  const a = node.inputs.a;
+  const b = node.inputs.b;
+  const outBuf = node.outputs.out.buffer;
+  let aBuf = a.buffer;
+  let bBuf = b.buffer;
+  let aShape = a.shape;
+  let bShape = b.shape;
+  if (aBuf.length < bBuf.length) {
+    let temp = aBuf;
+    aBuf = bBuf;
+    bBuf = temp;
+    let tempS = aShape;
+    aShape = bShape;
+    bShape = tempS;
+  }
+  const elements = aBuf.length;
+  if (bBuf.length === 1) {
+    for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] + bBuf[0];
+  } else if (bBuf.length === elements) {
+    for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] + bBuf[i];
+  } else if (aShape.length === 4 && bBuf.length === aShape[3]) {
+    const c = aShape[3];
+    for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] + bBuf[i % c];
+  } else if (aShape.length === 4 && bShape.length === 4 && bShape[0] === 1 && bShape[1] === 1 && bShape[2] === 1 && bShape[3] === aShape[3]) {
+    const c = aShape[3];
+    for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] + bBuf[i % c];
+  } else {
+    console.warn("[VolvoxAI CPU] Executing Add is not fully implemented yet for shapes", a.shape, b.shape);
+  }
+}
+
+// js/ops/globalAveragePool.js
+function _cpuGlobalAveragePool(node) {
+  const input = node.inputs.input;
+  const output = node.outputs.out;
+  const B = input.shape[0];
+  const H = input.shape[1];
+  const W = input.shape[2];
+  const C = input.shape[3];
+  const spatial = H * W;
+  for (let b = 0; b < B; b++) {
+    for (let c = 0; c < C; c++) {
+      let sum = 0;
+      for (let i = 0; i < spatial; i++) {
+        const y = Math.floor(i / W);
+        const x = i - y * W;
+        sum += input.buffer[((b * H + y) * W + x) * C + c];
+      }
+      output.buffer[b * C + c] = sum / spatial;
+    }
+  }
+}
+
+// js/ops/clip.js
+function _cpuClip(node) {
+  const input = node.inputs.input;
+  const output = node.outputs.out;
+  let min = node.params.min !== void 0 ? node.params.min : -Infinity;
+  let max = node.params.max !== void 0 ? node.params.max : Infinity;
+  if (node.inputs.min) min = node.inputs.min.buffer[0];
+  if (node.inputs.max) max = node.inputs.max.buffer[0];
+  for (let i = 0; i < input.buffer.length; i++) {
+    let v = input.buffer[i];
+    if (v < min) v = min;
+    if (v > max) v = max;
+    output.buffer[i] = v;
+  }
+}
+
+// js/ops/reshape.js
+function _cpuReshape(node) {
+  const input = node.inputs.input;
+  const output = node.outputs.out;
+  output.buffer.set(input.buffer);
+}
+
+// js/ops/split.js
+function _cpuSplit(node) {
+  const input = node.inputs.input;
+  const inBuf = input.buffer;
+  const inShape = input.shape;
+  let axis = node.params.axis || 0;
+  if (axis < 0) axis += inShape.length;
+  const outKeys = Object.keys(node.outputs).sort();
+  const numOutputs = outKeys.length;
+  const splitSize = inShape[axis] / numOutputs;
+  let outerSize = 1;
+  for (let i = 0; i < axis; i++) outerSize *= inShape[i];
+  let innerSize = 1;
+  for (let i = axis + 1; i < inShape.length; i++) innerSize *= inShape[i];
+  const chunkSize = splitSize * innerSize;
+  for (let o = 0; o < numOutputs; o++) {
+    const outBuf = node.outputs[outKeys[o]].buffer;
+    for (let i = 0; i < outerSize; i++) {
+      const inOffset = (i * inShape[axis] + o * splitSize) * innerSize;
+      const outOffset = i * chunkSize;
+      outBuf.set(inBuf.subarray(inOffset, inOffset + chunkSize), outOffset);
+    }
+  }
+}
+
+// js/ops/resize.js
+function _cpuResize(node) {
+  const inp = node.inputs.input, out = node.outputs.out;
+  const [b, inH, inW, c] = inp.shape;
+  const [, outH, outW] = out.shape;
+  const src = inp.buffer, dst = out.buffer;
+  if (node.opType === "ResizeNearest2D" || node.params.mode === "nearest") {
+    for (let n = 0; n < b; n++) {
+      for (let y = 0; y < outH; y++) {
+        let iy = Math.floor(y * inH / outH);
+        if (iy >= inH) iy = inH - 1;
+        for (let x = 0; x < outW; x++) {
+          let ix = Math.floor(x * inW / outW);
+          if (ix >= inW) ix = inW - 1;
+          for (let ch = 0; ch < c; ch++) {
+            dst[((n * outH + y) * outW + x) * c + ch] = src[((n * inH + iy) * inW + ix) * c + ch];
+          }
+        }
+      }
+    }
+    return;
+  }
+  const sy = inH / outH, sx = inW / outW;
+  for (let n = 0; n < b; n++) {
+    for (let y = 0; y < outH; y++) {
+      let iy = (y + 0.5) * sy - 0.5;
+      if (iy < 0) iy = 0;
+      const y0 = Math.min(inH - 1, Math.floor(iy)), y1 = Math.min(inH - 1, y0 + 1), dy = iy - y0;
+      for (let x = 0; x < outW; x++) {
+        let ix = (x + 0.5) * sx - 0.5;
+        if (ix < 0) ix = 0;
+        const x0 = Math.min(inW - 1, Math.floor(ix)), x1 = Math.min(inW - 1, x0 + 1), dx = ix - x0;
+        for (let ch = 0; ch < c; ch++) {
+          const v00 = src[((n * inH + y0) * inW + x0) * c + ch];
+          const v01 = src[((n * inH + y0) * inW + x1) * c + ch];
+          const v10 = src[((n * inH + y1) * inW + x0) * c + ch];
+          const v11 = src[((n * inH + y1) * inW + x1) * c + ch];
+          dst[((n * outH + y) * outW + x) * c + ch] = v00 * (1 - dy) * (1 - dx) + v01 * (1 - dy) * dx + v10 * dy * (1 - dx) + v11 * dy * dx;
+        }
+      }
+    }
+  }
+}
+
+// js/ops/sigmoid.js
+function _cpuSigmoid(node) {
+  const inBuf = node.inputs.input.buffer;
+  const outBuf = node.outputs.out.buffer;
+  for (let i = 0; i < inBuf.length; i++) outBuf[i] = 1 / (1 + Math.exp(-inBuf[i]));
+}
+
+// js/ops/hardSigmoid.js
+function _cpuHardSigmoid(node) {
+  const inBuf = node.inputs.input.buffer;
+  const outBuf = node.outputs.out.buffer;
+  for (let i = 0; i < inBuf.length; i++) {
+    const x = inBuf[i];
+    let v = x + 3;
+    if (v < 0) v = 0;
+    else if (v > 6) v = 6;
+    outBuf[i] = v / 6;
+  }
+}
+
+// js/ops/hardSwish.js
+function _cpuHardSwish(node) {
+  const inBuf = node.inputs.input.buffer;
+  const outBuf = node.outputs.out.buffer;
+  for (let i = 0; i < inBuf.length; i++) {
+    const x = inBuf[i];
+    let v = x + 3;
+    if (v < 0) v = 0;
+    else if (v > 6) v = 6;
+    outBuf[i] = x * v / 6;
+  }
+}
+
+// js/ops/reLU.js
+function _cpuReLU(node) {
+  const inBuf = node.inputs.input.buffer;
+  const outBuf = node.outputs.out.buffer;
+  for (let i = 0; i < inBuf.length; i++) {
+    outBuf[i] = inBuf[i] > 0 ? inBuf[i] : 0;
+  }
+}
+
+// js/ops/leakyReLU.js
+function _cpuLeakyReLU(node) {
+  const inBuf = node.inputs.input.buffer;
+  const outBuf = node.outputs.out.buffer;
+  const alpha = node.params.alpha !== void 0 ? node.params.alpha : 0.01;
+  for (let i = 0; i < inBuf.length; i++) {
+    const v = inBuf[i];
+    outBuf[i] = v > 0 ? v : alpha * v;
+  }
+}
+
+// js/ops/gELU.js
+function _cpuGELU(node) {
+  const inBuf = node.inputs.input.buffer;
+  const outBuf = node.outputs.out.buffer;
+  for (let i = 0; i < inBuf.length; i++) {
+    const x = inBuf[i];
+    outBuf[i] = 0.5 * x * (1 + Math.tanh(0.7978845608 * (x + 0.044715 * x * x * x)));
+  }
+}
+
+// js/ops/layerNorm.js
+function _cpuLayerNorm(node) {
+  const inBuf = node.inputs.input.buffer;
+  const wBuf = node.inputs.weight.buffer;
+  const bBuf = node.inputs.bias.buffer;
+  const outBuf = node.outputs.out.buffer;
+  const d_model = node.params.d_model;
+  const seq_len = node.inputs.input.shape.slice(0, -1).reduce((a, b) => a * b, 1);
+  for (let i = 0; i < seq_len; i++) {
+    const offset = i * d_model;
+    let sum = 0, sq_sum = 0;
+    for (let j = 0; j < d_model; j++) {
+      const val = inBuf[offset + j];
+      sum += val;
+      sq_sum += val * val;
+    }
+    const mean = sum / d_model;
+    const variance = sq_sum / d_model - mean * mean;
+    const inv_std = 1 / Math.sqrt(variance + 1e-5);
+    for (let j = 0; j < d_model; j++) {
+      const norm_val = (inBuf[offset + j] - mean) * inv_std;
+      outBuf[offset + j] = norm_val * wBuf[j] + bBuf[j];
+    }
+  }
+}
+
+// js/ops/conv2D.js
+function _cpuConv2D(node) {
+  const input = node.inputs.input;
+  const weight = node.inputs.weight;
+  const bias = node.inputs.bias ? node.inputs.bias.buffer : null;
+  const output = node.outputs.out;
+  const [batch, in_h, in_w, in_c] = input.shape;
+  const [k_h, k_w] = weight.shape;
+  const out_c = output.shape[3];
+  const out_h = output.shape[1];
+  const out_w = output.shape[2];
+  const [stride_y, stride_x] = _pair(node.params.stride, 1);
+  const [pad_y, pad_x] = _pair(node.params.padding, 0);
+  const pads = node.params.pads || [pad_y, pad_x, pad_y, pad_x];
+  const [dil_y, dil_x] = _pair(node.params.dilation, 1);
+  const inBuf = input.buffer;
+  const wBuf = weight.buffer;
+  const outBuf = output.buffer;
+  const groups = node.params.groups || 1;
+  const group_out = out_c / groups;
+  const group_in = weight.shape[2];
+  for (let b = 0; b < batch; b++) {
+    for (let oh = 0; oh < out_h; oh++) {
+      for (let ow = 0; ow < out_w; ow++) {
+        for (let oc = 0; oc < out_c; oc++) {
+          let sum = 0;
+          if (groups === in_c) {
+            const mult = out_c / in_c;
+            const ic = Math.floor(oc / mult);
+            const m = oc - ic * mult;
+            for (let kh = 0; kh < k_h; kh++) {
+              for (let kw = 0; kw < k_w; kw++) {
+                const ih = oh * stride_y + kh * dil_y - pads[0];
+                const iw = ow * stride_x + kw * dil_x - pads[1];
+                if (ih >= 0 && ih < in_h && iw >= 0 && iw < in_w) {
+                  const in_idx = ((b * in_h + ih) * in_w + iw) * in_c + ic;
+                  const w_idx = ((kh * k_w + kw) * in_c + ic) * mult + m;
+                  sum += inBuf[in_idx] * wBuf[w_idx];
+                }
+              }
+            }
+          } else {
+            const g = Math.floor(oc / group_out);
+            const in_start = g * group_in;
+            for (let icl = 0; icl < group_in; icl++) {
+              const ic = in_start + icl;
+              for (let kh = 0; kh < k_h; kh++) {
+                for (let kw = 0; kw < k_w; kw++) {
+                  const ih = oh * stride_y + kh * dil_y - pads[0];
+                  const iw = ow * stride_x + kw * dil_x - pads[1];
+                  if (ih >= 0 && ih < in_h && iw >= 0 && iw < in_w) {
+                    const in_idx = ((b * in_h + ih) * in_w + iw) * in_c + ic;
+                    const w_idx = ((kh * k_w + kw) * group_in + icl) * out_c + oc;
+                    sum += inBuf[in_idx] * wBuf[w_idx];
+                  }
+                }
+              }
+            }
+          }
+          if (bias) sum += bias[oc];
+          if (node.params.relu === 1 && sum < 0) sum = 0;
+          else if (node.params.relu >= 2) sum = Math.min(Math.max(sum, 0), 6);
+          outBuf[((b * out_h + oh) * out_w + ow) * out_c + oc] = sum;
+        }
+      }
+    }
+  }
+}
+
+// js/ops/conv1D.js
+function _cpuConv1D(node) {
+  const input = node.inputs.input;
+  const weight = node.inputs.weight;
+  const bias = node.inputs.bias ? node.inputs.bias.buffer : null;
+  const output = node.outputs.out;
+  const [in_c, in_l] = input.shape.slice(1);
+  const [out_c, k_c, k] = weight.shape;
+  const out_l = output.shape[2];
+  const stride = _pair(node.params.stride, 1)[0];
+  const padding = _pair(node.params.padding, 0)[0];
+  const relu = node.params.relu;
+  const inBuf = input.buffer;
+  const wBuf = weight.buffer;
+  const outBuf = output.buffer;
+  for (let oc = 0; oc < out_c; oc++) {
+    for (let x = 0; x < out_l; x++) {
+      let sum = bias ? bias[oc] : 0;
+      for (let ic = 0; ic < in_c; ic++) {
+        for (let k_idx = 0; k_idx < k; k_idx++) {
+          const ix = x * stride + k_idx - padding;
+          if (ix >= 0 && ix < in_l) {
+            const in_idx = ic * in_l + ix;
+            const w_idx = (oc * in_c + ic) * k + k_idx;
+            sum += inBuf[in_idx] * wBuf[w_idx];
+          }
+        }
+      }
+      if (relu && sum < 0) sum = 0;
+      outBuf[oc * out_l + x] = sum;
+    }
+  }
+}
+
+// js/ops/matMul.js
+function _cpuMatMul(node) {
+  const input = node.inputs.input;
+  const weight = node.inputs.weight;
+  const output = node.outputs.out;
+  const M = input.shape.slice(0, -1).reduce((a, b) => a * b, 1);
+  const K = input.shape[input.shape.length - 1];
+  const N = output.shape[output.shape.length - 1];
+  const inBuf = input.buffer;
+  const wBuf = weight.buffer;
+  const outBuf = output.buffer;
+  const scale = node.inputs.scale ? node.inputs.scale.buffer : null;
+  const bias = node.inputs.bias ? node.inputs.bias.buffer : null;
+  const w0 = weight.shape.length >= 2 ? weight.shape[0] : N;
+  const w1 = weight.shape.length >= 2 ? weight.shape[1] : K;
+  const doutFirst = scale ? true : node.wLayout ? node.wLayout === "dout" : w0 === N && w1 === K;
+  for (let i = 0; i < M; i++) {
+    for (let j = 0; j < N; j++) {
+      let sum = 0;
+      if (doutFirst) {
+        for (let k = 0; k < K; k++) sum += inBuf[i * K + k] * wBuf[j * K + k];
+      } else {
+        for (let k = 0; k < K; k++) sum += inBuf[i * K + k] * wBuf[k * N + j];
+      }
+      if (scale) sum *= scale[j];
+      if (bias) sum += bias[j];
+      outBuf[i * N + j] = sum;
+    }
+  }
+}
+
+// js/ops/cast.js
+function _cpuCast(node) {
+  const input = node.inputs.input || node.inputs.data;
+  const output = node.outputs.out;
+  const inBuf = input.buffer;
+  const outBuf = output.buffer;
+  const to = node.params.to;
+  const intCast = to === "int32" || to === "int64" || to === "int8" || to === 3 || to === 5 || to === 6 || to === 7;
+  const n = Math.min(inBuf.length, outBuf.length);
+  if (intCast) {
+    for (let i = 0; i < n; i++) outBuf[i] = Math.trunc(inBuf[i]);
+  } else {
+    outBuf.set(inBuf.subarray(0, n));
+  }
+}
+
+// js/ops/argMax.js
+function _cpuArgMax(node) {
+  const input = node.inputs.input || node.inputs.data;
+  const out = node.outputs.out;
+  const inBuf = input.buffer;
+  const outBuf = out.buffer;
+  const shape = input.shape;
+  let axis = node.params.axis !== void 0 ? node.params.axis : 0;
+  if (axis < 0) axis += shape.length;
+  const axisSize = shape[axis];
+  let innerBlock = 1;
+  for (let i = axis + 1; i < shape.length; i++) innerBlock *= shape[i];
+  let outerBlock = 1;
+  for (let i = 0; i < axis; i++) outerBlock *= shape[i];
+  let o = 0;
+  for (let ob = 0; ob < outerBlock; ob++) {
+    for (let ib = 0; ib < innerBlock; ib++) {
+      const base = ob * axisSize * innerBlock + ib;
+      let best = inBuf[base];
+      let bestIdx = 0;
+      for (let a = 1; a < axisSize; a++) {
+        const v = inBuf[base + a * innerBlock];
+        if (v > best) {
+          best = v;
+          bestIdx = a;
+        }
+      }
+      outBuf[o++] = bestIdx;
+    }
+  }
+}
+
+// js/CPUEngine.js
+var CPUEngine = class {
+  constructor() {
+    this.tensors = /* @__PURE__ */ new Map();
+    console.log("[VolvoxAI] CPU Fallback Engine ready.");
+  }
+  /**
+   * Allocates CPU memory (ArrayBuffers) for the graph's tensors.
+   */
+  allocateGraph(graph) {
+    this.graph = graph;
+    for (const [name, tensor] of graph.tensors.entries()) {
+      if (!tensor.buffer) {
+        if (tensor.dtype === "int8") {
+          tensor.buffer = new Int8Array(tensor.sizeBytes);
+        } else {
+          tensor.buffer = new Float32Array(tensor.sizeBytes / 4);
+        }
+      }
+    }
+  }
+  /**
+   * Executes the graph linearly on the CPU.
+   */
+  async execute(inputsOrGraph, maybeInputs) {
+    const graph = maybeInputs ? inputsOrGraph : this.graph;
+    const inputs = maybeInputs || inputsOrGraph;
+    for (const [name, data] of Object.entries(inputs)) {
+      const tensor = graph.tensors.get(name);
+      if (tensor && tensor.buffer) {
+        tensor.buffer.set(data);
+      }
+    }
+    for (const node of graph.nodes) {
+      this._runNode(node);
+    }
+    const result = {};
+    if (graph.outputNames && graph.outputNames.length > 0) {
+      for (const name of graph.outputNames) {
+        result[name] = graph.tensors.get(name).buffer;
+      }
+    } else {
+      const lastNode = graph.nodes[graph.nodes.length - 1];
+      for (const [key, t] of Object.entries(lastNode.outputs)) {
+        result[t.name] = graph.tensors.get(t.name).buffer;
+      }
+    }
+    return result;
+  }
+  _runNode(node) {
+    switch (node.opType) {
+      // --- Linear / attention ---
+      case "MatMul":
+        return this._cpuMatMul(node);
+      case "LayerNorm":
+        return this._cpuLayerNorm(node);
+      case "RMSNorm":
+        return this._cpuRMSNorm(node);
+      case "Embedding":
+        return this._cpuEmbedding(node);
+      case "SDPA":
+        return this._cpuSDPA(node);
+      case "CrossSDPA":
+        return this._cpuCrossSDPA(node);
+      case "CrossAttention":
+        return this._cpuCrossAttention(node);
+      // --- Convolution / pooling ---
+      case "Conv2D":
+        return this._cpuConv2D(node);
+      case "Conv1D":
+        return this._cpuConv1D(node);
+      case "ConvTranspose2D":
+        return this._cpuConvTranspose2D(node);
+      case "MaxPool2D":
+        return this._cpuMaxPool2D(node);
+      case "AveragePool":
+      case "AveragePool2D":
+        return this._cpuAveragePool2D(node);
+      case "GlobalAveragePool":
+        return this._cpuGlobalAveragePool(node);
+      case "BatchNorm2D":
+        return this._cpuBatchNorm2D(node);
+      case "ResizeNearest2D":
+      case "Resize":
+        return this._cpuResize(node);
+      case "Upsample2x":
+      case "UpsampleNearest2D":
+        return this._cpuUpsample2x(node);
+      case "Interp1D":
+      case "InterpLinear1D":
+        return this._cpuInterp1D(node);
+      // --- Activations ---
+      case "ReLU":
+        return this._cpuReLU(node);
+      case "LeakyReLU":
+        return this._cpuLeakyReLU(node);
+      case "PReLU":
+        return this._cpuPReLU(node);
+      case "GELU":
+        return this._cpuGELU(node);
+      case "SiLU":
+      case "Swish":
+        return this._cpuSiLU(node);
+      case "Sigmoid":
+        return this._cpuSigmoid(node);
+      case "HardSwish":
+        return this._cpuHardSwish(node);
+      case "HardSigmoid":
+        return this._cpuHardSigmoid(node);
+      case "Tanh":
+        return this._cpuTanh(node);
+      case "Clip":
+        return this._cpuClip(node);
+      // --- Elementwise / reduction ---
+      case "Add":
+        return this._cpuAdd(node);
+      case "Mul":
+        return this._cpuMul(node);
+      case "Sub":
+        return this._cpuSub(node);
+      case "Div":
+        return this._cpuDiv(node);
+      case "Softmax":
+        return this._cpuSoftmax(node);
+      case "LogSoftmax":
+        return this._cpuLogSoftmax(node);
+      case "ReduceSum":
+        return this._cpuReduceSum(node);
+      case "ReduceMean":
+        return this._cpuReduceMean(node);
+      case "ArgMax":
+        return this._cpuArgMax(node);
+      // --- Shape / gather / misc ---
+      case "Transpose":
+        return this._cpuTranspose(node);
+      case "Concat":
+      case "Concat2":
+        return this._cpuConcat2(node);
+      case "Split":
+        return this._cpuSplit(node);
+      case "Slice":
+        return this._cpuSlice(node);
+      case "Pad":
+        return this._cpuPad(node);
+      case "Expand":
+      case "Broadcast":
+        return this._cpuExpand(node);
+      case "Gather":
+        return this._cpuGather(node);
+      case "GatherElements":
+        return this._cpuGatherElements(node);
+      case "Where":
+      case "Mask":
+        return this._cpuWhere(node);
+      case "Cast":
+        return this._cpuCast(node);
+      case "DequantizeLinear":
+        return this._cpuDequantizeLinear(node);
+      case "NonMaxSuppression":
+        return this._cpuNonMaxSuppression(node);
+      case "SpatialSoftargmaxY":
+        return this._cpuSpatialSoftargmaxY(node);
+      case "ProfileX":
+        return this._cpuProfileX(node);
+      case "ProfileY":
+        return this._cpuProfileY(node);
+      case "MeanHeight":
+        return this._cpuMeanHeight(node);
+      // Shape-only ops just copy their data through to the output buffer.
+      case "Reshape":
+      case "Flatten":
+      case "Squeeze":
+      case "Unsqueeze":
+      case "Dropout":
+      case "Identity":
+        return this._cpuReshape(node);
+      default:
+        console.warn(`[VolvoxAI CPU] Executing ${node.opType} is not implemented; node ${node.id} skipped.`);
+    }
+  }
+};
+CPUEngine.prototype._cpuWhere = _cpuWhere;
+CPUEngine.prototype._cpuPad = _cpuPad;
+CPUEngine.prototype._cpuAveragePool2D = _cpuAveragePool2D;
+CPUEngine.prototype._cpuSlice = _cpuSlice;
+CPUEngine.prototype._cpuConvTranspose2D = _cpuConvTranspose2D;
+CPUEngine.prototype._cpuReduceSum = _cpuReduceSum;
+CPUEngine.prototype._cpuReduceMean = _cpuReduceMean;
+CPUEngine.prototype._cpuBatchNorm2D = _cpuBatchNorm2D;
+CPUEngine.prototype._cpuSoftmax = _cpuSoftmax;
+CPUEngine.prototype._cpuLogSoftmax = _cpuLogSoftmax;
+CPUEngine.prototype._cpuSub = _cpuSub;
+CPUEngine.prototype._cpuSiLU = _cpuSiLU;
+CPUEngine.prototype._cpuRMSNorm = _cpuRMSNorm;
+CPUEngine.prototype._cpuTanh = _cpuTanh;
+CPUEngine.prototype._cpuDequantizeLinear = _cpuDequantizeLinear;
+CPUEngine.prototype._cpuExpand = _cpuExpand;
+CPUEngine.prototype._cpuPReLU = _cpuPReLU;
+CPUEngine.prototype._cpuDiv = _cpuDiv;
+CPUEngine.prototype._cpuNonMaxSuppression = _cpuNonMaxSuppression;
+CPUEngine.prototype._cpuGather = _cpuGather;
+CPUEngine.prototype._cpuGatherElements = _cpuGatherElements;
+CPUEngine.prototype._cpuCrossAttention = _cpuCrossAttention;
+CPUEngine.prototype._cpuSpatialSoftargmaxY = _cpuSpatialSoftargmaxY;
+CPUEngine.prototype._cpuTranspose = _cpuTranspose;
+CPUEngine.prototype._cpuCrossSDPA = _cpuCrossSDPA;
+CPUEngine.prototype._cpuMeanHeight = _cpuMeanHeight;
+CPUEngine.prototype._cpuMaxPool2D = _cpuMaxPool2D;
+CPUEngine.prototype._cpuInterp1D = _cpuInterp1D;
+CPUEngine.prototype._cpuProfileX = _cpuProfileX;
+CPUEngine.prototype._cpuProfileY = _cpuProfileY;
+CPUEngine.prototype._cpuConcat2 = _cpuConcat2;
+CPUEngine.prototype._cpuUpsample2x = _cpuUpsample2x;
+CPUEngine.prototype._cpuSDPA = _cpuSDPA;
+CPUEngine.prototype._cpuEmbedding = _cpuEmbedding;
+CPUEngine.prototype._cpuMul = _cpuMul;
+CPUEngine.prototype._cpuAdd = _cpuAdd;
+CPUEngine.prototype._cpuGlobalAveragePool = _cpuGlobalAveragePool;
+CPUEngine.prototype._cpuClip = _cpuClip;
+CPUEngine.prototype._cpuReshape = _cpuReshape;
+CPUEngine.prototype._cpuSplit = _cpuSplit;
+CPUEngine.prototype._cpuResize = _cpuResize;
+CPUEngine.prototype._cpuSigmoid = _cpuSigmoid;
+CPUEngine.prototype._cpuHardSigmoid = _cpuHardSigmoid;
+CPUEngine.prototype._cpuHardSwish = _cpuHardSwish;
+CPUEngine.prototype._cpuReLU = _cpuReLU;
+CPUEngine.prototype._cpuLeakyReLU = _cpuLeakyReLU;
+CPUEngine.prototype._cpuGELU = _cpuGELU;
+CPUEngine.prototype._cpuLayerNorm = _cpuLayerNorm;
+CPUEngine.prototype._cpuConv2D = _cpuConv2D;
+CPUEngine.prototype._cpuConv1D = _cpuConv1D;
+CPUEngine.prototype._cpuMatMul = _cpuMatMul;
+CPUEngine.prototype._cpuCast = _cpuCast;
+CPUEngine.prototype._cpuArgMax = _cpuArgMax;
+
+// js/WasmEngine.js
+var WasmEngine = class _WasmEngine extends CPUEngine {
+  constructor(wasmModule) {
+    super();
+    this.wasmModule = wasmModule;
+    this.api = wasmModule.instance.exports;
+    this.mem = this.api.memory;
+    this.pointers = /* @__PURE__ */ new Map();
+    console.log("[VolvoxAI] WASM Engine ready (Tier 2 Fallback).");
+  }
+  static async init(wasmUrl) {
+    try {
+      let buffer;
+      if (typeof process !== "undefined" && process.versions && process.versions.node) {
+        const fs = await import("fs");
+        let url = wasmUrl;
+        if (!url.startsWith("/")) url = "./" + url;
+        buffer = fs.readFileSync(url);
+      } else {
+        const response = await fetch(wasmUrl);
+        if (!response.ok) throw new Error("WASM file not found.");
+        buffer = await response.arrayBuffer();
+      }
+      const env = { expf: Math.exp, logf: Math.log, powf: Math.pow };
+      const module = await WebAssembly.instantiate(buffer, { env, math: env });
+      return new _WasmEngine(module);
+    } catch (e) {
+      console.warn(`[VolvoxAI] Failed to load WASM from ${wasmUrl}:`, e);
+      return null;
+    }
+  }
+  createGraph() {
+    return new Graph();
+  }
+  _alloc(tensor) {
+    if (!this.pointers.has(tensor.name)) {
+      const ptr = this.api.alloc_bytes(tensor.sizeBytes);
+      const needed = ptr + tensor.sizeBytes;
+      const currentBytes = this.mem.buffer.byteLength;
+      if (needed > currentBytes) {
+        const pagesNeeded = Math.ceil((needed - currentBytes) / 65536);
+        this.mem.grow(pagesNeeded);
+      }
+      this.pointers.set(tensor.name, ptr);
+      const wasmView = new Float32Array(this.mem.buffer, ptr, tensor.sizeBytes / 4);
+      if (tensor.isWeight && tensor.buffer) {
+        let view = tensor.buffer;
+        const dw = this._doutWeights && this._doutWeights.get(tensor.name);
+        if (dw) {
+          const { din, dout } = dw;
+          const t = new Float32Array(din * dout);
+          for (let j = 0; j < dout; j++) for (let k = 0; k < din; k++) t[k * dout + j] = view[j * din + k];
+          view = t;
+        }
+        const src = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+        const bytesToCopy = Math.min(view.byteLength, tensor.sizeBytes);
+        new Uint8Array(this.mem.buffer, ptr, bytesToCopy).set(src.subarray(0, bytesToCopy));
+      }
+      tensor.buffer = wasmView;
+    }
+    return this.pointers.get(tensor.name);
+  }
+  allocateGraph(graph) {
+    return this.compile(graph);
+  }
+  compile(graph) {
+    console.log("[VolvoxAI WASM] Allocating graph tensors on WASM heap...");
+    if (this.api.reset_heap) this.api.reset_heap();
+    this.pointers.clear();
+    this._doutWeights = /* @__PURE__ */ new Map();
+    for (const n of graph.nodes) {
+      if ((n.opType === "MatMul" || n.opType === "Linear" || n.opType === "Gemm") && n.wLayout === "dout" && n.inputs.weight && !n.inputs.scale) {
+        const din = n.inputs.input.shape[n.inputs.input.shape.length - 1];
+        const dout = n.outputs.out.shape[n.outputs.out.shape.length - 1];
+        this._doutWeights.set(n.inputs.weight.name, { din, dout });
+      }
+    }
+    for (const [name, tensor] of graph.tensors.entries()) {
+      this._alloc(tensor);
+    }
+    for (const [name, tensor] of graph.tensors.entries()) {
+      const ptr = this.pointers.get(name);
+      tensor.buffer = new Float32Array(this.mem.buffer, ptr, tensor.sizeBytes / 4);
+    }
+    this.graph = graph;
+    return this;
+  }
+  async execute(inputs) {
+    for (const [name, data] of Object.entries(inputs)) {
+      const tensor = this.graph.tensors.get(name);
+      if (!tensor) continue;
+      const ptr = this.pointers.get(name);
+      new Float32Array(this.mem.buffer, ptr, data.length).set(data);
+    }
+    for (const node of this.graph.nodes) {
+      try {
+        const inPtr = this.pointers.get(node.inputs.input?.name);
+        const outPtr = this.pointers.get(node.outputs.out?.name);
+        const wPtr = this.pointers.get(node.inputs.weight?.name);
+        const bPtr = this.pointers.get(node.inputs.bias?.name);
+        if (node.opType === "Conv2D") {
+          const wPtr2 = this.pointers.get(node.inputs.weight.name);
+          const bPtr2 = node.inputs.bias ? this.pointers.get(node.inputs.bias.name) : 0;
+          const inShape = node.inputs.input.shape;
+          const outShape = node.outputs.out.shape;
+          const wShape = node.inputs.weight.shape;
+          const [sy, sx] = _pair(node.params.stride, 1);
+          const [dy, dx] = _pair(node.params.dilation, 1);
+          const padPair = _pair(node.params.padding, 0);
+          const pads = node.params.pads || [padPair[0], padPair[1], padPair[0], padPair[1]];
+          const groups = node.params.groups || 1;
+          const relu = node.params.relu ? 1 : 0;
+          this.api.conv2d_f32(
+            inPtr,
+            outPtr,
+            wPtr2,
+            bPtr2,
+            inShape[0],
+            inShape[1],
+            inShape[2],
+            inShape[3],
+            wShape[0],
+            wShape[1],
+            wShape[2],
+            wShape[3],
+            outShape[1],
+            outShape[2],
+            sy,
+            sx,
+            pads[0],
+            pads[1],
+            groups,
+            relu,
+            dy,
+            dx
+          );
+        } else if (node.opType === "ConvTranspose2D") {
+          const wPtr2 = this.pointers.get(node.inputs.weight.name);
+          const bPtr2 = node.inputs.bias ? this.pointers.get(node.inputs.bias.name) : 0;
+          const [b, in_h, in_w, in_c] = node.inputs.input.shape;
+          const [out_b, out_h, out_w, out_c] = node.outputs.out.shape;
+          const kh = node.params.kernel[0], kw = node.params.kernel[1];
+          const sh = node.params.stride ? node.params.stride[0] : 1;
+          const sw = node.params.stride ? node.params.stride[1] : 1;
+          const ph = node.params.padding ? node.params.padding[0] : 0;
+          const pw = node.params.padding ? node.params.padding[1] : 0;
+          this.api.conv_transpose2d_f32(
+            inPtr,
+            wPtr2,
+            bPtr2,
+            outPtr,
+            b,
+            in_h,
+            in_w,
+            in_c,
+            out_h,
+            out_w,
+            out_c,
+            kh,
+            kw,
+            sh,
+            sw,
+            ph,
+            pw
+          );
+        } else if (node.opType === "ReduceSum") {
+          const inShape = node.inputs.input ? node.inputs.input.shape : node.inputs.data.shape;
+          const shape = inShape.length === 2 ? inShape : [1, node.inputs.input ? node.inputs.input.buffer.length : node.inputs.data.buffer.length];
+          this.api.reduce_sum_f32(inPtr, outPtr, shape[0], shape[1]);
+        } else if (node.opType === "ReduceMean") {
+          const inShape = node.inputs.input ? node.inputs.input.shape : node.inputs.data.shape;
+          const shape = inShape.length === 2 ? inShape : [1, node.inputs.input ? node.inputs.input.buffer.length : node.inputs.data.buffer.length];
+          this.api.reduce_mean_f32(inPtr, outPtr, shape[0], shape[1]);
+        } else if (node.opType === "MatMul") {
+          const wPtr2 = this.pointers.get(node.inputs.weight.name);
+          const bPtr2 = node.inputs.bias ? this.pointers.get(node.inputs.bias.name) : 0;
+          const d_in = node.inputs.input.shape[node.inputs.input.shape.length - 1];
+          const d_out = node.outputs.out.shape[node.outputs.out.shape.length - 1];
+          const flatSeq = node.inputs.input.shape.slice(0, -1).reduce((a, b) => a * b, 1);
+          if (node.inputs.scale) {
+            const sPtr = this.pointers.get(node.inputs.scale.name);
+            this.api.matmul_int8_f32(inPtr, wPtr2, sPtr, bPtr2, outPtr, flatSeq, d_in, d_out);
+          } else {
+            this.api.matmul_f32(inPtr, wPtr2, bPtr2, outPtr, flatSeq, d_in, d_out);
+          }
+        } else if (node.opType === "LayerNorm") {
+          const flatSeq = node.inputs.input.shape.slice(0, -1).reduce((a, b) => a * b, 1);
+          const d_model = node.params.d_model;
+          this.api.layernorm_f32(inPtr, wPtr, bPtr, outPtr, flatSeq, d_model, 1e-5);
+        } else if (node.opType === "SDPA") {
+          const qkvPtr = this.pointers.get(node.inputs.qkv.name);
+          const seqLen = node.inputs.qkv.shape[1];
+          const d_model = node.outputs.out.shape[node.outputs.out.shape.length - 1];
+          const heads = node.params.heads || node.params.num_heads || 8;
+          const head_dim = node.params.head_dim || d_model / heads;
+          const scale = node.params.scale !== void 0 ? node.params.scale : 1 / Math.sqrt(head_dim);
+          this.api.sdpa_f32(qkvPtr, outPtr, seqLen, d_model, heads, head_dim, scale);
+        } else if (node.opType === "CrossSDPA") {
+          const qPtr = this.pointers.get(node.inputs.q.name);
+          const kPtr = this.pointers.get(node.inputs.k.name);
+          const vPtr = this.pointers.get(node.inputs.v.name);
+          const seqQ = node.inputs.q.shape[1];
+          const seqKV = node.inputs.k.shape[1];
+          const d_model = node.outputs.out.shape[node.outputs.out.shape.length - 1];
+          const heads = node.params.heads || node.params.num_heads || 8;
+          const head_dim = node.params.head_dim || d_model / heads;
+          this.api.cross_sdpa_f32(qPtr, kPtr, vPtr, outPtr, seqQ, seqKV, d_model, heads, head_dim, 1 / Math.sqrt(head_dim));
+        } else if (node.opType === "Embedding") {
+          const seqLen = node.inputs.input.shape.reduce((a, b) => a * b, 1);
+          const d_model = node.outputs.out.shape[node.outputs.out.shape.length - 1];
+          this.api.embedding_f32(inPtr, wPtr, outPtr, seqLen, d_model);
+        } else if (node.opType === "ReLU") {
+          const inShape = node.inputs.input.shape;
+          const elements = inShape.reduce((a, b) => a * b, 1);
+          this.api.relu_f32(inPtr, outPtr, elements);
+        } else if (node.opType === "GELU") {
+          const elements = node.inputs.input.sizeBytes / 4;
+          this.api.gelu_f32(inPtr, outPtr, elements);
+        } else if (node.opType === "Add") {
+          this._cpuAdd(node);
+        } else if (node.opType === "Mul") {
+          this._cpuMul(node);
+        } else if (node.opType === "Conv1D") {
+          const inShape = node.inputs.input.shape;
+          const wShape = node.inputs.weight.shape;
+          const [st] = _pair(node.params.stride, 1);
+          const [pd] = _pair(node.params.padding, 0);
+          const groups = node.params.groups || 1;
+          const relu = node.params.relu ? 1 : 0;
+          this.api.conv1d_f32(
+            inPtr,
+            outPtr,
+            wPtr,
+            bPtr,
+            inShape[1],
+            inShape[2],
+            wShape[0],
+            wShape[1],
+            wShape[2],
+            st,
+            pd,
+            groups,
+            relu
+          );
+        } else if (node.opType === "UpsampleNearest2D") {
+          const inShape = node.inputs.input.shape;
+          this.api.upsample_nearest2x_f32(inPtr, outPtr, inShape[3], inShape[1], inShape[2]);
+        } else if (node.opType === "Concat" || node.opType === "Concat2") {
+          this._cpuConcat2(node);
+        } else if (node.opType === "ProfileY") {
+          const inShape = node.inputs.input.shape;
+          this.api.profile_y_f32(inPtr, outPtr, inShape[3], inShape[1], inShape[2]);
+        } else if (node.opType === "ProfileX") {
+          const inShape = node.inputs.input.shape;
+          this.api.profile_x_f32(inPtr, outPtr, inShape[3], inShape[1], inShape[2]);
+        } else if (node.opType === "InterpLinear1D") {
+          const inShape = node.inputs.input.shape;
+          const outL = node.params.size;
+          this.api.interp1d_f32(inPtr, outPtr, inShape[1], inShape[2], outL);
+        } else if (node.opType === "SpatialSoftargmaxY") {
+          const inShape = node.inputs.input.shape;
+          this.api.spatial_softargmax_y_f32(inPtr, outPtr, inShape[3], inShape[1], inShape[2]);
+        } else if (node.opType === "Sigmoid") {
+          const inS = node.inputs.input.shape;
+          const elements = inS.reduce((a, b) => a * b, 1);
+          this.api.sigmoid_f32(inPtr, outPtr, elements);
+        } else if (node.opType === "Clip") {
+          let minVal = node.params.min !== void 0 ? node.params.min : -1e9;
+          let maxVal = node.params.max !== void 0 ? node.params.max : 1e9;
+          if (node.inputs.min) {
+            const p = this.pointers.get(node.inputs.min.name);
+            minVal = new Float32Array(this.mem.buffer, p, 1)[0];
+          }
+          if (node.inputs.max) {
+            const p = this.pointers.get(node.inputs.max.name);
+            maxVal = new Float32Array(this.mem.buffer, p, 1)[0];
+          }
+          const inS = node.inputs.input.shape;
+          const elements = inS.reduce((a, b) => a * b, 1);
+          this.api.clip_f32(inPtr, outPtr, elements, minVal, maxVal);
+        } else if (node.opType === "HardSwish") {
+          const inS = node.inputs.input.shape;
+          const elements = inS.reduce((a, b) => a * b, 1);
+          this.api.hardswish_f32(inPtr, outPtr, elements);
+        } else if (node.opType === "LeakyReLU") {
+          const inS = node.inputs.input.shape;
+          const elements = inS.reduce((a, b) => a * b, 1);
+          const alpha = node.params.alpha || 0.01;
+          if (this.api.leakyrelu_f32) this.api.leakyrelu_f32(inPtr, outPtr, elements, alpha);
+          else this._cpuLeakyReLU(node);
+        } else if (node.opType === "PReLU") {
+          if (this.api.prelu_f32) {
+            const inS = node.inputs.input.shape;
+            const wPtr2 = this.pointers.get(node.inputs.weight.name);
+            this.api.prelu_f32(inPtr, wPtr2, outPtr, inS[0], inS[1], inS[2], inS[3]);
+          } else {
+            this._cpuPReLU(node);
+          }
+        } else if (node.opType === "HardSigmoid") {
+          const inS = node.inputs.input.shape;
+          const elements = inS.reduce((a, b) => a * b, 1);
+          this.api.hardsigmoid_f32(inPtr, outPtr, elements);
+        } else if (node.opType === "Reshape") {
+          const inS = node.inputs.input.shape;
+          const elements = inS.reduce((a, b) => a * b, 1);
+          this.api.copy_f32(inPtr, outPtr, elements);
+        } else if (node.opType === "Transpose") {
+          this._cpuTranspose(node);
+        } else if (node.opType === "GlobalAveragePool") {
+          const inShape = node.inputs.input.shape;
+          this.api.global_average_pool_f32(inPtr, outPtr, inShape[0], inShape[1], inShape[2], inShape[3]);
+        } else if (node.opType === "BatchNorm2D") {
+          const wPtr2 = this.pointers.get(node.inputs.weight.name);
+          const bPtr2 = this.pointers.get(node.inputs.bias.name);
+          const rmPtr = this.pointers.get(node.inputs.running_mean.name);
+          const rvPtr = this.pointers.get(node.inputs.running_var.name);
+          const [b, h, w, c] = node.inputs.input.shape;
+          const eps = node.params.eps || 1e-5;
+          this.api.batch_norm2d_f32(inPtr, wPtr2, bPtr2, rmPtr, rvPtr, outPtr, b, h, w, c, eps);
+        } else if (node.opType === "ResizeNearest2D") {
+          this._cpuResize(node);
+        } else if (node.opType === "Resize") {
+          const [b, in_h, in_w, c] = node.inputs.input.shape;
+          const [ob, out_h, out_w] = node.outputs.out.shape;
+          this.api.resize_bilinear_f32(inPtr, outPtr, b, in_h, in_w, c, out_h, out_w);
+        } else if (node.opType === "Cast") {
+          this._cpuCast(node);
+        } else if (node.opType === "Slice") {
+          const in_s = [1, 1, 1, 1].slice(0, 4 - node.inputs.input.shape.length).concat(node.inputs.input.shape);
+          const out_s = [1, 1, 1, 1].slice(0, 4 - node.outputs.out.shape.length).concat(node.outputs.out.shape);
+          const starts = node.params.starts || [0, 0, 0, 0];
+          const steps = node.params.steps || [1, 1, 1, 1];
+          const axes = node.params.axes || [0, 1, 2, 3];
+          const st = [0, 0, 0, 0];
+          const sp = [1, 1, 1, 1];
+          for (let i = 0; i < axes.length; i++) {
+            let ax = axes[i];
+            if (ax < 0) ax += node.inputs.input.shape.length;
+            ax += 4 - node.inputs.input.shape.length;
+            st[ax] = starts[i] < 0 ? starts[i] + in_s[ax] : starts[i];
+            sp[ax] = steps[i];
+          }
+          this.api.slice_4d_f32(inPtr, outPtr, in_s[0], in_s[1], in_s[2], in_s[3], out_s[0], out_s[1], out_s[2], out_s[3], st[0], st[1], st[2], st[3], sp[0], sp[1], sp[2], sp[3]);
+        } else if (node.opType === "Split") {
+          this._cpuSplit(node);
+        } else if (node.opType === "Gather") {
+          const in_s = [1, 1, 1, 1].slice(0, 4 - node.inputs.input.shape.length).concat(node.inputs.input.shape);
+          let axis = node.params.axis || 0;
+          if (axis < 0) axis += node.inputs.input.shape.length;
+          axis += 4 - node.inputs.input.shape.length;
+          const idxPtr = this.pointers.get(node.inputs.indices.name);
+          this.api.gather_4d_f32(inPtr, idxPtr, outPtr, in_s[0], in_s[1], in_s[2], in_s[3], node.inputs.indices.sizeBytes / 4, axis);
+        } else if (node.opType === "GatherElements") {
+          this._cpuGatherElements(node);
+        } else if (node.opType === "NonMaxSuppression") {
+          this._cpuNonMaxSuppression(node);
+        } else if (node.opType === "Where" || node.opType === "Mask") {
+          const condPtr = this.pointers.get(node.inputs.cond ? node.inputs.cond.name : node.inputs.condition.name);
+          const aPtr = this.pointers.get(node.inputs.x ? node.inputs.x.name : node.inputs.a.name);
+          const bPtr2 = this.pointers.get(node.inputs.y ? node.inputs.y.name : node.inputs.b.name);
+          this.api.where_f32(condPtr, aPtr, bPtr2, outPtr, node.outputs.out.sizeBytes / 4);
+        } else if (node.opType === "Pad") {
+          const pads = node.params.pads;
+          const pt = pads.length === 8 ? pads[1] : pads[0];
+          const pl = pads.length === 8 ? pads[2] : pads[1];
+          const pb = pads.length === 8 ? pads[5] : pads[2];
+          const pr = pads.length === 8 ? pads[6] : pads[3];
+          const val = node.params.value || 0;
+          const inShape = node.inputs.input ? node.inputs.input.shape : node.inputs.data.shape;
+          const s = inShape.length === 4 ? inShape : [1, inShape[0] || 1, inShape[1] || 1, 1];
+          this.api.pad_2d_f32(inPtr, outPtr, val, s[0], s[1], s[2], s[3], pt, pb, pl, pr);
+        } else if (node.opType === "AveragePool2D" || node.opType === "AveragePool") {
+          const [b, in_h, in_w, c] = (node.inputs.input || node.inputs.x).shape;
+          const [ob, out_h, out_w] = node.outputs.out.shape;
+          const ky = node.params.kernel[0], kx = node.params.kernel[1];
+          const sy = node.params.stride ? node.params.stride[0] : 1;
+          const sx = node.params.stride ? node.params.stride[1] : 1;
+          const py = node.params.padding ? node.params.padding[0] : 0;
+          const px = node.params.padding ? node.params.padding[1] : 0;
+          this.api.averagepool2d_f32(inPtr, outPtr, b, in_h, in_w, c, ky, kx, sy, sx, py, px, out_h, out_w);
+        } else if (node.opType === "Div") {
+          this._cpuDiv(node);
+        } else if (node.opType === "MaxPool2D") {
+          const inShape = node.inputs.input.shape;
+          const outShape = node.outputs.out.shape;
+          const ky = node.params.kernel[0], kx = node.params.kernel[1];
+          const sy = node.params.stride[0], sx = node.params.stride[1];
+          const py = node.params.padding ? node.params.padding[0] : 0;
+          const px = node.params.padding ? node.params.padding[1] : 0;
+          this.api.maxpool2d_f32(inPtr, outPtr, inShape[1], inShape[2], inShape[3], outShape[1], outShape[2], ky, kx, sy, sx, py, px);
+        } else if (node.opType === "MeanHeight") {
+          const inShape = node.inputs.input.shape;
+          this.api.mean_height_f32(inPtr, outPtr, inShape[3], inShape[1], inShape[2]);
+        } else if (node.opType === "Flatten" || node.opType === "Squeeze" || node.opType === "Unsqueeze" || node.opType === "Dropout" || node.opType === "Reshape" || node.opType === "Identity") {
+          this._cpuReshape(node);
+        } else {
+          super._runNode(node);
+        }
+      } catch (e) {
+        console.error("[WasmEngine] Execution failed at node:", node, e);
+        throw e;
+      }
+    }
+    const results = {};
+    for (const name of this.graph.outputNames) {
+      const tensor = this.graph.tensors.get(name);
+      const ptr = this.pointers.get(name);
+      results[name] = new Float32Array(this.mem.buffer, ptr, tensor.sizeBytes / 4).slice();
+    }
+    return results;
+  }
+};
+
+// js/GraphExecutor.js
+var ShaderLibrary2;
+var GraphExecutor = class {
+  constructor(device, graph) {
+    this.device = device;
+    this.graph = graph;
+    this.pipelines = [];
+    this.gpuBuffers = /* @__PURE__ */ new Map();
+    console.log("[VolvoxAI WebGPU] Starting Graph Compilation...");
+  }
+  /**
+   * Allocate VRAM for all tensors and compile shaders.
+   */
+  async compile() {
+    ({ ShaderLibrary: ShaderLibrary2 } = await Promise.resolve().then(() => (init_ShaderLibrary(), ShaderLibrary_exports)));
+    this._dinWeights = /* @__PURE__ */ new Map();
+    for (const n of this.graph.nodes) {
+      if ((n.opType === "MatMul" || n.opType === "Linear" || n.opType === "Gemm") && n.wLayout === "din" && n.inputs.weight && !n.inputs.scale) {
+        const din = n.inputs.input.shape[n.inputs.input.shape.length - 1];
+        const dout = n.outputs.out.shape[n.outputs.out.shape.length - 1];
+        this._dinWeights.set(n.inputs.weight.name, { din, dout });
+      }
+    }
+    this._allocateBuffers();
+    for (const node of this.graph.nodes) {
+      await this._buildNodePipeline(node);
+    }
+    console.log(`[VolvoxAI WebGPU] Compilation complete. Allocated ${this.gpuBuffers.size} VRAM buffers.`);
+  }
+  _allocateBuffers() {
+    for (const [name, tensor] of this.graph.tensors.entries()) {
+      let usage = GPUBufferUsage.STORAGE;
+      if (this.graph.nodes.some((n) => Object.values(n.inputs).some((t) => t.name === name))) {
+        usage |= GPUBufferUsage.COPY_DST;
+      }
+      if (this.graph.nodes.some((n) => Object.values(n.outputs).some((t) => t.name === name))) {
+        usage |= GPUBufferUsage.COPY_SRC;
+      }
+      if (!tensor.isWeight && !this.graph.nodes.some((n) => Object.values(n.outputs).some((t) => t.name === name))) {
+        usage |= GPUBufferUsage.COPY_DST;
+      }
+      if (tensor.isWeight && tensor.buffer) {
+        usage |= GPUBufferUsage.COPY_DST;
+      }
+      const buffer = this.device.createBuffer({
+        label: `Tensor_${name}`,
+        size: Math.ceil(tensor.sizeBytes / 4) * 4,
+        // Align to 4 bytes
+        usage
+      });
+      tensor.gpuBuffer = buffer;
+      this.gpuBuffers.set(name, buffer);
+      if (tensor.isWeight && tensor.buffer) {
+        let wbuf = tensor.buffer;
+        const dw = this._dinWeights && this._dinWeights.get(name);
+        if (dw) {
+          const { din, dout } = dw;
+          const t = new Float32Array(din * dout);
+          for (let k = 0; k < din; k++) for (let j = 0; j < dout; j++) t[j * din + k] = tensor.buffer[k * dout + j];
+          wbuf = t;
+        }
+        const src = new Uint8Array(wbuf.buffer, wbuf.byteOffset, wbuf.byteLength);
+        const padded = Math.ceil(src.byteLength / 4) * 4;
+        if (padded === src.byteLength) {
+          this.device.queue.writeBuffer(buffer, 0, src);
+        } else {
+          const tmp = new Uint8Array(padded);
+          tmp.set(src);
+          this.device.queue.writeBuffer(buffer, 0, tmp);
+        }
+      }
+    }
+  }
+  async _buildNodePipeline(node) {
+    let wgslCode = "";
+    let fallbackWgslCode = "";
+    let fallbackWorkgroupCount = null;
+    let bindGroupEntries = [];
+    let workgroupCount = [1, 1, 1];
+    if (node.opType === "Conv2D") {
+      wgslCode = ShaderLibrary2.getConv2DShader();
+      const inputBuf = node.inputs.input.gpuBuffer;
+      const weightBuf = node.inputs.weight.gpuBuffer;
+      const outputBuf = node.outputs.out.gpuBuffer;
+      const [n, h, w, c] = node.inputs.input.shape;
+      const [kh, kw] = node.inputs.weight.shape;
+      const outC = node.outputs.out.shape[3];
+      const outH = node.outputs.out.shape[1];
+      const outW = node.outputs.out.shape[2];
+      const [sy, sx] = _pair(node.params.stride, 1);
+      const [pt, pl] = _pair(node.params.padding, 0);
+      const [dy, dx] = _pair(node.params.dilation, 1);
+      const groups = node.params.groups || 1;
+      const pads = Array.isArray(node.params.pads) ? node.params.pads : [pt, pl, pt, pl];
+      const noPad = pads.length >= 4 && pads[0] === 0 && pads[1] === 0 && pads[2] === 0 && pads[3] === 0;
+      const weightLayout = node.params.weight_layout || (groups === c ? "HWCM" : "HWIO");
+      fallbackWgslCode = wgslCode;
+      fallbackWorkgroupCount = [Math.ceil(outW / 8), Math.ceil(outH / 8), n * outC];
+      if (groups === 1 && weightLayout === "HWIO" && c === 3 && (outC & 15) === 0) {
+        wgslCode = ShaderLibrary2.getConv2DRegularC3Out16Shader();
+        workgroupCount = [Math.ceil(outW / 8), Math.ceil(outH / 8), n * (outC / 16)];
+      } else if (groups === c && weightLayout === "HWCM" && outC === c && (outC & 7) === 0) {
+        wgslCode = ShaderLibrary2.getConv2DDepthwise8Shader();
+        workgroupCount = [Math.ceil(outW / 8), Math.ceil(outH / 8), n * Math.ceil(outC / 8)];
+      } else if (groups === 1 && weightLayout === "HWIO" && kh === 1 && kw === 1 && sy === 1 && sx === 1 && noPad && dy === 1 && dx === 1 && outH === h && outW === w) {
+        if ((outC & 15) === 0) {
+          wgslCode = ShaderLibrary2.getConv2DPointwise16TileShader();
+          workgroupCount = [Math.ceil(outW / 8), Math.ceil(outH / 8), n * (outC / 16)];
+        } else if ((outC & 3) === 0) {
+          wgslCode = ShaderLibrary2.getConv2DPointwise8Vec4Shader();
+          workgroupCount = [Math.ceil(outW / 8), Math.ceil(outH / 8), n * Math.ceil(outC / 8)];
+        } else if ((outC & 1) === 0) {
+          wgslCode = ShaderLibrary2.getConv2DPointwise8Vec2Shader();
+          workgroupCount = [Math.ceil(outW / 8), Math.ceil(outH / 8), n * Math.ceil(outC / 8)];
+        }
+      }
+      const biasBuf = this.device.createBuffer({
+        size: Math.ceil(outC * 4 / 4) * 4,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+      });
+      if (node.inputs.bias) {
+        this.device.queue.writeBuffer(biasBuf, 0, node.inputs.bias.buffer);
+      }
+      const p = new Uint32Array([
+        n,
+        h,
+        w,
+        c,
+        outC,
+        outH,
+        outW,
+        kh,
+        kw,
+        sy,
+        sx,
+        pt,
+        pl,
+        groups,
+        node.params.relu || 0,
+        dy,
+        dx
+      ]);
+      const paramBuf = this.device.createBuffer({ size: Math.ceil(p.byteLength / 16) * 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inputBuf } },
+        { binding: 1, resource: { buffer: weightBuf } },
+        { binding: 2, resource: { buffer: biasBuf } },
+        { binding: 3, resource: { buffer: outputBuf } },
+        { binding: 4, resource: { buffer: paramBuf } }
+      ];
+      if (wgslCode === fallbackWgslCode) workgroupCount = fallbackWorkgroupCount;
+    } else if (node.opType === "Conv1D") {
+      wgslCode = ShaderLibrary2.getConv1DShader();
+      const inputBuf = node.inputs.input.gpuBuffer;
+      const weightBuf = node.inputs.weight.gpuBuffer;
+      const outputBuf = node.outputs.out.gpuBuffer;
+      const biasBuf = this.device.createBuffer({
+        size: Math.ceil(node.inputs.weight.shape[0] * 4 / 4) * 4 || 4,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+      });
+      if (node.inputs.bias) {
+        this.device.queue.writeBuffer(biasBuf, 0, node.inputs.bias.buffer);
+      }
+      const p = new Uint32Array([
+        node.inputs.input.shape[1],
+        node.inputs.input.shape[2],
+        node.outputs.out.shape[1],
+        node.inputs.weight.shape[2],
+        _pair(node.params.stride, 1)[0],
+        _pair(node.params.padding, 0)[0],
+        node.params.relu ? 1 : 0
+      ]);
+      const paramBuf = this.device.createBuffer({ size: p.byteLength, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inputBuf } },
+        { binding: 1, resource: { buffer: weightBuf } },
+        { binding: 2, resource: { buffer: biasBuf } },
+        { binding: 3, resource: { buffer: outputBuf } },
+        { binding: 4, resource: { buffer: paramBuf } }
+      ];
+      workgroupCount = [Math.ceil(node.outputs.out.shape[2] / 64), node.outputs.out.shape[1], 1];
+    } else if (node.opType === "SpatialSoftargmaxY") {
+      wgslCode = ShaderLibrary2.getSpatialSoftargmaxYShader();
+      const inputBuf = node.inputs.input.gpuBuffer;
+      const outputBuf = node.outputs.out.gpuBuffer;
+      const p = new Uint32Array([
+        node.inputs.input.shape[1],
+        node.inputs.input.shape[2],
+        node.inputs.input.shape[3]
+      ]);
+      const paramBuf = this.device.createBuffer({ size: p.byteLength, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inputBuf } },
+        { binding: 1, resource: { buffer: outputBuf } },
+        { binding: 2, resource: { buffer: paramBuf } }
+      ];
+      workgroupCount = [Math.ceil(node.inputs.input.shape[2] / 64), node.inputs.input.shape[3], 1];
+    } else if (node.opType === "UpsampleNearest2D") {
+      wgslCode = ShaderLibrary2.getUpsample2xShader();
+      const inputBuf = node.inputs.input.gpuBuffer;
+      const outputBuf = node.outputs.out.gpuBuffer;
+      const p = new Uint32Array([
+        node.inputs.input.shape[0],
+        node.inputs.input.shape[1],
+        node.inputs.input.shape[2],
+        node.inputs.input.shape[3]
+      ]);
+      const paramBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inputBuf } },
+        { binding: 1, resource: { buffer: outputBuf } },
+        { binding: 2, resource: { buffer: paramBuf } }
+      ];
+      workgroupCount = [
+        Math.ceil(node.outputs.out.shape[2] / 8),
+        Math.ceil(node.outputs.out.shape[1] / 8),
+        node.outputs.out.shape[0] * node.outputs.out.shape[3]
+      ];
+    } else if (node.opType === "Concat") {
+      const shaderModule2 = this.device.createShaderModule({ code: ShaderLibrary2.getConcatCopyShader() });
+      const pipeline2 = await this.device.createComputePipelineAsync({
+        layout: "auto",
+        compute: { module: shaderModule2, entryPoint: "main" }
+      });
+      let offset = 0;
+      for (const k of ["input", "a", "b", "c", "d", "e", "f", "g", "h"]) {
+        const t = node.inputs[k];
+        if (!t) continue;
+        const size = t.sizeBytes / 4;
+        const p = new Uint32Array([size, offset]);
+        const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+        this.device.queue.writeBuffer(paramsBuf, 0, p);
+        const bindGroup2 = this.device.createBindGroup({
+          layout: pipeline2.getBindGroupLayout(0),
+          entries: [
+            { binding: 0, resource: { buffer: t.gpuBuffer } },
+            { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+            { binding: 2, resource: { buffer: paramsBuf } }
+          ]
+        });
+        this.pipelines.push({ pipeline: pipeline2, bindGroup: bindGroup2, workgroupCount: [Math.ceil(size / 64), 1, 1], nodeName: `${node.id}_concat` });
+        offset += size;
+      }
+      return;
+    } else if (node.opType === "ProfileY") {
+      wgslCode = ShaderLibrary2.getProfileYShader();
+      const inputBuf = node.inputs.input.gpuBuffer;
+      const outputBuf = node.outputs.out.gpuBuffer;
+      const p = new Uint32Array([node.inputs.input.shape[1], node.inputs.input.shape[2], node.inputs.input.shape[3]]);
+      const paramBuf = this.device.createBuffer({ size: p.byteLength, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inputBuf } },
+        { binding: 1, resource: { buffer: outputBuf } },
+        { binding: 2, resource: { buffer: paramBuf } }
+      ];
+      workgroupCount = [Math.ceil(node.inputs.input.shape[1] / 64), node.inputs.input.shape[3], 1];
+    } else if (node.opType === "ProfileX") {
+      wgslCode = ShaderLibrary2.getProfileXShader();
+      const inputBuf = node.inputs.input.gpuBuffer;
+      const outputBuf = node.outputs.out.gpuBuffer;
+      const p = new Uint32Array([node.inputs.input.shape[1], node.inputs.input.shape[2], node.inputs.input.shape[3]]);
+      const paramBuf = this.device.createBuffer({ size: p.byteLength, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inputBuf } },
+        { binding: 1, resource: { buffer: outputBuf } },
+        { binding: 2, resource: { buffer: paramBuf } }
+      ];
+      workgroupCount = [Math.ceil(node.inputs.input.shape[2] / 64), node.inputs.input.shape[3], 1];
+    } else if (node.opType === "InterpLinear1D") {
+      wgslCode = ShaderLibrary2.getInterp1DShader();
+      const inputBuf = node.inputs.input.gpuBuffer;
+      const outputBuf = node.outputs.out.gpuBuffer;
+      const p = new Uint32Array([node.inputs.input.shape[1], node.inputs.input.shape[2], node.params.size]);
+      const paramBuf = this.device.createBuffer({ size: p.byteLength, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inputBuf } },
+        { binding: 1, resource: { buffer: outputBuf } },
+        { binding: 2, resource: { buffer: paramBuf } }
+      ];
+      workgroupCount = [Math.ceil(node.params.size / 64), node.inputs.input.shape[1], 1];
+    } else if (node.opType === "MatMul") {
+      if (node.inputs.scale) {
+        wgslCode = ShaderLibrary2.getLinearInt8Shader();
+      } else {
+        wgslCode = ShaderLibrary2.getLinearF32Shader();
+      }
+      const dummyBias = this.device.createBuffer({ size: 4096, usage: GPUBufferUsage.STORAGE });
+      const seq_len = node.inputs.input.shape.slice(0, -1).reduce((a, b) => a * b, 1);
+      const d_in = node.inputs.input.shape[node.inputs.input.shape.length - 1];
+      const d_out = node.outputs.out.shape[node.outputs.out.shape.length - 1];
+      const p = new Uint32Array([seq_len, d_in, d_out]);
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      const biasBuf = node.inputs.bias ? node.inputs.bias.gpuBuffer : dummyBias;
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.inputs.weight.gpuBuffer } },
+        // binding 2 (scale) exists only in the int8 shader; the f32 shader's
+        // unused binding 2 is dropped by layout:"auto", so we must omit it.
+        ...node.inputs.scale ? [{ binding: 2, resource: { buffer: node.inputs.scale.gpuBuffer } }] : [],
+        { binding: 3, resource: { buffer: biasBuf } },
+        { binding: 4, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 5, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(d_out / 64), seq_len, 1];
+    } else if (node.opType === "LayerNorm") {
+      wgslCode = ShaderLibrary2.getLayerNormShader();
+      const d_model = node.params.d_model;
+      const seq_len = node.inputs.input.shape.slice(0, -1).reduce((a, b) => a * b, 1);
+      const p = new Uint32Array([seq_len, d_model]);
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.inputs.weight.gpuBuffer } },
+        { binding: 2, resource: { buffer: node.inputs.bias.gpuBuffer } },
+        { binding: 3, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 4, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(seq_len / 64), 1, 1];
+    } else if (node.opType === "GELU") {
+      wgslCode = ShaderLibrary2.getGELUShader();
+      const num_elements = node.outputs.out.shape.reduce((a, b) => a * b, 1);
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, new Uint32Array([num_elements]));
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(num_elements / 64), 1, 1];
+    } else if (node.opType === "Embedding") {
+      wgslCode = ShaderLibrary2.getEmbeddingShader();
+      const seq_len = node.inputs.input.shape.reduce((a, b) => a * b, 1);
+      const d_model = node.outputs.out.shape[node.outputs.out.shape.length - 1];
+      const p = new Uint32Array([seq_len, d_model]);
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.inputs.weight.gpuBuffer } },
+        { binding: 2, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 3, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(seq_len / 64), 1, 1];
+    } else if (node.opType === "SDPA") {
+      wgslCode = ShaderLibrary2.getSDPAShader();
+      const seq_len = node.inputs.qkv.shape[1];
+      const d_model = node.outputs.out.shape[2];
+      const num_heads = node.params.heads || 8;
+      const head_dim = d_model / num_heads;
+      const scale = node.params.scale !== void 0 ? node.params.scale : 1 / Math.sqrt(head_dim);
+      const p = new ArrayBuffer(20);
+      const p_u32 = new Uint32Array(p);
+      const p_f32 = new Float32Array(p);
+      p_u32[0] = seq_len;
+      p_u32[1] = d_model;
+      p_u32[2] = num_heads;
+      p_u32[3] = head_dim;
+      p_f32[4] = scale;
+      const paramsBuf = this.device.createBuffer({ size: 32, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.qkv.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(seq_len / 64), num_heads, 1];
+    } else if (node.opType === "CrossSDPA") {
+      wgslCode = ShaderLibrary2.getCrossSDPAShader();
+      const seq_len_q = node.inputs.q.shape[1];
+      const seq_len_kv = node.inputs.k.shape[1];
+      const d_model = node.inputs.q.shape[2];
+      const num_heads = node.params.heads || 8;
+      const head_dim = d_model / num_heads;
+      const scale = 1 / Math.sqrt(head_dim);
+      const p = new ArrayBuffer(24);
+      const p_u32 = new Uint32Array(p);
+      const p_f32 = new Float32Array(p);
+      p_u32[0] = seq_len_q;
+      p_u32[1] = seq_len_kv;
+      p_u32[2] = d_model;
+      p_u32[3] = num_heads;
+      p_u32[4] = head_dim;
+      p_f32[5] = scale;
+      const paramsBuf = this.device.createBuffer({ size: 32, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.q.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.inputs.k.gpuBuffer } },
+        { binding: 2, resource: { buffer: node.inputs.v.gpuBuffer } },
+        { binding: 3, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 4, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(seq_len_q / 64), num_heads, 1];
+    } else if (node.opType === "CrossAttention") {
+      wgslCode = ShaderLibrary2.getCrossAttentionShader();
+      const seq_len_q = node.inputs.q.shape[1];
+      const seq_len_kv = node.inputs.kv.shape[1];
+      const d_model = node.outputs.out.shape[2];
+      const num_heads = node.params.heads || 8;
+      const head_dim = d_model / num_heads;
+      const scale_factor = 1 / Math.sqrt(head_dim);
+      const p = new ArrayBuffer(32);
+      const p_u32 = new Uint32Array(p);
+      const p_f32 = new Float32Array(p);
+      p_u32[0] = seq_len_q;
+      p_u32[1] = seq_len_kv;
+      p_u32[2] = d_model;
+      p_u32[3] = num_heads;
+      p_u32[4] = head_dim;
+      p_f32[5] = scale_factor;
+      p_u32[6] = node.inputs.scale ? 1 : 0;
+      p_u32[7] = node.inputs.bias ? 1 : 0;
+      const paramsBuf = this.device.createBuffer({ size: 32, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      const dummyScale = this.device.createBuffer({ size: 4096, usage: GPUBufferUsage.STORAGE });
+      const dummyBias = this.device.createBuffer({ size: 4096, usage: GPUBufferUsage.STORAGE });
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.q.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.inputs.kv.gpuBuffer } },
+        { binding: 2, resource: { buffer: node.inputs.weight.gpuBuffer } },
+        { binding: 3, resource: { buffer: node.inputs.scale ? node.inputs.scale.gpuBuffer : dummyScale } },
+        { binding: 4, resource: { buffer: node.inputs.bias ? node.inputs.bias.gpuBuffer : dummyBias } },
+        { binding: 5, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 6, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(seq_len_q / 64), num_heads, 1];
+    } else if (node.opType === "MeanHeight") {
+      wgslCode = ShaderLibrary2.getMeanHeightShader();
+      const p = new Uint32Array([node.inputs.input.shape[1], node.inputs.input.shape[2], node.inputs.input.shape[3]]);
+      const paramBuf = this.device.createBuffer({ size: Math.ceil(p.byteLength / 16) * 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramBuf } }
+      ];
+      workgroupCount = [Math.ceil(node.inputs.input.shape[2] / 64), node.inputs.input.shape[3], 1];
+    } else if (node.opType === "ReLU" || node.opType === "Sigmoid" || node.opType === "HardSwish" || node.opType === "HardSigmoid" || node.opType === "SiLU" || node.opType === "Swish" || node.opType === "Tanh" || node.opType === "Reshape" || node.opType === "Squeeze" || node.opType === "Unsqueeze" || node.opType === "Flatten" || node.opType === "Dropout" || node.opType === "Identity") {
+      if (node.opType === "ReLU") wgslCode = ShaderLibrary2.getReLUShader();
+      else if (node.opType === "Sigmoid") wgslCode = ShaderLibrary2.getSigmoidShader();
+      else if (node.opType === "HardSwish") wgslCode = ShaderLibrary2.getHardSwishShader();
+      else if (node.opType === "HardSigmoid") wgslCode = ShaderLibrary2.getHardSigmoidShader();
+      else if (node.opType === "SiLU" || node.opType === "Swish") wgslCode = ShaderLibrary2.getSiLUShader();
+      else if (node.opType === "Tanh") wgslCode = ShaderLibrary2.getTanhShader();
+      else wgslCode = ShaderLibrary2.getCopyShader();
+      const elements = node.outputs.out.shape.reduce((a, b) => a * b, 1);
+      const p = new Uint32Array([elements]);
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(elements / 64), 1, 1];
+    } else if (node.opType === "Add" || node.opType === "Mul" || node.opType === "Sub" || node.opType === "Div") {
+      const binOp = {
+        Add: "out_val = av + bv;",
+        Mul: "out_val = av * bv;",
+        Sub: "out_val = av - bv;",
+        Div: "out_val = av / bv;"
+      }[node.opType];
+      wgslCode = ShaderLibrary2.getBroadcastBinaryShader(binOp);
+      const outShape = node.outputs.out.shape;
+      const rank = outShape.length;
+      const contigStrides = (shape) => {
+        const st = new Array(shape.length);
+        let s = 1;
+        for (let i = shape.length - 1; i >= 0; i--) {
+          st[i] = s;
+          s *= shape[i];
+        }
+        return st;
+      };
+      const outStrides = contigStrides(outShape);
+      const bcastStrides = (shape) => {
+        const padded = new Array(rank).fill(1);
+        for (let i = 0; i < shape.length; i++) padded[rank - shape.length + i] = shape[i];
+        const st = contigStrides(padded);
+        for (let i = 0; i < rank; i++) if (padded[i] === 1 && outShape[i] !== 1) st[i] = 0;
+        return st;
+      };
+      const aStrides = bcastStrides(node.inputs.a.shape);
+      const bStrides = bcastStrides(node.inputs.b.shape);
+      const total = outShape.reduce((a, b) => a * b, 1);
+      const meta = new Uint32Array(2 + rank * 3);
+      meta[0] = total;
+      meta[1] = rank;
+      for (let d = 0; d < rank; d++) {
+        meta[2 + d] = outStrides[d];
+        meta[2 + rank + d] = aStrides[d];
+        meta[2 + 2 * rank + d] = bStrides[d];
+      }
+      const metaBuf = this.device.createBuffer({ size: Math.ceil(meta.byteLength / 4) * 4, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(metaBuf, 0, meta);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.a.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.inputs.b.gpuBuffer } },
+        { binding: 2, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 3, resource: { buffer: metaBuf } }
+      ];
+      workgroupCount = [Math.ceil(total / 64), 1, 1];
+    } else if (node.opType === "Transpose") {
+      wgslCode = ShaderLibrary2.getGeneralTransposeShader();
+      const inShape = node.inputs.input.shape;
+      const rank = inShape.length;
+      const perm = node.params.perm || [...Array(rank).keys()].reverse();
+      const inStrides = new Array(rank);
+      {
+        let s = 1;
+        for (let i = rank - 1; i >= 0; i--) {
+          inStrides[i] = s;
+          s *= inShape[i];
+        }
+      }
+      const outShape = perm.map((pp) => inShape[pp]);
+      const outStrides = new Array(rank);
+      {
+        let s = 1;
+        for (let i = rank - 1; i >= 0; i--) {
+          outStrides[i] = s;
+          s *= outShape[i];
+        }
+      }
+      const total = inShape.reduce((a, b) => a * b, 1);
+      const meta = new Uint32Array(2 + rank * 2);
+      meta[0] = total;
+      meta[1] = rank;
+      for (let d = 0; d < rank; d++) {
+        meta[2 + d] = outStrides[d];
+        meta[2 + rank + d] = inStrides[perm[d]];
+      }
+      const metaBuf = this.device.createBuffer({ size: Math.ceil(meta.byteLength / 4) * 4, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(metaBuf, 0, meta);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: metaBuf } }
+      ];
+      workgroupCount = [Math.ceil(total / 64), 1, 1];
+    } else if (node.opType === "Softmax" || node.opType === "LogSoftmax") {
+      wgslCode = node.opType === "Softmax" ? ShaderLibrary2.getSoftmaxShader() : ShaderLibrary2.getLogSoftmaxShader();
+      const shape = node.inputs.input.shape;
+      const d = shape[shape.length - 1];
+      const b = shape.reduce((a, x) => a * x, 1) / d;
+      if (node.params.axis !== void 0) {
+        let ax = node.params.axis;
+        if (ax < 0) ax += shape.length;
+        if (ax !== shape.length - 1) console.warn(`[VolvoxAI WebGPU] ${node.opType} axis ${node.params.axis} != last; using last-axis.`);
+      }
+      const p = new Uint32Array([b, d]);
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(b / 64), 1, 1];
+    } else if (node.opType === "LeakyReLU") {
+      wgslCode = ShaderLibrary2.getLeakyReLUShader();
+      const elements = node.outputs.out.shape.reduce((a, b) => a * b, 1);
+      const alpha = node.params.alpha !== void 0 ? node.params.alpha : 0.01;
+      const p = new ArrayBuffer(16);
+      new Uint32Array(p, 0, 1)[0] = elements;
+      new Float32Array(p, 4, 1)[0] = alpha;
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(elements / 64), 1, 1];
+    } else if (node.opType === "PReLU") {
+      wgslCode = ShaderLibrary2.getPReLUShader();
+      const shape = node.inputs.input.shape;
+      const c = shape[shape.length - 1] || 1;
+      const elements = shape.reduce((a, b) => a * b, 1);
+      const p = new Uint32Array([elements, c]);
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.inputs.weight.gpuBuffer } },
+        { binding: 2, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 3, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(elements / 64), 1, 1];
+    } else if (node.opType === "RMSNorm") {
+      wgslCode = ShaderLibrary2.getRMSNormShader();
+      const shape = node.inputs.input.shape;
+      const d_model = node.params.d_model || shape[shape.length - 1];
+      const seq_len = shape.reduce((a, x) => a * x, 1) / d_model;
+      const eps = node.params.eps !== void 0 ? node.params.eps : 1e-6;
+      const p = new ArrayBuffer(16);
+      new Uint32Array(p, 0, 2).set([seq_len, d_model]);
+      new Float32Array(p, 8, 1)[0] = eps;
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.inputs.weight.gpuBuffer } },
+        { binding: 2, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 3, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(seq_len / 64), 1, 1];
+    } else if (node.opType === "GlobalAveragePool") {
+      wgslCode = ShaderLibrary2.getGlobalAveragePoolShader();
+      const inShape = node.inputs.input.shape;
+      const B = inShape[0];
+      const H = inShape[1] || 1;
+      const W = inShape[2] || 1;
+      const C = inShape[3] || 1;
+      const p = new Uint32Array([B, H, W, C]);
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(C / 64), B, 1];
+    } else if (node.opType === "BatchNorm2D") {
+      wgslCode = ShaderLibrary2.getBatchNorm2DShader();
+      const [bn, hn, wn, cn] = node.inputs.input.shape;
+      const eps = node.params.eps !== void 0 ? node.params.eps : 1e-5;
+      const p = new ArrayBuffer(32);
+      new Uint32Array(p, 0, 4).set([bn, cn, hn, wn]);
+      new Float32Array(p, 16, 1)[0] = eps;
+      const paramsBuf = this.device.createBuffer({ size: 32, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.inputs.weight.gpuBuffer } },
+        { binding: 2, resource: { buffer: node.inputs.bias.gpuBuffer } },
+        { binding: 3, resource: { buffer: node.inputs.running_mean.gpuBuffer } },
+        { binding: 4, resource: { buffer: node.inputs.running_var.gpuBuffer } },
+        { binding: 5, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 6, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(bn * cn * hn * wn / 64), 1, 1];
+    } else if (node.opType === "Resize" || node.opType === "ResizeNearest2D") {
+      wgslCode = ShaderLibrary2.getResizeShader();
+      const [rb, inH, inW, rc] = node.inputs.input.shape;
+      const [, outH, outW] = node.outputs.out.shape;
+      const mode = node.opType === "ResizeNearest2D" || node.params.mode === "nearest" ? 0 : 1;
+      const p = new Uint32Array([rb, inH, inW, rc, outH, outW, mode, 0]);
+      const paramsBuf = this.device.createBuffer({ size: 32, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(outW / 8), Math.ceil(outH / 8), rb * rc];
+    } else if (node.opType === "Split") {
+      const inShape = node.inputs.input.shape;
+      let axis = node.params.axis || 0;
+      if (axis < 0) axis += inShape.length;
+      const outKeys = Object.keys(node.outputs).sort();
+      const numOutputs = outKeys.length;
+      const splitSize = inShape[axis] / numOutputs;
+      let inner = 1;
+      for (let i = axis + 1; i < inShape.length; i++) inner *= inShape[i];
+      const shaderModule2 = this.device.createShaderModule({ code: ShaderLibrary2.getSplitShader() });
+      const pipeline2 = await this.device.createComputePipelineAsync({
+        layout: "auto",
+        compute: { module: shaderModule2, entryPoint: "main" }
+      });
+      for (let o = 0; o < numOutputs; o++) {
+        const outT = node.outputs[outKeys[o]];
+        const total = outT.shape.reduce((a, b) => a * b, 1);
+        const p = new Uint32Array([total, inner, splitSize, inShape[axis], o * splitSize]);
+        const paramsBuf = this.device.createBuffer({ size: 32, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+        this.device.queue.writeBuffer(paramsBuf, 0, p);
+        const bindGroup2 = this.device.createBindGroup({
+          layout: pipeline2.getBindGroupLayout(0),
+          entries: [
+            { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+            { binding: 1, resource: { buffer: outT.gpuBuffer } },
+            { binding: 2, resource: { buffer: paramsBuf } }
+          ]
+        });
+        this.pipelines.push({
+          pipeline: pipeline2,
+          bindGroup: bindGroup2,
+          workgroupCount: [Math.ceil(total / 64), 1, 1],
+          nodeName: `${node.id}_split${o}`
+        });
+      }
+      return;
+    } else if (node.opType === "Clip") {
+      wgslCode = ShaderLibrary2.getClipShader();
+      const elements = node.inputs.input.sizeBytes / 4;
+      let minVal = node.params.min !== void 0 ? node.params.min : -1e9;
+      let maxVal = node.params.max !== void 0 ? node.params.max : 1e9;
+      if (node.inputs.min) minVal = new Float32Array(node.inputs.min.buffer)[0];
+      if (node.inputs.max) maxVal = new Float32Array(node.inputs.max.buffer)[0];
+      const p = new Float32Array([0, minVal, maxVal, 0]);
+      new Uint32Array(p.buffer)[0] = elements;
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(elements / 64), 1, 1];
+    } else if (node.opType === "MaxPool2D") {
+      wgslCode = ShaderLibrary2.getMaxPool2DShader();
+      const [ky, kx] = _pair(node.params.kernel, 1);
+      const [sy, sx] = _pair(node.params.stride, 1);
+      const py = node.params.padding ? node.params.padding[0] : 0;
+      const px = node.params.padding ? node.params.padding[1] : 0;
+      const p = new Uint32Array([
+        node.inputs.input.shape[1],
+        node.inputs.input.shape[2],
+        node.inputs.input.shape[3],
+        node.outputs.out.shape[1],
+        node.outputs.out.shape[2],
+        ky,
+        kx,
+        sy,
+        sx,
+        py,
+        px
+      ]);
+      const paramBuf = this.device.createBuffer({ size: Math.ceil(p.byteLength / 16) * 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: node.inputs.input.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramBuf } }
+      ];
+      workgroupCount = [
+        Math.ceil(node.outputs.out.shape[2] / 8),
+        Math.ceil(node.outputs.out.shape[1] / 8),
+        node.outputs.out.shape[3]
+      ];
+    } else if (node.opType === "Cast") {
+      wgslCode = ShaderLibrary2.getCopyShader();
+      const inp = node.inputs.input || node.inputs.data;
+      const elements = node.outputs.out.shape.reduce((a, b) => a * b, 1);
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, new Uint32Array([elements]));
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inp.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(elements / 64), 1, 1];
+    } else if (node.opType === "Where" || node.opType === "Mask") {
+      wgslCode = ShaderLibrary2.getWhereShader();
+      const cond = node.inputs.cond || node.inputs.condition;
+      const a = node.inputs.x || node.inputs.a;
+      const b = node.inputs.y || node.inputs.b;
+      const elements = node.outputs.out.shape.reduce((x, y) => x * y, 1);
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, new Uint32Array([elements]));
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: cond.gpuBuffer } },
+        { binding: 1, resource: { buffer: a.gpuBuffer } },
+        { binding: 2, resource: { buffer: b.gpuBuffer } },
+        { binding: 3, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 4, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(elements / 64), 1, 1];
+    } else if (node.opType === "DequantizeLinear") {
+      wgslCode = ShaderLibrary2.getDequantizeLinearShader();
+      const inp = node.inputs.input || node.inputs.x;
+      const elements = node.outputs.out.shape.reduce((a, b) => a * b, 1);
+      const hasZp = node.inputs.zero_point ? 1 : 0;
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, new Uint32Array([elements, hasZp]));
+      const dummy = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.STORAGE });
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inp.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.inputs.scale.gpuBuffer } },
+        { binding: 2, resource: { buffer: hasZp ? node.inputs.zero_point.gpuBuffer : dummy } },
+        { binding: 3, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 4, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(elements / 64), 1, 1];
+    } else if (node.opType === "Expand" || node.opType === "Broadcast") {
+      wgslCode = ShaderLibrary2.getExpandShader();
+      const inp = node.inputs.input || node.inputs.data;
+      const pad4 = (sh) => [1, 1, 1, 1].slice(0, 4 - sh.length).concat(sh);
+      const [ib, ih, iw, ic] = pad4(inp.shape);
+      const [ob, oh, ow, oc] = pad4(node.outputs.out.shape);
+      const p = new Uint32Array([ib, ih, iw, ic, ob, oh, ow, oc]);
+      const paramsBuf = this.device.createBuffer({ size: 32, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inp.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(ob * oh * ow * oc / 64), 1, 1];
+    } else if (node.opType === "Pad") {
+      wgslCode = ShaderLibrary2.getPadShader();
+      const inp = node.inputs.input || node.inputs.data;
+      const pads = node.params.pads || [];
+      const pt = pads.length === 8 ? pads[1] : pads[0] || 0;
+      const pl = pads.length === 8 ? pads[2] : pads[1] || 0;
+      const val = node.params.value || 0;
+      const is = [1, 1, 1, 1].slice(0, 4 - inp.shape.length).concat(inp.shape);
+      const os = [1, 1, 1, 1].slice(0, 4 - node.outputs.out.shape.length).concat(node.outputs.out.shape);
+      const buf = new ArrayBuffer(48);
+      const u = new Uint32Array(buf);
+      const f = new Float32Array(buf);
+      u[0] = is[0];
+      u[1] = is[1];
+      u[2] = is[2];
+      u[3] = is[3];
+      u[4] = os[1];
+      u[5] = os[2];
+      u[6] = pt;
+      u[7] = pl;
+      f[8] = val;
+      const paramsBuf = this.device.createBuffer({ size: 48, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, buf);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inp.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(os[0] * os[1] * os[2] * os[3] / 64), 1, 1];
+    } else if (node.opType === "Slice") {
+      wgslCode = ShaderLibrary2.getSliceShader();
+      const inp = node.inputs.input || node.inputs.data;
+      const starts = node.params.starts || [0, 0, 0, 0];
+      const steps = node.params.steps || [1, 1, 1, 1];
+      const axes = node.params.axes || [0, 1, 2, 3];
+      const in_s = [1, 1, 1, 1].slice(0, 4 - inp.shape.length).concat(inp.shape);
+      const out_s = [1, 1, 1, 1].slice(0, 4 - node.outputs.out.shape.length).concat(node.outputs.out.shape);
+      const st = [0, 0, 0, 0], sp = [1, 1, 1, 1];
+      for (let i = 0; i < axes.length; i++) {
+        let ax = axes[i];
+        if (ax < 0) ax += inp.shape.length;
+        ax += 4 - inp.shape.length;
+        st[ax] = starts[i] < 0 ? starts[i] + in_s[ax] : starts[i];
+        sp[ax] = steps[i];
+      }
+      const total = out_s[0] * out_s[1] * out_s[2] * out_s[3];
+      const p = new Uint32Array([
+        out_s[0],
+        out_s[1],
+        out_s[2],
+        out_s[3],
+        in_s[1],
+        in_s[2],
+        in_s[3],
+        st[0],
+        st[1],
+        st[2],
+        st[3],
+        sp[0],
+        sp[1],
+        sp[2],
+        sp[3],
+        total
+      ]);
+      const paramsBuf = this.device.createBuffer({ size: 64, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inp.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(total / 64), 1, 1];
+    } else if (node.opType === "Gather") {
+      let axis = node.params.axis || 0;
+      if (axis < 0) axis += node.inputs.input.shape.length;
+      if (axis !== 0) {
+        console.warn(`[VolvoxAI WebGPU] Gather axis ${axis} not supported on GPU; node ${node.id} skipped (use WASM/CPU).`);
+        return;
+      }
+      wgslCode = ShaderLibrary2.getGatherShader();
+      const inp = node.inputs.input;
+      const rowSize = inp.shape.slice(1).reduce((a, b) => a * b, 1) || 1;
+      const total = node.outputs.out.shape.reduce((a, b) => a * b, 1);
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, new Uint32Array([rowSize, total / rowSize, total]));
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inp.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.inputs.indices.gpuBuffer } },
+        { binding: 2, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 3, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(total / 64), 1, 1];
+    } else if (node.opType === "ReduceSum" || node.opType === "ReduceMean") {
+      wgslCode = ShaderLibrary2.getReduceShader();
+      const inp = node.inputs.input || node.inputs.data;
+      const in_shape = inp.shape.length === 2 ? inp.shape : [1, inp.shape.reduce((a, b2) => a * b2, 1)];
+      const b = in_shape[0], d = in_shape[1];
+      const inv = node.opType === "ReduceMean" ? 1 / d : 1;
+      const buf = new ArrayBuffer(16);
+      new Uint32Array(buf, 0, 2).set([b, d]);
+      new Float32Array(buf, 8, 1)[0] = inv;
+      const paramsBuf = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, buf);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inp.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(b / 64), 1, 1];
+    } else if (node.opType === "AveragePool" || node.opType === "AveragePool2D") {
+      wgslCode = ShaderLibrary2.getAveragePool2DShader();
+      const inp = node.inputs.input || node.inputs.x;
+      const [b, in_h, in_w, c] = inp.shape;
+      const [, out_h, out_w] = node.outputs.out.shape;
+      const [kh, kw] = _pair(node.params.kernel, 1);
+      const [sh, sw] = _pair(node.params.stride, 1);
+      const ph = node.params.padding ? node.params.padding[0] : 0;
+      const pw = node.params.padding ? node.params.padding[1] : 0;
+      const p = new Uint32Array([b, in_h, in_w, c, out_h, out_w, kh, kw, sh, sw, ph, pw]);
+      const paramsBuf = this.device.createBuffer({ size: 48, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inp.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 2, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(out_w / 8), Math.ceil(out_h / 8), b * c];
+    } else if (node.opType === "ConvTranspose2D") {
+      wgslCode = ShaderLibrary2.getConvTranspose2DShader();
+      const inp = node.inputs.input || node.inputs.x;
+      const [b, in_h, in_w, in_c] = inp.shape;
+      const [, out_h, out_w, out_c] = node.outputs.out.shape;
+      const kh = node.params.kernel[0], kw = node.params.kernel[1];
+      const sh = node.params.stride ? node.params.stride[0] : 1;
+      const sw = node.params.stride ? node.params.stride[1] : 1;
+      const ph = node.params.padding ? node.params.padding[0] : 0;
+      const pw = node.params.padding ? node.params.padding[1] : 0;
+      const hasBias = node.inputs.bias ? 1 : 0;
+      const p = new Uint32Array([b, in_h, in_w, in_c, out_h, out_w, out_c, kh, kw, sh, sw, ph, pw, hasBias]);
+      const paramsBuf = this.device.createBuffer({ size: 64, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      this.device.queue.writeBuffer(paramsBuf, 0, p);
+      const dummyBias = this.device.createBuffer({ size: 16, usage: GPUBufferUsage.STORAGE });
+      bindGroupEntries = [
+        { binding: 0, resource: { buffer: inp.gpuBuffer } },
+        { binding: 1, resource: { buffer: node.inputs.weight.gpuBuffer } },
+        { binding: 2, resource: { buffer: hasBias ? node.inputs.bias.gpuBuffer : dummyBias } },
+        { binding: 3, resource: { buffer: node.outputs.out.gpuBuffer } },
+        { binding: 4, resource: { buffer: paramsBuf } }
+      ];
+      workgroupCount = [Math.ceil(out_w / 8), Math.ceil(out_h / 8), b * out_c];
+    } else {
+      console.warn(`[VolvoxAI WebGPU] Shader for ${node.opType} not implemented yet in Executor.`);
+      return;
+    }
+    if (!wgslCode) {
+      console.warn(`[VolvoxAI WebGPU] ${node.opType} has no native GPU shader; node ${node.id} skipped.`);
+      return;
+    }
+    if (isNaN(workgroupCount[0]) || isNaN(workgroupCount[1]) || isNaN(workgroupCount[2]) || workgroupCount[0] <= 0 || workgroupCount[1] <= 0 || workgroupCount[2] <= 0) {
+      console.error(`Invalid workgroupCount [${workgroupCount}] for node ${node.id} (${node.opType})`);
+      workgroupCount = [1, 1, 1];
+    }
+    let shaderModule = this.device.createShaderModule({ code: wgslCode });
+    let pipeline;
+    try {
+      pipeline = await this.device.createComputePipelineAsync({
+        layout: "auto",
+        compute: { module: shaderModule, entryPoint: "main" }
+      });
+    } catch (err) {
+      if (!fallbackWgslCode || fallbackWgslCode === wgslCode || !fallbackWorkgroupCount) throw err;
+      console.warn(`[VolvoxAI WebGPU] Specialized shader for ${node.id} failed; falling back to generic Conv2D.`, err);
+      wgslCode = fallbackWgslCode;
+      workgroupCount = fallbackWorkgroupCount;
+      shaderModule = this.device.createShaderModule({ code: wgslCode });
+      pipeline = await this.device.createComputePipelineAsync({
+        layout: "auto",
+        compute: { module: shaderModule, entryPoint: "main" }
+      });
+    }
+    const bindGroup = this.device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: bindGroupEntries
+    });
+    this.pipelines.push({ pipeline, bindGroup, workgroupCount, nodeName: node.id });
+  }
+  /**
+   * Execute the compiled graph on the GPU.
+   * @param {Object} inputs - Key-value pair of input tensor names to Float32Array/Int32Array
+   */
+  async execute(inputs) {
+    for (const [name, data] of Object.entries(inputs)) {
+      const buffer = this.gpuBuffers.get(name);
+      if (buffer) {
+        this.device.queue.writeBuffer(buffer, 0, data.buffer, data.byteOffset, data.byteLength);
+      }
+    }
+    let commandEncoder = this.device.createCommandEncoder();
+    let passEncoder = commandEncoder.beginComputePass();
+    for (let i = 0; i < this.pipelines.length; i++) {
+      const p = this.pipelines[i];
+      passEncoder.setPipeline(p.pipeline);
+      passEncoder.setBindGroup(0, p.bindGroup);
+      passEncoder.dispatchWorkgroups(p.workgroupCount[0], p.workgroupCount[1], p.workgroupCount[2]);
+      if ((i + 1) % 20 === 0) {
+        passEncoder.end();
+        this.device.queue.submit([commandEncoder.finish()]);
+        commandEncoder = this.device.createCommandEncoder();
+        passEncoder = commandEncoder.beginComputePass();
+      }
+    }
+    passEncoder.end();
+    this.device.queue.submit([commandEncoder.finish()]);
+    const lastNode = this.graph.nodes[this.graph.nodes.length - 1];
+    const outName = Object.keys(lastNode.outputs)[0];
+    return this.gpuBuffers.get(lastNode.outputs[outName].name);
+  }
+  /**
+   * Helper to read a GPUBuffer back to CPU (Float32Array) for validation.
+   */
+  async readBuffer(gpuBuffer, sizeBytes) {
+    const stagingBuffer = this.device.createBuffer({
+      size: sizeBytes,
+      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+    });
+    const commandEncoder = this.device.createCommandEncoder();
+    commandEncoder.copyBufferToBuffer(gpuBuffer, 0, stagingBuffer, 0, sizeBytes);
+    this.device.queue.submit([commandEncoder.finish()]);
+    await stagingBuffer.mapAsync(GPUMapMode.READ);
+    const copyArray = new Float32Array(stagingBuffer.getMappedRange().slice(0));
+    stagingBuffer.unmap();
+    return copyArray;
+  }
+};
+
+// js/GraphLoader.js
+var GraphLoader = class _GraphLoader {
+  /**
+   * Loads a graph from a single Safetensors file.
+   * The Safetensors __metadata__ field must contain a 'volvox_nodes' JSON string.
+   * @param {Object} graphBuilder - An empty Graph instance from VolvoxAI.createGraph()
+   * @param {string} safetensorsUrl - URL to the .safetensors file
+   * @returns {Promise<Graph>} Populated graph
+   */
+  static async load(graphBuilder, safetensorsUrl) {
+    let configUrl;
+    if (safetensorsUrl.endsWith("_weights.safetensors")) {
+      configUrl = safetensorsUrl.replace("_weights.safetensors", "_config.json");
+    } else {
+      configUrl = safetensorsUrl.replace(/\/[^\/]+$/, "/config.json");
+    }
+    console.log(`[VolvoxAI] Loading config from ${configUrl}...`);
+    const configResponse = await fetch(configUrl);
+    if (!configResponse.ok) throw new Error(`Failed to load config.json: ${configResponse.statusText}`);
+    const config = await configResponse.json();
+    console.log(`[VolvoxAI] Loading Safetensors model from ${safetensorsUrl}...`);
+    const response = await fetch(safetensorsUrl);
+    if (!response.ok) throw new Error(`Failed to load safetensors: ${response.statusText}`);
+    const buffer = await response.arrayBuffer();
+    const dataView = new DataView(buffer);
+    const headerLen = Number(dataView.getBigUint64(0, true));
+    const headerBytes = new Uint8Array(buffer, 8, headerLen);
+    const headerStr = new TextDecoder("utf-8").decode(headerBytes);
+    const header = JSON.parse(headerStr);
+    const metadata = header.__metadata__ || {};
+    const binaryOffset = 8 + headerLen;
+    const tensorsMap = /* @__PURE__ */ new Map();
+    for (const [name, info] of Object.entries(header)) {
+      if (name === "__metadata__") continue;
+      const dtype = info.dtype === "I8" ? "int8" : info.dtype === "U8" ? "uint8" : "float32";
+      const tensor = graphBuilder.addWeight(name, info.shape, dtype);
+      const startByte = binaryOffset + info.data_offsets[0];
+      const lengthBytes = info.data_offsets[1] - info.data_offsets[0];
+      if (dtype === "int8") {
+        tensor.buffer = new Int8Array(buffer, startByte, lengthBytes);
+      } else if (dtype === "uint8") {
+        tensor.buffer = new Uint8Array(buffer, startByte, lengthBytes);
+      } else if (info.dtype === "F16") {
+        tensor.buffer = _GraphLoader._float16ToFloat32Array(buffer, startByte, lengthBytes);
+      } else {
+        tensor.buffer = new Float32Array(buffer, startByte, lengthBytes / 4);
+      }
+      tensorsMap.set(name, tensor);
+    }
+    if (config.inputs) {
+      const inputsDef = config.inputs;
+      for (const [name, info] of Object.entries(inputsDef)) {
+        const tensor = graphBuilder.addInput(name, info.shape, info.dtype || "float32");
+        tensorsMap.set(name, tensor);
+      }
+    }
+    if (config.nodes) {
+      _GraphLoader._buildFromBlueprint(graphBuilder, config, tensorsMap);
+    } else if (config.model_type) {
+      if (typeof _GraphLoader.ModelBuilders === "undefined" || !_GraphLoader.ModelBuilders[config.model_type]) {
+        throw new Error(`[VolvoxAI] Unsupported Hugging Face model_type: '${config.model_type}'. No builder registered.`);
+      }
+      console.log(`[VolvoxAI] Building graph on the fly using model builder for '${config.model_type}'...`);
+      _GraphLoader.ModelBuilders[config.model_type](graphBuilder, config, tensorsMap);
+    } else {
+      throw new Error("[VolvoxAI] config.json must contain either 'nodes' (Volvox blueprint) or 'model_type' (Hugging Face).");
+    }
+    _GraphLoader._dequantizeConvWeights(graphBuilder);
+    _GraphLoader._normalizeConvWeightsForImageLayout(graphBuilder);
+    const usedAsInput = /* @__PURE__ */ new Set();
+    for (const node of graphBuilder.nodes) {
+      for (const t of Object.values(node.inputs)) {
+        if (t && t.name) usedAsInput.add(t.name);
+      }
+    }
+    const outputNames = [];
+    for (const node of graphBuilder.nodes) {
+      for (const t of Object.values(node.outputs)) {
+        if (t && t.name && !usedAsInput.has(t.name)) {
+          outputNames.push(t.name);
+        }
+      }
+    }
+    graphBuilder.outputNames = outputNames;
+    _GraphLoader._resolveMatMulLayouts(graphBuilder);
+    console.log(`[VolvoxAI] Successfully assembled graph. Outputs:`, outputNames);
+    return graphBuilder;
+  }
+  /**
+   * MatMul weights come in two layouts: PyTorch Linear stores [d_out, d_in]
+   * (out = x·Wᵀ); GPT-Neo/Conv1D stores [d_in, d_out] (out = x·W). Non-square weights
+   * disambiguate by shape; square ones can't, so infer the model-wide convention from
+   * the unambiguous weights and tag every MatMul node with `wLayout` ('dout' | 'din').
+   */
+  static _resolveMatMulLayouts(graph) {
+    const isMM = (n) => n.opType === "MatMul" || n.opType === "Linear" || n.opType === "Gemm";
+    const dims = (n) => {
+      const K = n.inputs.input?.shape?.[n.inputs.input.shape.length - 1];
+      const outT = Object.values(n.outputs)[0];
+      const N = outT?.shape?.[outT.shape.length - 1];
+      return [K, N];
+    };
+    let din = 0, dout = 0;
+    for (const n of graph.nodes) {
+      if (!isMM(n) || !n.inputs.weight || n.inputs.scale) continue;
+      const w = n.inputs.weight.shape;
+      if (!w || w.length < 2) continue;
+      const [K, N] = dims(n);
+      if (K === N) continue;
+      if (w[0] === N && w[1] === K) dout++;
+      else if (w[0] === K && w[1] === N) din++;
+    }
+    const model = din > dout ? "din" : "dout";
+    for (const n of graph.nodes) {
+      if (!isMM(n)) continue;
+      const w = n.inputs.weight?.shape;
+      const [K, N] = dims(n);
+      if (n.inputs.scale) n.wLayout = "dout";
+      else if (w && w.length >= 2 && K !== N && w[0] === N && w[1] === K) n.wLayout = "dout";
+      else if (w && w.length >= 2 && K !== N && w[0] === K && w[1] === N) n.wLayout = "din";
+      else n.wLayout = model;
+    }
+  }
+  static _buildFromBlueprint(graphBuilder, config, tensorsMap) {
+    const nodesDef = config.nodes;
+    for (const nodeDef of nodesDef) {
+      const inputs = {};
+      for (const [key, tName] of Object.entries(nodeDef.inputs)) {
+        let t = tensorsMap.get(tName) || graphBuilder.tensors.get(tName);
+        if (!t) {
+          console.warn(`[GraphLoader] Implicitly adding missing graph input '${tName}' with shape [1, 3, 224, 224]`);
+          t = graphBuilder.addInput(tName, [1, 3, 224, 224], "float32");
+          tensorsMap.set(tName, t);
+        }
+        inputs[key] = t;
+      }
+      const outputsShape = nodeDef.outputs_shape || {};
+      const opName = nodeDef.opType || nodeDef.op;
+      const outTensors = graphBuilder.addOp(opName, inputs, outputsShape, nodeDef.params || {});
+      for (const [key, tName] of Object.entries(nodeDef.outputs)) {
+        const t = outTensors[key];
+        if (!t) continue;
+        if (t.name !== tName) {
+          graphBuilder.tensors.delete(t.name);
+          t.name = tName;
+          graphBuilder.tensors.set(tName, t);
+        }
+        tensorsMap.set(tName, t);
+      }
+    }
+  }
+  // Registry for Hugging Face model builders
+  static ModelBuilders = {};
+  static _float16ToFloat32Array(buffer, byteOffset, lengthBytes) {
+    const n = lengthBytes / 2;
+    const view = new DataView(buffer, byteOffset, lengthBytes);
+    const out = new Float32Array(n);
+    for (let i = 0; i < n; i++) out[i] = _GraphLoader._float16BitsToFloat32(view.getUint16(i * 2, true));
+    return out;
+  }
+  static _float16BitsToFloat32(h) {
+    const sign = h & 32768 ? -1 : 1;
+    const exp = h >> 10 & 31;
+    const mant = h & 1023;
+    if (exp === 0) {
+      if (mant === 0) return sign < 0 ? -0 : 0;
+      return sign * Math.pow(2, -14) * (mant / 1024);
+    }
+    if (exp === 31) return mant ? NaN : sign * Infinity;
+    return sign * Math.pow(2, exp - 15) * (1 + mant / 1024);
+  }
+  /**
+   * Conv kernels (JS and WASM) expect float32 weights and have no QConv path, so
+   * fold per-output-channel int8 scales into the weights up front. MatMul keeps
+   * its int8+scale fast path and is left untouched.
+   */
+  static _dequantizeConvWeights(graph) {
+    for (const node of graph.nodes) {
+      if (node.opType !== "Conv2D" && node.opType !== "Conv1D" && node.opType !== "QConv2D") continue;
+      const w = node.inputs.weight;
+      const s = node.inputs.scale || node.inputs.weight_scale;
+      if (!s || !w || w.dtype !== "int8" || !w.buffer) continue;
+      const zp = node.inputs.weight_zero_point;
+      const outC = w.shape[0];
+      const perOut = w.buffer.length / outC;
+      const deq = new Float32Array(w.buffer.length);
+      for (let oc = 0; oc < outC; oc++) {
+        const sc = s.buffer[oc];
+        const z = zp && zp.buffer ? zp.buffer[zp.buffer.length === 1 ? 0 : oc] : 0;
+        const base = oc * perOut;
+        for (let j = 0; j < perOut; j++) deq[base + j] = (w.buffer[base + j] - z) * sc;
+      }
+      if (node.opType === "QConv2D") {
+        const deqWeight = graph.addWeight(`${w.name}__deq_${node.id}`, w.shape, "float32");
+        deqWeight.buffer = deq;
+        deqWeight.sizeBytes = deq.length * 4;
+        node.inputs.weight = deqWeight;
+      } else {
+        w.buffer = deq;
+        w.dtype = "float32";
+        w.sizeBytes = deq.length * 4;
+      }
+      delete node.inputs.scale;
+      delete node.inputs.weight_scale;
+      delete node.inputs.weight_zero_point;
+      if (node.opType === "QConv2D") node.opType = "Conv2D";
+    }
+  }
+  static _normalizeConvWeightsForImageLayout(graph) {
+    for (const node of graph.nodes) {
+      if (node.opType !== "Conv2D") continue;
+      const w = node.inputs.weight;
+      const input = node.inputs.input;
+      const output = node.outputs.out;
+      if (!w || !w.buffer || !input || !output || w.shape.length !== 4) continue;
+      const layout = node.params?.weight_layout || "HWIO";
+      if (layout === "HWIO" || layout === "HWCM") continue;
+      if (layout === "OHWI" || layout === "OIHW") {
+        const [ocN, a, b, c] = w.shape;
+        const kh = layout === "OHWI" ? a : b;
+        const kw = layout === "OHWI" ? b : c;
+        const icN = layout === "OHWI" ? c : a;
+        const src = w.buffer;
+        const dst = new Float32Array(src.length);
+        for (let oc = 0; oc < ocN; oc++) {
+          for (let y = 0; y < kh; y++) {
+            for (let x = 0; x < kw; x++) {
+              for (let ic = 0; ic < icN; ic++) {
+                dst[((y * kw + x) * icN + ic) * ocN + oc] = layout === "OHWI" ? src[((oc * kh + y) * kw + x) * icN + ic] : src[((oc * icN + ic) * kh + y) * kw + x];
+              }
+            }
+          }
+        }
+        w.buffer = dst;
+        w.shape = [kh, kw, icN, ocN];
+        w.sizeBytes = dst.length * 4;
+        node.params.weight_layout = "HWIO";
+      } else if (layout === "1HWO" || layout === "1HWM") {
+        const [, kh, kw, ocN] = w.shape;
+        const icN = input.shape[3];
+        const mult = output.shape[3] / icN;
+        if (!Number.isInteger(mult) || mult <= 0 || icN * mult !== ocN) {
+          throw new Error(`[GraphLoader] Invalid depthwise Conv2D shape for node ${node.id}`);
+        }
+        const src = w.buffer;
+        const dst = new Float32Array(src.length);
+        for (let y = 0; y < kh; y++) {
+          for (let x = 0; x < kw; x++) {
+            for (let ic = 0; ic < icN; ic++) {
+              for (let m = 0; m < mult; m++) {
+                dst[((y * kw + x) * icN + ic) * mult + m] = src[(y * kw + x) * ocN + ic * mult + m];
+              }
+            }
+          }
+        }
+        w.buffer = dst;
+        w.shape = [kh, kw, icN, mult];
+        w.sizeBytes = dst.length * 4;
+        node.params.weight_layout = "HWCM";
+      } else {
+        throw new Error(`[GraphLoader] Unsupported Conv2D weight_layout '${layout}'. VolvoxAI uses NHWC/HWIO only.`);
+      }
+    }
+  }
+};
+
+// js/WebNNEngine.js
+var WebNNEngine = class {
+  constructor(context) {
+    this.context = context;
+    this.graph = null;
+    this.compiledGraph = null;
+    this.operands = {};
+    this.inputs = [];
+    this.outputs = [];
+  }
+  async allocateGraph(graph) {
+    this.graph = graph;
+    this.operands = {};
+    this.inputs = [];
+    this.outputs = [];
+    const builder = new MLGraphBuilder(this.context);
+    const desc = (shape) => {
+      const d = shape.length ? shape : [1];
+      return { dataType: "float32", type: "float32", shape: d, dimensions: d };
+    };
+    const generated = /* @__PURE__ */ new Set();
+    for (const node of graph.nodes)
+      for (const t of Object.values(node.outputs)) if (t && t.name) generated.add(t.name);
+    for (const t of graph.tensors.values()) {
+      if (t.isWeight && t.buffer) {
+        this.operands[t.name] = builder.constant(desc(t.shape), t.buffer);
+        generated.add(t.name);
+      } else if (!generated.has(t.name)) {
+        this.inputs.push(t.name);
+        this.operands[t.name] = builder.input(t.name, desc(t.shape));
+        generated.add(t.name);
+      }
+    }
+    const getOp = (name) => {
+      if (!name || !this.operands[name]) {
+        console.warn(`[WebNN] missing operand: ${name}`);
+        this.operands[name] = builder.constant(desc([1]), new Float32Array([0]));
+      }
+      return this.operands[name];
+    };
+    const nin = (node, key) => node.inputs[key] ? node.inputs[key].name : null;
+    for (const node of graph.nodes) {
+      const op = node.opType;
+      const outName = Object.values(node.outputs)[0].name;
+      try {
+        if (op === "MatMul" || op === "Linear" || op === "Gemm") {
+          const a = getOp(nin(node, "input") || nin(node, "a"));
+          const w = getOp(nin(node, "weight") || nin(node, "b"));
+          let res = node.wLayout === "dout" ? builder.gemm(a, w, { bTranspose: true }) : builder.matmul(a, w);
+          if (nin(node, "bias")) res = builder.add(res, getOp(nin(node, "bias")));
+          this.operands[outName] = res;
+        } else if (op === "Add") {
+          this.operands[outName] = builder.add(getOp(nin(node, "a") || nin(node, "input")), getOp(nin(node, "b")));
+        } else if (op === "Mul") {
+          this.operands[outName] = builder.mul(getOp(nin(node, "a") || nin(node, "input")), getOp(nin(node, "b")));
+        } else if (op === "ReLU") {
+          this.operands[outName] = builder.relu(getOp(nin(node, "input")));
+        } else if (op === "GELU") {
+          this.operands[outName] = builder.gelu(getOp(nin(node, "input")));
+        } else if (op === "SiLU" || op === "Swish") {
+          const x = getOp(nin(node, "input"));
+          this.operands[outName] = builder.mul(x, builder.sigmoid(x));
+        } else if (op === "Sigmoid") {
+          this.operands[outName] = builder.sigmoid(getOp(nin(node, "input")));
+        } else if (op === "Softmax") {
+          this.operands[outName] = builder.softmax(getOp(nin(node, "input")));
+        } else if (op === "Reshape" || op === "Flatten") {
+          const shape = Object.values(node.outputs)[0].shape;
+          this.operands[outName] = builder.reshape(getOp(nin(node, "input")), shape.length ? shape : [1]);
+        } else if (op === "LayerNorm") {
+          const input = getOp(nin(node, "input"));
+          const scale = nin(node, "weight") ? getOp(nin(node, "weight")) : void 0;
+          const bias = nin(node, "bias") ? getOp(nin(node, "bias")) : void 0;
+          const inShape = node.inputs.input.shape;
+          this.operands[outName] = builder.layerNormalization(input, { axes: [inShape.length - 1], scale, bias });
+        } else if (op === "Conv2D") {
+          this.operands[outName] = builder.conv2d(
+            getOp(nin(node, "input")),
+            getOp(nin(node, "weight")),
+            {
+              bias: nin(node, "bias") ? getOp(nin(node, "bias")) : void 0,
+              strides: node.params.stride,
+              padding: node.params.padding,
+              groups: node.params.groups || 1
+            }
+          );
+        } else if (op === "Embedding") {
+          const idx = builder.cast(getOp(nin(node, "input")), "int32");
+          this.operands[outName] = builder.gather(getOp(nin(node, "weight")), idx, { axis: 0 });
+        } else if (op === "SDPA") {
+          const qkvT = node.inputs.qkv;
+          const seq = qkvT.shape[1];
+          const d = Math.floor(qkvT.shape[2] / 3);
+          const heads = node.params.heads || 8;
+          const hd = Math.floor(d / heads);
+          const scale = node.params.scale !== void 0 ? node.params.scale : 1 / Math.sqrt(hd);
+          const qkv = builder.reshape(getOp(nin(node, "qkv")), [seq, 3 * d]);
+          const Q = builder.slice(qkv, [0, 0], [seq, d]);
+          const K = builder.slice(qkv, [0, d], [seq, d]);
+          const V = builder.slice(qkv, [0, 2 * d], [seq, d]);
+          const toHeads = (x) => builder.transpose(builder.reshape(x, [seq, heads, hd]), { permutation: [1, 0, 2] });
+          const Qh = toHeads(Q), Vh = toHeads(V);
+          const Kh = builder.transpose(builder.reshape(K, [seq, heads, hd]), { permutation: [1, 2, 0] });
+          let scores = builder.matmul(Qh, Kh);
+          scores = builder.mul(scores, builder.constant(desc([1]), new Float32Array([scale])));
+          const mask = new Float32Array(seq * seq);
+          for (let i = 0; i < seq; i++) for (let j = 0; j < seq; j++) mask[i * seq + j] = j <= i ? 0 : -1e9;
+          scores = builder.add(scores, builder.constant(desc([seq, seq]), mask));
+          const attn = builder.softmax(scores, 2);
+          let out = builder.matmul(attn, Vh);
+          out = builder.transpose(out, { permutation: [1, 0, 2] });
+          this.operands[outName] = builder.reshape(out, [1, seq, d]);
+        } else {
+          throw new Error(`Unsupported op in WebNNEngine: ${op}`);
+        }
+      } catch (e) {
+        console.warn(`[WebNN] cannot map op ${op}: ${e.message}`);
+        throw e;
+      }
+    }
+    const outputOperands = {};
+    for (const name of graph.outputNames) {
+      if (this.operands[name]) {
+        outputOperands[name] = this.operands[name];
+        this.outputs.push(name);
+      }
+    }
+    console.log(`[WebNN] building graph, outputs:`, this.outputs);
+    this.compiledGraph = await builder.build(outputOperands);
+    console.log(`[WebNN] graph compiled.`);
+    return this;
+  }
+  async execute(inputsMap) {
+    if (!this.compiledGraph) throw new Error("WebNN graph not compiled.");
+    const ctx = this.context;
+    const numel = (name) => {
+      const t = this.graph.tensors.get(name);
+      return t ? t.shape.reduce((a, b) => a * b, 1) : 1;
+    };
+    const shapeOf = (name) => {
+      const t = this.graph.tensors.get(name);
+      return t && t.shape.length ? t.shape : [1];
+    };
+    if (typeof ctx.compute === "function") {
+      const ins = {}, outs = {};
+      for (const name of this.inputs) ins[name] = inputsMap[name] || new Float32Array(numel(name));
+      for (const name of this.outputs) outs[name] = new Float32Array(numel(name));
+      return (await ctx.compute(this.compiledGraph, ins, outs)).outputs;
+    }
+    const inT = {}, outT = {};
+    for (const name of this.inputs) {
+      const t = await ctx.createTensor({ dataType: "float32", shape: shapeOf(name), dimensions: shapeOf(name), writable: true });
+      ctx.writeTensor(t, inputsMap[name] || new Float32Array(numel(name)));
+      inT[name] = t;
+    }
+    for (const name of this.outputs)
+      outT[name] = await ctx.createTensor({ dataType: "float32", shape: shapeOf(name), dimensions: shapeOf(name), readable: true });
+    ctx.dispatch(this.compiledGraph, inT, outT);
+    const results = {};
+    for (const name of this.outputs) {
+      const ab = await ctx.readTensor(outT[name]);
+      results[name] = new Float32Array(ab);
+      outT[name].destroy?.();
+    }
+    for (const name of this.inputs) inT[name].destroy?.();
+    return results;
+  }
+};
+
+// js/VolvoxAI.js
+var VolvoxAI = class _VolvoxAI {
+  constructor() {
+    this.engines = [];
+    this.weightsBaseUrl = null;
+  }
+  static async init(preferredBackend = "auto", wasmUrl = "./volvoxai.wasm") {
+    const instance = new _VolvoxAI();
+    const stringOrders = {
+      auto: ["webnn", "webgpu", "wasm", "cpu"],
+      webnn: ["webnn", "wasm", "cpu"],
+      webgpu: ["webgpu", "wasm", "cpu"],
+      wasm: ["wasm", "cpu"],
+      cpu: ["cpu"]
+    };
+    const validBackends = /* @__PURE__ */ new Set(["webnn", "webgpu", "wasm", "cpu"]);
+    const strictList = Array.isArray(preferredBackend);
+    const order = strictList ? [...preferredBackend] : stringOrders[preferredBackend];
+    if (!order || order.length === 0) {
+      throw new Error(`[VolvoxAI] Invalid backend selection: ${JSON.stringify(preferredBackend)}`);
+    }
+    for (const backend of order) {
+      if (!validBackends.has(backend)) {
+        throw new Error(`[VolvoxAI] Unknown backend '${backend}'. Use 'auto', 'webnn', 'webgpu', 'wasm', 'cpu', or an array of those backend names.`);
+      }
+    }
+    const added = /* @__PURE__ */ new Set();
+    for (const backend of order) {
+      if (added.has(backend)) continue;
+      if (backend === "webnn") {
+        if (typeof navigator !== "undefined" && navigator.ml) {
+          try {
+            const context = await navigator.ml.createContext({ deviceType: "npu" });
+            console.log("[VolvoxAI] WebNN Engine (NPU) Initialized successfully.");
+            instance.engines.push({ type: "webnn", engine: new WebNNEngine(context) });
+            added.add(backend);
+          } catch (e) {
+            console.warn("[VolvoxAI] WebNN initialization failed.", e.message);
+          }
+        } else if (strictList || preferredBackend === "webnn") {
+          console.warn("[VolvoxAI] WebNN is not supported.");
+        }
+      } else if (backend === "webgpu") {
+        if (typeof navigator !== "undefined" && navigator.gpu) {
+          try {
+            const adapter = await navigator.gpu.requestAdapter();
+            if (adapter) {
+              const device = await adapter.requestDevice();
+              console.log("[VolvoxAI] WebGPU Engine Initialized successfully.");
+              instance.engines.push({ type: "webgpu", device });
+              added.add(backend);
+            } else {
+              console.warn("[VolvoxAI] WebGPU adapter is not available.");
+            }
+          } catch (e) {
+            console.warn("[VolvoxAI] WebGPU initialization failed.", e.message);
+          }
+        } else if (strictList || preferredBackend === "webgpu") {
+          console.warn("[VolvoxAI] WebGPU is not supported.");
+        }
+      } else if (backend === "wasm") {
+        const wasmEngine = await WasmEngine.init(wasmUrl);
+        if (wasmEngine) {
+          console.log("[VolvoxAI] WASM Engine Initialized successfully.");
+          instance.engines.push({ type: "wasm", engine: wasmEngine });
+          added.add(backend);
+        } else {
+          console.warn("[VolvoxAI] WASM initialization failed.");
+        }
+      } else if (backend === "cpu") {
+        console.log("[VolvoxAI] Pure JS CPU Engine Initialized.");
+        instance.engines.push({ type: "cpu", engine: new CPUEngine() });
+        added.add(backend);
+      }
+    }
+    if (instance.engines.length === 0) {
+      throw new Error(`[VolvoxAI] None of the requested backends initialized: ${order.join(", ")}`);
+    }
+    return instance;
+  }
+  createGraph() {
+    return new Graph();
+  }
+  async loadGraph(safetensorsUrl) {
+    const graph = this.createGraph();
+    return await GraphLoader.load(graph, safetensorsUrl);
+  }
+  async compile(graph, weightsUrl) {
+    this.weightsBaseUrl = weightsUrl;
+    console.log(`[VolvoxAI] Compiling graph with ${graph.nodes.length} nodes...`);
+    for (const entry of this.engines) {
+      try {
+        if (entry.type === "webgpu") {
+          console.log(`[VolvoxAI] Trying to allocate graph on WebGPU (Tier 2)...`);
+          const executor = new GraphExecutor(entry.device, graph);
+          await executor.compile();
+          console.log(`[VolvoxAI] WebGPU Engine compiled successfully.`);
+          return executor;
+        } else {
+          console.log(`[VolvoxAI] Trying to allocate graph on ${entry.engine.constructor.name}...`);
+          await entry.engine.allocateGraph(graph);
+          console.log(`[VolvoxAI] ${entry.engine.constructor.name} compiled successfully.`);
+          return entry.engine;
+        }
+      } catch (e) {
+        console.warn(`[VolvoxAI] Compilation failed on ${entry.type}. Falling back to next tier. Error: ${e.message}`);
+      }
+    }
+    throw new Error("[VolvoxAI] All engine tiers failed to compile the graph.");
+  }
+};
+
+// js/Tokenizer.js
+var Tokenizer = class {
+  constructor() {
+    this.vocabByText = /* @__PURE__ */ new Map();
+    this.vocabByLatin1 = /* @__PURE__ */ new Map();
+    this.idToText = [];
+    this.idToBytes = [];
+    this.merges = /* @__PURE__ */ new Map();
+    this.mergeEnabled = false;
+    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;
+  }
+  // vocab.json and vocab.bin are both supported.
+  // pass vocabUrl, mergesUrl.
+  async load(vocabUrl, mergesUrl = null) {
+    try {
+      const isBin = /\.bin$/i.test(vocabUrl);
+      if (isBin) await this.loadFromBinary(vocabUrl);
+      else await this.loadFromJson(vocabUrl);
+      if (mergesUrl) await this.loadMerges(mergesUrl);
+    } catch (err) {
+      console.error("Tokenizer load error:", err);
+      throw err;
+    }
+  }
+  resetVocab() {
+    this.vocabByText.clear();
+    this.vocabByLatin1.clear();
+    this.idToText = [];
+    this.idToBytes = [];
+    this.merges.clear();
+    this.mergeEnabled = false;
+  }
+  async loadFromJson(vocabUrl) {
+    const res = await fetch(vocabUrl);
+    if (!res.ok) throw new Error(`Failed to fetch vocab: ${res.statusText}`);
+    const vocabJson = await res.json();
+    this.resetVocab();
+    for (const [text, id] of Object.entries(vocabJson)) {
+      const bytes = this.encoder.encode(text);
+      this.vocabByText.set(text, id);
+      this.vocabByLatin1.set(this.bytesToLatin1(bytes), id);
+      this.idToText[id] = text;
+      this.idToBytes[id] = bytes;
+    }
+    console.log(`Loaded ${Object.keys(vocabJson).length} tokens from ${vocabUrl}`);
+  }
+  async loadFromBinary(vocabUrl) {
+    const res = await fetch(vocabUrl);
+    if (!res.ok) throw new Error(`Failed to fetch vocab.bin: ${res.statusText}`);
+    const buf = new Uint8Array(await res.arrayBuffer());
+    if (buf.length < 4) throw new Error("Invalid vocab.bin");
+    const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    const size = dv.getInt32(0, true);
+    this.resetVocab();
+    let off = 4;
+    for (let i = 0; i < size; i++) {
+      if (off + 4 > buf.length) throw new Error(`vocab.bin truncated at token ${i}`);
+      const len = dv.getInt32(off, true);
+      off += 4;
+      if (len < 0 || off + len > buf.length) throw new Error(`vocab.bin malformed at token ${i}`);
+      const tokenBytes = buf.slice(off, off + len);
+      off += len;
+      const text = this.decoder.decode(tokenBytes);
+      this.vocabByText.set(text, i);
+      this.vocabByLatin1.set(this.bytesToLatin1(tokenBytes), i);
+      this.idToText[i] = text;
+      this.idToBytes[i] = tokenBytes;
+    }
+    console.log(`Loaded ${size} tokens from ${vocabUrl}`);
+  }
+  async loadMerges(mergesUrl) {
+    const res = await fetch(mergesUrl);
+    if (!res.ok) throw new Error(`Failed to fetch merges: ${res.statusText}`);
+    const text = await res.text();
+    let rank = 0;
+    this.merges.clear();
+    for (const rawLine of text.split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) continue;
+      const parts = line.split(/\s+/);
+      if (parts.length < 2) continue;
+      const leftToken = this.normalizeMergeToken(parts[0]);
+      const rightToken = this.normalizeMergeToken(parts[1]);
+      const leftId = this.findTokenByText(leftToken);
+      const rightId = this.findTokenByText(rightToken);
+      if (leftId < 0 || rightId < 0) continue;
+      const mergedText = `${this.idToText[leftId]}${this.idToText[rightId]}`;
+      const mergedId = this.vocabByText.get(mergedText);
+      if (mergedId === void 0) continue;
+      const key = this.pairKey(leftId, rightId);
+      if (!this.merges.has(key)) {
+        this.merges.set(key, { rank: rank++, mergedId });
+      }
+    }
+    this.mergeEnabled = this.merges.size > 0;
+    console.log(`Loaded ${this.merges.size} merge rules from ${mergesUrl}`);
+  }
+  bytesToLatin1(bytes) {
+    let out = "";
+    for (let i = 0; i < bytes.length; i++) out += String.fromCharCode(bytes[i]);
+    return out;
+  }
+  utf8Len(byte) {
+    if (byte < 128) return 1;
+    if ((byte & 224) === 192) return 2;
+    if ((byte & 240) === 224) return 3;
+    if ((byte & 248) === 240) return 4;
+    return 1;
+  }
+  pairKey(left, right) {
+    return `${left},${right}`;
+  }
+  normalizeMergeToken(token) {
+    if (token.startsWith("\u0120")) return ` ${token.slice(1)}`;
+    return token;
+  }
+  findTokenByText(text) {
+    let id = this.vocabByText.get(text);
+    if (id !== void 0) return id;
+    id = this.vocabByLatin1.get(text);
+    return id === void 0 ? -1 : id;
+  }
+  findTokenByBytes(bytes) {
+    const text = this.decoder.decode(bytes);
+    let id = this.vocabByText.get(text);
+    if (id !== void 0) return id;
+    id = this.vocabByLatin1.get(this.bytesToLatin1(bytes));
+    return id === void 0 ? -1 : id;
+  }
+  // Decode a single token ID to its text representation.
+  decodeToken(tokenId) {
+    const bytes = this.idToBytes[tokenId];
+    if (!bytes) return "";
+    return this.decoder.decode(bytes).replace(/Ġ/g, " ");
+  }
+  // Decode a token-id array.
+  decode(tokenIds) {
+    return tokenIds.map((id) => this.decodeToken(id)).join("");
+  }
+  encodeBpeWord(word, maxTokens) {
+    const bytes = this.encoder.encode(word);
+    if (bytes.length === 0 || maxTokens <= 0) return [];
+    const symbols = [];
+    for (let pos = 0; pos < bytes.length; ) {
+      let clen = this.utf8Len(bytes[pos]);
+      if (pos + clen > bytes.length) clen = bytes.length - pos;
+      const symbolBytes = bytes.slice(pos, pos + clen);
+      const id = this.findTokenByBytes(symbolBytes);
+      if (id >= 0) {
+        symbols.push(id);
+      } else {
+        for (let i = 0; i < clen; i++) {
+          const byteId = this.findTokenByBytes(Uint8Array.of(bytes[pos + i]));
+          if (byteId >= 0) symbols.push(byteId);
+        }
+      }
+      pos += clen;
+    }
+    while (symbols.length > 1) {
+      let bestIdx = -1;
+      let bestRank = Number.MAX_SAFE_INTEGER;
+      let bestMerged = -1;
+      for (let i = 0; i < symbols.length - 1; i++) {
+        const merge = this.merges.get(this.pairKey(symbols[i], symbols[i + 1]));
+        if (!merge) continue;
+        if (merge.rank >= bestRank) continue;
+        if (merge.mergedId < 0) continue;
+        bestIdx = i;
+        bestRank = merge.rank;
+        bestMerged = merge.mergedId;
+      }
+      if (bestIdx < 0) break;
+      symbols[bestIdx] = bestMerged;
+      symbols.splice(bestIdx + 1, 1);
+    }
+    return symbols.slice(0, maxTokens);
+  }
+  encodeGreedy(text, maxTokens) {
+    const bytes = this.encoder.encode(text);
+    const tokens = [];
+    let pos = 0;
+    while (pos < bytes.length && tokens.length < maxTokens) {
+      let bestId = -1;
+      let bestLen = 0;
+      for (let i = 0; i < this.idToBytes.length; i++) {
+        const tokenBytes = this.idToBytes[i];
+        if (!tokenBytes || tokenBytes.length <= bestLen || pos + tokenBytes.length > bytes.length) continue;
+        let match = true;
+        for (let j = 0; j < tokenBytes.length; j++) {
+          if (bytes[pos + j] !== tokenBytes[j]) {
+            match = false;
+            break;
+          }
+        }
+        if (match) {
+          bestId = i;
+          bestLen = tokenBytes.length;
+        }
+      }
+      if (bestId < 0) {
+        pos++;
+        continue;
+      }
+      tokens.push(bestId);
+      pos += bestLen;
+    }
+    return tokens;
+  }
+  // Tokenize with GPT-2-style regex pretokenization and run one BPE pass per chunk.
+  encode(text, maxTokens = 256) {
+    if (maxTokens <= 0) return [];
+    if (this.vocabByText.size === 0 && this.vocabByLatin1.size === 0) return [];
+    if (!this.mergeEnabled) return this.encodeGreedy(text, maxTokens);
+    const tokens = [];
+    for (const match of text.matchAll(this.bpePattern)) {
+      const chunk = match[0];
+      if (!chunk || tokens.length >= maxTokens) continue;
+      const remain = maxTokens - tokens.length;
+      if (remain <= 0) break;
+      const part = this.encodeBpeWord(chunk, remain);
+      for (const id of part) tokens.push(id);
+    }
+    return tokens;
+  }
+};
+export {
+  CPUEngine,
+  Graph,
+  GraphExecutor,
+  GraphLoader,
+  Tensor,
+  Tokenizer,
+  VolvoxAI,
+  WasmEngine,
+  _pair
+};