@tryhamster/gerbil 1.6.0 → 1.6.1

package/dist/{moonshine-stt-bExSnd2o.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;
@@ -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
 
@@ -4235,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)
@@ -6461,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",
@@ -6965,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",
@@ -8124,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,
@@ -8406,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) {
@@ -9748,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++) {
@@ -13425,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-bExSnd2o.mjs.map
+//# sourceMappingURL=moonshine-stt-BwX7NQ0O.mjs.map