@tryhamster/gerbil 1.5.0 → 1.6.1

package/dist/{moonshine-stt-BeXNc7o2.mjs → moonshine-stt-BwX7NQ0O.mjs}

@@ -1,4 +1,4 @@
-import { C as quantizeInt4, D as createDefaultHFKeyMapper, S as DEFAULT_GROUP_SIZE, T as DTYPE_BYTES, a as generateMoonshineEncoderGraph, b as nanoCodecWeightMap, i as generateMoonshineDecoderGraph, o as moonshineEncoderFrames, p as foldNanoCodecWeightNorm, s as parseMoonshineConfig, t as generateGraph, w as CANONICAL_KEYS } from "./architectures-Ol7yUmKf.mjs";
+import { C as quantizeInt4, D as createDefaultHFKeyMapper, S as DEFAULT_GROUP_SIZE, T as DTYPE_BYTES, a as generateMoonshineEncoderGraph, b as nanoCodecWeightMap, i as generateMoonshineDecoderGraph, o as moonshineEncoderFrames, p as foldNanoCodecWeightNorm, s as parseMoonshineConfig, t as generateGraph, w as CANONICAL_KEYS } from "./architectures-CpmH4Gha.mjs";
 
 //#region src/gpu/device.ts
 const COPY_SRC = 4;
@@ -27,7 +27,7 @@ async function initGPU(options) {
 	if (!adapter) throw new Error("No WebGPU adapter found. Your GPU may not support WebGPU, or another tab may be using it. Try closing other tabs.");
 	const hasF16 = adapter.features.has("shader-f16");
 	const hasSubgroups = adapter.features.has("subgroups");
-	const hasTimestamp = typeof process !== "undefined" && process.env?.GERBIL_PROFILE != null && adapter.features.has("timestamp-query");
+	const hasTimestamp = typeof process !== "undefined" && (process.env?.GERBIL_PROFILE != null || process.env?.GERBIL_TS_TOTAL != null) && adapter.features.has("timestamp-query");
 	const requiredFeatures = [];
 	if (hasF16) requiredFeatures.push("shader-f16");
 	if (hasSubgroups) requiredFeatures.push("subgroups");
@@ -2341,6 +2341,98 @@ fn main(
   }
 }
 `;
+const WGSL_DUAL_RMSNORM_ROPE = `\
+struct Params {
+  rows0: u32,          // T * num_q_heads
+  rows1: u32,          // T * num_kv_heads
+  head_dim: u32,
+  eps_bits: u32,
+  num_q_heads: u32,
+  num_kv_heads: u32,
+  rope_base_bits: u32,
+  position_offset: u32,
+  rope_half: u32,
+  rope_denom: u32,
+  rope_active_pairs: u32,
+  _pad: u32,
+}
+
+@group(0) @binding(0) var<storage, read> input0: array<f32>;
+@group(0) @binding(1) var<storage, read> weight0: array<f32>;
+@group(0) @binding(2) var<storage, read> input1: array<f32>;
+@group(0) @binding(3) var<storage, read> weight1: array<f32>;
+@group(0) @binding(4) var<storage, read_write> output0: array<f32>;
+@group(0) @binding(5) var<storage, read_write> output1: array<f32>;
+@group(0) @binding(6) var<storage, read> params: Params;
+
+var<workgroup> shared_sum: array<f32, 256>;
+var<workgroup> shared_row: array<f32, 256>;
+
+@compute @workgroup_size(256)
+fn main(
+  @builtin(local_invocation_id) lid: vec3u,
+  @builtin(workgroup_id) wid: vec3u,
+) {
+  let wg = wid.x;
+  if (wg >= params.rows0 + params.rows1) { return; }
+
+  let tid = lid.x;
+  let hd = params.head_dim;
+  let eps = bitcast<f32>(params.eps_bits);
+
+  let is1 = wg >= params.rows0;
+  let row = select(wg, wg - params.rows0, is1);
+  let row_offset = row * hd;
+  let heads = select(params.num_q_heads, params.num_kv_heads, is1);
+  let pos = row / heads;
+
+  // ── Phase 1: row sum of squares ──
+  var val: f32 = 0.0;
+  if (tid < hd) {
+    if (is1) { val = input1[row_offset + tid]; } else { val = input0[row_offset + tid]; }
+  }
+  shared_sum[tid] = val * val;
+  workgroupBarrier();
+  var stride: u32 = 128u;
+  while (stride > 0u) {
+    if (tid < stride) { shared_sum[tid] += shared_sum[tid + stride]; }
+    workgroupBarrier();
+    stride = stride / 2u;
+  }
+  let rms = sqrt(shared_sum[0] / f32(hd) + eps);
+
+  // ── Phase 2: normalized row into shared memory ──
+  if (tid < hd) {
+    var w: f32;
+    if (is1) { w = weight1[tid]; } else { w = weight0[tid]; }
+    shared_row[tid] = (val / rms) * w;
+  }
+  workgroupBarrier();
+
+  // ── Phase 3: rotate_half rotation from shared pairs, write out ──
+  if (tid < hd) {
+    let rope_half = params.rope_half;
+    var out_val = shared_row[tid];
+    if (tid < 2u * rope_half) {
+      let is_hi = tid >= rope_half;
+      let pair_idx = select(tid, tid - rope_half, is_hi);
+      var cos_val = 1.0;
+      var sin_val = 0.0;
+      if (pair_idx < params.rope_active_pairs) {
+        let rope_base = bitcast<f32>(params.rope_base_bits);
+        let position = f32(pos + params.position_offset);
+        let freq = position / pow(rope_base, f32(2u * pair_idx) / f32(params.rope_denom));
+        cos_val = cos(freq);
+        sin_val = sin(freq);
+      }
+      let lo = shared_row[pair_idx];
+      let hi = shared_row[pair_idx + rope_half];
+      out_val = select(lo * cos_val - hi * sin_val, lo * sin_val + hi * cos_val, is_hi);
+    }
+    if (is1) { output1[row_offset + tid] = out_val; } else { output0[row_offset + tid] = out_val; }
+  }
+}
+`;
 const WGSL_LAYERNORM = `\
 // Layer Normalization: output = ((x - mean) / sqrt(var + eps)) * weight + bias
 
@@ -3864,8 +3956,10 @@ fn main(
 `;
 const WGSL_SWIGLU_MATVEC_INT4 = `\
 // CONSTRAINT: N_TILE must equal workgroup_size / K_THREADS
-const N_TILE: u32 = 8u;
-const K_THREADS: u32 = 32u;
+// 16/16 matches the plain-matvec sweep winner (8/32 measured slower at every
+// production shape; this fused kernel had never been re-swept).
+const N_TILE: u32 = 16u;
+const K_THREADS: u32 = 16u;
 
 struct Params {
   K: u32,
@@ -3969,8 +4063,8 @@ fn main(
 }
 `;
 const WGSL_DUAL_MATVEC_INT4 = `\
-const N_TILE: u32 = 8u;
-const K_THREADS: u32 = 32u;
+const N_TILE: u32 = 16u;
+const K_THREADS: u32 = 16u;
 
 struct Params {
   K: u32,
@@ -4233,6 +4327,235 @@ fn main(@builtin(global_invocation_id) gid: vec3u) {
   output[t * params.channels + c] = sum / (1.0 + exp(max(-sum, -80.0)));
 }
 `;
+const WGSL_CAUSAL_CONV1D_SILU_UPDATE = `\
+struct Params {
+  seq_len: u32,
+  channels: u32,
+  kernel_size: u32,
+  _pad: u32,
+}
+
+@group(0) @binding(0) var<storage, read> input: array<f32>;
+@group(0) @binding(1) var<storage, read> weight: array<f32>;
+@group(0) @binding(2) var<storage, read_write> conv_state: array<f32>;
+@group(0) @binding(3) var<storage, read_write> output: array<f32>;
+@group(0) @binding(4) var<storage, read> params: Params;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3u) {
+  let idx = gid.x;
+  let total = params.seq_len * params.channels;
+  if (idx >= total) { return; }
+
+  let t = idx / params.channels;
+  let c = idx % params.channels;
+  let state_size = params.kernel_size - 1u;
+
+  // Snapshot this channel's rolling state (kernel_size <= 8) before any write.
+  var olds: array<f32, 8>;
+  for (var s: u32 = 0u; s < state_size; s = s + 1u) {
+    olds[s] = conv_state[s * params.channels + c];
+  }
+
+  var sum: f32 = 0.0;
+  for (var k: u32 = 0u; k < params.kernel_size; k = k + 1u) {
+    let src_t = i32(t) - i32(k);
+    var in_val: f32 = 0.0;
+    if (src_t >= 0) {
+      in_val = input[u32(src_t) * params.channels + c];
+    } else {
+      let state_t = i32(state_size) + src_t;
+      if (state_t >= 0) {
+        in_val = olds[u32(state_t)];
+      }
+    }
+    let w_val = weight[c * params.kernel_size + (params.kernel_size - 1u - k)];
+    sum += in_val * w_val;
+  }
+
+  // Fused SiLU: silu(x) = x / (1 + exp(-x))
+  output[t * params.channels + c] = sum / (1.0 + exp(max(-sum, -80.0)));
+
+  // Rolling-state shift (decode T=1): new state = [olds[1..], input[0,c]].
+  if (params.seq_len == 1u && t == 0u) {
+    for (var s: u32 = 0u; s + 1u < state_size; s = s + 1u) {
+      conv_state[s * params.channels + c] = olds[s + 1u];
+    }
+    if (state_size > 0u) {
+      conv_state[(state_size - 1u) * params.channels + c] = input[c];
+    }
+  }
+}
+`;
+const WGSL_CAUSAL_CONV1D_GATED_UPDATE = `\
+struct Params {
+  seq_len: u32,
+  channels: u32,
+  kernel_size: u32,
+  _pad: u32,
+}
+
+@group(0) @binding(0) var<storage, read> input: array<f32>;
+@group(0) @binding(1) var<storage, read> weight: array<f32>;
+@group(0) @binding(2) var<storage, read_write> conv_state: array<f32>;
+@group(0) @binding(3) var<storage, read> gate: array<f32>;
+@group(0) @binding(4) var<storage, read_write> output: array<f32>;
+@group(0) @binding(5) var<storage, read> params: Params;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3u) {
+  let idx = gid.x;
+  let total = params.seq_len * params.channels;
+  if (idx >= total) { return; }
+
+  let t = idx / params.channels;
+  let c = idx % params.channels;
+  let state_size = params.kernel_size - 1u;
+
+  var olds: array<f32, 8>;
+  for (var s: u32 = 0u; s < state_size; s = s + 1u) {
+    olds[s] = conv_state[s * params.channels + c];
+  }
+
+  var sum: f32 = 0.0;
+  for (var k: u32 = 0u; k < params.kernel_size; k = k + 1u) {
+    let src_t = i32(t) - i32(k);
+    var in_val: f32 = 0.0;
+    if (src_t >= 0) {
+      in_val = input[u32(src_t) * params.channels + c];
+    } else {
+      let state_t = i32(state_size) + src_t;
+      if (state_t >= 0) {
+        in_val = olds[u32(state_t)];
+      }
+    }
+    let w_val = weight[c * params.kernel_size + (params.kernel_size - 1u - k)];
+    sum += in_val * w_val;
+  }
+
+  output[t * params.channels + c] = gate[idx] * sum;
+
+  if (params.seq_len == 1u && t == 0u) {
+    for (var s: u32 = 0u; s + 1u < state_size; s = s + 1u) {
+      conv_state[s * params.channels + c] = olds[s + 1u];
+    }
+    if (state_size > 0u) {
+      conv_state[(state_size - 1u) * params.channels + c] = input[c];
+    }
+  }
+}
+`;
+const WGSL_CAUSAL_CONV1D_GATED_BCX = `\
+struct Params {
+  seq_len: u32,
+  channels: u32,
+  kernel_size: u32,
+  in_width: u32,   // bcx row stride = 3 * channels
+}
+
+@group(0) @binding(0) var<storage, read> bcx: array<f32>;
+@group(0) @binding(1) var<storage, read> weight: array<f32>;
+@group(0) @binding(2) var<storage, read_write> conv_state: array<f32>;
+@group(0) @binding(3) var<storage, read_write> output: array<f32>;
+@group(0) @binding(4) var<storage, read> params: Params;
+
+fn bx_at(t: u32, c: u32) -> f32 {
+  let row = t * params.in_width;
+  return bcx[row + c] * bcx[row + 2u * params.channels + c];
+}
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3u) {
+  let idx = gid.x;
+  let total = params.seq_len * params.channels;
+  if (idx >= total) { return; }
+
+  let t = idx / params.channels;
+  let c = idx % params.channels;
+  let state_size = params.kernel_size - 1u;
+
+  // Snapshot this channel's rolling state (kernel_size <= 8) before any write.
+  var olds: array<f32, 8>;
+  for (var s: u32 = 0u; s < state_size; s = s + 1u) {
+    olds[s] = conv_state[s * params.channels + c];
+  }
+
+  var sum: f32 = 0.0;
+  for (var k: u32 = 0u; k < params.kernel_size; k = k + 1u) {
+    let src_t = i32(t) - i32(k);
+    var in_val: f32 = 0.0;
+    if (src_t >= 0) {
+      in_val = bx_at(u32(src_t), c);
+    } else {
+      let state_t = i32(state_size) + src_t;
+      if (state_t >= 0) {
+        in_val = olds[u32(state_t)];
+      }
+    }
+    let w_val = weight[c * params.kernel_size + (params.kernel_size - 1u - k)];
+    sum += in_val * w_val;
+  }
+
+  // Fused multiplicative gate from the C block.
+  output[t * params.channels + c] = bcx[t * params.in_width + params.channels + c] * sum;
+
+  // Rolling-state shift (decode T=1 only; prefill uses ConvStateUpdateBcx).
+  if (params.seq_len == 1u && t == 0u) {
+    for (var s: u32 = 0u; s + 1u < state_size; s = s + 1u) {
+      conv_state[s * params.channels + c] = olds[s + 1u];
+    }
+    if (state_size > 0u) {
+      conv_state[(state_size - 1u) * params.channels + c] = bx_at(0u, c);
+    }
+  }
+}
+`;
+const WGSL_CONV_STATE_UPDATE_BCX = `\
+// ConvStateUpdate reading raw bcx (computes B*x for the copied timesteps).
+struct Params {
+  seq_len: u32,
+  channels: u32,
+  state_size: u32,
+  in_width: u32,
+}
+
+@group(0) @binding(0) var<storage, read> bcx: array<f32>;
+@group(0) @binding(1) var<storage, read_write> conv_state: array<f32>;
+@group(0) @binding(2) var<storage, read> params: Params;
+
+fn bx_at(t: u32, c: u32) -> f32 {
+  let row = t * params.in_width;
+  return bcx[row + c] * bcx[row + 2u * params.channels + c];
+}
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3u) {
+  let c = gid.x;
+  if (c >= params.channels) { return; }
+  let ss = params.state_size;
+
+  if (params.seq_len >= ss) {
+    for (var s: u32 = 0u; s < ss; s = s + 1u) {
+      conv_state[s * params.channels + c] = bx_at(params.seq_len - ss + s, c);
+    }
+  } else {
+    var olds: array<f32, 8>;
+    for (var s: u32 = 0u; s < ss; s = s + 1u) {
+      olds[s] = conv_state[s * params.channels + c];
+    }
+    let shift = ss - params.seq_len;
+    for (var s: u32 = 0u; s < ss; s = s + 1u) {
+      var val: f32 = 0.0;
+      if (s < shift) {
+        val = olds[s + params.seq_len];
+      } else {
+        val = bx_at(s - shift, c);
+      }
+      conv_state[s * params.channels + c] = val;
+    }
+  }
+}
+`;
 const WGSL_CAUSAL_CONV1D_GATED = `\
 // Causal 1D depthwise convolution with a fused multiplicative output gate:
 //   output = gate * conv(input)
@@ -4470,20 +4793,45 @@ struct Params {
 @group(0) @binding(6) var<storage, read_write> output: array<f32>;
 @group(0) @binding(7) var<storage, read> params: Params;
 
-// Shared memory for Q and K vectors (L2-normalized) and reduction
+// OCCUPANCY FAN-OUT: one workgroup per (head, d-chunk) instead of per head.
+// Each head's state column d is touched ONLY by the workgroup owning d's chunk
+// (kv_dot for lane d reads state[:, d]; the rank-1 update writes state[:, d]),
+// so chunks are fully independent across timesteps — no cross-workgroup sync.
+// 16 heads → 128 workgroups (vs 16), each 128 threads = D_LANES(16) × K_SPLITS(8).
+// Requires val_dim % (D_CHUNKS*... ) handled via bounds guards; key_dim <= 128.
+
+const D_CHUNKS: u32 = 8u;   // workgroups per head (must match JS dispatch)
+const D_LANES: u32 = 16u;   // d lanes per workgroup
+const K_SPLITS: u32 = 8u;   // threads cooperating on each d lane's k loop
+
+// Shared memory for Q and K vectors (L2-normalized), reduction, partials
 var<workgroup> shared_q: array<f32, 128>;
 var<workgroup> shared_k: array<f32, 128>;
 var<workgroup> shared_norm: array<f32, 128>;
+var<workgroup> shared_partial: array<f32, 128>;  // [D_LANES][K_SPLITS]
+var<workgroup> shared_kvmem: array<f32, D_LANES>;
 
 @compute @workgroup_size(128)
 fn main(
   @builtin(local_invocation_id) lid: vec3u,
   @builtin(workgroup_id) wid: vec3u,
 ) {
-  let h = wid.x;  // uniform within workgroup
+  let h = wid.x / D_CHUNKS;
+  let chunk = wid.x % D_CHUNKS;
   if (h >= params.num_heads) { return; }
 
-  let d = lid.x;  // 0..127, all threads participate in barriers
+  let tid = lid.x;             // 0..127
+  let d_local = tid % D_LANES; // lane within chunk
+  let k_split = tid / D_LANES; // 0..K_SPLITS-1
+  let d_per_chunk = (params.val_dim + D_CHUNKS - 1u) / D_CHUNKS;
+  // This lane's output dim (may exceed val_dim for ragged sizes — guarded below).
+  // d_per_chunk > D_LANES is unsupported (val_dim > 128 with D_CHUNKS=8).
+  let d = chunk * d_per_chunk + d_local;
+  let d_ok = d < params.val_dim && d_local < d_per_chunk;
+
+  let k_slice = (params.key_dim + K_SPLITS - 1u) / K_SPLITS;
+  let k_begin = k_split * k_slice;
+  let k_end = min(k_begin + k_slice, params.key_dim);
 
   let A_val = -exp(A_log[h]);
   let state_base = h * params.key_dim * params.val_dim;
@@ -4497,37 +4845,48 @@ fn main(
   for (var t: u32 = 0u; t < params.T; t = t + 1u) {
     let qkv_base = t * params.qkv_dim;
 
-    // ── Load Q and K into shared memory ──
-    shared_q[d] = qkv_conv[qkv_base + q_off + d];
-    shared_k[d] = qkv_conv[qkv_base + k_off + d];
+    // ── Load Q and K into shared memory (lane tid covers key_dim <= 128) ──
+    if (tid < params.key_dim) {
+      shared_q[tid] = qkv_conv[qkv_base + q_off + tid];
+      shared_k[tid] = qkv_conv[qkv_base + k_off + tid];
+      shared_norm[tid] = shared_q[tid] * shared_q[tid];
+    } else {
+      shared_norm[tid] = 0.0;
+    }
     workgroupBarrier();
 
     // ── L2-normalize Q (parallel reduction) ──
-    shared_norm[d] = shared_q[d] * shared_q[d];
-    workgroupBarrier();
     var stride: u32 = 64u;
     while (stride > 0u) {
-      if (d < stride) { shared_norm[d] += shared_norm[d + stride]; }
+      if (tid < stride) { shared_norm[tid] += shared_norm[tid + stride]; }
       workgroupBarrier();
       stride /= 2u;
     }
     let q_inv_norm = 1.0 / sqrt(shared_norm[0] + 1e-12);
-    shared_q[d] *= q_inv_norm;
+    workgroupBarrier();
 
     // ── L2-normalize K (parallel reduction) ──
-    shared_norm[d] = shared_k[d] * shared_k[d];
+    if (tid < params.key_dim) {
+      shared_q[tid] *= q_inv_norm;
+      shared_norm[tid] = shared_k[tid] * shared_k[tid];
+    } else {
+      shared_norm[tid] = 0.0;
+    }
     workgroupBarrier();
     stride = 64u;
     while (stride > 0u) {
-      if (d < stride) { shared_norm[d] += shared_norm[d + stride]; }
+      if (tid < stride) { shared_norm[tid] += shared_norm[tid + stride]; }
       workgroupBarrier();
       stride /= 2u;
     }
     let k_inv_norm = 1.0 / sqrt(shared_norm[0] + 1e-12);
-    shared_k[d] *= k_inv_norm;
+    workgroupBarrier();
+    if (tid < params.key_dim) {
+      shared_k[tid] *= k_inv_norm;
+    }
     workgroupBarrier();
 
-    // ── Compute decay and beta ──
+    // ── Compute decay and beta (redundantly per thread — trivial scalars) ──
     let a_val = a_input[t * params.num_heads + h];
     let b_val = b_input[t * params.num_heads + h];
     let dt_in = a_val + dt_bias[h];
@@ -4536,32 +4895,52 @@ fn main(
     let decay = exp(max(g, -80.0));
     let beta = 1.0 / (1.0 + exp(max(-b_val, -80.0)));
 
-    // ── 1+2. Retrieve from memory (decay is a per-step scalar, so it factors
-    // out of the dot product): kv_mem[d] = decay * Σ_k state[k,d] * k_norm[k] ──
-    let v_val = qkv_conv[qkv_base + v_off + d];
+    // ── 1+2. kv_mem[d] = decay * Σ_k state[k,d] * k_norm[k], k split 8 ways ──
     var kv_dot: f32 = 0.0;
-    for (var k: u32 = 0u; k < params.key_dim; k = k + 1u) {
-      kv_dot += f32(ssm_state[state_base + k * params.val_dim + d]) * shared_k[k];
+    if (d_ok) {
+      for (var k: u32 = k_begin; k < k_end; k = k + 1u) {
+        kv_dot += f32(ssm_state[state_base + k * params.val_dim + d]) * shared_k[k];
+      }
     }
-    let kv_mem = kv_dot * decay;
-
-    // ── 3. Delta rule: delta[d] = (v[d] - kv_mem[d]) * beta ──
-    let delta_val = (v_val - kv_mem) * beta;
+    shared_partial[d_local * K_SPLITS + k_split] = kv_dot;
+    workgroupBarrier();
+    if (k_split == 0u) {
+      var acc: f32 = 0.0;
+      for (var j: u32 = 0u; j < K_SPLITS; j = j + 1u) {
+        acc += shared_partial[d_local * K_SPLITS + j];
+      }
+      shared_kvmem[d_local] = acc;
+    }
+    workgroupBarrier();
 
-    // ── 4+5. Fused decay + rank-1 update + output in ONE pass over state
-    // (one read + one write instead of three reads + two writes):
-    //   state'[k,d] = state[k,d] * decay + k_norm[k] * delta[d]
-    //   out[d]      = Σ_k state'[k,d] * q_norm[k] * scale ──
-    var out_val: f32 = 0.0;
-    for (var k: u32 = 0u; k < params.key_dim; k = k + 1u) {
-      let idx = state_base + k * params.val_dim + d;
-      let s = f32(ssm_state[idx]) * decay + shared_k[k] * delta_val;
-      ssm_state[idx] = f16(s);
-      out_val += s * shared_q[k];
+    // ── 3. Delta rule (each of the d's 8 threads recomputes — cheap) ──
+    var delta_val: f32 = 0.0;
+    if (d_ok) {
+      let v_val = qkv_conv[qkv_base + v_off + d];
+      let kv_mem = shared_kvmem[d_local] * decay;
+      delta_val = (v_val - kv_mem) * beta;
     }
-    output[t * out_stride + h * params.val_dim + d] = out_val * scale;
 
-    workgroupBarrier();  // sync before next timestep loads shared_q/k
+    // ── 4+5. Fused decay + rank-1 update + output, k split 8 ways ──
+    var out_dot: f32 = 0.0;
+    if (d_ok) {
+      for (var k: u32 = k_begin; k < k_end; k = k + 1u) {
+        let idx = state_base + k * params.val_dim + d;
+        let s = f32(ssm_state[idx]) * decay + shared_k[k] * delta_val;
+        ssm_state[idx] = f16(s);
+        out_dot += s * shared_q[k];
+      }
+    }
+    shared_partial[d_local * K_SPLITS + k_split] = out_dot;
+    workgroupBarrier();
+    if (k_split == 0u && d_ok) {
+      var acc: f32 = 0.0;
+      for (var j: u32 = 0u; j < K_SPLITS; j = j + 1u) {
+        acc += shared_partial[d_local * K_SPLITS + j];
+      }
+      output[t * out_stride + h * params.val_dim + d] = acc * scale;
+    }
+    workgroupBarrier();  // sync before next timestep reuses shared arrays
   }
 }
 `;
@@ -6165,7 +6544,7 @@ const SWIGLU_MATVEC_INT4_SPEC = {
 	getDispatchSize(op) {
 		const N = op.attributes.N;
 		return [
-			cdiv(N, 8),
+			cdiv(N, 16),
 			1,
 			1
 		];
@@ -6200,7 +6579,7 @@ const DUAL_MATVEC_INT4_SPEC = {
 	getDispatchSize(op) {
 		const N = op.attributes.N;
 		return [
-			cdiv(N, 8),
+			cdiv(N, 16),
 			1,
 			1
 		];
@@ -6403,6 +6782,62 @@ const embeddingInt4Spec = {
 		]);
 	}
 };
+const DUAL_RMSNORM_ROPE_SPEC = {
+	shaderCode: WGSL_DUAL_RMSNORM_ROPE,
+	entryPoint: "main",
+	bindings: [
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read-write" },
+		{ type: "storage-read-write" },
+		{ type: "uniform" }
+	],
+	getDispatchSize(op, resolvedShapes) {
+		const num_q_heads = op.attributes.num_q_heads;
+		const num_kv_heads = op.attributes.num_kv_heads;
+		const seqRef = op.attributes.seq_len_tensor;
+		let T;
+		if (seqRef && resolvedShapes[seqRef]) T = resolvedShapes[seqRef][0];
+		else T = op.attributes.seq_len ?? 1;
+		return [
+			T * (num_q_heads + num_kv_heads),
+			1,
+			1
+		];
+	},
+	buildParams(op, resolvedShapes, context) {
+		const head_dim = op.attributes.hidden_size;
+		const eps = op.attributes.eps ?? 1e-6;
+		const num_q_heads = op.attributes.num_q_heads;
+		const num_kv_heads = op.attributes.num_kv_heads;
+		const rope_base = op.attributes.rope_base;
+		const rope_dim = op.attributes.rope_dim ?? head_dim;
+		const rope_half = op.attributes.rope_half ?? rope_dim / 2;
+		const rope_denom = op.attributes.rope_denom ?? rope_dim;
+		const rope_active_pairs = op.attributes.rope_active_pairs ?? rope_dim / 2;
+		const position_offset = context?.seqPos ?? op.attributes.position_offset ?? 0;
+		const seqRef = op.attributes.seq_len_tensor;
+		let T;
+		if (seqRef && resolvedShapes[seqRef]) T = resolvedShapes[seqRef][0];
+		else T = op.attributes.seq_len ?? 1;
+		return buildUniformBuffer([
+			T * num_q_heads,
+			T * num_kv_heads,
+			head_dim,
+			f32BitsToU32(eps),
+			num_q_heads,
+			num_kv_heads,
+			f32BitsToU32(rope_base),
+			position_offset,
+			rope_half,
+			rope_denom,
+			rope_active_pairs,
+			0
+		]);
+	}
+};
 const ropeSpec = {
 	shaderCode: WGSL_ROPE,
 	entryPoint: "main",
@@ -6907,6 +7342,134 @@ const causalConv1dSiluSpec = {
 		]);
 	}
 };
+const convUpdateDispatch = {
+	getDispatchSize(op, resolvedShapes) {
+		const channels = op.attributes.channels;
+		const ref = op.attributes.seq_len_tensor;
+		let seq_len;
+		if (ref && resolvedShapes[ref]) seq_len = resolvedShapes[ref][0];
+		else seq_len = op.attributes.seq_len;
+		return [
+			cdiv(seq_len * channels, 256),
+			1,
+			1
+		];
+	},
+	buildParams(op, resolvedShapes) {
+		const channels = op.attributes.channels;
+		const kernel_size = op.attributes.kernel_size;
+		const ref = op.attributes.seq_len_tensor;
+		let seq_len;
+		if (ref && resolvedShapes[ref]) seq_len = resolvedShapes[ref][0];
+		else seq_len = op.attributes.seq_len;
+		return buildUniformBuffer([
+			seq_len,
+			channels,
+			kernel_size,
+			0
+		]);
+	}
+};
+const CAUSAL_CONV1D_SILU_UPDATE_SPEC = {
+	shaderCode: WGSL_CAUSAL_CONV1D_SILU_UPDATE,
+	entryPoint: "main",
+	bindings: [
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read-write" },
+		{ type: "storage-read-write" },
+		{ type: "uniform" }
+	],
+	getDispatchSize: convUpdateDispatch.getDispatchSize,
+	buildParams: convUpdateDispatch.buildParams
+};
+const CAUSAL_CONV1D_GATED_UPDATE_SPEC = {
+	shaderCode: WGSL_CAUSAL_CONV1D_GATED_UPDATE,
+	entryPoint: "main",
+	bindings: [
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read-write" },
+		{ type: "storage-read" },
+		{ type: "storage-read-write" },
+		{ type: "uniform" }
+	],
+	getDispatchSize: convUpdateDispatch.getDispatchSize,
+	buildParams: convUpdateDispatch.buildParams
+};
+const bcxDispatch = (op, resolvedShapes) => {
+	const channels = op.attributes.channels;
+	const ref = op.attributes.seq_len_tensor;
+	let seq_len;
+	if (ref && resolvedShapes[ref]) seq_len = resolvedShapes[ref][0];
+	else seq_len = op.attributes.seq_len ?? 1;
+	return {
+		channels,
+		seq_len
+	};
+};
+const CAUSAL_CONV1D_GATED_BCX_SPEC = {
+	shaderCode: WGSL_CAUSAL_CONV1D_GATED_BCX,
+	entryPoint: "main",
+	bindings: [
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read-write" },
+		{ type: "storage-read-write" },
+		{ type: "uniform" }
+	],
+	getDispatchSize(op, resolvedShapes) {
+		const { channels, seq_len } = bcxDispatch(op, resolvedShapes);
+		return [
+			cdiv(seq_len * channels, 256),
+			1,
+			1
+		];
+	},
+	buildParams(op, resolvedShapes) {
+		const { channels, seq_len } = bcxDispatch(op, resolvedShapes);
+		const kernel_size = op.attributes.kernel_size;
+		const in_width = op.attributes.in_width;
+		return buildUniformBuffer([
+			seq_len,
+			channels,
+			kernel_size,
+			in_width
+		]);
+	}
+};
+const CONV_STATE_UPDATE_BCX_SPEC = {
+	shaderCode: WGSL_CONV_STATE_UPDATE_BCX,
+	entryPoint: "main",
+	bindings: [
+		{ type: "storage-read" },
+		{ type: "storage-read-write" },
+		{ type: "uniform" }
+	],
+	getDispatchSize(op) {
+		const channels = op.attributes.channels;
+		return [
+			cdiv(channels, 256),
+			1,
+			1
+		];
+	},
+	buildParams(op, resolvedShapes) {
+		const channels = op.attributes.channels;
+		const state_size = op.attributes.state_size;
+		const in_width = op.attributes.in_width;
+		const ref = op.attributes.T_tensor;
+		let T;
+		if (ref && resolvedShapes[ref]) T = resolvedShapes[ref][0];
+		else T = op.attributes.T ?? 1;
+		return buildUniformBuffer([
+			T,
+			channels,
+			state_size,
+			in_width
+		]);
+	}
+};
 const causalConv1dGatedSpec = {
 	shaderCode: WGSL_CAUSAL_CONV1D_GATED,
 	entryPoint: "main",
@@ -7008,7 +7571,14 @@ const mambaSSMSpec = {
 };
 const MAMBA_SSM_F16_SPEC = {
 	...mambaSSMSpec,
-	shaderCode: WGSL_MAMBA_SSM_F16
+	shaderCode: WGSL_MAMBA_SSM_F16,
+	getDispatchSize(op) {
+		return [
+			op.attributes.num_heads * 8,
+			1,
+			1
+		];
+	}
 };
 const kvCacheAppendSpec = {
 	shaderCode: WGSL_KV_CACHE_APPEND,
@@ -8059,6 +8629,8 @@ const KERNEL_REGISTRY = {
 	CausalConv1d: causalConv1dSpec,
 	CausalConv1dSiLU: causalConv1dSiluSpec,
 	CausalConv1dGated: causalConv1dGatedSpec,
+	CausalConv1dGatedBcx: CAUSAL_CONV1D_GATED_BCX_SPEC,
+	ConvStateUpdateBcx: CONV_STATE_UPDATE_BCX_SPEC,
 	SigmoidGate: sigmoidGateSpec,
 	MambaSSM: mambaSSMSpec,
 	KVCacheAppend: kvCacheAppendSpec,
@@ -8341,7 +8913,10 @@ var Executor = class Executor {
 		this.fuseDualKVCacheAppendEntries();
 		this.fuseGatedOProjDecodeEntries();
 		this.fuseSwiGLUGatedProjDecodeEntries();
+		this.fuseDualRMSNormRoPEDecodeEntries();
 		this.fuseDualRMSNormDecodeEntries();
+		this.fuseConvStateUpdateDecodeEntries();
+		this.fuseAddRMSNormDecodeEntries();
 		console.log(`[executor] decode: ${this.decodeEntries.length} dispatches/token`);
 		const logitsBuffer = this.getBuffer("logits");
 		if (logitsBuffer) {
@@ -8908,7 +9483,39 @@ var Executor = class Executor {
 		}
 		const encoder = this.ctx.device.createCommandEncoder({ label: "decode_step" });
 		if (tokenId === null) encoder.copyBufferToBuffer(this.argmaxResultBuffer, 0, this.inputIdsBuffer, 0, 4);
-		const pass = encoder.beginComputePass({ label: "decode_pass" });
+		const g = globalThis;
+		if (process.env?.GERBIL_TS_TOTAL != null) {
+			g.__tsTotal ??= {
+				ns: 0,
+				steps: 0,
+				seq: 0,
+				inFlight: false
+			};
+			g.__tsTotal.seq++;
+		}
+		const tsTotal = this.ctx.hasTimestamp && typeof process !== "undefined" && process.env?.GERBIL_TS_TOTAL != null && g.__tsTotal.seq % 8 === 0 && !g.__tsTotal.inFlight;
+		if (tsTotal && !this.querySet) {
+			this.querySet = this.ctx.device.createQuerySet({
+				type: "timestamp",
+				count: 2
+			});
+			this.queryResolveBuf = this.ctx.device.createBuffer({
+				size: 16,
+				usage: 516
+			});
+			this.queryReadbackBuf = this.ctx.device.createBuffer({
+				size: 16,
+				usage: 9
+			});
+		}
+		const pass = encoder.beginComputePass(tsTotal ? {
+			label: "decode_pass",
+			timestampWrites: {
+				querySet: this.querySet,
+				beginningOfPassWriteIndex: 0,
+				endOfPassWriteIndex: 1
+			}
+		} : { label: "decode_pass" });
 		for (let i = 0; i < this.decodeEntries.length; i++) {
 			const entry = this.decodeEntries[i];
 			pass.setPipeline(entry.pipeline);
@@ -8922,7 +9529,27 @@ var Executor = class Executor {
 		}
 		pass.end();
 		encoder.copyBufferToBuffer(this.argmaxResultBuffer, 0, this.decodeReadbacks[slot], 0, 4);
+		if (tsTotal) {
+			encoder.resolveQuerySet(this.querySet, 0, 2, this.queryResolveBuf, 0);
+			encoder.copyBufferToBuffer(this.queryResolveBuf, 0, this.queryReadbackBuf, 0, 16);
+		}
 		this.ctx.device.queue.submit([encoder.finish()]);
+		if (tsTotal) {
+			const rb = this.queryReadbackBuf;
+			const acc = g.__tsTotal;
+			acc.inFlight = true;
+			(async () => {
+				try {
+					await rb.mapAsync(MAP_MODE_READ$1, 0, 16);
+					const ts = new BigUint64Array(rb.getMappedRange(0, 16).slice(0));
+					rb.unmap();
+					acc.ns += Number(ts[1] - ts[0]);
+					acc.steps += 1;
+				} catch {} finally {
+					acc.inFlight = false;
+				}
+			})();
+		}
 		this.seqPos += 1;
 	}
 	/** Read back the token produced by the pipelined step that used `slot`. */
@@ -9631,6 +10258,243 @@ var Executor = class Executor {
 	* WebKit risk: low — same single-workgroup reduction as the proven RMSNorm
 	* kernel, only the row→input routing is added.
 	*/
+	/**
+	* Fuse [CausalConv1dSiLU|CausalConv1dGated → ConvStateUpdate] into one
+	* dispatch (decode entries only). At T=1 the conv read and the rolling-state
+	* write for a channel live in the same thread, so the fused kernel is
+	* race-free; prefill (T>1) keeps the two-dispatch path.
+	*/
+	fuseConvStateUpdateDecodeEntries() {
+		let fusionCount = 0;
+		for (let i = 0; i < this.decodeEntries.length - 1; i++) {
+			const e1 = this.decodeEntries[i];
+			const e2 = this.decodeEntries[i + 1];
+			if (e1.node.opType === "CausalConv1dGatedBcx" && e2.node.opType === "ConvStateUpdateBcx" && e2.node.inputs[0] === e1.node.inputs[0] && e2.node.outputs[0] === e1.node.inputs[2] && e1.node.attributes.kernel_size <= 8) {
+				this.decodeEntries.splice(i + 1, 1);
+				fusionCount++;
+				continue;
+			}
+			const isSilu = e1.node.opType === "CausalConv1dSiLU";
+			const isGated = e1.node.opType === "CausalConv1dGated";
+			if (!isSilu && !isGated) continue;
+			if (e2.node.opType !== "ConvStateUpdate") continue;
+			if (e2.node.inputs[0] !== e1.node.inputs[0]) continue;
+			if (e2.node.outputs[0] !== e1.node.inputs[2]) continue;
+			const kernelSize = e1.node.attributes.kernel_size;
+			if (e2.node.attributes.state_size !== kernelSize - 1) continue;
+			if (kernelSize > 8) continue;
+			const inputBuf = this.getBuffer(e1.node.inputs[0]);
+			const weightBuf = this.getBuffer(e1.node.inputs[1]);
+			const stateBuf = this.getBuffer(e1.node.inputs[2]);
+			const gateBuf = isGated ? this.getBuffer(e1.node.inputs[3]) : null;
+			const outBuf = this.getBuffer(e1.node.outputs[0]);
+			if (!inputBuf || !weightBuf || !stateBuf || !outBuf || isGated && !gateBuf) continue;
+			if (outBuf === inputBuf || outBuf === stateBuf || stateBuf === inputBuf) continue;
+			if (gateBuf && (gateBuf === outBuf || gateBuf === stateBuf)) continue;
+			const fusedSpec = isSilu ? CAUSAL_CONV1D_SILU_UPDATE_SPEC : CAUSAL_CONV1D_GATED_UPDATE_SPEC;
+			const fusedPipeline = getOrCreatePipeline(this.ctx, `conv_update_${e1.nodeId}`, fusedSpec.shaderCode, fusedSpec.entryPoint);
+			const fusedUniformData = fusedSpec.buildParams(e1.node, {}, { seqPos: 0 });
+			const fusedUniform = createUniformBuffer(this.ctx, `uniform_conv_update_${e1.nodeId}`, fusedUniformData);
+			const bufferList = isSilu ? [
+				{ buffer: inputBuf },
+				{ buffer: weightBuf },
+				{ buffer: stateBuf },
+				{ buffer: outBuf },
+				{ buffer: fusedUniform }
+			] : [
+				{ buffer: inputBuf },
+				{ buffer: weightBuf },
+				{ buffer: stateBuf },
+				{ buffer: gateBuf },
+				{ buffer: outBuf },
+				{ buffer: fusedUniform }
+			];
+			const fusedBindGroup = createBindGroup(this.ctx, fusedPipeline, bufferList, `bg_conv_update_${e1.nodeId}`);
+			const fusedEntry = {
+				nodeId: `fused_conv_update_${e1.nodeId}`,
+				node: e1.node,
+				spec: fusedSpec,
+				pipeline: fusedPipeline,
+				bindGroup: fusedBindGroup,
+				uniformBuffer: fusedUniform,
+				lastParamsBytes: null,
+				lastDispatchSize: null,
+				buffers: bufferList
+			};
+			this.decodeEntries.splice(i, 2, fusedEntry);
+			fusionCount++;
+		}
+		if (fusionCount > 0) console.log(`[executor] Fused ${fusionCount} conv+state-update pairs (saved ${fusionCount} dispatches)`);
+	}
+	/**
+	* Fuse [per-head q_norm RMSNorm, k_norm RMSNorm, in-place RoPE] into ONE
+	* DualRMSNormRoPE dispatch. Numerically identical (norm then rotate, same
+	* math); requires head_dim <= 256 and RoPE operating in-place on exactly the
+	* two norm outputs. Saves 2 dispatches per full-attention layer — a mobile
+	* (WebKit submit-per-dispatch) win, desktop-neutral.
+	*/
+	/**
+	* Fuse [Add → RMSNorm] into a single ResidualRMSNorm dispatch: the add's sum
+	* is still materialized (sum_output — downstream residual chain reads it) and
+	* the norm result is written in the same dispatch. Numerically identical.
+	*/
+	fuseAddRMSNormDecodeEntries() {
+		let fusionCount = 0;
+		for (let i = 0; i < this.decodeEntries.length - 1; i++) {
+			const e0 = this.decodeEntries[i];
+			const e1 = this.decodeEntries[i + 1];
+			if (e0.node.opType !== "Add" || e1.node.opType !== "RMSNorm") continue;
+			if (e1.node.inputs[0] !== e0.node.outputs[0]) continue;
+			const a = e0.node.inputs[0];
+			const b = e0.node.inputs[1];
+			const sumOut = e0.node.outputs[0];
+			const normW = e1.node.inputs[1];
+			const normOut = e1.node.outputs[0];
+			const aBuf = this.getBuffer(a);
+			const bBuf = this.getBuffer(b);
+			const sumBuf = this.getBuffer(sumOut);
+			const wBuf = this.getBuffer(normW);
+			const outBuf = this.getBuffer(normOut);
+			if (!aBuf || !bBuf || !sumBuf || !wBuf || !outBuf) continue;
+			const bufs = [
+				aBuf,
+				bBuf,
+				wBuf,
+				sumBuf,
+				outBuf
+			];
+			if (new Set(bufs).size !== bufs.length) continue;
+			const fusedNode = {
+				id: `fused_addnorm_${e0.nodeId}`,
+				opType: "ResidualRMSNorm",
+				inputs: [
+					a,
+					b,
+					normW
+				],
+				outputs: [sumOut, normOut],
+				attributes: {
+					hidden_size: e1.node.attributes.hidden_size,
+					eps: e1.node.attributes.eps,
+					seq_len_tensor: e1.node.attributes.seq_len_tensor ?? e0.node.attributes.count_tensor
+				}
+			};
+			const fusedSpec = KERNEL_REGISTRY.ResidualRMSNorm;
+			if (!fusedSpec) continue;
+			const fusedPipeline = getOrCreatePipeline(this.ctx, `add_norm_${e0.nodeId}`, fusedSpec.shaderCode, fusedSpec.entryPoint);
+			const dummyShapes = this.resolveShapes(1);
+			const fusedUniformData = fusedSpec.buildParams(fusedNode, dummyShapes, { seqPos: 0 });
+			const fusedUniform = createUniformBuffer(this.ctx, `uniform_add_norm_${e0.nodeId}`, fusedUniformData);
+			const bufferEntries = [
+				{ buffer: aBuf },
+				{ buffer: bBuf },
+				{ buffer: wBuf },
+				{ buffer: sumBuf },
+				{ buffer: outBuf },
+				{ buffer: fusedUniform }
+			];
+			const fusedBindGroup = createBindGroup(this.ctx, fusedPipeline, bufferEntries, `bg_add_norm_${e0.nodeId}`);
+			this.decodeEntries.splice(i, 2, {
+				nodeId: fusedNode.id,
+				node: fusedNode,
+				spec: fusedSpec,
+				pipeline: fusedPipeline,
+				bindGroup: fusedBindGroup,
+				uniformBuffer: fusedUniform,
+				lastParamsBytes: null,
+				lastDispatchSize: null,
+				buffers: bufferEntries
+			});
+			fusionCount++;
+		}
+		if (fusionCount > 0) console.log(`[executor] Fused ${fusionCount} add+RMSNorm pairs (saved ${fusionCount} dispatches)`);
+	}
+	fuseDualRMSNormRoPEDecodeEntries() {
+		let fusionCount = 0;
+		for (let i = 0; i < this.decodeEntries.length - 2; i++) {
+			const e0 = this.decodeEntries[i];
+			const e1 = this.decodeEntries[i + 1];
+			const e2 = this.decodeEntries[i + 2];
+			if (e0.node.opType !== "RMSNorm" || e1.node.opType !== "RMSNorm") continue;
+			if (e2.node.opType !== "RoPE") continue;
+			if (e2.node.attributes.interleaved === true) continue;
+			if (e0.node.attributes.hidden_size !== e1.node.attributes.hidden_size) continue;
+			if (e0.node.attributes.eps !== e1.node.attributes.eps) continue;
+			const headDim = e0.node.attributes.hidden_size;
+			if (headDim > 256) continue;
+			if (e2.node.attributes.head_dim !== headDim) continue;
+			const out0 = e0.node.outputs[0];
+			const out1 = e1.node.outputs[0];
+			if (e2.node.inputs[0] !== out0 || e2.node.inputs[1] !== out1) continue;
+			if (e2.node.outputs[0] !== out0 || e2.node.outputs[1] !== out1) continue;
+			const in0 = e0.node.inputs[0];
+			const w0 = e0.node.inputs[1];
+			const in1 = e1.node.inputs[0];
+			const w1 = e1.node.inputs[1];
+			const in0Buf = this.getBuffer(in0);
+			const w0Buf = this.getBuffer(w0);
+			const out0Buf = this.getBuffer(out0);
+			const in1Buf = this.getBuffer(in1);
+			const w1Buf = this.getBuffer(w1);
+			const out1Buf = this.getBuffer(out1);
+			if (!in0Buf || !w0Buf || !out0Buf || !in1Buf || !w1Buf || !out1Buf) continue;
+			if (out0Buf === out1Buf) continue;
+			if (in0Buf === out1Buf || in1Buf === out0Buf) continue;
+			const fusedNode = {
+				id: `fused_dualnorm_rope_${e0.nodeId}`,
+				opType: "RMSNorm",
+				inputs: [
+					in0,
+					w0,
+					in1,
+					w1
+				],
+				outputs: [out0, out1],
+				attributes: {
+					hidden_size: headDim,
+					eps: e0.node.attributes.eps,
+					seq_len_tensor: e0.node.attributes.seq_len_tensor,
+					seq_len: e0.node.attributes.seq_len,
+					num_q_heads: e2.node.attributes.num_q_heads,
+					num_kv_heads: e2.node.attributes.num_kv_heads,
+					rope_base: e2.node.attributes.rope_base,
+					rope_dim: e2.node.attributes.rope_dim,
+					rope_half: e2.node.attributes.rope_half,
+					rope_denom: e2.node.attributes.rope_denom,
+					rope_active_pairs: e2.node.attributes.rope_active_pairs
+				}
+			};
+			const fusedSpec = DUAL_RMSNORM_ROPE_SPEC;
+			const fusedPipeline = getOrCreatePipeline(this.ctx, `dual_norm_rope_${e0.nodeId}`, fusedSpec.shaderCode, fusedSpec.entryPoint);
+			const dummyShapes = this.resolveShapes(1);
+			const fusedUniformData = fusedSpec.buildParams(fusedNode, dummyShapes, { seqPos: 0 });
+			const fusedUniform = createUniformBuffer(this.ctx, `uniform_dual_norm_rope_${e0.nodeId}`, fusedUniformData);
+			const bufferEntries = [
+				{ buffer: in0Buf },
+				{ buffer: w0Buf },
+				{ buffer: in1Buf },
+				{ buffer: w1Buf },
+				{ buffer: out0Buf },
+				{ buffer: out1Buf },
+				{ buffer: fusedUniform }
+			];
+			const fusedBindGroup = createBindGroup(this.ctx, fusedPipeline, bufferEntries, `bg_dual_norm_rope_${e0.nodeId}`);
+			const fusedEntry = {
+				nodeId: fusedNode.id,
+				node: fusedNode,
+				spec: fusedSpec,
+				pipeline: fusedPipeline,
+				bindGroup: fusedBindGroup,
+				uniformBuffer: fusedUniform,
+				lastParamsBytes: null,
+				lastDispatchSize: null,
+				buffers: bufferEntries
+			};
+			this.decodeEntries.splice(i, 3, fusedEntry);
+			fusionCount++;
+		}
+		if (fusionCount > 0) console.log(`[executor] Fused ${fusionCount} norm+norm+RoPE triples (saved ${fusionCount * 2} dispatches)`);
+	}
 	fuseDualRMSNormDecodeEntries() {
 		let fusionCount = 0;
 		for (let i = 0; i < this.decodeEntries.length - 1; i++) {
@@ -13308,4 +14172,4 @@ function selectGraphWeights(graph, weights) {
 
 //#endregion
 export { verifyGPU as S, createStorageBuffer as _, loadMoonshine as a, getOrCreatePipeline as b, quantizeBackboneInt4 as c, Tokenizer as d, Executor as f, createBindGroup as g, clearPipelineCache as h, loadModel as i, quantizeKaniBackbone as l, MATMUL_BIAS_F16C_SPEC as m, MoonshineEncoderExecutor as n, loadOuteTTS as o, KERNEL_REGISTRY as p, loadKaniTTS as r, loadParlerTTS as s, MoonshineSTT as t, remapPrunedToken as u, createUniformBuffer as v, initGPU as x, destroyBuffers as y };
-//# sourceMappingURL=moonshine-stt-BeXNc7o2.mjs.map
+//# sourceMappingURL=moonshine-stt-BwX7NQ0O.mjs.map