@tryhamster/gerbil 1.10.1 → 1.11.0

package/dist/{gpu-B1xk3xOJ.mjs → gpu-CzgbyVeq.mjs}

@@ -1,6 +1,6 @@
 import { i as resolveDefaultRepo, n as OUTETTS_ASSETS, r as OUTETTS_PRESET_VOICES, t as DEFAULT_MODELS } from "./defaults-C_bJK9zs.mjs";
-import { E as GEMMA4_VIS_KEYS, S as DEFAULT_GROUP_SIZE, T as DTYPE_BYTES, _ as kaniCosTensor, c as KANI_END_OF_HUMAN, d as buildKaniLayerCosSin, f as computeKaniPositions, g as kaniAttentionLayerIndices, h as generateNanoCodecDecoderGraph, l as KANI_START_OF_HUMAN, m as generateKaniTtsGraph, u as audioTokensToCodes, v as kaniLayerAlpha, w as CANONICAL_KEYS, x as parseKaniConfig, y as kaniSinTensor } from "./architectures-BHkqQ9xp.mjs";
-import { C as destroyBuffers, E as verifyGPU, S as createUniformBuffer, T as initGPU, _ as KERNEL_REGISTRY, a as loadModel, b as createBindGroup, c as loadParlerTTS, d as remapPrunedToken, g as Executor, h as fetchAdapter, i as loadKaniTTS, l as quantizeBackboneInt4, m as buildLoRADeltas, r as createKeyMapperForArch, s as loadOuteTTS, u as quantizeKaniBackbone, v as MATMUL_BIAS_F16C_SPEC, w as getOrCreatePipeline, x as createStorageBuffer, y as clearPipelineCache } from "./moonshine-stt-BKeD6OYF.mjs";
+import { A as kaniSinTensor, C as computeKaniPositions, D as kaniAttentionLayerIndices, E as generateNanoCodecDecoderGraph, F as CANONICAL_KEYS, I as DTYPE_BYTES, L as GEMMA4_VIS_KEYS, M as parseKaniConfig, N as DEFAULT_GROUP_SIZE, O as kaniCosTensor, S as buildKaniLayerCosSin, T as generateKaniTtsGraph, a as PARLER_DAC_LATENT_DIM, b as KANI_START_OF_HUMAN, c as PARLER_SAMPLE_RATE, d as generateParlerEncoderGraph, f as parseParlerConfig, i as PARLER_DAC_DECODER_DIM, k as kaniLayerAlpha, l as buildT5RelativeBias, o as PARLER_DECODER_RATES, p as revertDelayPattern, r as PARLER_BOS_TOKEN_ID, s as PARLER_EOS_TOKEN_ID, u as generateParlerDecoderGraph, x as audioTokensToCodes, y as KANI_END_OF_HUMAN } from "./architectures-DmZMEFsA.mjs";
+import { C as destroyBuffers, E as verifyGPU, S as createUniformBuffer, T as initGPU, _ as KERNEL_REGISTRY, a as loadModel, b as createBindGroup, c as loadParlerTTS, d as remapPrunedToken, g as Executor, h as fetchAdapter, i as loadKaniTTS, l as quantizeBackboneInt4, m as buildLoRADeltas, r as createKeyMapperForArch, s as loadOuteTTS, u as quantizeKaniBackbone, v as MATMUL_BIAS_F16C_SPEC, w as getOrCreatePipeline, x as createStorageBuffer, y as clearPipelineCache } from "./moonshine-stt-CgDXoLFd.mjs";
 
 //#region src/gpu/architectures/gemma4_vision.ts
 /**
@@ -806,7 +806,7 @@ function nucleusSample$1(probs, ids, topP) {
 * In-place top-k filter over a probability array: keep only the `k` highest, zero
 * the rest, and renormalize. No-op when k <= 0 or k >= length (keep everything).
 */
-function applyTopK$1(scores, k) {
+function applyTopK(scores, k) {
 	const n = scores.length;
 	if (k <= 0 || k >= n) return;
 	const order = Array.from({ length: n }, (_, i) => i).sort((a, b) => scores[b] - scores[a]);
@@ -1065,7 +1065,7 @@ var KaniTTS = class KaniTTS {
 			scores[i] = s / p.temperature;
 		}
 		softmaxInPlace$1(scores);
-		applyTopK$1(scores, p.topK);
+		applyTopK(scores, p.topK);
 		return nucleusSample$1(scores, ids, p.topP);
 	}
 	/**
@@ -2880,16 +2880,6 @@ function softmaxInPlace(scores) {
 	}
 	for (let i = 0; i < scores.length; i++) scores[i] /= sum;
 }
-/** In-place top-k filter: keep the k highest, zero the rest, renormalize. */
-function applyTopK(scores, k) {
-	const n = scores.length;
-	if (k <= 0 || k >= n) return;
-	const order = Array.from({ length: n }, (_, i) => i).sort((a, b) => scores[b] - scores[a]);
-	let keepSum = 0;
-	for (let r = 0; r < k; r++) keepSum += scores[order[r]];
-	for (let r = k; r < n; r++) scores[order[r]] = 0;
-	if (keepSum > 0) for (let i = 0; i < n; i++) scores[i] /= keepSum;
-}
 /** Top-p nucleus sample from a softmaxed prob array over `ids`. */
 function nucleusSample(probs, ids, topP) {
 	const n = probs.length;
@@ -2913,6 +2903,81 @@ function nucleusSample(probs, ids, topP) {
 	return ids[order[0]];
 }
 /**
+* Select the `k` highest-scoring token ids in a single O(n·logk) pass (bounded
+* min-heap), applying the repetition penalty to `previous` tokens inline so a
+* penalized token can drop out of the shortlist. Returns the kept ids and their
+* (penalized, pre-temperature) logits, unsorted.
+*
+* This replaces the two full-vocab `Array.from(...).sort(...)` passes the sampler
+* ran PER TOKEN over OuteTTS's ~157k vocab (the top-k filter + the nucleus sort):
+* a codec-LM emits hundreds-to-thousands of tokens per utterance, so those two
+* O(n·logn) sorts — plus their two fresh 157k-element allocations every step —
+* dominated host-side decode and made the browser SPEECH tab look stalled
+* ("SYNTHESIZING…" for minutes). Restricting the softmax + nucleus to the kept
+* top-k is distribution-identical to the old full-vocab path (softmax is
+* monotonic and the discarded tail is renormalized away either way).
+*/
+function selectTopKPenalized(logits, k, penalized, penalty) {
+	const n = logits.length;
+	const cap = Math.min(k, n);
+	const heapVal = new Float32Array(cap);
+	const heapId = new Int32Array(cap);
+	let size = 0;
+	const penalize = (i, v) => {
+		if (penalized?.has(i)) return v > 0 ? v / penalty : v * penalty;
+		return v;
+	};
+	const siftDown$1 = () => {
+		let root = 0;
+		for (;;) {
+			let smallest = root;
+			const l = 2 * root + 1;
+			const r = 2 * root + 2;
+			if (l < size && heapVal[l] < heapVal[smallest]) smallest = l;
+			if (r < size && heapVal[r] < heapVal[smallest]) smallest = r;
+			if (smallest === root) break;
+			const tv = heapVal[root];
+			const ti = heapId[root];
+			heapVal[root] = heapVal[smallest];
+			heapId[root] = heapId[smallest];
+			heapVal[smallest] = tv;
+			heapId[smallest] = ti;
+			root = smallest;
+		}
+	};
+	const siftUp = (node0) => {
+		let node = node0;
+		while (node > 0) {
+			const parent = node - 1 >> 1;
+			if (heapVal[parent] <= heapVal[node]) break;
+			const tv = heapVal[node];
+			const ti = heapId[node];
+			heapVal[node] = heapVal[parent];
+			heapId[node] = heapId[parent];
+			heapVal[parent] = tv;
+			heapId[parent] = ti;
+			node = parent;
+		}
+	};
+	for (let i = 0; i < n; i++) {
+		const v = penalize(i, logits[i]);
+		if (size < cap) {
+			heapVal[size] = v;
+			heapId[size] = i;
+			size++;
+			siftUp(size - 1);
+		} else if (v > heapVal[0]) {
+			heapVal[0] = v;
+			heapId[0] = i;
+			siftDown$1();
+		}
+	}
+	return {
+		ids: heapId.subarray(0, size),
+		vals: heapVal.subarray(0, size)
+	};
+}
+/**
 * Resample interleaved-or-mono PCM to mono at `targetRate` via linear interpolation.
 * Audio is assumed already mono (Float32 [-1,1]); if `srcRate === targetRate` the
 * input is returned as-is. Linear resampling is sufficient for codec conditioning
@@ -3145,9 +3210,16 @@ var OuteTTS = class OuteTTS {
 	*/
 	sampleToken(logits, p) {
 		const n = logits.length;
+		const prev = p.repetitionPenalty !== 1 ? new Set(p.previous) : null;
+		if (p.topK > 0 && p.topK < n) {
+			const { ids: kIds, vals: kVals } = selectTopKPenalized(logits, p.topK, prev, p.repetitionPenalty);
+			const scores$1 = new Float32Array(kVals.length);
+			for (let i = 0; i < kVals.length; i++) scores$1[i] = kVals[i] / p.temperature;
+			softmaxInPlace(scores$1);
+			return nucleusSample(scores$1, Int32Array.from(kIds), p.topP);
+		}
 		const ids = new Int32Array(n);
 		const scores = new Float32Array(n);
-		const prev = p.repetitionPenalty !== 1 ? new Set(p.previous) : null;
 		for (let i = 0; i < n; i++) {
 			ids[i] = i;
 			let s = logits[i];
@@ -3155,7 +3227,6 @@ var OuteTTS = class OuteTTS {
 			scores[i] = s / p.temperature;
 		}
 		softmaxInPlace(scores);
-		applyTopK(scores, p.topK);
 		return nucleusSample(scores, ids, p.topP);
 	}
 	/**
@@ -3195,633 +3266,6 @@ var OuteTTS = class OuteTTS {
 	}
 };
 
-//#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
-	};
-}
-
 //#endregion
 //#region src/gpu/parler-tts.ts
 /**
@@ -3847,12 +3291,18 @@ function revertDelayPattern(delayed, numCodebooks, T) {
 *   4. Revert the delay pattern → [9, frames] code grid → shared DAC decode → 44.1 kHz
 *      PCM (tanh applied host-side).
 *
-* STATUS — FIRST IMPLEMENTATION. Typechecks + builds. The end-to-end run is GPU-
-* contended on the dev box, so coherence is pending a final reference check once the
-* GPU frees up (the T5 encoder cosine + a decoder forward should be diffed vs
-* transformers ParlerTTSForConditionalGeneration; see scripts/engine/parler-*-ref.py
-* stubs). The architecture, weight layout, tokenization, delay pattern, and DAC config
-* are all verified against the live config.json + safetensors header.
+* STATUS — WIRED + RUNS END-TO-END. Typechecks + builds, and the full pipeline runs
+* on Dawn (node): parler-tts/parler-tts-mini-v1 loads, the T5 encoder runs, the prompt
+* prefills, the 9-codebook delay-pattern AR loop decodes, and the shared DAC decoder
+* produces finite, non-silent, in-range 44.1 kHz PCM (verified via
+* scripts/engine/test-parler-speak.mjs). Reached from the high-level engine through
+* `g.speak(text, { model: DEFAULT_MODELS.ttsParler, describeVoice })`, which routes
+* Parler repos here directly (bypassing the single-graph text loader, the same way
+* MoonshineSTT is reached for STT). A bit-exact reference diff vs transformers
+* ParlerTTSForConditionalGeneration (T5 encoder cosine + a decoder forward; see
+* scripts/engine/parler-*-ref.py stubs) remains as a follow-up for numerical parity.
+* The architecture, weight layout, tokenization, delay pattern, and DAC config are all
+* verified against the live config.json + safetensors header.
 */
 const MAP_MODE_READ$1 = 1;
 /** Default voice description when the caller doesn't supply one. */
@@ -7272,4 +6722,4 @@ var WebGPUEngine = class WebGPUEngine {
 
 //#endregion
 export { dequantizeGemma4VisionProjection as A, audioTokensToDacCodes as C, parseOuteTtsConfig as D, generateOuteTtsBackboneGraph as E, generateGemma4VisionGraph as M, patchGemma4VisionClips as N, KaniTTS as O, resolveGemma4VisionInfo as P, loadOuteSpeaker as S, generateDacSpeechDecoderGraph as T, smartResize as _, buildGemma4PosEmbeds as a, OuteTTS as b, buildMRoPECosSin as c, buildPositionIds as d, buildRotaryCosSin as f, preprocessImageGemma4 as g, preprocessImage as h, buildGemma4PoolMatrix as i, dequantizeMLXProjection as j, generateQwen3_5VisionGraph as k, buildMRoPEPositionIds as l, mropeFreqDims as m, GEMMA4_IMAGE_PROCESSOR as n, buildGemma4RotaryCosSin as o, buildVisionPositionTensors as p, QWEN3_5_IMAGE_PROCESSOR as r, buildGemma4VisionPositionTensors as s, WebGPUEngine as t, buildPosEmbeds as u, VisionExecutor as v, dacOutputLength as w, buildOutePromptString as x, ParlerTTS as y };
-//# sourceMappingURL=gpu-B1xk3xOJ.mjs.map
+//# sourceMappingURL=gpu-CzgbyVeq.mjs.map