@tryhamster/gerbil 1.12.0 → 1.13.0

package/dist/{moonshine-stt-B1kV5n1c.mjs → moonshine-stt-COJeK2Zb.mjs}

@@ -1,4 +1,4 @@
-import { F as CANONICAL_KEYS, I as DTYPE_BYTES, N as DEFAULT_GROUP_SIZE, P as quantizeInt4, R as createDefaultHFKeyMapper, _ as moonshineEncoderFrames, g as generateMoonshineEncoderGraph, h as generateMoonshineDecoderGraph, j as nanoCodecWeightMap, t as generateGraph, v as parseMoonshineConfig, w as foldNanoCodecWeightNorm } from "./architectures-BH_z6k9d.mjs";
+import { F as CANONICAL_KEYS, I as DTYPE_BYTES, N as DEFAULT_GROUP_SIZE, P as quantizeInt4, R as createDefaultHFKeyMapper, _ as moonshineEncoderFrames, g as generateMoonshineEncoderGraph, h as generateMoonshineDecoderGraph, j as nanoCodecWeightMap, t as generateGraph, v as parseMoonshineConfig, w as foldNanoCodecWeightNorm } from "./architectures-DHwj9AQD.mjs";
 
 //#region src/gpu/device.ts
 const COPY_SRC = 4;
@@ -2096,6 +2096,103 @@ fn main(
   }
 }
 `;
+const WGSL_QUAD_MATVEC_INT4 = `\
+const N_TILE: u32 = 16u;
+const K_THREADS: u32 = 16u;
+
+struct Params {
+  K: u32,
+  N: u32,
+  group_size: u32,
+  n0: u32,
+  n1: u32,
+  n2: u32,
+  _pad0: u32,
+  _pad1: u32,
+}
+
+@group(0) @binding(0) var<storage, read> A: array<vec4f>;
+@group(0) @binding(1) var<storage, read> B_q: array<vec4u>;
+@group(0) @binding(2) var<storage, read> scales: array<f32>;
+@group(0) @binding(3) var<storage, read> zeros: array<f32>;
+@group(0) @binding(4) var<storage, read_write> out0: array<f32>;
+@group(0) @binding(5) var<storage, read_write> out1: array<f32>;
+@group(0) @binding(6) var<storage, read_write> out2: array<f32>;
+@group(0) @binding(7) var<storage, read_write> out3: array<f32>;
+@group(0) @binding(8) var<storage, read> params: Params;
+
+var<workgroup> shared_sums: array<f32, 256>;
+
+@compute @workgroup_size(256)
+fn main(
+  @builtin(local_invocation_id) lid: vec3u,
+  @builtin(workgroup_id) wid: vec3u,
+) {
+  let tid = lid.x;
+  let n_idx = tid / K_THREADS;
+  let k_tid = tid % K_THREADS;
+  let col = wid.x * N_TILE + n_idx;
+  let K = params.K;
+  let k_vec = K / 32u;
+  let groups_per_col = K / params.group_size;
+  let packed_per_group = params.group_size / 8u;
+
+  var sum: f32 = 0.0;
+  if (col < params.N) {
+    let b_off_v = col * k_vec;
+    let col_g_base = col * groups_per_col;
+
+    var v = k_tid;
+    while (v < k_vec) {
+      let bq = B_q[b_off_v + v];
+      let g = (v * 4u) / packed_per_group;
+      let scale = scales[col_g_base + g];
+      let zero = zeros[col_g_base + g];
+      let a_base = v * 8u;
+
+      for (var j: u32 = 0u; j < 4u; j++) {
+        let packed = bq[j];
+        let n0v = f32(packed & 0xFu);
+        let n1v = f32((packed >> 4u) & 0xFu);
+        let n2v = f32((packed >> 8u) & 0xFu);
+        let n3v = f32((packed >> 12u) & 0xFu);
+        let n4v = f32((packed >> 16u) & 0xFu);
+        let n5v = f32((packed >> 20u) & 0xFu);
+        let n6v = f32((packed >> 24u) & 0xFu);
+        let n7v = f32((packed >> 28u) & 0xFu);
+
+        let b0 = vec4f(n0v - zero, n1v - zero, n2v - zero, n3v - zero) * scale;
+        let b1 = vec4f(n4v - zero, n5v - zero, n6v - zero, n7v - zero) * scale;
+
+        sum += dot(A[a_base + j * 2u], b0) + dot(A[a_base + j * 2u + 1u], b1);
+      }
+
+      v += K_THREADS;
+    }
+  }
+
+  shared_sums[tid] = sum;
+  workgroupBarrier();
+
+  if (k_tid == 0u && col < params.N) {
+    let base = n_idx * K_THREADS;
+    var total: f32 = shared_sums[base];
+    for (var i: u32 = 1u; i < K_THREADS; i++) {
+      total += shared_sums[base + i];
+    }
+    // Route the column to its original destination buffer.
+    if (col < params.n0) {
+      out0[col] = total;
+    } else if (col < params.n1) {
+      out1[col - params.n0] = total;
+    } else if (col < params.n2) {
+      out2[col - params.n1] = total;
+    } else {
+      out3[col - params.n2] = total;
+    }
+  }
+}
+`;
 const WGSL_GATED_MATVEC_INT4 = `\
 const N_TILE: u32 = 8u;
 const K_THREADS: u32 = 16u;
@@ -4331,6 +4428,133 @@ fn main(
   }
 }
 `;
+const WGSL_NORM_MATVEC_INT4 = `\
+const N_TILE: u32 = 16u;
+const K_THREADS: u32 = 16u;
+
+struct Params {
+  K: u32,
+  N: u32,
+  group_size: u32,
+  eps_bits: u32,
+}
+
+@group(0) @binding(0) var<storage, read> A_a: array<vec4f>;
+@group(0) @binding(1) var<storage, read> A_b: array<vec4f>;
+@group(0) @binding(2) var<storage, read> W_norm: array<vec4f>;
+@group(0) @binding(3) var<storage, read> B_q: array<vec4u>;
+@group(0) @binding(4) var<storage, read> scales: array<f32>;
+@group(0) @binding(5) var<storage, read> zeros: array<f32>;
+@group(0) @binding(6) var<storage, read_write> C: array<f32>;
+@group(0) @binding(7) var<storage, read_write> residual_out: array<vec4f>;
+@group(0) @binding(8) var<storage, read_write> norm_out: array<vec4f>;
+@group(0) @binding(9) var<storage, read> params: Params;
+
+var<workgroup> shared_sq: array<f32, 256>;
+var<workgroup> shared_sums: array<f32, 256>;
+
+@compute @workgroup_size(256)
+fn main(
+  @builtin(local_invocation_id) lid: vec3u,
+  @builtin(workgroup_id) wid: vec3u,
+) {
+  let tid = lid.x;
+  let K = params.K;
+  let k_vec4 = K / 4u;
+
+  // ── Prologue: residual sum + RMS (all threads, uniform control flow) ──
+  var local_sq: f32 = 0.0;
+  var v4 = tid;
+  while (v4 < k_vec4) {
+    let x = A_a[v4] + A_b[v4];
+    if (wid.x == 0u) { residual_out[v4] = x; }
+    local_sq += dot(x, x);
+    v4 += 256u;
+  }
+  shared_sq[tid] = local_sq;
+  workgroupBarrier();
+  var stride: u32 = 128u;
+  while (stride > 0u) {
+    if (tid < stride) {
+      shared_sq[tid] += shared_sq[tid + stride];
+    }
+    workgroupBarrier();
+    stride = stride / 2u;
+  }
+  let eps = bitcast<f32>(params.eps_bits);
+  let inv_rms = 1.0 / sqrt(shared_sq[0] / f32(K) + eps);
+  workgroupBarrier();
+
+  // Workgroup 0 materializes the full normed vector — it stays live for the
+  // sibling a_proj/b_proj/z_proj projections that read the same layernorm output.
+  if (wid.x == 0u) {
+    var w4 = tid;
+    while (w4 < k_vec4) {
+      norm_out[w4] = (A_a[w4] + A_b[w4]) * inv_rms * W_norm[w4];
+      w4 += 256u;
+    }
+  }
+
+  // ── Main GEMV: C[col] = normed · dequant(B[col,:]) ──
+  let n_idx = tid / K_THREADS;
+  let k_tid = tid % K_THREADS;
+  let col = wid.x * N_TILE + n_idx;
+  let k_vec = K / 32u;
+  let groups_per_col = K / params.group_size;
+  let packed_per_group = params.group_size / 8u;
+
+  var sum: f32 = 0.0;
+  if (col < params.N) {
+    let b_off_v = col * k_vec;
+    let col_g_base = col * groups_per_col;
+
+    var v = k_tid;
+    while (v < k_vec) {
+      let bq = B_q[b_off_v + v];
+      let g = (v * 4u) / packed_per_group;
+      let scale = scales[col_g_base + g];
+      let zero = zeros[col_g_base + g];
+      let a_base = v * 8u;
+
+      for (var j: u32 = 0u; j < 4u; j++) {
+        let packed = bq[j];
+        let n0 = f32(packed & 0xFu);
+        let n1 = f32((packed >> 4u) & 0xFu);
+        let n2 = f32((packed >> 8u) & 0xFu);
+        let n3 = f32((packed >> 12u) & 0xFu);
+        let n4 = f32((packed >> 16u) & 0xFu);
+        let n5 = f32((packed >> 20u) & 0xFu);
+        let n6 = f32((packed >> 24u) & 0xFu);
+        let n7 = f32((packed >> 28u) & 0xFu);
+
+        let b0 = vec4f(n0 - zero, n1 - zero, n2 - zero, n3 - zero) * scale;
+        let b1 = vec4f(n4 - zero, n5 - zero, n6 - zero, n7 - zero) * scale;
+
+        let i0 = a_base + j * 2u;
+        let i1 = a_base + j * 2u + 1u;
+        let a0 = (A_a[i0] + A_b[i0]) * inv_rms * W_norm[i0];
+        let a1 = (A_a[i1] + A_b[i1]) * inv_rms * W_norm[i1];
+
+        sum += dot(a0, b0) + dot(a1, b1);
+      }
+
+      v += K_THREADS;
+    }
+  }
+
+  shared_sums[tid] = sum;
+  workgroupBarrier();
+
+  if (k_tid == 0u && col < params.N) {
+    let base = n_idx * K_THREADS;
+    var total: f32 = shared_sums[base];
+    for (var i: u32 = 1u; i < K_THREADS; i++) {
+      total += shared_sums[base + i];
+    }
+    C[col] = total;
+  }
+}
+`;
 const WGSL_DUAL_MATVEC_INT4 = `\
 const N_TILE: u32 = 16u;
 const K_THREADS: u32 = 16u;
@@ -6870,6 +7094,47 @@ const MATVEC_INT4_SPEC = {
 		]);
 	}
 };
+const QUAD_MATVEC_INT4_SPEC = {
+	shaderCode: WGSL_QUAD_MATVEC_INT4,
+	entryPoint: "main",
+	bindings: [
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read-write" },
+		{ type: "storage-read-write" },
+		{ type: "storage-read-write" },
+		{ type: "storage-read-write" },
+		{ type: "uniform" }
+	],
+	getDispatchSize(op) {
+		const N = op.attributes.N;
+		return [
+			cdiv$1(N, 16),
+			1,
+			1
+		];
+	},
+	buildParams(op) {
+		const K = op.attributes.K;
+		const N = op.attributes.N;
+		const group_size = op.attributes.group_size;
+		const n0 = op.attributes.n0;
+		const n1 = op.attributes.n1;
+		const n2 = op.attributes.n2;
+		return buildUniformBuffer$1([
+			K,
+			N,
+			group_size,
+			n0,
+			n1,
+			n2,
+			0,
+			0
+		]);
+	}
+};
 function deriveMatvecGeometry(nTile, kThreads) {
 	return {
 		...MATVEC_INT4_SPEC,
@@ -7084,6 +7349,41 @@ const NORM_SWIGLU_MATVEC_INT4_SPEC = {
 		]);
 	}
 };
+const NORM_MATVEC_INT4_SPEC = {
+	shaderCode: WGSL_NORM_MATVEC_INT4,
+	entryPoint: "main",
+	bindings: [
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read-write" },
+		{ type: "storage-read-write" },
+		{ type: "storage-read-write" },
+		{ type: "uniform" }
+	],
+	getDispatchSize(op) {
+		const N = op.attributes.N;
+		return [
+			cdiv$1(N, 16),
+			1,
+			1
+		];
+	},
+	buildParams(op) {
+		const K = op.attributes.K;
+		const N = op.attributes.N;
+		const group_size = op.attributes.group_size;
+		return buildUniformBuffer$1([
+			K,
+			N,
+			group_size,
+			f32BitsToU32$1(op.attributes.norm_eps ?? 1e-6)
+		]);
+	}
+};
 const DUAL_MATVEC_INT4_SPEC = {
 	shaderCode: WGSL_DUAL_MATVEC_INT4,
 	entryPoint: "main",
@@ -11246,6 +11546,11 @@ const BATCH_LORA_NONE = 4294967295;
 var Executor = class Executor {
 	ctx;
 	graph;
+	/** Output tensor names of this executor's graph (read-only; used by non-LM
+	* codec executors that need to locate the decoded-audio output tensor). */
+	get graphOutputs() {
+		return this.graph.outputs;
+	}
 	weightBuffers = /* @__PURE__ */ new Map();
 	activationBuffers = /* @__PURE__ */ new Map();
 	ssmStateBuffers = /* @__PURE__ */ new Map();
@@ -11310,6 +11615,13 @@ var Executor = class Executor {
 	dispatchEntries = [];
 	/** Dispatch entries for decode (M=1): uses K-parallel matvec kernels. */
 	decodeEntries = [];
+	/**
+	* Column-concatenated INT4 weight buffers built by the Mamba-front fusion
+	* (qkv|a|b|z packed into one q/scales/zeros set per layer). Retained here so
+	* they outlive the fusion pass and are not garbage-collected while the fused
+	* bind groups still reference them.
+	*/
+	mambaFrontConcatBuffers = [];
 	/** Per-node decode entries captured BEFORE fusion (the overlay base). */
 	decodeEntriesUnfused = [];
 	/** True while a runtime adapter is applied. */
@@ -11594,6 +11906,7 @@ var Executor = class Executor {
 		this.decodeEntriesUnfused = this.decodeEntries.slice();
 		this.fuseNormSwiGLUDecodeEntries();
 		this.fuseSwiGLUDecodeEntries();
+		this.fuseMambaFrontDecodeEntries();
 		this.fuseDualMatVecDecodeEntries();
 		this.fuseDualKVCacheAppendEntries();
 		this.fuseGatedOProjDecodeEntries();
@@ -11602,6 +11915,7 @@ var Executor = class Executor {
 		this.fuseDualRMSNormDecodeEntries();
 		this.fuseConvStateUpdateDecodeEntries();
 		this.fuseAddRMSNormDecodeEntries();
+		this.fuseNormMatVecDecodeEntries();
 		console.log(`[executor] decode: ${this.decodeEntries.length} dispatches/token`);
 		if (this.batchSize > 0) this.buildBatchEntries();
 		const logitsBuffer = this.getBuffer("logits");
@@ -11631,6 +11945,7 @@ var Executor = class Executor {
 			size: this.uniformStagingCapacity,
 			usage: 12
 		});
+		if (globalThis.process?.env?.GERBIL_DUMP_GRAPH === "1") globalThis.__GERBIL_DECODE_GRAPH__ = this.dumpDecodeGraph();
 	}
 	/** True while a runtime LoRA overlay is applied. */
 	get hasRuntimeAdapter() {
@@ -12041,6 +12356,97 @@ var Executor = class Executor {
 		return this.ctx.limits.maxStorageBuffersPerShaderStage;
 	}
 	/**
+	* Build a machine-readable dump of the post-fusion decode entry list (the
+	* exact per-token dispatch sequence), with per-tensor pool-buffer identities
+	* so pooled-aliasing hazards are visible offline. Debug/analysis only — never
+	* called on any hot path; reached via the GERBIL_DUMP_GRAPH hook at the end
+	* of {@link initBindGroups} or directly by tooling.
+	*/
+	dumpDecodeGraph(dumpSeqPos = 64) {
+		const bufferLabels = /* @__PURE__ */ new Map();
+		const bufferKinds = /* @__PURE__ */ new Map();
+		const register = (map, kind) => {
+			for (const [name, buf] of map) if (!bufferLabels.has(buf)) {
+				bufferLabels.set(buf, buf.label || `${kind}_${name}`);
+				bufferKinds.set(buf, kind);
+			}
+		};
+		register(this.weightBuffers, "weight");
+		register(this.activationBuffers, "activation");
+		register(this.ssmStateBuffers, "ssm-state");
+		register(this.kvCacheBuffers, "kv-cache");
+		const resolved = this.resolveShapes(1, dumpSeqPos);
+		const runtimeContext = {
+			seqPos: dumpSeqPos,
+			tableBase: 0
+		};
+		const tensorRef = (tensor) => {
+			const desc = this.graph.tensors[tensor];
+			const buf = this.getBuffer(tensor);
+			return {
+				tensor,
+				shape: desc ? [...desc.shape] : [],
+				resolvedShape: resolved[tensor] ?? null,
+				buffer: buf ? bufferLabels.get(buf) ?? buf.label ?? null : null,
+				bufferBytes: buf ? buf.size : null
+			};
+		};
+		const nodeById = new Map(this.graph.nodes.map((n) => [n.id, n]));
+		const dumpNode = (id) => {
+			const node = nodeById.get(id);
+			if (!node) return null;
+			const attributes = {};
+			for (const [k, v] of Object.entries(node.attributes ?? {})) if (typeof v === "number" || typeof v === "string" || typeof v === "boolean") attributes[k] = v;
+			return {
+				id,
+				opType: node.opType,
+				inputs: node.inputs.map(tensorRef),
+				outputs: node.outputs.map(tensorRef),
+				attributes
+			};
+		};
+		const entries = this.decodeEntries.map((entry, index) => {
+			let dispatchSize = null;
+			try {
+				dispatchSize = entry.spec.getDispatchSize(entry.node, resolved, runtimeContext);
+			} catch {}
+			let paramsU32 = [];
+			let paramsBytes = 0;
+			try {
+				const params = entry.spec.buildParams(entry.node, resolved, runtimeContext);
+				paramsBytes = params.byteLength;
+				paramsU32 = [...new Uint32Array(params.slice(0, Math.floor(params.byteLength / 4) * 4))];
+			} catch {}
+			const bindings = entry.spec.bindings ?? [];
+			return {
+				index,
+				nodeId: entry.nodeId,
+				opType: entry.node.opType,
+				fused: entry.fusedNodeIds !== void 0,
+				fusedNodeIds: entry.fusedNodeIds ? [...entry.fusedNodeIds] : null,
+				storageBindings: bindings.filter((b) => b.type !== "uniform").length,
+				totalBindings: bindings.length,
+				dispatchSize,
+				paramsBytes,
+				paramsU32,
+				bindBufferLabels: entry.buffers ? entry.buffers.map((b) => bufferLabels.get(b.buffer) ?? b.buffer.label ?? "uniform-or-unregistered") : null,
+				nodes: this.coveredNodeIds(entry).map(dumpNode).filter((n) => n !== null)
+			};
+		});
+		return {
+			dispatchesPerToken: this.decodeEntries.length,
+			unfusedDispatchesPerToken: this.decodeEntriesUnfused.length,
+			maxStorageBuffersPerShaderStage: this.ctx.limits.maxStorageBuffersPerShaderStage,
+			dumpSeqPos,
+			buffers: [...bufferLabels.entries()].map(([buf, label]) => ({
+				label,
+				bytes: buf.size,
+				kind: bufferKinds.get(buf) ?? "unknown"
+			})),
+			entries
+		};
+	}
+	/**
 	* Profile ONE real decode step: times the actual `decodeEntries` (the kernels
 	* the pipelined greedy benchmark runs) with per-dispatch timestamps. Timing is
 	* token-independent, so pass any valid id; runs un-pipelined with a synchronous
@@ -14242,6 +14648,111 @@ var Executor = class Executor {
 	* when the device can't bind 11 storage buffers. Windows it skips fall
 	* through to fuseSwiGLUDecodeEntries.
 	*/
+	/**
+	* Fuse [ResidualRMSNorm → Mamba qkv MatVecInt4] → ONE NormMatVec dispatch.
+	* The kernel recomputes the residual sum + RMS in a prologue (workgroup 0
+	* persists BOTH the residual sum and the full normed vector — the latter is
+	* live for the sibling a_proj/b_proj/z_proj), then the GEMV normalizes the
+	* activation on the fly. Saves the ResidualRMSNorm dispatch (−1 per Mamba
+	* layer, ×17). 10 storage bindings — fits the Dawn/Metal 10-binding adapter.
+	* INT4-only.
+	*
+	* OPT-IN, DEFAULT OFF (GERBIL_FUSE_NORM_QKV=1). Round r28 (2026-07-25) measured
+	* this a −4.6% REGRESSION on M4 Max/Metal: the qkv GEMV is the widest projection
+	* (N=6144 → 384 workgroups), so recomputing the 1024-wide residual+RMS reduction
+	* per workgroup + normalizing activations on the fly costs far more ALU than the
+	* single saved ResidualRMSNorm dispatch returns on a bandwidth-plateaued backend.
+	* The −17 dispatch/token reduction still targets Vulkan/WebKit (dispatch-count-
+	* bound) — validate on the kernel-lab A5000 rig before enabling anywhere.
+	*/
+	fuseNormMatVecDecodeEntries() {
+		const maxBindings = this.ctx.limits.maxStorageBuffersPerShaderStage;
+		const dbg = process.env?.GERBIL_FUSE_DEBUG != null;
+		if (process.env?.GERBIL_FUSE_NORM_QKV == null || maxBindings < 10) {
+			if (dbg) console.log(`[norm-qkv-debug] disabled (maxBindings=${maxBindings})`);
+			return;
+		}
+		if (process.env?.GERBIL_MATVEC_GEO != null) return;
+		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 !== "ResidualRMSNorm") continue;
+			if (e1.spec !== MATVEC_INT4_SPEC || e1.node.opType !== "MatMulInt4") continue;
+			const normOut = e0.node.outputs[1];
+			if (e1.node.inputs[0] !== normOut) {
+				if (dbg) console.log(`[norm-qkv-debug] i=${i} reject=norm-input e1in=${e1.node.inputs[0]} normOut=${normOut}`);
+				continue;
+			}
+			const aBuf = this.getBuffer(e0.node.inputs[0]);
+			const bBuf = this.getBuffer(e0.node.inputs[1]);
+			const wBuf = this.getBuffer(e0.node.inputs[2]);
+			const qBuf = this.getBuffer(e1.node.inputs[1]);
+			const sBuf = this.getBuffer(e1.node.inputs[2]);
+			const zBuf = this.getBuffer(e1.node.inputs[3]);
+			const outBuf = this.getBuffer(e1.node.outputs[0]);
+			const residualBuf = this.getBuffer(e0.node.outputs[0]);
+			const normBuf = this.getBuffer(normOut);
+			if (!(aBuf && bBuf && wBuf && qBuf && sBuf && zBuf && outBuf && residualBuf && normBuf)) {
+				if (dbg) console.log(`[norm-qkv-debug] i=${i} reject=missing-buffer`);
+				continue;
+			}
+			const reads = [
+				aBuf,
+				bBuf,
+				wBuf,
+				qBuf,
+				sBuf,
+				zBuf
+			];
+			const writes = [
+				outBuf,
+				residualBuf,
+				normBuf
+			];
+			let hazard = false;
+			for (const w of writes) if (reads.includes(w)) {
+				hazard = true;
+				break;
+			}
+			if (hazard || outBuf === residualBuf || outBuf === normBuf || residualBuf === normBuf) {
+				if (dbg) console.log(`[norm-qkv-debug] i=${i} reject=aliasing`);
+				continue;
+			}
+			e1.node.attributes.norm_eps = e0.node.attributes.eps ?? 1e-6;
+			const fusedSpec = NORM_MATVEC_INT4_SPEC;
+			const fusedPipeline = getOrCreatePipeline(this.ctx, `norm_mv_${e1.nodeId}`, fusedSpec.shaderCode, fusedSpec.entryPoint);
+			const fusedUniformData = fusedSpec.buildParams(e1.node, {}, { seqPos: 0 });
+			const fusedUniform = createUniformBuffer(this.ctx, `uniform_norm_mv_${e1.nodeId}`, fusedUniformData);
+			const bufferEntries = [
+				{ buffer: aBuf },
+				{ buffer: bBuf },
+				{ buffer: wBuf },
+				{ buffer: qBuf },
+				{ buffer: sBuf },
+				{ buffer: zBuf },
+				{ buffer: outBuf },
+				{ buffer: residualBuf },
+				{ buffer: normBuf },
+				{ buffer: fusedUniform }
+			];
+			const fusedBindGroup = createBindGroup(this.ctx, fusedPipeline, bufferEntries, `bg_norm_mv_${e1.nodeId}`);
+			const fusedEntry = {
+				nodeId: `fused_norm_qkv_${e1.nodeId}`,
+				fusedNodeIds: [...this.coveredNodeIds(e0), ...this.coveredNodeIds(e1)],
+				node: e1.node,
+				spec: fusedSpec,
+				pipeline: fusedPipeline,
+				bindGroup: fusedBindGroup,
+				uniformBuffer: fusedUniform,
+				lastParamsBytes: null,
+				lastDispatchSize: null
+			};
+			this.decodeEntries.splice(i, 2, fusedEntry);
+			fusionCount++;
+		}
+		if (fusionCount > 0) console.log(`[executor] Fused ${fusionCount} norm+qkv Mamba blocks (saved ${fusionCount} dispatches)`);
+	}
 	fuseNormSwiGLUDecodeEntries() {
 		const maxBindings = this.ctx.limits.maxStorageBuffersPerShaderStage;
 		if (process.env?.GERBIL_FUSE_DEBUG != null) {
@@ -14420,6 +14931,158 @@ var Executor = class Executor {
 		if (fusionCount > 0) console.log(`[executor] Fused ${fusionCount} SwiGLU MLP blocks (saved ${fusionCount * 2} dispatches)`);
 	}
 	/**
+	* Fuse the Mamba-front projections — qkv (MatVec), a (MatVec), b (MatVec),
+	* z (MatVec) — into ONE QuadMatVecInt4 dispatch per Mamba layer. All four
+	* read the SAME `input_layernorm` output and share K and group_size, so their
+	* INT4 weight matrices (stored column-major, one column contiguous) are
+	* column-concatenated into a single q/scales/zeros buffer by a plain
+	* byte-append (a GPU buffer-to-buffer copy at init). The fused kernel runs a
+	* single GEMV over the concatenated N and routes each output column back to
+	* its ORIGINAL destination buffer, so downstream consumers (conv1d reads qkv,
+	* MambaSSM reads a/b, the gated out_proj reads z) are untouched.
+	*
+	* Numerically identical to the three separate dispatches (same dequant, same
+	* K-parallel reduction, same per-column sum — the concatenated weights are the
+	* same bytes), so this is token-exact and WebKit-safe. It removes 2
+	* dispatches per Mamba layer (3 front dispatches → 1) plus one input read and
+	* two weight-read passes.
+	*
+	* Runs BEFORE fuseDualMatVecDecodeEntries so the a/b pair is still two
+	* standalone MatVec entries here (not yet a DualMatVec). Restricted to the
+	* Mamba front by weight-name (`.in_proj_qkv/a/b/z.`), so the attention front
+	* (q/gate/k/v) is never matched. Bindings: A + q/s/z + 4 outs + params = 9
+	* (fits Metal's 10-binding wall). Gate: default-on when the adapter offers ≥9
+	* storage bindings; opt-out via GERBIL_FUSE_MAMBA_FRONT=0.
+	*/
+	fuseMambaFrontDecodeEntries() {
+		const maxBindings = this.ctx.limits.maxStorageBuffersPerShaderStage;
+		const dbg = process.env?.GERBIL_FUSE_DEBUG != null;
+		if (process.env?.GERBIL_FUSE_MAMBA_FRONT === "0" || maxBindings < 9) {
+			if (dbg) console.log(`[mamba-front-debug] disabled (flag=${process.env?.GERBIL_FUSE_MAMBA_FRONT ?? "unset"} maxBindings=${maxBindings})`);
+			return;
+		}
+		const isFrontProj = (entry, marker) => {
+			if (entry.node.opType !== "MatMulInt4") return false;
+			if (entry.fusedNodeIds && entry.fusedNodeIds.length > 1) return false;
+			const wq = entry.node.inputs[1];
+			return typeof wq === "string" && wq.includes(marker);
+		};
+		let fusionCount = 0;
+		for (let i = 0; i < this.decodeEntries.length - 3; i++) {
+			const eQkv = this.decodeEntries[i];
+			const eA = this.decodeEntries[i + 1];
+			const eB = this.decodeEntries[i + 2];
+			const eZ = this.decodeEntries[i + 3];
+			if (!isFrontProj(eQkv, ".in_proj_qkv.") || !isFrontProj(eA, ".in_proj_a.") || !isFrontProj(eB, ".in_proj_b.") || !isFrontProj(eZ, ".in_proj_z.")) continue;
+			const inputTensor = eQkv.node.inputs[0];
+			if (eA.node.inputs[0] !== inputTensor || eB.node.inputs[0] !== inputTensor || eZ.node.inputs[0] !== inputTensor) continue;
+			const K = eQkv.node.attributes.K;
+			const groupSize = eQkv.node.attributes.group_size;
+			if (![
+				eA,
+				eB,
+				eZ
+			].every((e) => e.node.attributes.K === K && e.node.attributes.group_size === groupSize)) continue;
+			const nQkv = eQkv.node.attributes.N;
+			const nA = eA.node.attributes.N;
+			const nB = eB.node.attributes.N;
+			const nZ = eZ.node.attributes.N;
+			const inputBuf = this.getBuffer(inputTensor);
+			const outQkv = this.getBuffer(eQkv.node.outputs[0]);
+			const outA = this.getBuffer(eA.node.outputs[0]);
+			const outB = this.getBuffer(eB.node.outputs[0]);
+			const outZ = this.getBuffer(eZ.node.outputs[0]);
+			if (!(inputBuf && outQkv && outA && outB && outZ)) continue;
+			const outs = [
+				outQkv,
+				outA,
+				outB,
+				outZ
+			];
+			if (outs.includes(inputBuf)) continue;
+			if (new Set(outs).size !== outs.length) continue;
+			const concat = (label, tensors) => {
+				const bufs = tensors.map((t) => this.getBuffer(t));
+				const total = bufs.reduce((acc, b) => acc + b.size, 0);
+				const dst = createStorageBuffer(this.ctx, label, total);
+				const enc = this.ctx.device.createCommandEncoder();
+				let off = 0;
+				for (const b of bufs) {
+					enc.copyBufferToBuffer(b, 0, dst, off, b.size);
+					off += b.size;
+				}
+				this.ctx.device.queue.submit([enc.finish()]);
+				this.mambaFrontConcatBuffers.push(dst);
+				return dst;
+			};
+			const concatQ = concat(`mamba_front_q_${eQkv.nodeId}`, [
+				eQkv.node.inputs[1],
+				eA.node.inputs[1],
+				eB.node.inputs[1],
+				eZ.node.inputs[1]
+			]);
+			const concatS = concat(`mamba_front_s_${eQkv.nodeId}`, [
+				eQkv.node.inputs[2],
+				eA.node.inputs[2],
+				eB.node.inputs[2],
+				eZ.node.inputs[2]
+			]);
+			const concatZ = concat(`mamba_front_z_${eQkv.nodeId}`, [
+				eQkv.node.inputs[3],
+				eA.node.inputs[3],
+				eB.node.inputs[3],
+				eZ.node.inputs[3]
+			]);
+			const fusedNode = {
+				...eQkv.node,
+				attributes: {
+					...eQkv.node.attributes,
+					K,
+					N: nQkv + nA + nB + nZ,
+					group_size: groupSize,
+					n0: nQkv,
+					n1: nQkv + nA,
+					n2: nQkv + nA + nB
+				}
+			};
+			const fusedSpec = QUAD_MATVEC_INT4_SPEC;
+			const fusedPipeline = getOrCreatePipeline(this.ctx, `quad_mv_${eQkv.nodeId}`, fusedSpec.shaderCode, fusedSpec.entryPoint);
+			const fusedUniform = createUniformBuffer(this.ctx, `uniform_quad_mv_${eQkv.nodeId}`, fusedSpec.buildParams(fusedNode, {}, { seqPos: 0 }));
+			const bufferEntries = [
+				{ buffer: inputBuf },
+				{ buffer: concatQ },
+				{ buffer: concatS },
+				{ buffer: concatZ },
+				{ buffer: outQkv },
+				{ buffer: outA },
+				{ buffer: outB },
+				{ buffer: outZ },
+				{ buffer: fusedUniform }
+			];
+			const fusedBindGroup = createBindGroup(this.ctx, fusedPipeline, bufferEntries, `bg_quad_mv_${eQkv.nodeId}`);
+			const fusedEntry = {
+				nodeId: `fused_mamba_front_${eQkv.nodeId}`,
+				fusedNodeIds: [
+					...this.coveredNodeIds(eQkv),
+					...this.coveredNodeIds(eA),
+					...this.coveredNodeIds(eB),
+					...this.coveredNodeIds(eZ)
+				],
+				node: fusedNode,
+				spec: fusedSpec,
+				pipeline: fusedPipeline,
+				bindGroup: fusedBindGroup,
+				uniformBuffer: fusedUniform,
+				lastParamsBytes: null,
+				lastDispatchSize: null
+			};
+			this.decodeEntries.splice(i, 4, fusedEntry);
+			fusionCount++;
+		}
+		if (fusionCount > 0) console.log(`[executor] Fused ${fusionCount} mamba-front qkv+a+b+z projections (saved ${fusionCount * 2} dispatches)`);
+		else if (dbg) console.log("[mamba-front-debug] no matching qkv/a/b/z windows found");
+	}
+	/**
 	* Fuse two adjacent INT4 projections that share the same input activation and
 	* the same K/N (e.g. q_proj+gate_proj and k_proj+v_proj in full-attention
 	* decode) into a single DualMatVecInt4 dispatch. Reads the shared input vector
@@ -17964,6 +18627,118 @@ function quantizeKaniBackbone(graph, weights) {
 * the embedding/LM-head are left untouched (the graph keeps them f32). Idempotent.
 */
 const quantizeBackboneInt4 = quantizeKaniBackbone;
+/** Default NanoCodec checkpoint Gepard uses (NeMo 22 kHz, 1.89 kbps, 21.5 fps). */
+const GEPARD_NANOCODEC_REPO = "mlx-community/nemo-nano-codec-22khz-1.89kbps-21.5fps";
+/** Overlay key prefixes that run host-side (kept f32 in a separate map). */
+const GEPARD_OVERLAY_RE = /^(audio_embeddings\.|audio_embed_proj\.|audio_embed_scale$|codebook_heads\.|stop_head\.)/;
+/** Voice-cloning / training-only tensors, skipped until cloning is wired. */
+const GEPARD_SKIP_RE = /^(ref_compressor\.|null_prefix$|supcon_head\.)/;
+async function loadGepardTTS(options) {
+	const revision = options.revision ?? "main";
+	const repo = options.repo ?? "nineninesix/gepard-1.0";
+	const codecRepo = options.codecRepo ?? GEPARD_NANOCODEC_REPO;
+	const baseURL = await resolveModelBaseURL(repo, revision);
+	const codecURL = await resolveModelBaseURL(codecRepo, "main");
+	await initFs();
+	options.onProgress?.(0, 100, "Fetching config + tokenizer…");
+	const [rawConfig, gepardConfig, tokenizerJSON] = await Promise.all([
+		fetchJSON(baseURL, "config.json", options.hfToken, options.cacheDir),
+		fetchJSON(baseURL, "gepard_config.json", options.hfToken, options.cacheDir),
+		fetchJSON(baseURL, "tokenizer.json", options.hfToken, options.cacheDir)
+	]);
+	const tokenizerConfig = await fetchJSON(baseURL, "tokenizer_config.json", options.hfToken, options.cacheDir).catch(() => null);
+	const tokenizer = Tokenizer.fromJSON(tokenizerJSON, tokenizerConfig);
+	options.onProgress?.(8, 100, "Downloading Gepard backbone…");
+	const mainBuf = await fetchBinary(baseURL, "model.safetensors", options.hfToken, (loaded, total) => options.onProgress?.(8 + loaded / (total || 1) * 55, 100, "backbone weights"), options.cacheDir);
+	const mainFile = parseSafetensorsHeader(mainBuf);
+	const backboneWeights = /* @__PURE__ */ new Map();
+	const overlayWeights = /* @__PURE__ */ new Map();
+	let embedTokensBF16 = null;
+	for (const entry of mainFile.entries) {
+		if (GEPARD_SKIP_RE.test(entry.name)) continue;
+		if (GEPARD_OVERLAY_RE.test(entry.name)) {
+			overlayWeights.set(entry.name, {
+				data: toF32(entry, mainBuf, mainFile),
+				shape: entry.shape
+			});
+			continue;
+		}
+		if (!entry.name.startsWith("model.")) continue;
+		const key = entry.name.slice(6);
+		if (key === "embed_tokens.weight") {
+			if (entry.dtype !== "BF16") throw new Error(`Gepard embed_tokens.weight is ${entry.dtype}; expected BF16.`);
+			const view = getTensorData(mainBuf, mainFile, entry);
+			embedTokensBF16 = new Uint16Array(view.buffer, view.byteOffset, view.byteLength / 2);
+			continue;
+		}
+		backboneWeights.set(key, {
+			data: toF32(entry, mainBuf, mainFile),
+			shape: entry.shape
+		});
+	}
+	if (!embedTokensBF16) throw new Error("Gepard checkpoint has no model.embed_tokens.weight.");
+	const numLayers = rawConfig.num_hidden_layers;
+	const numHeads = rawConfig.num_attention_heads;
+	const headDim = rawConfig.head_dim ?? Math.floor(rawConfig.hidden_size / numHeads);
+	for (let i = 0; i < numLayers; i++) {
+		const qProjKey = `layers.${i}.self_attn.q_proj.weight`;
+		const attnGateKey = `layers.${i}.self_attn.attn_gate.weight`;
+		const fused = backboneWeights.get(qProjKey);
+		if (!fused || backboneWeights.has(attnGateKey)) continue;
+		const [fusedRows, cols] = fused.shape;
+		if (fusedRows !== numHeads * 2 * headDim) continue;
+		const src = fused.data;
+		const halfRows = fusedRows / 2;
+		const qData = new Float32Array(halfRows * cols);
+		const gateData = new Float32Array(halfRows * cols);
+		const headBlock = 2 * headDim;
+		for (let h = 0; h < numHeads; h++) {
+			const srcBase = h * headBlock * cols;
+			const dstBase = h * headDim * cols;
+			qData.set(src.subarray(srcBase, srcBase + headDim * cols), dstBase);
+			gateData.set(src.subarray(srcBase + headDim * cols, srcBase + headBlock * cols), dstBase);
+		}
+		backboneWeights.set(qProjKey, {
+			data: qData,
+			shape: [halfRows, cols]
+		});
+		backboneWeights.set(attnGateKey, {
+			data: gateData,
+			shape: [halfRows, cols]
+		});
+	}
+	const normKeys = ["norm.weight"];
+	for (let i = 0; i < numLayers; i++) normKeys.push(`layers.${i}.input_layernorm.weight`, `layers.${i}.post_attention_layernorm.weight`, `layers.${i}.self_attn.q_norm.weight`, `layers.${i}.self_attn.k_norm.weight`);
+	for (const key of normKeys) {
+		const w = backboneWeights.get(key);
+		if (!w) throw new Error(`Gepard backbone is missing norm weight ${key}.`);
+		const data = w.data;
+		for (let j = 0; j < data.length; j++) data[j] += 1;
+	}
+	options.onProgress?.(65, 100, "Downloading NanoCodec decoder…");
+	const codecCacheDir = options.cacheDir ? `${options.cacheDir}/nanocodec-21_5fps` : void 0;
+	const codecBuf = await fetchBinary(codecURL, "model.safetensors", options.hfToken, (loaded, total) => options.onProgress?.(65 + loaded / (total || 1) * 30, 100, "codec weights"), codecCacheDir);
+	const codecFile = parseSafetensorsHeader(codecBuf);
+	const codecRaw = /* @__PURE__ */ new Map();
+	for (const entry of codecFile.entries) {
+		if (!entry.name.startsWith("audio_decoder.")) continue;
+		codecRaw.set(entry.name, {
+			data: toF32(entry, codecBuf, codecFile),
+			shape: entry.shape
+		});
+	}
+	const codecWeights = buildKaniCodecWeights(codecRaw);
+	options.onProgress?.(100, 100, "Gepard TTS loaded.");
+	return {
+		backboneWeights,
+		overlayWeights,
+		embedTokensBF16,
+		codecWeights,
+		tokenizer,
+		rawConfig,
+		gepardConfig
+	};
+}
 const OUTETTS_DEFAULT_REPO = "OuteAI/OuteTTS-1.0-0.6B";
 /** Parse a folded DAC safetensors buffer into a canonical-name weight map (F32 only). */
 function parseFoldedDacSafetensors(buf) {
@@ -18510,5 +19285,5 @@ function selectGraphWeights(graph, weights) {
 }
 
 //#endregion
-export { createUniformBuffer as C, verifyGPU as D, initGPU as E, createStorageBuffer as S, getOrCreatePipeline as T, splitFusedQGateDelta as _, loadModel as a, clearPipelineCache as b, loadParlerTTS as c, remapPrunedToken as d, Tokenizer as f, fetchAdapter as g, buildLoRADeltas as h, loadKaniTTS as i, quantizeBackboneInt4 as l, applyLoRAToStore as m, MoonshineEncoderExecutor as n, loadMoonshine as o, Executor as p, createKeyMapperForArch as r, loadOuteTTS as s, MoonshineSTT as t, quantizeKaniBackbone as u, KERNEL_REGISTRY as v, destroyBuffers as w, createBindGroup as x, MATMUL_BIAS_F16C_SPEC as y };
-//# sourceMappingURL=moonshine-stt-B1kV5n1c.mjs.map
+export { createStorageBuffer as C, initGPU as D, getOrCreatePipeline as E, verifyGPU as O, createBindGroup as S, destroyBuffers as T, fetchAdapter as _, loadKaniTTS as a, MATMUL_BIAS_F16C_SPEC as b, loadOuteTTS as c, quantizeKaniBackbone as d, remapPrunedToken as f, buildLoRADeltas as g, applyLoRAToStore as h, loadGepardTTS as i, loadParlerTTS as l, Executor as m, MoonshineEncoderExecutor as n, loadModel as o, Tokenizer as p, createKeyMapperForArch as r, loadMoonshine as s, MoonshineSTT as t, quantizeBackboneInt4 as u, splitFusedQGateDelta as v, createUniformBuffer as w, clearPipelineCache as x, KERNEL_REGISTRY as y };
+//# sourceMappingURL=moonshine-stt-COJeK2Zb.mjs.map