@tryhamster/gerbil 1.10.2 → 1.11.1

package/dist/{architectures-BHkqQ9xp.mjs → architectures-DmZMEFsA.mjs}

@@ -3630,7 +3630,7 @@ function convOutLen(L, K, stride, pad = 0, dilation = 1) {
 function moonshineEncoderFrames(nSamples) {
 	return convOutLen(convOutLen(convOutLen(nSamples, 127, 64), 7, 3), 3, 2);
 }
-function baseConfig(d, layers) {
+function baseConfig$1(d, layers) {
 	return {
 		hidden_size: d.hidden_size,
 		num_layers: layers,
@@ -3649,7 +3649,7 @@ function baseConfig(d, layers) {
 		has_vision_tower: false
 	};
 }
-const CAPS = {
+const CAPS$1 = {
 	text: true,
 	vision: false,
 	moe: false
@@ -3989,8 +3989,8 @@ function generateMoonshineEncoderGraph(raw, nSamples) {
 	}
 	return {
 		architecture: "MoonshineEncoder",
-		config: baseConfig(d, d.enc_layers),
-		capabilities: CAPS,
+		config: baseConfig$1(d, d.enc_layers),
+		capabilities: CAPS$1,
 		tensors,
 		nodes,
 		executionOrder,
@@ -4565,8 +4565,8 @@ function generateMoonshineDecoderGraph(raw, sEnc) {
 	});
 	return {
 		architecture: "MoonshineDecoder",
-		config: baseConfig(d, d.dec_layers),
-		capabilities: CAPS,
+		config: baseConfig$1(d, d.dec_layers),
+		capabilities: CAPS$1,
 		tensors,
 		nodes,
 		executionOrder,
@@ -4584,6 +4584,648 @@ function generateMoonshineGraph() {
 	throw new Error("Moonshine is an encoder-decoder STT model and is not loadable via the single-graph generate() path. Use the dedicated STT engine instead:\n  import { MoonshineSTT } from '@tryhamster/gerbil';\n  const stt = await MoonshineSTT.create();\n  const { text } = await stt.transcribe(pcm16kMonoFloat32);");
 }
 
+//#endregion
+//#region src/gpu/architectures/parler.ts
+const PARLER_SAMPLE_RATE = 44100;
+const PARLER_NUM_CODEBOOKS = 9;
+const PARLER_DECODER_RATES = [
+	8,
+	8,
+	4,
+	2
+];
+const PARLER_DAC_LATENT_DIM = 1024;
+const PARLER_DAC_DECODER_DIM = 1536;
+/** Decoder audio-vocab: 1024 codes + eos(1024)+bos(1025)+pad(1024); lm_head vocab. */
+const PARLER_AUDIO_VOCAB = 1088;
+const PARLER_BOS_TOKEN_ID = 1025;
+const PARLER_EOS_TOKEN_ID = 1024;
+const PARLER_PAD_TOKEN_ID = 1024;
+const CAPS = {
+	text: true,
+	vision: false,
+	moe: false
+};
+/** Pull Parler dims from the (nested) HF config. */
+function parseParlerConfig(raw) {
+	const te = raw.text_encoder ?? {};
+	const dec = raw.decoder ?? {};
+	const enc_heads = te.num_heads ?? 16;
+	const enc_d_model = te.d_model ?? 1024;
+	const dec_heads = dec.num_attention_heads ?? 16;
+	return {
+		enc_d_model,
+		enc_layers: te.num_layers ?? 24,
+		enc_heads,
+		enc_d_kv: te.d_kv ?? Math.floor(enc_d_model / enc_heads),
+		enc_d_ff: te.d_ff ?? 2816,
+		enc_vocab: te.vocab_size ?? 32128,
+		rel_num_buckets: te.relative_attention_num_buckets ?? 32,
+		rel_max_distance: te.relative_attention_max_distance ?? 128,
+		ln_eps: te.layer_norm_epsilon ?? 1e-6,
+		dec_hidden: dec.hidden_size ?? 1024,
+		dec_layers: dec.num_hidden_layers ?? 24,
+		dec_heads,
+		dec_kv_heads: dec.num_key_value_heads ?? dec_heads,
+		dec_ffn: dec.ffn_dim ?? 4096,
+		num_codebooks: dec.num_codebooks ?? PARLER_NUM_CODEBOOKS,
+		audio_vocab: dec.vocab_size ?? PARLER_AUDIO_VOCAB,
+		embed_vocab: (dec.vocab_size ?? PARLER_AUDIO_VOCAB) + 1,
+		max_position: dec.max_position_embeddings ?? 4096,
+		bos_token_id: dec.bos_token_id ?? PARLER_BOS_TOKEN_ID,
+		eos_token_id: dec.eos_token_id ?? PARLER_EOS_TOKEN_ID,
+		pad_token_id: dec.pad_token_id ?? PARLER_PAD_TOKEN_ID
+	};
+}
+function baseConfig(c, hidden, heads, layers) {
+	return {
+		hidden_size: hidden,
+		num_layers: layers,
+		num_heads: heads,
+		num_kv_heads: heads,
+		head_dim: Math.floor(hidden / heads),
+		intermediate_size: c.dec_ffn,
+		vocab_size: c.audio_vocab,
+		context_length: c.max_position,
+		rms_norm_eps: c.ln_eps,
+		norm_type: "layernorm",
+		rope_base: 0,
+		rope_dim: 0,
+		kv_layout: "LHSd",
+		is_moe: false,
+		has_vision_tower: false
+	};
+}
+/**
+* T5's bidirectional relative-position bucket (verbatim port of
+* transformers' T5Attention._relative_position_bucket, bidirectional=True).
+* Maps a signed relative position (key − query) to a bucket id in [0, num_buckets).
+*/
+function relativePositionBucket(relativePosition, numBuckets, maxDistance) {
+	let bucket = 0;
+	let n = relativePosition;
+	const halfBuckets = Math.floor(numBuckets / 2);
+	if (n > 0) bucket += halfBuckets;
+	else n = -n;
+	const maxExact = Math.floor(halfBuckets / 2);
+	const isSmall = n < maxExact;
+	let largeVal = maxExact + Math.floor(Math.log(n / maxExact) / Math.log(maxDistance / maxExact) * (halfBuckets - maxExact));
+	largeVal = Math.min(largeVal, halfBuckets - 1);
+	bucket += isSmall ? n : largeVal;
+	return bucket;
+}
+/**
+* Build the dense per-head relative-position bias B[head, q, k] = bias_table[bucket(k-q), head]
+* for a length-S encoder sequence. `biasTable` is the learned
+* relative_attention_bias.weight, row-major [num_buckets, num_heads].
+* Returns a flat Float32Array of length num_heads*S*S (head-major, then q, then k).
+*/
+function buildT5RelativeBias(biasTable, numBuckets, maxDistance, numHeads, S) {
+	const out = new Float32Array(numHeads * S * S);
+	const buckets = new Int32Array(S * S);
+	for (let q = 0; q < S; q++) for (let k = 0; k < S; k++) buckets[q * S + k] = relativePositionBucket(k - q, numBuckets, maxDistance);
+	for (let h = 0; h < numHeads; h++) {
+		const headBase = h * S * S;
+		for (let q = 0; q < S; q++) for (let k = 0; k < S; k++) {
+			const bucket = buckets[q * S + k];
+			out[headBase + q * S + k] = biasTable[bucket * numHeads + h];
+		}
+	}
+	return out;
+}
+/**
+* Build the T5 encoder graph for a concrete description length S. The relative
+* bias `t5_rel_bias` enters as a host-written activation [num_heads, S, S]. Like
+* Moonshine, the graph also pre-projects encoder_out through every decoder layer's
+* encoder_attn.k/v_proj → enc_k_layer{i}/enc_v_layer{i} (frozen cross-attn K/V).
+*/
+function generateParlerEncoderGraph(raw, sDesc) {
+	const c = parseParlerConfig(raw);
+	const H = c.enc_d_model;
+	const innerDim = c.enc_heads * c.enc_d_kv;
+	const tensors = {};
+	const nodes = [];
+	const executionOrder = [];
+	const addTensor = (t) => {
+		tensors[t.name] = t;
+	};
+	const addNode = (n) => {
+		nodes.push(n);
+		executionOrder.push(n.id);
+	};
+	const w = (name, shape) => addTensor({
+		name,
+		shape,
+		dtype: "f32",
+		storage: "constant",
+		safetensorsKey: name
+	});
+	const act = (name, shape) => addTensor({
+		name,
+		shape,
+		dtype: "f32",
+		storage: "activation"
+	});
+	const linear = (id, inp, weight, out, K, N) => {
+		w(weight, [N, K]);
+		addNode({
+			id,
+			opType: "MatMul",
+			inputs: [inp, weight],
+			outputs: [out],
+			attributes: {
+				M_tensor: inp,
+				K,
+				N
+			}
+		});
+	};
+	const t5norm = (id, inp, weight, out) => {
+		w(weight, [H]);
+		act(out, [sDesc, H]);
+		addNode({
+			id,
+			opType: "RMSNorm",
+			inputs: [inp, weight],
+			outputs: [out],
+			attributes: {
+				hidden_size: H,
+				eps: c.ln_eps,
+				seq_len_tensor: inp
+			}
+		});
+	};
+	addTensor({
+		name: "input_ids",
+		shape: ["T"],
+		dtype: "u32",
+		storage: "activation"
+	});
+	addTensor({
+		name: "text_encoder.shared.weight",
+		shape: [c.enc_vocab, H],
+		dtype: "f32",
+		storage: "constant",
+		safetensorsKey: "text_encoder.shared.weight"
+	});
+	act("enc_embed", [sDesc, H]);
+	addNode({
+		id: "enc_embed",
+		opType: "Embedding",
+		inputs: ["input_ids", "text_encoder.shared.weight"],
+		outputs: ["enc_embed"],
+		attributes: {
+			vocab_size: c.enc_vocab,
+			hidden_size: H
+		}
+	});
+	addTensor({
+		name: "t5_rel_bias",
+		shape: [
+			c.enc_heads,
+			sDesc,
+			sDesc
+		],
+		dtype: "f32",
+		storage: "activation"
+	});
+	let prev = "enc_embed";
+	for (let i = 0; i < c.enc_layers; i++) {
+		const p = `enc${i}`;
+		const k = (s) => `text_encoder.encoder.block.${i}.${s}`;
+		t5norm(`${p}_norm0`, prev, k("layer.0.layer_norm.weight"), `${p}_n0`);
+		act(`${p}_q`, [sDesc, innerDim]);
+		act(`${p}_k`, [sDesc, innerDim]);
+		act(`${p}_v`, [sDesc, innerDim]);
+		linear(`${p}_qp`, `${p}_n0`, k("layer.0.SelfAttention.q.weight"), `${p}_q`, H, innerDim);
+		linear(`${p}_kp`, `${p}_n0`, k("layer.0.SelfAttention.k.weight"), `${p}_k`, H, innerDim);
+		linear(`${p}_vp`, `${p}_n0`, k("layer.0.SelfAttention.v.weight"), `${p}_v`, H, innerDim);
+		act(`${p}_attn`, [sDesc, innerDim]);
+		addNode({
+			id: `${p}_sa`,
+			opType: "T5Attention",
+			inputs: [
+				`${p}_q`,
+				`${p}_k`,
+				`${p}_v`,
+				"t5_rel_bias"
+			],
+			outputs: [`${p}_attn`],
+			attributes: {
+				num_heads: c.enc_heads,
+				head_dim: c.enc_d_kv,
+				S: sDesc
+			}
+		});
+		act(`${p}_o`, [sDesc, H]);
+		linear(`${p}_op`, `${p}_attn`, k("layer.0.SelfAttention.o.weight"), `${p}_o`, innerDim, H);
+		act(`${p}_res0`, [sDesc, H]);
+		addNode({
+			id: `${p}_add0`,
+			opType: "Add",
+			inputs: [prev, `${p}_o`],
+			outputs: [`${p}_res0`],
+			attributes: {
+				count_tensor: prev,
+				hidden_size: H
+			}
+		});
+		t5norm(`${p}_norm1`, `${p}_res0`, k("layer.1.layer_norm.weight"), `${p}_n1`);
+		act(`${p}_wi0`, [sDesc, c.enc_d_ff]);
+		act(`${p}_wi1`, [sDesc, c.enc_d_ff]);
+		linear(`${p}_wi0p`, `${p}_n1`, k("layer.1.DenseReluDense.wi_0.weight"), `${p}_wi0`, H, c.enc_d_ff);
+		linear(`${p}_wi1p`, `${p}_n1`, k("layer.1.DenseReluDense.wi_1.weight"), `${p}_wi1`, H, c.enc_d_ff);
+		act(`${p}_gelu`, [sDesc, c.enc_d_ff]);
+		addNode({
+			id: `${p}_act`,
+			opType: "GELU",
+			inputs: [`${p}_wi0`],
+			outputs: [`${p}_gelu`],
+			attributes: { count_tensor: `${p}_wi0` }
+		});
+		act(`${p}_gated`, [sDesc, c.enc_d_ff]);
+		addNode({
+			id: `${p}_gate`,
+			opType: "Mul",
+			inputs: [`${p}_gelu`, `${p}_wi1`],
+			outputs: [`${p}_gated`],
+			attributes: {
+				count_tensor: `${p}_gelu`,
+				hidden_size: c.enc_d_ff
+			}
+		});
+		act(`${p}_wo`, [sDesc, H]);
+		linear(`${p}_wop`, `${p}_gated`, k("layer.1.DenseReluDense.wo.weight"), `${p}_wo`, c.enc_d_ff, H);
+		act(`${p}_res1`, [sDesc, H]);
+		addNode({
+			id: `${p}_add1`,
+			opType: "Add",
+			inputs: [`${p}_res0`, `${p}_wo`],
+			outputs: [`${p}_res1`],
+			attributes: {
+				count_tensor: `${p}_res0`,
+				hidden_size: H
+			}
+		});
+		prev = `${p}_res1`;
+	}
+	w("text_encoder.encoder.final_layer_norm.weight", [H]);
+	act("encoder_out", [sDesc, H]);
+	addNode({
+		id: "enc_final_norm",
+		opType: "RMSNorm",
+		inputs: [prev, "text_encoder.encoder.final_layer_norm.weight"],
+		outputs: ["encoder_out"],
+		attributes: {
+			hidden_size: H,
+			eps: c.ln_eps,
+			seq_len_tensor: prev
+		}
+	});
+	const outputs = ["encoder_out"];
+	for (let i = 0; i < c.dec_layers; i++) {
+		const kw = `decoder.model.decoder.layers.${i}.encoder_attn.k_proj.weight`;
+		const vw = `decoder.model.decoder.layers.${i}.encoder_attn.v_proj.weight`;
+		w(kw, [H, H]);
+		w(vw, [H, H]);
+		const encK = `enc_k_layer${i}`;
+		const encV = `enc_v_layer${i}`;
+		act(encK, [sDesc, H]);
+		act(encV, [sDesc, H]);
+		addNode({
+			id: `enc_kproj${i}`,
+			opType: "MatMul",
+			inputs: ["encoder_out", kw],
+			outputs: [encK],
+			attributes: {
+				M_tensor: "encoder_out",
+				K: H,
+				N: H
+			}
+		});
+		addNode({
+			id: `enc_vproj${i}`,
+			opType: "MatMul",
+			inputs: ["encoder_out", vw],
+			outputs: [encV],
+			attributes: {
+				M_tensor: "encoder_out",
+				K: H,
+				N: H
+			}
+		});
+		outputs.push(encK, encV);
+	}
+	return {
+		architecture: "ParlerTextEncoder",
+		config: baseConfig(c, H, c.enc_heads, c.enc_layers),
+		capabilities: CAPS,
+		tensors,
+		nodes,
+		executionOrder,
+		inputs: ["input_ids", "t5_rel_bias"],
+		outputs
+	};
+}
+/**
+* Build the Parler decoder graph for a single decode step (T=1). The host supplies:
+*   - `dec_input_embed` [1, H]: the SUMMED 9-codebook embedding of the current step's
+*     codes PLUS the sinusoidal position (computed host-side from embed_tokens +
+*     embed_positions, since the 9-way embedding sum is cheap on the host and avoids
+*     9 Embedding ops + an Add tree per step).
+*   - `enc_k_layer{i}` / `enc_v_layer{i}`: frozen cross-attn K/V from the encoder.
+* Output: 9 logit rows `logits_cb{c}` [1, audio_vocab] (one per codebook head).
+*
+* The prompt prefix (transcript) is handled by prefilling its embeddings through the
+* SAME graph before audio decode begins (the driver feeds the prompt rows first, with
+* their sinusoidal positions, so the self-attn KV-cache holds [prompt ++ audio]).
+*/
+function generateParlerDecoderGraph(raw, sEnc) {
+	const c = parseParlerConfig(raw);
+	const H = c.dec_hidden;
+	const heads = c.dec_heads;
+	const headDim = Math.floor(H / heads);
+	const tensors = {};
+	const nodes = [];
+	const executionOrder = [];
+	const addTensor = (t) => {
+		tensors[t.name] = t;
+	};
+	const addNode = (n) => {
+		nodes.push(n);
+		executionOrder.push(n.id);
+	};
+	const w = (name, shape) => addTensor({
+		name,
+		shape,
+		dtype: "f32",
+		storage: "constant",
+		safetensorsKey: name
+	});
+	const act = (name, shape) => addTensor({
+		name,
+		shape,
+		dtype: "f32",
+		storage: "activation"
+	});
+	const linear = (id, inp, weight, out, K, N) => {
+		w(weight, [N, K]);
+		addNode({
+			id,
+			opType: "MatMul",
+			inputs: [inp, weight],
+			outputs: [out],
+			attributes: {
+				M_tensor: inp,
+				K,
+				N
+			}
+		});
+	};
+	const layernorm = (id, inp, prefix, out) => {
+		w(`${prefix}.weight`, [H]);
+		w(`${prefix}.bias`, [H]);
+		act(out, ["T", H]);
+		addNode({
+			id,
+			opType: "LayerNorm",
+			inputs: [
+				inp,
+				`${prefix}.weight`,
+				`${prefix}.bias`
+			],
+			outputs: [out],
+			attributes: {
+				hidden_size: H,
+				eps: c.ln_eps,
+				seq_len_tensor: inp,
+				has_bias: true
+			}
+		});
+	};
+	const inputs = ["dec_input_embed"];
+	addTensor({
+		name: "dec_input_embed",
+		shape: ["T", H],
+		dtype: "f32",
+		storage: "activation"
+	});
+	let prev = "dec_input_embed";
+	for (let i = 0; i < c.dec_layers; i++) {
+		const p = `dec${i}`;
+		const lk = `decoder.model.decoder.layers.${i}`;
+		layernorm(`${p}_n1`, prev, `${lk}.self_attn_layer_norm`, `${p}_ln1`);
+		act(`${p}_q`, ["T", H]);
+		act(`${p}_k`, ["T", H]);
+		act(`${p}_v`, ["T", H]);
+		linear(`${p}_qp`, `${p}_ln1`, `${lk}.self_attn.q_proj.weight`, `${p}_q`, H, H);
+		linear(`${p}_kp`, `${p}_ln1`, `${lk}.self_attn.k_proj.weight`, `${p}_k`, H, H);
+		linear(`${p}_vp`, `${p}_ln1`, `${lk}.self_attn.v_proj.weight`, `${p}_v`, H, H);
+		addTensor({
+			name: `${p}_kcache`,
+			shape: ["L_max", H],
+			dtype: "f32",
+			storage: "kv_cache"
+		});
+		addTensor({
+			name: `${p}_vcache`,
+			shape: ["L_max", H],
+			dtype: "f32",
+			storage: "kv_cache"
+		});
+		addNode({
+			id: `${p}_kappend`,
+			opType: "KVCacheAppend",
+			inputs: [`${p}_k`],
+			outputs: [`${p}_kcache`],
+			attributes: {
+				width: H,
+				T_tensor: `${p}_k`
+			}
+		});
+		addNode({
+			id: `${p}_vappend`,
+			opType: "KVCacheAppend",
+			inputs: [`${p}_v`],
+			outputs: [`${p}_vcache`],
+			attributes: {
+				width: H,
+				T_tensor: `${p}_v`
+			}
+		});
+		act(`${p}_sa`, ["T", H]);
+		addNode({
+			id: `${p}_self_attn`,
+			opType: "Attention",
+			inputs: [
+				`${p}_q`,
+				`${p}_kcache`,
+				`${p}_vcache`
+			],
+			outputs: [`${p}_sa`],
+			attributes: {
+				hidden_size: H,
+				num_q_heads: heads,
+				num_kv_heads: c.dec_kv_heads,
+				head_dim: headDim,
+				causal: true,
+				layer_index: i
+			}
+		});
+		act(`${p}_sao`, ["T", H]);
+		linear(`${p}_sap`, `${p}_sa`, `${lk}.self_attn.out_proj.weight`, `${p}_sao`, H, H);
+		act(`${p}_res1`, ["T", H]);
+		addNode({
+			id: `${p}_add1`,
+			opType: "Add",
+			inputs: [prev, `${p}_sao`],
+			outputs: [`${p}_res1`],
+			attributes: {
+				count_tensor: prev,
+				hidden_size: H
+			}
+		});
+		layernorm(`${p}_n2`, `${p}_res1`, `${lk}.encoder_attn_layer_norm`, `${p}_ln2`);
+		act(`${p}_cq`, ["T", H]);
+		linear(`${p}_cqp`, `${p}_ln2`, `${lk}.encoder_attn.q_proj.weight`, `${p}_cq`, H, H);
+		const encK = `enc_k_layer${i}`;
+		const encV = `enc_v_layer${i}`;
+		act(encK, [sEnc, H]);
+		act(encV, [sEnc, H]);
+		inputs.push(encK, encV);
+		act(`${p}_ca`, ["T", H]);
+		addNode({
+			id: `${p}_cross_attn`,
+			opType: "CrossAttention",
+			inputs: [
+				`${p}_cq`,
+				encK,
+				encV
+			],
+			outputs: [`${p}_ca`],
+			attributes: {
+				num_q_heads: heads,
+				num_kv_heads: c.dec_kv_heads,
+				head_dim: headDim
+			}
+		});
+		act(`${p}_cao`, ["T", H]);
+		linear(`${p}_cap`, `${p}_ca`, `${lk}.encoder_attn.out_proj.weight`, `${p}_cao`, H, H);
+		act(`${p}_res2`, ["T", H]);
+		addNode({
+			id: `${p}_add2`,
+			opType: "Add",
+			inputs: [`${p}_res1`, `${p}_cao`],
+			outputs: [`${p}_res2`],
+			attributes: {
+				count_tensor: `${p}_res1`,
+				hidden_size: H
+			}
+		});
+		layernorm(`${p}_n3`, `${p}_res2`, `${lk}.final_layer_norm`, `${p}_ln3`);
+		act(`${p}_fc1`, ["T", c.dec_ffn]);
+		linear(`${p}_fc1p`, `${p}_ln3`, `${lk}.fc1.weight`, `${p}_fc1`, H, c.dec_ffn);
+		act(`${p}_gelu`, ["T", c.dec_ffn]);
+		addNode({
+			id: `${p}_act`,
+			opType: "GeluErf",
+			inputs: [`${p}_fc1`],
+			outputs: [`${p}_gelu`],
+			attributes: { count_tensor: `${p}_fc1` }
+		});
+		act(`${p}_fc2`, ["T", H]);
+		linear(`${p}_fc2p`, `${p}_gelu`, `${lk}.fc2.weight`, `${p}_fc2`, c.dec_ffn, H);
+		act(`${p}_res3`, ["T", H]);
+		addNode({
+			id: `${p}_add3`,
+			opType: "Add",
+			inputs: [`${p}_res2`, `${p}_fc2`],
+			outputs: [`${p}_res3`],
+			attributes: {
+				count_tensor: `${p}_res2`,
+				hidden_size: H
+			}
+		});
+		prev = `${p}_res3`;
+	}
+	layernorm("dec_final_norm", prev, "decoder.model.decoder.layer_norm", "dec_normed");
+	act("dec_last", [1, H]);
+	addNode({
+		id: "slice_last",
+		opType: "SliceLastRow",
+		inputs: ["dec_normed"],
+		outputs: ["dec_last"],
+		attributes: { width: H }
+	});
+	const outputs = [];
+	for (let cb = 0; cb < c.num_codebooks; cb++) {
+		const headW = `decoder.lm_heads.${cb}.weight`;
+		w(headW, [c.audio_vocab, H]);
+		const logit = `logits_cb${cb}`;
+		act(logit, [1, c.audio_vocab]);
+		addNode({
+			id: `lm_head${cb}`,
+			opType: "MatMul",
+			inputs: ["dec_last", headW],
+			outputs: [logit],
+			attributes: {
+				M_tensor: "dec_last",
+				K: H,
+				N: c.audio_vocab
+			}
+		});
+		outputs.push(logit);
+	}
+	return {
+		architecture: "ParlerTTSDecoder",
+		config: baseConfig(c, H, heads, c.dec_layers),
+		capabilities: CAPS,
+		tensors,
+		nodes,
+		executionOrder,
+		inputs,
+		outputs
+	};
+}
+/**
+* Apply the Parler/MusicGen delay pattern to a [numCodebooks, T] code grid produced
+* by AR decode. During generation, codebook `i` is delayed by `i` steps: at decode
+* step t the model emits, for each codebook i, the code for ACOUSTIC frame (t − i).
+* To recover the aligned acoustic grid we simply read codebook i's stream starting
+* at offset i. This returns the de-delayed [numCodebooks, frames] grid (codebook-major)
+* ready for the DAC decoder, where frames = T − (numCodebooks − 1).
+*
+* `delayed` is codebook-major [numCodebooks, T] (delayed[i*T + t]).
+*/
+function revertDelayPattern(delayed, numCodebooks, T) {
+	const frames = T - (numCodebooks - 1);
+	if (frames <= 0) return {
+		codes: new Uint32Array(0),
+		frames: 0
+	};
+	const codes = new Uint32Array(numCodebooks * frames);
+	for (let i = 0; i < numCodebooks; i++) for (let f = 0; f < frames; f++) codes[i * frames + f] = delayed[i * T + (f + i)];
+	return {
+		codes,
+		frames
+	};
+}
+/**
+* Single-graph architecture entry for `ParlerTTSForConditionalGeneration`.
+*
+* Registering this in the architecture registry makes the loader RECOGNIZE the
+* Parler checkpoint (so `isArchitectureSupported` is true and the error is precise)
+* rather than reporting "Unsupported model architecture". Parler is an
+* encoder-decoder codec-LM (Flan-T5 encoder + AR decoder + DAC codec) that cannot
+* be expressed as one text graph, so — exactly like Moonshine STT — it is not
+* loadable through the single-graph `generate()` path; callers use the dedicated
+* ParlerTTS engine (or `g.speak(text, { model, describeVoice })`), which drives the
+* encoder/decoder/DAC graphs directly.
+*/
+function generateParlerGraph() {
+	throw new Error("Parler-TTS is an encoder-decoder (Flan-T5 + DAC) describe-your-voice TTS model and is not loadable via the single-graph generate() path. Use the dedicated TTS engine instead:\n  import { ParlerTTS } from '@tryhamster/gerbil';\n  const tts = await ParlerTTS.create();\n  const { pcm, sampleRate } = await tts.speak('Hello.', { describeVoice: 'a warm female voice' });\nor, from the high-level Gerbil class:\n  await g.speak('Hello.', { model: 'parler-tts/parler-tts-mini-v1', describeVoice: 'a warm female voice' });");
+}
+
 //#endregion
 //#region src/gpu/architectures/qwen2.ts
 function generateQwen2Graph(rawConfig, dtype, groupSizeOverride, _kvDtype, embedding) {
@@ -6097,7 +6739,8 @@ const ARCHITECTURES = {
 	Gemma3Model: generateGemma3EncoderGraph,
 	Gemma4ForConditionalGeneration: generateGemma4Graph,
 	MoonshineForConditionalGeneration: generateMoonshineGraph,
-	KaniTTS2ForCausalLM: generateKaniTtsGraph
+	KaniTTS2ForCausalLM: generateKaniTtsGraph,
+	ParlerTTSForConditionalGeneration: generateParlerGraph
 };
 /**
 * Look up and generate a ModelGraph for a given architecture string.
@@ -6123,5 +6766,5 @@ function isArchitectureSupported(name) {
 }
 
 //#endregion
-export { quantizeInt4 as C, createDefaultHFKeyMapper as D, GEMMA4_VIS_KEYS as E, DEFAULT_GROUP_SIZE as S, DTYPE_BYTES as T, kaniCosTensor as _, generateMoonshineEncoderGraph as a, nanoCodecWeightMap as b, KANI_END_OF_HUMAN as c, buildKaniLayerCosSin as d, computeKaniPositions as f, kaniAttentionLayerIndices as g, generateNanoCodecDecoderGraph as h, generateMoonshineDecoderGraph as i, KANI_START_OF_HUMAN as l, generateKaniTtsGraph as m, isArchitectureSupported as n, moonshineEncoderFrames as o, foldNanoCodecWeightNorm as p, MOONSHINE_REMAINING_WORK as r, parseMoonshineConfig as s, generateGraph as t, audioTokensToCodes as u, kaniLayerAlpha as v, CANONICAL_KEYS as w, parseKaniConfig as x, kaniSinTensor as y };
-//# sourceMappingURL=architectures-BHkqQ9xp.mjs.map
+export { kaniSinTensor as A, computeKaniPositions as C, kaniAttentionLayerIndices as D, generateNanoCodecDecoderGraph as E, CANONICAL_KEYS as F, DTYPE_BYTES as I, GEMMA4_VIS_KEYS as L, parseKaniConfig as M, DEFAULT_GROUP_SIZE as N, kaniCosTensor as O, quantizeInt4 as P, createDefaultHFKeyMapper as R, buildKaniLayerCosSin as S, generateKaniTtsGraph as T, moonshineEncoderFrames as _, PARLER_DAC_LATENT_DIM as a, KANI_START_OF_HUMAN as b, PARLER_SAMPLE_RATE as c, generateParlerEncoderGraph as d, parseParlerConfig as f, generateMoonshineEncoderGraph as g, generateMoonshineDecoderGraph as h, PARLER_DAC_DECODER_DIM as i, nanoCodecWeightMap as j, kaniLayerAlpha as k, buildT5RelativeBias as l, MOONSHINE_REMAINING_WORK as m, isArchitectureSupported as n, PARLER_DECODER_RATES as o, revertDelayPattern as p, PARLER_BOS_TOKEN_ID as r, PARLER_EOS_TOKEN_ID as s, generateGraph as t, generateParlerDecoderGraph as u, parseMoonshineConfig as v, foldNanoCodecWeightNorm as w, audioTokensToCodes as x, KANI_END_OF_HUMAN as y };
+//# sourceMappingURL=architectures-DmZMEFsA.mjs.map