@tryhamster/gerbil 1.3.1 → 1.4.0

package/dist/{gpu-BECDib8p.mjs → gpu-DbB321DN.mjs}

@@ -1,6 +1,6 @@
-import { i as resolveDefaultRepo, n as OUTETTS_ASSETS, r as OUTETTS_PRESET_VOICES, t as DEFAULT_MODELS } from "./defaults-CudhglS1.mjs";
+import { i as resolveDefaultRepo, n as OUTETTS_ASSETS, r as OUTETTS_PRESET_VOICES, t as DEFAULT_MODELS } from "./defaults-KnrRSIeJ.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-Ol7yUmKf.mjs";
-import { _ as destroyBuffers, b as verifyGPU, c as quantizeKaniBackbone, d as KERNEL_REGISTRY, f as MATMUL_BIAS_F16C_SPEC, g as createUniformBuffer, h as createStorageBuffer, i as loadModel, l as remapPrunedToken, m as createBindGroup, o as loadOuteTTS, p as clearPipelineCache, r as loadKaniTTS, s as quantizeBackboneInt4, u as Executor, v as getOrCreatePipeline, y as initGPU } from "./moonshine-stt-BO5gZ_D6.mjs";
+import { S as verifyGPU, _ as createStorageBuffer, b as getOrCreatePipeline, c as quantizeBackboneInt4, f as Executor, g as createBindGroup, h as clearPipelineCache, i as loadModel, l as quantizeKaniBackbone, m as MATMUL_BIAS_F16C_SPEC, o as loadOuteTTS, p as KERNEL_REGISTRY, r as loadKaniTTS, s as loadParlerTTS, u as remapPrunedToken, v as createUniformBuffer, x as initGPU, y as destroyBuffers } from "./moonshine-stt-BGmctcdO.mjs";
 
 //#region src/gpu/architectures/gemma4_vision.ts
 /**
@@ -767,7 +767,7 @@ const KANI_CODEC_LOOKBACK_FRAMES = 32;
 /** Hard cap so a stuck decode cannot loop forever (reference uses 3000). */
 const DEFAULT_MAX_NEW_TOKENS$1 = 3e3;
 /** Build a fresh map of just the constant weights a graph references (see moonshine-stt). */
-function selectGraphWeights$1(graph, weights) {
+function selectGraphWeights$2(graph, weights) {
 	const out = /* @__PURE__ */ new Map();
 	for (const [name, desc] of Object.entries(graph.tensors)) {
 		if (desc.storage !== "constant") continue;
@@ -795,10 +795,10 @@ function nucleusSample$1(probs, ids, topP) {
 	}
 	let keepSum = 0;
 	for (let r = 0; r < cutoff; r++) keepSum += probs[order[r]];
-	let pick = Math.random() * keepSum;
+	let pick$1 = Math.random() * keepSum;
 	for (let r = 0; r < cutoff; r++) {
-		pick -= probs[order[r]];
-		if (pick <= 0) return ids[order[r]];
+		pick$1 -= probs[order[r]];
+		if (pick$1 <= 0) return ids[order[r]];
 	}
 	return ids[order[0]];
 }
@@ -891,7 +891,7 @@ var KaniTTS = class KaniTTS {
 			maxSeqLen,
 			kvMode: "f32"
 		});
-		exec.uploadWeightsMap(selectGraphWeights$1(graph, loaded.backboneWeights));
+		exec.uploadWeightsMap(selectGraphWeights$2(graph, loaded.backboneWeights));
 		exec.initBindGroups();
 		return exec;
 	}
@@ -1105,7 +1105,7 @@ var KaniTTS = class KaniTTS {
 			kvMode: "f32"
 		});
 		try {
-			exec.uploadWeightsMap(selectGraphWeights$1(graph, this.loaded.codecWeights));
+			exec.uploadWeightsMap(selectGraphWeights$2(graph, this.loaded.codecWeights));
 			exec.initBindGroups();
 			exec.reset();
 			exec.writeInput("audio_codes", winCodes);
@@ -1212,6 +1212,10 @@ function dacKey(name) {
 }
 function generateDacSpeechDecoderGraph(opts) {
 	const T = opts.numFrames;
+	const NCB = opts.numCodebooks ?? DAC_NUM_CODEBOOKS;
+	const rates = opts.decoderRates ?? DAC_DECODER_RATES;
+	const decoderDim = opts.decoderDim ?? DAC_DECODER_DIM;
+	const latentDim = opts.latentDim ?? DAC_LATENT_DIM;
 	const tensors = {};
 	const nodes = [];
 	const executionOrder = [];
@@ -1224,14 +1228,14 @@ function generateDacSpeechDecoderGraph(opts) {
 	};
 	addTensor({
 		name: "audio_codes",
-		shape: [DAC_NUM_CODEBOOKS, T],
+		shape: [NCB, T],
 		dtype: "u32",
 		storage: "activation"
 	});
 	addTensor({
 		name: dacKey("quantizer.codebook"),
 		shape: [
-			DAC_NUM_CODEBOOKS,
+			NCB,
 			DAC_CODEBOOK_SIZE,
 			DAC_CODEBOOK_DIM
 		],
@@ -1242,8 +1246,8 @@ function generateDacSpeechDecoderGraph(opts) {
 	addTensor({
 		name: dacKey("quantizer.out_proj.weight"),
 		shape: [
-			DAC_NUM_CODEBOOKS,
-			DAC_LATENT_DIM,
+			NCB,
+			latentDim,
 			DAC_CODEBOOK_DIM
 		],
 		dtype: "f32",
@@ -1252,14 +1256,14 @@ function generateDacSpeechDecoderGraph(opts) {
 	});
 	addTensor({
 		name: dacKey("quantizer.out_proj.bias"),
-		shape: [DAC_NUM_CODEBOOKS, DAC_LATENT_DIM],
+		shape: [NCB, latentDim],
 		dtype: "f32",
 		storage: "constant",
 		safetensorsKey: dacKey("quantizer.out_proj.bias")
 	});
 	addTensor({
 		name: "dac_latent",
-		shape: [DAC_LATENT_DIM, T],
+		shape: [latentDim, T],
 		dtype: "f32",
 		storage: "activation"
 	});
@@ -1274,8 +1278,8 @@ function generateDacSpeechDecoderGraph(opts) {
 		],
 		outputs: ["dac_latent"],
 		attributes: {
-			NCB: DAC_NUM_CODEBOOKS,
-			Cout: DAC_LATENT_DIM,
+			NCB,
+			Cout: latentDim,
 			T,
 			D: DAC_CODEBOOK_DIM,
 			codebook_size: DAC_CODEBOOK_SIZE
@@ -1425,11 +1429,11 @@ function generateDacSpeechDecoderGraph(opts) {
 		});
 	}
 	let cur = "dac_conv1_out";
-	let length = conv1dFull("dac_conv1", "dac_latent", dacKey("decoder.model.0.weight"), dacKey("decoder.model.0.bias"), DAC_LATENT_DIM, DAC_DECODER_DIM, 7, T, 1, 3, cur);
-	let channels = DAC_DECODER_DIM;
-	for (let stage = 0; stage < DAC_DECODER_RATES.length; stage++) {
+	let length = conv1dFull("dac_conv1", "dac_latent", dacKey("decoder.model.0.weight"), dacKey("decoder.model.0.bias"), latentDim, decoderDim, 7, T, 1, 3, cur);
+	let channels = decoderDim;
+	for (let stage = 0; stage < rates.length; stage++) {
 		const m = stage + 1;
-		const rate = DAC_DECODER_RATES[stage];
+		const rate = rates[stage];
 		const outCh = channels / 2;
 		const upK = 2 * rate;
 		const upPad = Math.ceil(rate / 2);
@@ -1458,15 +1462,17 @@ function generateDacSpeechDecoderGraph(opts) {
 		}
 		cur = h;
 	}
+	const finalSnakeIdx = rates.length + 1;
+	const finalConvIdx = rates.length + 2;
 	const postSnake = "dac_post_snake";
-	snake("dac_post_snake_op", cur, channels, length, dacKey("decoder.model.5.alpha"), postSnake);
+	snake("dac_post_snake_op", cur, channels, length, dacKey(`decoder.model.${finalSnakeIdx}.alpha`), postSnake);
 	const pcm = "dac_pcm";
-	const pcmLen = conv1dFull("dac_conv2", postSnake, dacKey("decoder.model.6.weight"), dacKey("decoder.model.6.bias"), channels, 1, 7, length, 1, 3, pcm);
+	const pcmLen = conv1dFull("dac_conv2", postSnake, dacKey(`decoder.model.${finalConvIdx}.weight`), dacKey(`decoder.model.${finalConvIdx}.bias`), channels, 1, 7, length, 1, 3, pcm);
 	return {
 		architecture: "DacSpeechDecoder",
 		config: {
-			hidden_size: DAC_DECODER_DIM,
-			num_layers: DAC_DECODER_RATES.length,
+			hidden_size: decoderDim,
+			num_layers: rates.length,
 			num_heads: 0,
 			num_kv_heads: 0,
 			head_dim: 0,
@@ -1493,10 +1499,13 @@ function generateDacSpeechDecoderGraph(opts) {
 		outputs: [pcm]
 	};
 }
-/** Final decoded PCM length (samples) for a T-frame code grid, via the DAC stage chain. */
-function dacOutputLength(numFrames) {
+/**
+* Final decoded PCM length (samples) for a T-frame code grid, via the DAC stage chain.
+* `rates` defaults to DAC.speech.v1.0 ([8,5,4,2]); pass [8,8,4,2] for Parler's dac_44khz.
+*/
+function dacOutputLength(numFrames, rates = DAC_DECODER_RATES) {
 	let length = numFrames;
-	for (const rate of DAC_DECODER_RATES) length = convTransposeLen(length, rate, 2 * rate, Math.ceil(rate / 2), 0);
+	for (const rate of rates) length = convTransposeLen(length, rate, 2 * rate, Math.ceil(rate / 2), 0);
 	return length;
 }
 /** Strided/dilated Conv1d output length: floor((L + 2*pad - dilation*(K-1) - 1)/stride) + 1. */
@@ -2253,13 +2262,30 @@ function generateOuteTtsBackboneGraph(rawConfig, dtype, groupSize, kvDtype) {
 * builder emits match the reference speaker JSONs the presets ship.
 *
 * The DAC encode (audio → c1/c2 codes) is done bit-exact on the GPU
-* (generateDacSpeechEncoderGraph + RVQEncode, validated 450/450 vs torch). The
-* ALIGNMENT here is pragmatic: outetts uses Whisper word-level timestamps to slice
-* the code stream per word; with no on-device Whisper we distribute the encoded
-* frames across the transcript's words PROPORTIONALLY to word length (chars), then
-* compute each word's prosody from its audio span. This matches the reference shape
-* and the global/per-word feature math exactly; only the word→frame boundaries are
-* approximated (documented on `OuteTTS.encodeSpeaker`).
+* (generateDacSpeechEncoderGraph + RVQEncode, validated 450/450 vs torch). The codes
+* are EXACT; only the word→frame boundaries are estimated. outetts uses Whisper
+* word-level timestamps to slice the code stream per word. We provide two on-device
+* estimators (both leave the codes untouched — they only decide which frames map to
+* which word, and which audio span each word's prosody is computed over):
+*
+*   1. alignWordsByEnergy (default) — a forced-segmentation aligner driven by the
+*      clip's OWN short-time energy envelope. It finds the silence gaps (low-energy
+*      runs) between utterances and snaps word boundaries onto them, distributing the
+*      transcript words across the detected speech runs (char-weighted within a run).
+*      This is audio-driven: boundaries land on real pauses instead of being guessed.
+*
+*   2. alignWordsProportional (fallback) — the original audio-BLIND estimator that
+*      spreads frames across words proportionally to char length. Used when the energy
+*      envelope yields no usable structure (one continuous speech run, or fewer gaps
+*      than word boundaries).
+*
+* On-device STT note: Gerbil's Moonshine STT (MoonshineSTT, src/gpu/moonshine-stt.ts)
+* is an encoder-decoder ASR that emits a transcript but does NOT expose Whisper-style
+* word timestamps — its decoder cross-attention scores are consumed inside the kernel
+* and never read back, so there is no per-token→frame map to slice on. Energy-based
+* forced segmentation is therefore the closest achievable on-device alignment; STT is
+* used (when wired by the caller) to obtain/confirm the WORD SEQUENCE, and the energy
+* aligner places the boundaries. See `OuteTTS.encodeSpeaker`.
 */
 const DAC_TPS = 75;
 const WHITESPACE_RE = /\s+/;
@@ -2422,6 +2448,146 @@ function alignWordsProportional(transcript, numFrames) {
 	}
 	return out;
 }
+/**
+* Short-time RMS energy envelope sampled at the DAC frame rate (one value per code
+* frame). frame f covers audio samples [f·hop, f·hop + win). Used by the energy
+* aligner to locate silence gaps. `hop` is DAC_HOP (320 samples ≈ 13.3 ms @ 24 kHz),
+* matching the DAC frame stride so envelope index == code-frame index.
+*/
+function frameEnergyEnvelope(audio, hop, numFrames) {
+	const env = new Float32Array(numFrames);
+	const win = hop;
+	for (let f = 0; f < numFrames; f++) {
+		const start = f * hop;
+		const end = Math.min(start + win, audio.length);
+		let sum = 0;
+		let n = 0;
+		for (let i = start; i < end; i++) {
+			sum += audio[i] * audio[i];
+			n++;
+		}
+		env[f] = n > 0 ? Math.sqrt(sum / n) : 0;
+	}
+	return env;
+}
+/**
+* Segment the energy envelope into speech runs separated by silence gaps. A frame is
+* "silent" when its energy is below `floor + (peak-floor)*silenceRatio`; a run of
+* silent frames at least `minGapFrames` long is treated as a word/phrase boundary.
+* Leading/trailing silence is trimmed. Returns the speech runs in order.
+*/
+function detectSpeechRuns(env, silenceRatio, minGapFrames) {
+	const numFrames = env.length;
+	if (numFrames === 0) return [];
+	let peak = 0;
+	let floor = Number.POSITIVE_INFINITY;
+	for (let f = 0; f < numFrames; f++) {
+		peak = Math.max(peak, env[f]);
+		floor = Math.min(floor, env[f]);
+	}
+	if (peak <= 0) return [];
+	const threshold = floor + (peak - floor) * silenceRatio;
+	const runs = [];
+	let runStart = -1;
+	let silentRun = 0;
+	for (let f = 0; f < numFrames; f++) if (env[f] > threshold) {
+		if (runStart < 0) runStart = f;
+		silentRun = 0;
+	} else {
+		silentRun++;
+		if (runStart >= 0 && silentRun >= minGapFrames) {
+			runs.push({
+				start: runStart,
+				end: f - silentRun + 1
+			});
+			runStart = -1;
+		}
+	}
+	if (runStart >= 0) runs.push({
+		start: runStart,
+		end: numFrames
+	});
+	return runs.filter((r) => r.end > r.start);
+}
+const ENERGY_SILENCE_RATIO = .15;
+const ENERGY_MIN_GAP_FRAMES = 4;
+/**
+* Distribute `numWords` whole words across speech runs proportionally to each run's
+* frame length, giving every run ≥1 word and summing to exactly `numWords`. Surplus
+* (from the per-run floor) is handed to the longest runs first; any overshoot is taken
+* back from the shortest runs (never below 1). Returns the per-run word count.
+*/
+function distributeWordCounts(runLens, numWords) {
+	const totalRunLen = runLens.reduce((a, b) => a + b, 0) || 1;
+	const targets = runLens.map((len) => Math.max(1, Math.floor(len / totalRunLen * numWords)));
+	const order = runLens.map((_, i) => i).sort((a, b) => runLens[b] - runLens[a]);
+	let assigned = targets.reduce((a, b) => a + b, 0);
+	let oi = 0;
+	while (assigned < numWords) {
+		targets[order[oi % order.length]]++;
+		assigned++;
+		oi++;
+	}
+	while (assigned > numWords) {
+		const idx = order[order.length - 1 - oi % order.length];
+		if (targets[idx] > 1) {
+			targets[idx]--;
+			assigned--;
+		}
+		oi++;
+	}
+	return targets;
+}
+/**
+* Split a contiguous frame span [spanStart, spanEnd) among `groupWords` char-
+* proportionally, appending the resulting {@link AlignedWord}s to `out`. Boundaries
+* are contiguous within the span (the last word reaches spanEnd exactly).
+*/
+function splitRunWords(groupWords, spanStart, spanEnd, out) {
+	const span = Math.max(1, spanEnd - spanStart);
+	const chars = groupWords.map((w) => w.length || 1);
+	const groupTotal = chars.reduce((a, b) => a + b, 0) || groupWords.length;
+	let acc = 0;
+	for (let g = 0; g < groupWords.length; g++) {
+		const wStart = g === 0 ? spanStart : spanStart + Math.round(acc / groupTotal * span);
+		acc += chars[g];
+		const wEnd = g === groupWords.length - 1 ? spanEnd : spanStart + Math.round(acc / groupTotal * span);
+		out.push({
+			word: groupWords[g],
+			startFrame: wStart,
+			endFrame: Math.max(wEnd, wStart)
+		});
+	}
+}
+/**
+* Forced word→frame alignment driven by the clip's energy envelope. Detects the
+* silence gaps in `audio` (at DAC frame resolution) and distributes the transcript's
+* words across the detected speech runs so that word boundaries land on real pauses.
+* Within a run, words are split char-proportionally (same local rule as the fallback).
+* Run spans are made contiguous across the silence gaps (a run owns the frames up to
+* the next run's start) so the per-word c1/c2 slices still tile the full [0, numFrames)
+* code stream with no dropped frames.
+*
+* Falls back to {@link alignWordsProportional} when the envelope has no usable
+* structure (≤1 speech run). The DAC codes are never touched; only the boundaries move.
+*/
+function alignWordsByEnergy(transcript, numFrames, audio, hop) {
+	const words = transcript.split(WHITESPACE_RE).filter((w) => w.length > 0);
+	if (words.length === 0) return [];
+	if (words.length === 1 || numFrames <= 0) return alignWordsProportional(transcript, numFrames);
+	const runs = detectSpeechRuns(frameEnergyEnvelope(audio, hop, numFrames), ENERGY_SILENCE_RATIO, ENERGY_MIN_GAP_FRAMES);
+	if (runs.length < 2) return alignWordsProportional(transcript, numFrames);
+	const targets = distributeWordCounts(runs.map((r) => r.end - r.start), words.length);
+	const out = [];
+	let wordIdx = 0;
+	for (let r = 0; r < runs.length; r++) {
+		const spanStart = r === 0 ? 0 : runs[r].start;
+		const spanEnd = r === runs.length - 1 ? numFrames : runs[r + 1].start;
+		splitRunWords(words.slice(wordIdx, wordIdx + targets[r]), spanStart, spanEnd, out);
+		wordIdx += targets[r];
+	}
+	return out;
+}
 
 //#endregion
 //#region src/gpu/outetts.ts
@@ -2581,7 +2747,7 @@ async function loadOuteSpeaker(voiceOrUrl, baseURL) {
 	return await resp.json();
 }
 /** Build a fresh map of just the constant weights a graph references (see kani-tts). */
-function selectGraphWeights(graph, weights) {
+function selectGraphWeights$1(graph, weights) {
 	const out = /* @__PURE__ */ new Map();
 	for (const [name, desc] of Object.entries(graph.tensors)) {
 		if (desc.storage !== "constant") continue;
@@ -2591,7 +2757,7 @@ function selectGraphWeights(graph, weights) {
 	return out;
 }
 /** Index of the maximum logit (greedy / argmax decode). */
-function argmax$1(logits) {
+function argmax$2(logits) {
 	let best = 0;
 	let bestV = logits[0];
 	for (let i = 1; i < logits.length; i++) if (logits[i] > bestV) {
@@ -2637,10 +2803,10 @@ function nucleusSample(probs, ids, topP) {
 	}
 	let keepSum = 0;
 	for (let r = 0; r < cutoff; r++) keepSum += probs[order[r]];
-	let pick = Math.random() * keepSum;
+	let pick$1 = Math.random() * keepSum;
 	for (let r = 0; r < cutoff; r++) {
-		pick -= probs[order[r]];
-		if (pick <= 0) return ids[order[r]];
+		pick$1 -= probs[order[r]];
+		if (pick$1 <= 0) return ids[order[r]];
 	}
 	return ids[order[0]];
 }
@@ -2690,7 +2856,7 @@ var OuteTTS = class OuteTTS {
 			maxSeqLen,
 			kvMode: "f32"
 		});
-		exec.uploadWeightsMap(selectGraphWeights(graph, loaded.backboneWeights));
+		exec.uploadWeightsMap(selectGraphWeights$1(graph, loaded.backboneWeights));
 		exec.initBindGroups();
 		this.backboneExec = exec;
 	}
@@ -2765,11 +2931,14 @@ var OuteTTS = class OuteTTS {
 	* Fidelity vs outetts `create_speaker`: the DAC-encode (audio → c1/c2 codes) and the
 	* energy/spectral_centroid/pitch feature math are a faithful port. Two documented
 	* approximations: (a) word→frame ALIGNMENT — outetts uses Whisper word timestamps to
-	* slice the code stream; with no on-device Whisper we distribute the encoded frames
-	* across the transcript words proportionally to word length (see
-	* {@link alignWordsProportional}); (b) we skip outetts' pyloudnorm pre-normalization
-	* (it mainly rescales absolute level / the energy bucket). The cloned voice timbre
-	* and prosody come through; the per-word boundaries are heuristic.
+	* slice the code stream. Gerbil's on-device Moonshine STT does not expose word
+	* timestamps (its decoder cross-attention is never read back), so we instead run an
+	* energy-forced aligner ({@link alignWordsByEnergy}) that snaps word boundaries onto
+	* the clip's own silence gaps — audio-driven, tighter than the old char-proportional
+	* guess, and exact when each word is pause-separated; it falls back to proportional
+	* for continuous speech. (b) we skip outetts' pyloudnorm pre-normalization (it mainly
+	* rescales absolute level / the energy bucket). The cloned voice timbre and prosody
+	* come through; only the per-word boundaries remain an estimate.
 	*/
 	async encodeSpeaker(ref) {
 		if ("words" in ref && "text" in ref) return ref;
@@ -2785,7 +2954,7 @@ var OuteTTS = class OuteTTS {
 		const codes = await this.encodeAudioToCodes(pcm, numFrames);
 		const c1All = codes.subarray(0, numFrames);
 		const c2All = codes.subarray(numFrames, 2 * numFrames);
-		const words = alignWordsProportional(transcript, numFrames).map((a) => {
+		const words = alignWordsByEnergy(transcript, numFrames, mono, DAC_HOP).map((a) => {
 			const startSample = Math.min(a.startFrame * DAC_HOP, mono.length);
 			const endSample = Math.min(a.endFrame * DAC_HOP, mono.length);
 			const features = extractAudioFeatures(mono.subarray(startSample, endSample), DAC_SAMPLE_RATE);
@@ -2810,7 +2979,7 @@ var OuteTTS = class OuteTTS {
 			kvMode: "f32"
 		});
 		try {
-			exec.uploadWeightsMap(selectGraphWeights(graph, this.loaded.codecWeights));
+			exec.uploadWeightsMap(selectGraphWeights$1(graph, this.loaded.codecWeights));
 			exec.initBindGroups();
 			exec.reset();
 			exec.writeInput("pcm_in", pcm);
@@ -2852,7 +3021,7 @@ var OuteTTS = class OuteTTS {
 		const generated = [];
 		let logits = prefillLogits;
 		for (let step = 0; step < p.maxNewTokens; step++) {
-			const next = p.greedy ? argmax$1(logits) : this.sampleToken(logits, {
+			const next = p.greedy ? argmax$2(logits) : this.sampleToken(logits, {
 				temperature: p.temperature,
 				topP: p.topP,
 				topK: p.topK,
@@ -2903,7 +3072,7 @@ var OuteTTS = class OuteTTS {
 			kvMode: "f32"
 		});
 		try {
-			exec.uploadWeightsMap(selectGraphWeights(graph, this.loaded.codecWeights));
+			exec.uploadWeightsMap(selectGraphWeights$1(graph, this.loaded.codecWeights));
 			exec.initBindGroups();
 			exec.reset();
 			exec.writeInput("audio_codes", codes);
@@ -2925,198 +3094,1295 @@ var OuteTTS = class OuteTTS {
 };
 
 //#endregion
-//#region src/gpu/sampler.ts
-let _heapIndices = null;
-let _heapValues = null;
+//#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
+	};
+}
 /**
-* Sample a token ID from logits.
-*
-* Pipeline: repetition penalty → temperature → top-k (min-heap) → softmax → top-p → sample.
+* 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 sampleToken(logits, params = {}, previousTokens) {
-	const temperature = params.temperature ?? .7;
-	const topK = params.topK ?? 50;
-	const topP = params.topP ?? .9;
-	const repetitionPenalty = params.repetitionPenalty ?? 1;
-	if (temperature < 1e-6) return argmax(logits);
-	const N = logits.length;
-	const K = Math.min(topK > 0 ? topK : N, N);
-	if (!_heapIndices || _heapIndices.length < K) {
-		_heapIndices = new Uint32Array(K);
-		_heapValues = new Float32Array(K);
-	}
-	const hIdx = _heapIndices;
-	const hVal = _heapValues;
-	let penaltySet = null;
-	if (repetitionPenalty !== 1 && previousTokens?.length) penaltySet = new Set(previousTokens);
-	let heapSize = 0;
-	for (let i = 0; i < N; i++) {
-		let s = logits[i];
-		if (penaltySet?.has(i)) s = s > 0 ? s / repetitionPenalty : s * repetitionPenalty;
-		s /= temperature;
-		if (heapSize < K) {
-			hIdx[heapSize] = i;
-			hVal[heapSize] = s;
-			heapSize++;
-			if (heapSize === K) for (let j = (K >> 1) - 1; j >= 0; j--) siftDown(hIdx, hVal, j, K);
-		} else if (s > hVal[0]) {
-			hIdx[0] = i;
-			hVal[0] = s;
-			siftDown(hIdx, hVal, 0, K);
-		}
-	}
-	for (let i = 1; i < heapSize; i++) {
-		const vi = hVal[i];
-		const ii = hIdx[i];
-		let j = i - 1;
-		while (j >= 0 && hVal[j] < vi) {
-			hVal[j + 1] = hVal[j];
-			hIdx[j + 1] = hIdx[j];
-			j--;
-		}
-		hVal[j + 1] = vi;
-		hIdx[j + 1] = ii;
-	}
-	const maxScore = hVal[0];
-	let sumExp = 0;
-	for (let i = 0; i < heapSize; i++) {
-		const p = Math.exp(hVal[i] - maxScore);
-		hVal[i] = p;
-		sumExp += p;
-	}
-	const invSum = 1 / sumExp;
-	for (let i = 0; i < heapSize; i++) hVal[i] *= invSum;
-	let candidateCount = heapSize;
-	if (topP < 1) {
-		let cumulative$1 = 0;
-		for (let i = 0; i < heapSize; i++) {
-			cumulative$1 += hVal[i];
-			if (cumulative$1 >= topP) {
-				candidateCount = i + 1;
-				break;
-			}
-		}
-		let sum = 0;
-		for (let i = 0; i < candidateCount; i++) sum += hVal[i];
-		const inv = 1 / sum;
-		for (let i = 0; i < candidateCount; i++) hVal[i] *= inv;
-	}
-	const r = Math.random();
-	let cumulative = 0;
-	for (let i = 0; i < candidateCount; i++) {
-		cumulative += hVal[i];
-		if (r <= cumulative) return hIdx[i];
-	}
-	return hIdx[candidateCount - 1];
+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;
 }
 /**
-* Return the index of the maximum value (greedy decoding).
+* 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 argmax(arr) {
-	let maxIdx = 0;
-	let maxVal = arr[0];
-	for (let i = 1; i < arr.length; i++) if (arr[i] > maxVal) {
-		maxVal = arr[i];
-		maxIdx = i;
-	}
-	return maxIdx;
-}
-/** Min-heap sift down on parallel index/value typed arrays. */
-function siftDown(indices, values, i, n) {
-	while (true) {
-		let smallest = i;
-		const left = 2 * i + 1;
-		const right = 2 * i + 2;
-		if (left < n && values[left] < values[smallest]) smallest = left;
-		if (right < n && values[right] < values[smallest]) smallest = right;
-		if (smallest === i) break;
-		const ti = indices[i];
-		indices[i] = indices[smallest];
-		indices[smallest] = ti;
-		const tv = values[i];
-		values[i] = values[smallest];
-		values[smallest] = tv;
-		i = smallest;
-	}
-}
-
-//#endregion
-//#region src/gpu/vision-executor.ts
-const MAP_MODE_READ = 1;
-/** Pack an f32 array to IEEE half (f16) bits (round-to-nearest-even). */
-const _f16scratch = /* @__PURE__ */ new ArrayBuffer(4);
-const _f16f32 = new Float32Array(_f16scratch);
-const _f16u32 = new Uint32Array(_f16scratch);
-function packF16(src) {
-	const out = new Uint16Array(src.length);
-	for (let i = 0; i < src.length; i++) {
-		_f16f32[0] = src[i];
-		const f = _f16u32[0];
-		const sign = f >>> 16 & 32768;
-		const exp = (f >>> 23 & 255) - 112;
-		const mant = f & 8388607;
-		if (exp <= 0) out[i] = sign;
-		else if (exp >= 31) out[i] = sign | 31744;
-		else {
-			const round = (mant & 4096) !== 0;
-			let half = sign | exp << 10 | mant >>> 13;
-			if (round) half += 1;
-			out[i] = half;
+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;
 }
 /**
-* WebKit only: the ViT bidirectional Attention op is a single dispatch whose
-* grid is [N query rows, heads], each row looping over all N keys — O(N²) work in
-* one submission. Past a few hundred rows that can exceed Metal's ~few-second GPU
-* watchdog and kill the web-content process (indistinguishable from OOM). We split
-* the attention grid into windows of this many query rows, each its own
-* submit + onSubmittedWorkDone() drain, so no single submission runs long enough
-* to trip the watchdog. Math is unchanged: every query row computes identically
-* regardless of how the grid is partitioned.
+* 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).
 */
-const WEBKIT_ATTN_CHUNK_ROWS = 64;
-var VisionExecutor = class {
-	ctx;
-	graph;
-	mergeUnit;
-	weightBuffers = /* @__PURE__ */ new Map();
-	activationBuffers = /* @__PURE__ */ new Map();
-	dispatches = [];
-	maxPatches;
-	/** Weight (B) names of MatMulBias nodes stored as f16 (empty without shader-f16). */
-	f16WeightNames = /* @__PURE__ */ new Set();
-	/** Runtime pooled-token count for the Gemma 4 ViT ("Np" dim); 0 for Qwen. */
-	gemma4Np = 0;
-	/** True when this graph is the Gemma 4 vision tower (uses "Np" + PoolMatMul). */
-	isGemma4;
-	constructor(ctx, graph, maxPatches) {
-		this.ctx = ctx;
-		this.graph = graph;
-		this.maxPatches = maxPatches;
-		this.isGemma4 = graph.architecture === "Gemma4VisionModel";
-		const mergedIn = graph.tensors[CANONICAL_KEYS.visMergerFc1W]?.shape[1];
-		const hidden = graph.config.hidden_size;
-		this.mergeUnit = mergedIn && hidden ? mergedIn / hidden : 1;
-		if (ctx.hasF16) {
-			for (const node of graph.nodes) if (node.opType === "MatMulBias" && node.inputs[1]) this.f16WeightNames.add(node.inputs[1]);
-		}
-		this.allocateActivationBuffers();
-	}
-	uploadWeights(weights) {
-		for (const [name, desc] of Object.entries(this.graph.tensors)) {
-			if (desc.storage !== "constant") continue;
-			const w = weights.get(name);
-			if (!w) throw new Error(`VisionExecutor: missing weight "${name}"`);
-			let data = w.data;
-			if (this.f16WeightNames.has(name) && w.data instanceof Float32Array) data = packF16(w.data);
-			const buffer = createStorageBuffer(this.ctx, `vweight_${name}`, data.byteLength, data);
-			this.weightBuffers.set(name, buffer);
-		}
-	}
-	initBindGroups() {
-		const dummyShapes = this.resolveShapes(this.maxPatches);
+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
+/**
+* ParlerTTS — native describe-your-voice text-to-speech for Gerbil's WebGPU backend.
+*
+* Parler-TTS (parler-tts/parler-tts-mini-v1) is an encoder-decoder codec-LM: you
+* describe the voice in natural language and a Flan-T5 encoder turns that DESCRIPTION
+* into cross-attention states, while a 24-layer decoder LM cross-attends to them and
+* autoregressively emits DAC audio codes for the TRANSCRIPT. Same dual-graph shape as
+* MoonshineSTT (encoder once → frozen cross-attn K/V → AR decode), and the same DAC
+* codec family as OuteTTS (the shared generateDacSpeechDecoderGraph, here with 9
+* codebooks + rates [8,8,4,2]).
+*
+* Pipeline (engine.speak(text, { describeVoice })):
+*   1. Tokenize the DESCRIPTION with the T5 tokenizer; build the relative-position
+*      bias; run the T5 encoder once → encoder_out + per-decoder-layer frozen K/V.
+*   2. Tokenize the TRANSCRIPT (embed_prompts); prefill its embeddings (+ sinusoidal
+*      positions) through the decoder so the self-attn KV-cache holds the prompt.
+*   3. AR-decode 9 interleaved codebooks under the delay pattern: each step the host
+*      sums the 9 per-codebook embeddings of the current (delayed) codes + the
+*      sinusoidal position, forwards one step, and samples each of the 9 lm_head logit
+*      rows. Stop on EOS in codebook 0 (or the frame cap).
+*   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.
+*/
+const MAP_MODE_READ$1 = 1;
+/** Default voice description when the caller doesn't supply one. */
+const DEFAULT_VOICE_DESCRIPTION = "A clear, neutral voice speaking at a moderate pace with good audio quality.";
+/** Hard cap on decoded audio frames (~86 fps → ~30 s at 2600). */
+const DEFAULT_MAX_FRAMES = 2600;
+/** Build a fresh map of just the constant weights a graph references. */
+function selectGraphWeights(graph, weights) {
+	const out = /* @__PURE__ */ new Map();
+	for (const [name, desc] of Object.entries(graph.tensors)) {
+		if (desc.storage !== "constant") continue;
+		const w = weights.get(name) ?? (desc.safetensorsKey ? weights.get(desc.safetensorsKey) : void 0);
+		if (w) out.set(name, w);
+	}
+	return out;
+}
+/** Argmax over a logit row. */
+function argmax$1(logits) {
+	let best = 0;
+	let bestV = logits[0];
+	for (let i = 1; i < logits.length; i++) if (logits[i] > bestV) {
+		bestV = logits[i];
+		best = i;
+	}
+	return best;
+}
+/** Temperature + optional top-k sample over a logit row. */
+function sampleLogits(logits, temperature, topK) {
+	const n = logits.length;
+	const scaled = new Float32Array(n);
+	let maxV = Number.NEGATIVE_INFINITY;
+	const invT = 1 / Math.max(temperature, 1e-5);
+	for (let i = 0; i < n; i++) {
+		scaled[i] = logits[i] * invT;
+		if (scaled[i] > maxV) maxV = scaled[i];
+	}
+	let allowed = null;
+	if (topK > 0 && topK < n) {
+		const order = Array.from({ length: n }, (_, i) => i).sort((a, b) => scaled[b] - scaled[a]);
+		allowed = new Int32Array(order.slice(0, topK));
+	}
+	let sum = 0;
+	const probs = new Float32Array(n);
+	if (allowed) for (const idx of allowed) {
+		const e = Math.exp(scaled[idx] - maxV);
+		probs[idx] = e;
+		sum += e;
+	}
+	else for (let i = 0; i < n; i++) {
+		const e = Math.exp(scaled[i] - maxV);
+		probs[i] = e;
+		sum += e;
+	}
+	let pick$1 = Math.random() * sum;
+	if (allowed) {
+		for (const idx of allowed) {
+			pick$1 -= probs[idx];
+			if (pick$1 <= 0) return idx;
+		}
+		return allowed[0];
+	}
+	for (let i = 0; i < n; i++) {
+		pick$1 -= probs[i];
+		if (pick$1 <= 0) return i;
+	}
+	return n - 1;
+}
+var ParlerEncoderExecutor = class {
+	ctx;
+	graph;
+	decLayers;
+	hidden;
+	sDesc;
+	weightBuffers = /* @__PURE__ */ new Map();
+	activationBuffers = /* @__PURE__ */ new Map();
+	dispatches = [];
+	constructor(ctx, graph, decLayers, sDesc) {
+		this.ctx = ctx;
+		this.graph = graph;
+		this.decLayers = decLayers;
+		this.hidden = graph.config.hidden_size;
+		this.sDesc = sDesc;
+		for (const [name, desc] of Object.entries(graph.tensors)) {
+			if (desc.storage !== "activation") continue;
+			const count = desc.shape.reduce((a, dim) => a * (typeof dim === "number" ? dim : sDesc), 1);
+			this.activationBuffers.set(name, createStorageBuffer(this.ctx, `penc_${name}`, count * DTYPE_BYTES[desc.dtype]));
+		}
+	}
+	uploadWeights(weights) {
+		for (const [name, desc] of Object.entries(this.graph.tensors)) {
+			if (desc.storage !== "constant") continue;
+			const w = weights.get(name);
+			if (!w) throw new Error(`ParlerEncoderExecutor: missing weight "${name}"`);
+			this.weightBuffers.set(name, createStorageBuffer(this.ctx, `pencw_${name}`, w.data.byteLength, w.data));
+		}
+	}
+	initBindGroups() {
+		const shapes = this.resolveShapes();
+		for (const nodeId of this.graph.executionOrder) {
+			const node = this.graph.nodes.find((n) => n.id === nodeId);
+			const spec = KERNEL_REGISTRY[node.opType];
+			if (!spec) throw new Error(`ParlerEncoderExecutor: no kernel for op "${node.opType}"`);
+			const pipeline = getOrCreatePipeline(this.ctx, `penck_${nodeId}`, spec.shaderCode, spec.entryPoint);
+			const paramsData = spec.buildParams(node, shapes, { seqPos: 0 });
+			const uniformBuffer = createUniformBuffer(this.ctx, `pencu_${nodeId}`, paramsData);
+			const bufferEntries = this.gatherBuffers(spec, node, uniformBuffer);
+			const bindGroup = createBindGroup(this.ctx, pipeline, bufferEntries, `pencbg_${nodeId}`);
+			this.dispatches.push({
+				node,
+				spec,
+				pipeline,
+				bindGroup,
+				uniformBuffer
+			});
+		}
+	}
+	/** Run the encoder. `inputIds` u32 [S], `relBias` f32 [heads,S,S]. */
+	async encode(inputIds, relBias) {
+		const q = this.ctx.device.queue;
+		const inputBuf = this.activationBuffers.get("input_ids");
+		const biasBuf = this.activationBuffers.get("t5_rel_bias");
+		if (!(inputBuf && biasBuf)) throw new Error("ParlerEncoderExecutor: input_ids / t5_rel_bias buffers missing.");
+		q.writeBuffer(inputBuf, 0, inputIds);
+		q.writeBuffer(biasBuf, 0, relBias);
+		const shapes = this.resolveShapes();
+		const sizes = [];
+		for (const d of this.dispatches) {
+			const params = d.spec.buildParams(d.node, shapes, { seqPos: 0 });
+			q.writeBuffer(d.uniformBuffer, 0, params);
+			sizes.push(d.spec.getDispatchSize(d.node, shapes, { seqPos: 0 }));
+		}
+		if (this.ctx.isWebKitWebGPU) for (let i = 0; i < this.dispatches.length; i++) {
+			const enc = this.ctx.device.createCommandEncoder();
+			const p = enc.beginComputePass();
+			p.setPipeline(this.dispatches[i].pipeline);
+			p.setBindGroup(0, this.dispatches[i].bindGroup);
+			p.dispatchWorkgroups(...sizes[i]);
+			p.end();
+			q.submit([enc.finish()]);
+			await q.onSubmittedWorkDone();
+		}
+		else {
+			const enc = this.ctx.device.createCommandEncoder({ label: "parler_encode" });
+			const pass = enc.beginComputePass({ label: "parler_enc_pass" });
+			for (let i = 0; i < this.dispatches.length; i++) {
+				pass.setPipeline(this.dispatches[i].pipeline);
+				pass.setBindGroup(0, this.dispatches[i].bindGroup);
+				pass.dispatchWorkgroups(...sizes[i]);
+			}
+			pass.end();
+			q.submit([enc.finish()]);
+		}
+		const encK = [];
+		const encV = [];
+		for (let i = 0; i < this.decLayers; i++) {
+			encK.push(await this.readBack(`enc_k_layer${i}`, this.sDesc * this.hidden));
+			encV.push(await this.readBack(`enc_v_layer${i}`, this.sDesc * this.hidden));
+		}
+		return {
+			encK,
+			encV
+		};
+	}
+	destroy() {
+		destroyBuffers([...this.weightBuffers.values()]);
+		destroyBuffers([...this.activationBuffers.values()]);
+		for (const d of this.dispatches) d.uniformBuffer.destroy();
+		this.weightBuffers.clear();
+		this.activationBuffers.clear();
+		this.dispatches = [];
+	}
+	resolveShapes() {
+		const resolved = {};
+		for (const [name, desc] of Object.entries(this.graph.tensors)) resolved[name] = desc.shape.map((dim) => typeof dim === "number" ? dim : this.sDesc);
+		return resolved;
+	}
+	gatherBuffers(spec, node, uniformBuffer) {
+		const entries = [];
+		const tensorNames = [...node.inputs, ...node.outputs];
+		let tensorIdx = 0;
+		for (const binding of spec.bindings) if (binding.type === "uniform") entries.push({ buffer: uniformBuffer });
+		else {
+			const tensorName = tensorNames[tensorIdx++];
+			const buffer = this.weightBuffers.get(tensorName) ?? this.activationBuffers.get(tensorName);
+			if (!buffer) throw new Error(`ParlerEncoderExecutor: no buffer for "${tensorName}" in op ${node.id}`);
+			entries.push({ buffer });
+		}
+		return entries;
+	}
+	async readBack(name, elements) {
+		const buffer = this.activationBuffers.get(name);
+		if (!buffer) throw new Error(`ParlerEncoderExecutor: no buffer "${name}"`);
+		const byteLen = Math.min(elements * 4, buffer.size);
+		const readback = this.ctx.device.createBuffer({
+			size: byteLen,
+			usage: 9
+		});
+		const enc = this.ctx.device.createCommandEncoder();
+		enc.copyBufferToBuffer(buffer, 0, readback, 0, byteLen);
+		this.ctx.device.queue.submit([enc.finish()]);
+		await readback.mapAsync(MAP_MODE_READ$1, 0, byteLen);
+		const data = new Float32Array(readback.getMappedRange(0, byteLen).slice(0));
+		readback.unmap();
+		readback.destroy();
+		return data;
+	}
+};
+var ParlerTTS = class ParlerTTS {
+	ctx;
+	loaded;
+	cfg;
+	maxSeqLen;
+	_destroyed = false;
+	sampleRate = PARLER_SAMPLE_RATE;
+	constructor(ctx, loaded, maxSeqLen) {
+		this.ctx = ctx;
+		this.loaded = loaded;
+		this.cfg = parseParlerConfig(loaded.rawConfig);
+		this.maxSeqLen = maxSeqLen;
+	}
+	static async create(options = {}) {
+		const ctx = await initGPU();
+		const loaded = await loadParlerTTS({
+			repo: options.repo,
+			revision: options.revision,
+			hfToken: options.hfToken,
+			cacheDir: options.cacheDir,
+			onProgress: options.onProgress
+		});
+		const cfg = parseParlerConfig(loaded.rawConfig);
+		return new ParlerTTS(ctx, loaded, Math.min(options.maxSeqLen ?? 4096, cfg.max_position));
+	}
+	/**
+	* Generate a random natural-language voice description using a host-side template
+	* bank (no model call). Pass the result as `describeVoice` for variety. A loaded
+	* text model can write richer ones — exposed on the Gerbil class as
+	* {@link inventVoiceDescription}.
+	*/
+	static randomVoiceDescription() {
+		const gender = pick(["male", "female"]);
+		return `A ${pick([
+			"warm",
+			"bright",
+			"calm",
+			"energetic",
+			"gentle",
+			"confident",
+			"soft"
+		])} ${gender} voice speaking at a ${pick([
+			"slightly slow",
+			"moderate",
+			"slightly fast"
+		])} pace, in a ${pick([
+			"very clear, studio-quality recording",
+			"clean recording with minimal background noise",
+			"close-sounding, high-quality audio"
+		])}.`;
+	}
+	/** Synthesize `text` in the described voice. Returns 44.1 kHz mono PCM. */
+	async speak(text, opts = {}) {
+		if (this._destroyed) throw new Error("ParlerTTS has been destroyed.");
+		const startTime = performance.now();
+		const description = (opts.describeVoice ?? DEFAULT_VOICE_DESCRIPTION).trim();
+		const descIds = this.loaded.tokenizer.encode(description);
+		const sDesc = descIds.length;
+		const biasTable = this.loaded.modelWeights.get("text_encoder.encoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight");
+		if (!biasTable) throw new Error("ParlerTTS: relative_attention_bias.weight missing from checkpoint.");
+		const relBias = buildT5RelativeBias(biasTable.data, this.cfg.rel_num_buckets, this.cfg.rel_max_distance, this.cfg.enc_heads, sDesc);
+		const encGraph = generateParlerEncoderGraph(this.loaded.rawConfig, sDesc);
+		const encExec = new ParlerEncoderExecutor(this.ctx, encGraph, this.cfg.dec_layers, sDesc);
+		let encK;
+		let encV;
+		try {
+			encExec.uploadWeights(selectGraphWeights(encGraph, this.loaded.modelWeights));
+			encExec.initBindGroups();
+			const enc = await encExec.encode(new Uint32Array(descIds), relBias);
+			encK = enc.encK;
+			encV = enc.encV;
+		} finally {
+			encExec.destroy();
+		}
+		const promptIds = this.loaded.tokenizer.encode(text);
+		const delayed = await this.decodeAudioTokens(promptIds, encK, encV, sDesc, opts);
+		const { codes, frames } = revertDelayPattern(delayed.codes, this.cfg.num_codebooks, delayed.steps);
+		if (frames <= 0) throw new Error(`ParlerTTS produced no audio frames (steps=${delayed.steps}).`);
+		opts.onCodes?.(codes, this.cfg.num_codebooks, frames);
+		const pcm = await this.decodeCodes(codes, frames);
+		const totalTime = (performance.now() - startTime) / 1e3;
+		const audioSeconds = pcm.length / PARLER_SAMPLE_RATE;
+		console.log(`[parler] desc=${sDesc} frames=${frames} audio=${audioSeconds.toFixed(2)}s wall=${totalTime.toFixed(2)}s`);
+		return {
+			pcm,
+			sampleRate: PARLER_SAMPLE_RATE,
+			frames,
+			audioSeconds
+		};
+	}
+	/**
+	* Run the decoder: prefill the transcript prompt rows, then AR-decode the 9-codebook
+	* delay-pattern stream. Returns the DELAYED code grid [9, steps] (codebook-major)
+	* plus the step count, for revertDelayPattern.
+	*
+	* Each step the host sums the 9 per-codebook embeddings of the current delayed codes
+	* + the sinusoidal position, writes that single [1,H] row to `dec_input_embed`,
+	* forwards one step (KV-cache grows over [prompt ++ audio]), and reads back 9 logit
+	* rows — one per codebook lm_head.
+	*/
+	async decodeAudioTokens(promptIds, encK, encV, sEnc, opts) {
+		const cfg = this.cfg;
+		const H = cfg.dec_hidden;
+		const NCB = cfg.num_codebooks;
+		const graph = generateParlerDecoderGraph(this.loaded.rawConfig, sEnc);
+		const maxSteps = Math.min(opts.maxFrames ?? DEFAULT_MAX_FRAMES, this.maxSeqLen - promptIds.length) + (NCB - 1);
+		const exec = new Executor(this.ctx, graph, {
+			maxSeqLen: this.maxSeqLen,
+			kvMode: "f32"
+		});
+		const embedTokens = [];
+		for (let cb = 0; cb < NCB; cb++) {
+			const t = this.loaded.modelWeights.get(`decoder.model.decoder.embed_tokens.${cb}.weight`);
+			if (!t) throw new Error(`ParlerTTS: embed_tokens.${cb} missing.`);
+			embedTokens.push(t.data);
+		}
+		const embedPositions = this.loaded.modelWeights.get("decoder.model.decoder.embed_positions.weights");
+		const embedPrompts = this.loaded.modelWeights.get("embed_prompts.weight");
+		if (!(embedPositions && embedPrompts)) throw new Error("ParlerTTS: embed_positions / embed_prompts missing.");
+		const posTable = embedPositions.data;
+		const promptTable = embedPrompts.data;
+		const grid = new Uint32Array(NCB * maxSteps);
+		let steps = 0;
+		try {
+			exec.uploadWeightsMap(selectGraphWeights(graph, this.loaded.modelWeights));
+			exec.initBindGroups();
+			for (let i = 0; i < cfg.dec_layers; i++) {
+				exec.writeInput(`enc_k_layer${i}`, encK[i]);
+				exec.writeInput(`enc_v_layer${i}`, encV[i]);
+			}
+			exec.reset();
+			let pos = 0;
+			const row = new Float32Array(H);
+			const logitOutputs = graph.outputs.map((name) => ({
+				name,
+				elemCount: cfg.audio_vocab
+			}));
+			for (const tokenId of promptIds) {
+				addRow(row, promptTable, tokenId, H, true);
+				addPosition(row, posTable, pos, H);
+				exec.writeInput("dec_input_embed", row);
+				await exec.runGraphStep([logitOutputs[0]], 1);
+				pos++;
+			}
+			let prevCodes = new Uint32Array(NCB).fill(PARLER_BOS_TOKEN_ID);
+			let frontier = 0;
+			let finished = false;
+			for (let step = 0; step < maxSteps && !finished; step++) {
+				row.fill(0);
+				for (let cb = 0; cb < NCB; cb++) addRow(row, embedTokens[cb], prevCodes[cb], H, false);
+				addPosition(row, posTable, pos, H);
+				exec.writeInput("dec_input_embed", row);
+				const logitRows = await exec.runGraphStep(logitOutputs, 1);
+				pos++;
+				const nextCodes = new Uint32Array(NCB);
+				for (let cb = 0; cb < NCB; cb++) {
+					if (step < cb) {
+						nextCodes[cb] = PARLER_BOS_TOKEN_ID;
+						continue;
+					}
+					if (cb > frontier) logitRows[cb][PARLER_EOS_TOKEN_ID] = Number.NEGATIVE_INFINITY;
+					const code = opts.greedy ? argmax$1(logitRows[cb]) : sampleLogits(logitRows[cb], opts.temperature ?? 1, opts.topK ?? 0);
+					nextCodes[cb] = code;
+					grid[cb * maxSteps + step] = code < PARLER_CODEBOOK_SIZE ? code : 0;
+				}
+				if (frontier < NCB - 1 && nextCodes[frontier] === PARLER_EOS_TOKEN_ID) frontier++;
+				else if (frontier === NCB - 1 && nextCodes[frontier] === PARLER_EOS_TOKEN_ID) finished = true;
+				steps = step + 1;
+				prevCodes = nextCodes;
+				if (pos >= this.maxSeqLen) break;
+			}
+		} finally {
+			exec.destroy();
+		}
+		const tight = new Uint32Array(NCB * steps);
+		for (let cb = 0; cb < NCB; cb++) for (let s = 0; s < steps; s++) tight[cb * steps + s] = grid[cb * maxSteps + s];
+		return {
+			codes: tight,
+			steps
+		};
+	}
+	/** Decode the [9, frames] code grid → 44.1 kHz PCM (tanh host-side). */
+	async decodeCodes(codes, numFrames) {
+		const graph = generateDacSpeechDecoderGraph({
+			numFrames,
+			numCodebooks: this.cfg.num_codebooks,
+			decoderRates: PARLER_DECODER_RATES,
+			decoderDim: PARLER_DAC_DECODER_DIM,
+			latentDim: PARLER_DAC_LATENT_DIM
+		});
+		const pcmLen = dacOutputLength(numFrames, PARLER_DECODER_RATES);
+		const exec = new Executor(this.ctx, graph, {
+			maxSeqLen: numFrames,
+			kvMode: "f32"
+		});
+		try {
+			exec.uploadWeightsMap(selectGraphWeights(graph, this.loaded.codecWeights));
+			exec.initBindGroups();
+			exec.reset();
+			exec.writeInput("audio_codes", codes);
+			const raw = await exec.runGraphOutput(graph.outputs[0], pcmLen);
+			const pcm = new Float32Array(raw.length);
+			for (let i = 0; i < raw.length; i++) pcm[i] = Math.tanh(raw[i]);
+			return pcm;
+		} finally {
+			exec.destroy();
+		}
+	}
+	destroy() {
+		if (this._destroyed) return;
+		this._destroyed = true;
+		this.loaded.modelWeights.clear();
+		this.loaded.codecWeights.clear();
+	}
+};
+const PARLER_CODEBOOK_SIZE = 1024;
+/** Random pick from a list. */
+function pick(arr) {
+	return arr[Math.floor(Math.random() * arr.length)];
+}
+/** Add (or set) the embedding row for `tokenId` into `row`. */
+function addRow(row, table, tokenId, H, set) {
+	const base = tokenId * H;
+	if (set) for (let i = 0; i < H; i++) row[i] = table[base + i];
+	else for (let i = 0; i < H; i++) row[i] += table[base + i];
+}
+/** Add the sinusoidal position row (from the learned embed_positions table). */
+function addPosition(row, posTable, pos, H) {
+	const base = pos * H;
+	for (let i = 0; i < H; i++) row[i] += posTable[base + i];
+}
+
+//#endregion
+//#region src/gpu/sampler.ts
+let _heapIndices = null;
+let _heapValues = null;
+/**
+* Sample a token ID from logits.
+*
+* Pipeline: repetition penalty → temperature → top-k (min-heap) → softmax → top-p → sample.
+*/
+function sampleToken(logits, params = {}, previousTokens) {
+	const temperature = params.temperature ?? .7;
+	const topK = params.topK ?? 50;
+	const topP = params.topP ?? .9;
+	const repetitionPenalty = params.repetitionPenalty ?? 1;
+	if (temperature < 1e-6) return argmax(logits);
+	const N = logits.length;
+	const K = Math.min(topK > 0 ? topK : N, N);
+	if (!_heapIndices || _heapIndices.length < K) {
+		_heapIndices = new Uint32Array(K);
+		_heapValues = new Float32Array(K);
+	}
+	const hIdx = _heapIndices;
+	const hVal = _heapValues;
+	let penaltySet = null;
+	if (repetitionPenalty !== 1 && previousTokens?.length) penaltySet = new Set(previousTokens);
+	let heapSize = 0;
+	for (let i = 0; i < N; i++) {
+		let s = logits[i];
+		if (penaltySet?.has(i)) s = s > 0 ? s / repetitionPenalty : s * repetitionPenalty;
+		s /= temperature;
+		if (heapSize < K) {
+			hIdx[heapSize] = i;
+			hVal[heapSize] = s;
+			heapSize++;
+			if (heapSize === K) for (let j = (K >> 1) - 1; j >= 0; j--) siftDown(hIdx, hVal, j, K);
+		} else if (s > hVal[0]) {
+			hIdx[0] = i;
+			hVal[0] = s;
+			siftDown(hIdx, hVal, 0, K);
+		}
+	}
+	for (let i = 1; i < heapSize; i++) {
+		const vi = hVal[i];
+		const ii = hIdx[i];
+		let j = i - 1;
+		while (j >= 0 && hVal[j] < vi) {
+			hVal[j + 1] = hVal[j];
+			hIdx[j + 1] = hIdx[j];
+			j--;
+		}
+		hVal[j + 1] = vi;
+		hIdx[j + 1] = ii;
+	}
+	const maxScore = hVal[0];
+	let sumExp = 0;
+	for (let i = 0; i < heapSize; i++) {
+		const p = Math.exp(hVal[i] - maxScore);
+		hVal[i] = p;
+		sumExp += p;
+	}
+	const invSum = 1 / sumExp;
+	for (let i = 0; i < heapSize; i++) hVal[i] *= invSum;
+	let candidateCount = heapSize;
+	if (topP < 1) {
+		let cumulative$1 = 0;
+		for (let i = 0; i < heapSize; i++) {
+			cumulative$1 += hVal[i];
+			if (cumulative$1 >= topP) {
+				candidateCount = i + 1;
+				break;
+			}
+		}
+		let sum = 0;
+		for (let i = 0; i < candidateCount; i++) sum += hVal[i];
+		const inv = 1 / sum;
+		for (let i = 0; i < candidateCount; i++) hVal[i] *= inv;
+	}
+	const r = Math.random();
+	let cumulative = 0;
+	for (let i = 0; i < candidateCount; i++) {
+		cumulative += hVal[i];
+		if (r <= cumulative) return hIdx[i];
+	}
+	return hIdx[candidateCount - 1];
+}
+/**
+* Return the index of the maximum value (greedy decoding).
+*/
+function argmax(arr) {
+	let maxIdx = 0;
+	let maxVal = arr[0];
+	for (let i = 1; i < arr.length; i++) if (arr[i] > maxVal) {
+		maxVal = arr[i];
+		maxIdx = i;
+	}
+	return maxIdx;
+}
+/** Min-heap sift down on parallel index/value typed arrays. */
+function siftDown(indices, values, i, n) {
+	while (true) {
+		let smallest = i;
+		const left = 2 * i + 1;
+		const right = 2 * i + 2;
+		if (left < n && values[left] < values[smallest]) smallest = left;
+		if (right < n && values[right] < values[smallest]) smallest = right;
+		if (smallest === i) break;
+		const ti = indices[i];
+		indices[i] = indices[smallest];
+		indices[smallest] = ti;
+		const tv = values[i];
+		values[i] = values[smallest];
+		values[smallest] = tv;
+		i = smallest;
+	}
+}
+
+//#endregion
+//#region src/gpu/vision-executor.ts
+const MAP_MODE_READ = 1;
+/** Pack an f32 array to IEEE half (f16) bits (round-to-nearest-even). */
+const _f16scratch = /* @__PURE__ */ new ArrayBuffer(4);
+const _f16f32 = new Float32Array(_f16scratch);
+const _f16u32 = new Uint32Array(_f16scratch);
+function packF16(src) {
+	const out = new Uint16Array(src.length);
+	for (let i = 0; i < src.length; i++) {
+		_f16f32[0] = src[i];
+		const f = _f16u32[0];
+		const sign = f >>> 16 & 32768;
+		const exp = (f >>> 23 & 255) - 112;
+		const mant = f & 8388607;
+		if (exp <= 0) out[i] = sign;
+		else if (exp >= 31) out[i] = sign | 31744;
+		else {
+			const round = (mant & 4096) !== 0;
+			let half = sign | exp << 10 | mant >>> 13;
+			if (round) half += 1;
+			out[i] = half;
+		}
+	}
+	return out;
+}
+/**
+* WebKit only: the ViT bidirectional Attention op is a single dispatch whose
+* grid is [N query rows, heads], each row looping over all N keys — O(N²) work in
+* one submission. Past a few hundred rows that can exceed Metal's ~few-second GPU
+* watchdog and kill the web-content process (indistinguishable from OOM). We split
+* the attention grid into windows of this many query rows, each its own
+* submit + onSubmittedWorkDone() drain, so no single submission runs long enough
+* to trip the watchdog. Math is unchanged: every query row computes identically
+* regardless of how the grid is partitioned.
+*/
+const WEBKIT_ATTN_CHUNK_ROWS = 64;
+var VisionExecutor = class {
+	ctx;
+	graph;
+	mergeUnit;
+	weightBuffers = /* @__PURE__ */ new Map();
+	activationBuffers = /* @__PURE__ */ new Map();
+	dispatches = [];
+	maxPatches;
+	/** Weight (B) names of MatMulBias nodes stored as f16 (empty without shader-f16). */
+	f16WeightNames = /* @__PURE__ */ new Set();
+	/** Runtime pooled-token count for the Gemma 4 ViT ("Np" dim); 0 for Qwen. */
+	gemma4Np = 0;
+	/** True when this graph is the Gemma 4 vision tower (uses "Np" + PoolMatMul). */
+	isGemma4;
+	constructor(ctx, graph, maxPatches) {
+		this.ctx = ctx;
+		this.graph = graph;
+		this.maxPatches = maxPatches;
+		this.isGemma4 = graph.architecture === "Gemma4VisionModel";
+		const mergedIn = graph.tensors[CANONICAL_KEYS.visMergerFc1W]?.shape[1];
+		const hidden = graph.config.hidden_size;
+		this.mergeUnit = mergedIn && hidden ? mergedIn / hidden : 1;
+		if (ctx.hasF16) {
+			for (const node of graph.nodes) if (node.opType === "MatMulBias" && node.inputs[1]) this.f16WeightNames.add(node.inputs[1]);
+		}
+		this.allocateActivationBuffers();
+	}
+	uploadWeights(weights) {
+		for (const [name, desc] of Object.entries(this.graph.tensors)) {
+			if (desc.storage !== "constant") continue;
+			const w = weights.get(name);
+			if (!w) throw new Error(`VisionExecutor: missing weight "${name}"`);
+			let data = w.data;
+			if (this.f16WeightNames.has(name) && w.data instanceof Float32Array) data = packF16(w.data);
+			const buffer = createStorageBuffer(this.ctx, `vweight_${name}`, data.byteLength, data);
+			this.weightBuffers.set(name, buffer);
+		}
+	}
+	initBindGroups() {
+		const dummyShapes = this.resolveShapes(this.maxPatches);
 		for (const nodeId of this.graph.executionOrder) {
 			const node = this.graph.nodes.find((n) => n.id === nodeId);
 			let spec = KERNEL_REGISTRY[node.opType];
@@ -4281,6 +5547,8 @@ var WebGPUEngine = class WebGPUEngine {
 	_outeTTS = null;
 	/** The preset voice the lazily-built OuteTTS engine was created with. */
 	_outeVoice = null;
+	/** Lazily-created Parler-TTS engine (Flan-T5 encoder + decoder LM + dac_44khz). */
+	_parlerTTS = null;
 	/**
 	* WebKit group-size probe state. When true, a candidate group size is being
 	* tried this page-load and must be promoted (or capped) after the FIRST
@@ -4945,6 +6213,7 @@ var WebGPUEngine = class WebGPUEngine {
 	async speak(text, options = {}) {
 		this.checkDestroyed();
 		const repo = this._createOptions.repo ?? "";
+		if (/parler/i.test(repo) || /parler/i.test(this._architecture)) return this.speakParler(text, options);
 		if (/outetts/i.test(repo) || /oute/i.test(this._architecture)) return this.speakOute(text, options);
 		if (!(this._architecture === "KaniTTS2ForCausalLM" || /kani-tts/i.test(repo) || /\btts\b/i.test(repo))) throw new Error(`speak() requires a Kani-TTS or OuteTTS checkpoint (e.g. "${DEFAULT_MODELS.tts}" or "${DEFAULT_MODELS.ttsOute}"), loaded engine is "${this._architecture}" (repo "${repo}").`);
 		if (!this._kaniTTS) this._kaniTTS = await KaniTTS.create({
@@ -4965,6 +6234,31 @@ var WebGPUEngine = class WebGPUEngine {
 		});
 	}
 	/**
+	* Parler-TTS speak path: lazily build the Parler engine (Flan-T5 description encoder
+	* + cross-attending decoder LM + dac_44khz) and synthesize `text` in the voice given
+	* by `describeVoice`. Single-checkpoint (all weights, incl. the DAC, in one file).
+	*/
+	async speakParler(text, options) {
+		if (!this._parlerTTS) this._parlerTTS = await ParlerTTS.create({
+			repo: this._createOptions.repo,
+			revision: this._createOptions.revision,
+			hfToken: this._createOptions.hfToken,
+			cacheDir: this._createOptions.cacheDir,
+			maxSeqLen: this.maxSeqLen
+		});
+		const speakOpts = {
+			describeVoice: options.describeVoice,
+			temperature: options.temperature,
+			topK: options.topK,
+			maxFrames: options.maxFrames
+		};
+		return this._parlerTTS.speak(text, speakOpts);
+	}
+	/** A random natural-language voice description for Parler-TTS (host template bank). */
+	randomVoiceDescription() {
+		return ParlerTTS.randomVoiceDescription();
+	}
+	/**
 	* OuteTTS speak path: lazily build the OuteTTS engine (loading the chosen preset
 	* voice's speaker JSON + the folded DAC codec weights from the mirror), rebuilding
 	* if the requested voice changed. Mirrors the Kani public shape (temperature/topP/topK).
@@ -5452,12 +6746,12 @@ var WebGPUEngine = class WebGPUEngine {
 			const f = data instanceof Float32Array ? data : new Float32Array(data.buffer);
 			let sum = 0;
 			let maxVal = -Infinity;
-			let argmax$2 = 0;
+			let argmax$3 = 0;
 			for (let i = 0; i < f.length; i++) {
 				sum += f[i];
 				if (f[i] > maxVal) {
 					maxVal = f[i];
-					argmax$2 = i;
+					argmax$3 = i;
 				}
 			}
 			const entry = {
@@ -5470,7 +6764,7 @@ var WebGPUEngine = class WebGPUEngine {
 					Math.round(f[2] * 1e6) / 1e6,
 					Math.round(f[3] * 1e6) / 1e6
 				],
-				argmax: argmax$2,
+				argmax: argmax$3,
 				maxVal: Math.round(maxVal * 1e4) / 1e4
 			};
 			checks.push(entry);
@@ -5725,6 +7019,7 @@ var WebGPUEngine = class WebGPUEngine {
 		this.executor.destroy();
 		this._kaniTTS?.destroy();
 		this._outeTTS?.destroy();
+		this._parlerTTS?.destroy();
 		this.visionExecutor?.destroy();
 		clearPipelineCache(this.ctx.device);
 		this.ctx.device.destroy();
@@ -5735,5 +7030,5 @@ var WebGPUEngine = class WebGPUEngine {
 };
 
 //#endregion
-export { dequantizeMLXProjection as A, dacOutputLength as C, KaniTTS as D, parseOuteTtsConfig as E, patchGemma4VisionClips as M, resolveGemma4VisionInfo as N, generateQwen3_5VisionGraph as O, audioTokensToDacCodes as S, generateOuteTtsBackboneGraph as T, smartResize as _, buildGemma4PosEmbeds as a, buildOutePromptString as b, buildMRoPECosSin as c, buildPositionIds as d, buildRotaryCosSin as f, preprocessImageGemma4 as g, preprocessImage as h, buildGemma4PoolMatrix as i, generateGemma4VisionGraph as j, dequantizeGemma4VisionProjection 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, generateDacSpeechDecoderGraph as w, loadOuteSpeaker as x, OuteTTS as y };
-//# sourceMappingURL=gpu-BECDib8p.mjs.map
+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-DbB321DN.mjs.map