@tryhamster/gerbil 1.2.2 → 1.3.0

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

@@ -1,6 +1,6 @@
-import { n as resolveDefaultRepo, t as DEFAULT_MODELS } from "./defaults-bJcmOaRG.mjs";
-import { E as GEMMA4_VIS_KEYS, 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 initGPU, c as Executor, d as clearPipelineCache, f as createBindGroup, g as getOrCreatePipeline, h as destroyBuffers, i as loadModel, l as KERNEL_REGISTRY, m as createUniformBuffer, o as quantizeKaniBackbone, p as createStorageBuffer, r as loadKaniTTS, s as remapPrunedToken, u as MATMUL_BIAS_F16C_SPEC, v as verifyGPU } from "./moonshine-stt-Bj1zJfZg.mjs";
+import { i as resolveDefaultRepo, n as OUTETTS_ASSETS, r as OUTETTS_PRESET_VOICES, t as DEFAULT_MODELS } from "./defaults-CudhglS1.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";
 
 //#region src/gpu/architectures/gemma4_vision.ts
 /**
@@ -765,9 +765,9 @@ const KANI_END_OF_TEXT = 2;
 const KANI_CODEC_CHUNK_FRAMES = 32;
 const KANI_CODEC_LOOKBACK_FRAMES = 32;
 /** Hard cap so a stuck decode cannot loop forever (reference uses 3000). */
-const DEFAULT_MAX_NEW_TOKENS = 3e3;
+const DEFAULT_MAX_NEW_TOKENS$1 = 3e3;
 /** Build a fresh map of just the constant weights a graph references (see moonshine-stt). */
-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;
@@ -781,7 +781,7 @@ function selectGraphWeights(graph, weights) {
 * Sorts by prob desc, keeps the smallest prefix whose cumulative mass ≥ topP,
 * renormalizes, and samples one id.
 */
-function nucleusSample(probs, ids, topP) {
+function nucleusSample$1(probs, ids, topP) {
 	const n = probs.length;
 	const order = Array.from({ length: n }, (_, i) => i).sort((a, b) => probs[b] - probs[a]);
 	let cum = 0;
@@ -806,7 +806,7 @@ function nucleusSample(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(scores, k) {
+function applyTopK$1(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]);
@@ -816,7 +816,7 @@ function applyTopK(scores, k) {
 	if (keepSum > 0) for (let i = 0; i < n; i++) scores[i] /= keepSum;
 }
 /** In-place softmax of `scores`. */
-function softmaxInPlace(scores) {
+function softmaxInPlace$1(scores) {
 	let maxV = Number.NEGATIVE_INFINITY;
 	for (let i = 0; i < scores.length; i++) if (scores[i] > maxV) maxV = scores[i];
 	let sum = 0;
@@ -834,234 +834,2053 @@ var KaniTTS = class KaniTTS {
 	cfg;
 	rawConfig;
 	maxSeqLen;
-	/** Backbone executor (built once; reused across speak() calls). */
+	/** Backbone executor (built once; reused across speak() calls). */
+	backboneExec;
+	/** The attention layer indices (carry learnable α) and their α values. */
+	attnLayers;
+	layerAlpha;
+	headDim;
+	ropeBase;
+	_destroyed = false;
+	/** Accent/voice tags the loaded checkpoint advertises (empty = single voice). */
+	voiceTags;
+	/** The loaded checkpoint's architecture string ("KaniTTS2ForCausalLM" or "Lfm2ForCausalLM"). */
+	architecture;
+	/** The selected backbone precision ("q4" or "f32"). */
+	dtype;
+	constructor(ctx, loaded, maxSeqLen, dtype) {
+		this.ctx = ctx;
+		this.loaded = loaded;
+		this.tokenizer = loaded.tokenizer;
+		this.rawConfig = loaded.rawConfig;
+		this.cfg = parseKaniConfig(loaded.rawConfig);
+		this.maxSeqLen = maxSeqLen;
+		this.dtype = loaded.preQuantized ? "q4" : dtype;
+		this.architecture = (loaded.rawConfig.architectures ?? [])[0] ?? "Lfm2ForCausalLM";
+		const langSettings = loaded.rawConfig.language_settings;
+		this.voiceTags = Array.isArray(langSettings?.language_tags_list) ? langSettings.language_tags_list.filter((v) => typeof v === "string") : [];
+		const hidden = this.rawConfig.hidden_size;
+		const heads = this.rawConfig.num_attention_heads;
+		this.headDim = this.rawConfig.head_dim ?? Math.floor(hidden / heads);
+		this.ropeBase = this.rawConfig.rope_theta ?? 1e6;
+		this.attnLayers = kaniAttentionLayerIndices(this.rawConfig);
+		this.layerAlpha = /* @__PURE__ */ new Map();
+		const useLearnable = this.rawConfig.use_learnable_rope ?? false;
+		for (const layer of this.attnLayers) {
+			let alpha = 1;
+			if (useLearnable) {
+				const w = loaded.backboneWeights.get(`learnable_rope_layers.${layer}.alpha_weight`);
+				alpha = kaniLayerAlpha(w ? w.data[0] ?? 0 : 0, this.cfg);
+			}
+			this.layerAlpha.set(layer, alpha);
+		}
+		this.backboneExec = this.buildBackbone(ctx, loaded, maxSeqLen);
+	}
+	/**
+	* Build the codec-LM backbone graph, quantize it when q4, and upload its weights
+	* into a fresh Executor. For a pre-quantized (gerbil-int4) checkpoint the linear
+	* projections already carry `.q`/`.scales`/`.zeros`, so quantizeKaniBackbone is an
+	* idempotent no-op (it skips any projection whose `.q` is already present) and the
+	* int4 weights are uploaded verbatim — no on-device re-quantization.
+	*/
+	buildBackbone(ctx, loaded, maxSeqLen) {
+		const useQ4 = this.dtype === "q4";
+		const graph = generateKaniTtsGraph(this.rawConfig, useQ4 ? "q4" : void 0);
+		if (useQ4) quantizeKaniBackbone(graph, loaded.backboneWeights);
+		const exec = new Executor(ctx, graph, {
+			maxSeqLen,
+			kvMode: "f32"
+		});
+		exec.uploadWeightsMap(selectGraphWeights$1(graph, loaded.backboneWeights));
+		exec.initBindGroups();
+		return exec;
+	}
+	static async create(options = {}) {
+		const ctx = await initGPU();
+		const loaded = await loadKaniTTS({
+			repo: options.repo,
+			codecRepo: options.codecRepo,
+			revision: options.revision,
+			hfToken: options.hfToken,
+			cacheDir: options.cacheDir,
+			onProgress: options.onProgress
+		});
+		const ctxLen = loaded.rawConfig.max_position_embeddings ?? 4096;
+		return new KaniTTS(ctx, loaded, Math.min(options.maxSeqLen ?? 2048, ctxLen), options.dtype ?? "q4");
+	}
+	/** Write per-layer cos/sin for token rows [rowStart, rowStart+positions.length). */
+	writeCosSin(positions, rowStart) {
+		const rowBytes = this.headDim * 4;
+		for (const layer of this.attnLayers) {
+			const alpha = this.layerAlpha.get(layer) ?? 1;
+			const { cos, sin } = buildKaniLayerCosSin(positions, this.headDim, this.ropeBase, alpha);
+			if (rowStart === 0) {
+				this.backboneExec.writeInput(kaniCosTensor(layer), cos);
+				this.backboneExec.writeInput(kaniSinTensor(layer), sin);
+			} else {
+				this.backboneExec.writeInputAt(kaniCosTensor(layer), cos, rowStart * rowBytes);
+				this.backboneExec.writeInputAt(kaniSinTensor(layer), sin, rowStart * rowBytes);
+			}
+		}
+	}
+	/**
+	* Accent/voice tags the loaded checkpoint supports. Multi-accent KaniTTS2
+	* checkpoints (kani-tts-2-en) return e.g. ["en_us","en_nyork","en_glasg", …];
+	* the plain LFM2 family (the Apache default) returns [] (one trained voice,
+	* selectable only by fine-tuning the backbone — there is no runtime voice/
+	* speaker-prompt knob, and zero-shot cloning is not wired).
+	*/
+	availableVoices() {
+		return [...this.voiceTags];
+	}
+	/** NanoCodec's fixed output sample rate (Hz). Not selectable — see SpeakResult. */
+	get sampleRate() {
+		return KANI_SAMPLE_RATE;
+	}
+	/**
+	* Synthesize speech for `text`. Returns 22 kHz mono PCM.
+	*
+	* Pipeline: build the [SOH]+text+[EOT,EOH] prompt → prefill the codec-LM →
+	* AR-decode 4-token frames (per-codebook constrained sampling) until end_of_speech
+	* → strip markers → codes → NanoCodec decode → PCM.
+	*/
+	async speak(text, opts = {}) {
+		if (this._destroyed) throw new Error("KaniTTS has been destroyed.");
+		const temperature = opts.temperature ?? 1;
+		const topP = opts.topP ?? .95;
+		const topK = opts.topK ?? 0;
+		const repetitionPenalty = opts.repetitionPenalty ?? 1.1;
+		const maxNewTokens = Math.min(opts.maxNewTokens ?? DEFAULT_MAX_NEW_TOKENS$1, this.maxSeqLen);
+		const promptText = this.voiceTags.length > 0 ? `${(opts.languageTag ?? this.voiceTags[0]).trim()}: ${text}` : text;
+		const prompt = [
+			KANI_START_OF_HUMAN,
+			...this.tokenizer.encode(promptText),
+			KANI_END_OF_TEXT,
+			KANI_END_OF_HUMAN
+		];
+		if (prompt.length >= this.maxSeqLen) throw new Error(`Kani prompt is ${prompt.length} tokens >= maxSeqLen ${this.maxSeqLen}.`);
+		this.backboneExec.reset();
+		const promptPos = computeKaniPositions(prompt, this.cfg);
+		this.writeCosSin(promptPos, 0);
+		const { logits } = await this.backboneExec.forward(new Uint32Array(prompt));
+		const startTime = performance.now();
+		const { audioTokens, finished } = await this.runDecodeLoop(prompt, logits, {
+			temperature,
+			topP,
+			topK,
+			repetitionPenalty,
+			maxNewTokens,
+			maxFrames: opts.maxFrames ?? Number.POSITIVE_INFINITY
+		});
+		const usable = audioTokens.length - audioTokens.length % this.cfg.tokensPerFrame;
+		if (usable === 0) throw new Error(`Kani produced no complete audio frames (finished=${finished}, audioTokens=${audioTokens.length}). The codec-LM emitted no speech.`);
+		const { codes, numFrames } = audioTokensToCodes(audioTokens.slice(0, usable), this.cfg);
+		const pcm = await this.decodeCodes(codes, numFrames);
+		const totalTime = (performance.now() - startTime) / 1e3;
+		const audioSeconds = numFrames * KANI_HOP / KANI_SAMPLE_RATE;
+		console.log(`[kani] frames=${numFrames} audio=${audioSeconds.toFixed(2)}s wall=${totalTime.toFixed(2)}s RTF=${(audioSeconds / totalTime).toFixed(2)}x`);
+		return {
+			pcm,
+			sampleRate: KANI_SAMPLE_RATE,
+			frames: numFrames,
+			audioSeconds
+		};
+	}
+	/**
+	* Autoregressive decode: from the prefill logits, emit one token per step —
+	* greedy for the structural markers ([SOA][SOS]) and per-codebook constrained
+	* sampling once in speech — collecting the audio tokens between SOS and EOS.
+	* Writes each step's per-layer cos/sin row (frame-level logical position) before
+	* the forward. Returns the collected audio tokens and whether EOS/cap was hit.
+	*/
+	async runDecodeLoop(prompt, prefillLogits, p) {
+		const seq = [...prompt];
+		const audioTokens = [];
+		const frameCap = p.maxFrames * this.cfg.tokensPerFrame;
+		let logits = prefillLogits;
+		let inSpeech = false;
+		let finished = false;
+		for (let step = 0; step < p.maxNewTokens; step++) {
+			const nextToken = inSpeech ? this.sampleAudioToken(logits, audioTokens.length % this.cfg.tokensPerFrame, {
+				temperature: p.temperature,
+				topP: p.topP,
+				topK: p.topK,
+				repetitionPenalty: p.repetitionPenalty,
+				previous: seq
+			}) : this.argmax(logits);
+			if (nextToken === this.cfg.startOfSpeech) inSpeech = true;
+			else if (nextToken === this.cfg.endOfSpeech) {
+				seq.push(nextToken);
+				finished = true;
+				break;
+			} else if (inSpeech && nextToken >= this.cfg.audioTokensStart) audioTokens.push(nextToken);
+			seq.push(nextToken);
+			if (inSpeech && audioTokens.length >= frameCap) {
+				finished = true;
+				break;
+			}
+			if (seq.length >= this.maxSeqLen) break;
+			this.writeCosSin(Float32Array.of(this.logicalPositionAt(seq)), this.backboneExec.currentSeqPos);
+			logits = (await this.backboneExec.forward(new Uint32Array([nextToken]))).logits;
+		}
+		return {
+			audioTokens,
+			finished
+		};
+	}
+	/** Logical (frame-level) position of the LAST token in `seq`. */
+	logicalPositionAt(seq) {
+		const positions = computeKaniPositions(seq, this.cfg);
+		return positions[positions.length - 1];
+	}
+	/** Greedy argmax over a logits row. */
+	argmax(logits) {
+		let best = 0;
+		let bestVal = logits[0];
+		for (let i = 1; i < logits.length; i++) if (logits[i] > bestVal) {
+			bestVal = logits[i];
+			best = i;
+		}
+		return best;
+	}
+	/**
+	* Sample one audio token for codebook position `codebook`, constrained to that
+	* codebook's valid window [audio_tokens_start + 4032*c, +4032). Allows end_of_speech
+	* only at codebook 0 (frame boundary). Applies repetition penalty, temperature,
+	* optional top-k, then top-p nucleus sampling.
+	*/
+	sampleAudioToken(logits, codebook, p) {
+		const winStart = this.cfg.audioTokensStart + this.cfg.codebookSize * codebook;
+		const winLen = this.cfg.codebookSize;
+		const allowEos = codebook === 0;
+		const n = winLen + (allowEos ? 1 : 0);
+		const ids = new Int32Array(n);
+		for (let i = 0; i < winLen; i++) ids[i] = winStart + i;
+		if (allowEos) ids[winLen] = this.cfg.endOfSpeech;
+		const prev = p.repetitionPenalty !== 1 ? new Set(p.previous) : null;
+		const scores = new Float32Array(n);
+		for (let i = 0; i < n; i++) {
+			let s = logits[ids[i]];
+			if (prev?.has(ids[i])) s = s > 0 ? s / p.repetitionPenalty : s * p.repetitionPenalty;
+			scores[i] = s / p.temperature;
+		}
+		softmaxInPlace$1(scores);
+		applyTopK$1(scores, p.topK);
+		return nucleusSample$1(scores, ids, p.topP);
+	}
+	/**
+	* Decode NanoCodec codes [groups, T] (group-major) → PCM.
+	*
+	* The decoder graph carries concrete lengths, and the upsampled conv activations
+	* for long clips overflow WebGPU's 65535 per-dimension dispatch cap. The decoder
+	* is fully causal with a small (≤ a few frames) receptive field, so we decode in
+	* frame chunks with a left-context lookback and keep only each chunk's own output
+	* samples — numerically identical to a single decode, but bounded per dispatch.
+	*/
+	async decodeCodes(codes, numFrames) {
+		const groups = 4;
+		const lookback = KANI_CODEC_LOOKBACK_FRAMES;
+		const chunk = KANI_CODEC_CHUNK_FRAMES;
+		const pcm = new Float32Array(numFrames * KANI_HOP);
+		for (let start = 0; start < numFrames; start += chunk) {
+			const ctxStart = Math.max(0, start - lookback);
+			const ctxFrames = start - ctxStart;
+			const end = Math.min(numFrames, start + chunk);
+			const winFrames = end - ctxStart;
+			const winCodes = new Uint32Array(groups * winFrames);
+			for (let g = 0; g < groups; g++) for (let t = 0; t < winFrames; t++) winCodes[g * winFrames + t] = codes[g * numFrames + (ctxStart + t)];
+			const win = await this.decodeCodesWindow(winCodes, winFrames);
+			const dropSamples = ctxFrames * KANI_HOP;
+			const keepSamples = (end - start) * KANI_HOP;
+			pcm.set(win.subarray(dropSamples, dropSamples + keepSamples), start * KANI_HOP);
+		}
+		for (let i = 0; i < pcm.length; i++) pcm[i] = Math.min(1, Math.max(-1, pcm[i]));
+		return pcm;
+	}
+	/** Run the NanoCodec decoder graph for a single (bounded) code window → PCM. */
+	async decodeCodesWindow(winCodes, winFrames) {
+		const graph = generateNanoCodecDecoderGraph({ numFrames: winFrames });
+		const exec = new Executor(this.ctx, graph, {
+			maxSeqLen: winFrames,
+			kvMode: "f32"
+		});
+		try {
+			exec.uploadWeightsMap(selectGraphWeights$1(graph, this.loaded.codecWeights));
+			exec.initBindGroups();
+			exec.reset();
+			exec.writeInput("audio_codes", winCodes);
+			return await exec.runGraphOutput(graph.outputs[0], winFrames * KANI_HOP);
+		} finally {
+			exec.destroy();
+		}
+	}
+	destroy() {
+		if (this._destroyed) return;
+		this._destroyed = true;
+		this.backboneExec.destroy();
+		this.loaded.backboneWeights.clear();
+		this.loaded.codecWeights.clear();
+	}
+};
+
+//#endregion
+//#region src/gpu/architectures/outetts.ts
+const OUTETTS_C1_BASE = 151669;
+const OUTETTS_C2_BASE = 152694;
+const OUTETTS_CODES_PER_CODEBOOK = 1025;
+const OUTETTS_AUDIO_END = 156729;
+const OUTETTS_IM_END = 151645;
+const DAC_SAMPLE_RATE = 24e3;
+const DAC_HOP = 320;
+const DAC_NUM_CODEBOOKS = 2;
+const DAC_CODEBOOK_SIZE = 1024;
+const DAC_CODEBOOK_DIM = 8;
+const DAC_LATENT_DIM = 1024;
+const DAC_DECODER_DIM = 1536;
+const DAC_DECODER_RATES = [
+	8,
+	5,
+	4,
+	2
+];
+const DAC_RESBLOCK_DILATIONS = [
+	1,
+	3,
+	9
+];
+const DAC_ENCODER_DIM = 64;
+const DAC_ENCODER_RATES = [
+	2,
+	4,
+	5,
+	8
+];
+function parseOuteTtsConfig(rawConfig) {
+	const hidden_size = rawConfig.hidden_size;
+	const num_heads = rawConfig.num_attention_heads;
+	return {
+		hidden_size,
+		num_layers: rawConfig.num_hidden_layers,
+		num_heads,
+		num_kv_heads: rawConfig.num_key_value_heads ?? num_heads,
+		head_dim: rawConfig.head_dim ?? Math.floor(hidden_size / num_heads),
+		intermediate_size: rawConfig.intermediate_size,
+		vocab_size: rawConfig.vocab_size,
+		rope_base: rawConfig.rope_theta ?? 1e6,
+		rms_norm_eps: rawConfig.rms_norm_eps ?? 1e-6,
+		max_position_embeddings: rawConfig.max_position_embeddings ?? 40960
+	};
+}
+/**
+* Convert the flat generated token stream (the run BETWEEN <|audio_start|> and
+* <|audio_end|>) into a DAC code grid [NUM_CODEBOOKS, T] (codebook-major [c*T + t]).
+*
+* Mirrors outetts v3 `extract_audio_from_tokens`: filter the stream into two ordered
+* lists by membership of the c1 / c2 ranges, recover the raw code
+* (id − base), drop the reserved index 1024, and truncate to the shorter list. The
+* model emits c1,c2 interleaved per frame, but the parse is membership-based (it does
+* not assume strict pairing) so a stray token cannot desync the grid.
+*/
+function audioTokensToDacCodes(tokenIds) {
+	const c1 = [];
+	const c2 = [];
+	for (const id of tokenIds) if (id >= OUTETTS_C1_BASE && id < OUTETTS_C1_BASE + OUTETTS_CODES_PER_CODEBOOK) {
+		const code = id - OUTETTS_C1_BASE;
+		if (code < DAC_CODEBOOK_SIZE) c1.push(code);
+	} else if (id >= OUTETTS_C2_BASE && id < OUTETTS_C2_BASE + OUTETTS_CODES_PER_CODEBOOK) {
+		const code = id - OUTETTS_C2_BASE;
+		if (code < DAC_CODEBOOK_SIZE) c2.push(code);
+	}
+	const numFrames = Math.min(c1.length, c2.length);
+	const codes = new Uint32Array(DAC_NUM_CODEBOOKS * numFrames);
+	for (let t = 0; t < numFrames; t++) {
+		codes[t] = c1[t];
+		codes[numFrames + t] = c2[t];
+	}
+	return {
+		codes,
+		numFrames
+	};
+}
+/** ConvTranspose1d output length: (L-1)*stride - 2*pad + (K-1) + output_padding + 1. */
+function convTransposeLen(L, stride, K, pad, outPad) {
+	return (L - 1) * stride - 2 * pad + (K - 1) + outPad + 1;
+}
+/** Canonical DAC decoder weight name. */
+function dacKey(name) {
+	return `dac.${name}`;
+}
+function generateDacSpeechDecoderGraph(opts) {
+	const T = opts.numFrames;
+	const tensors = {};
+	const nodes = [];
+	const executionOrder = [];
+	const addTensor = (desc) => {
+		tensors[desc.name] = desc;
+	};
+	const addNode = (node) => {
+		nodes.push(node);
+		executionOrder.push(node.id);
+	};
+	addTensor({
+		name: "audio_codes",
+		shape: [DAC_NUM_CODEBOOKS, T],
+		dtype: "u32",
+		storage: "activation"
+	});
+	addTensor({
+		name: dacKey("quantizer.codebook"),
+		shape: [
+			DAC_NUM_CODEBOOKS,
+			DAC_CODEBOOK_SIZE,
+			DAC_CODEBOOK_DIM
+		],
+		dtype: "f32",
+		storage: "constant",
+		safetensorsKey: dacKey("quantizer.codebook")
+	});
+	addTensor({
+		name: dacKey("quantizer.out_proj.weight"),
+		shape: [
+			DAC_NUM_CODEBOOKS,
+			DAC_LATENT_DIM,
+			DAC_CODEBOOK_DIM
+		],
+		dtype: "f32",
+		storage: "constant",
+		safetensorsKey: dacKey("quantizer.out_proj.weight")
+	});
+	addTensor({
+		name: dacKey("quantizer.out_proj.bias"),
+		shape: [DAC_NUM_CODEBOOKS, DAC_LATENT_DIM],
+		dtype: "f32",
+		storage: "constant",
+		safetensorsKey: dacKey("quantizer.out_proj.bias")
+	});
+	addTensor({
+		name: "dac_latent",
+		shape: [DAC_LATENT_DIM, T],
+		dtype: "f32",
+		storage: "activation"
+	});
+	addNode({
+		id: "dac_rvq",
+		opType: "RVQDequant",
+		inputs: [
+			"audio_codes",
+			dacKey("quantizer.codebook"),
+			dacKey("quantizer.out_proj.weight"),
+			dacKey("quantizer.out_proj.bias")
+		],
+		outputs: ["dac_latent"],
+		attributes: {
+			NCB: DAC_NUM_CODEBOOKS,
+			Cout: DAC_LATENT_DIM,
+			T,
+			D: DAC_CODEBOOK_DIM,
+			codebook_size: DAC_CODEBOOK_SIZE
+		}
+	});
+	/** Emit a full (non-causal) Conv1dFull with symmetric padding. */
+	function conv1dFull(id, input, weightKey, biasKey, Cin, Cout, K, L, dilation, padding, output) {
+		const Lout = Math.floor((L + 2 * padding - dilation * (K - 1) - 1) / 1) + 1;
+		addTensor({
+			name: weightKey,
+			shape: [
+				Cout,
+				Cin,
+				K
+			],
+			dtype: "f32",
+			storage: "constant",
+			safetensorsKey: weightKey
+		});
+		addTensor({
+			name: biasKey,
+			shape: [Cout],
+			dtype: "f32",
+			storage: "constant",
+			safetensorsKey: biasKey
+		});
+		addTensor({
+			name: output,
+			shape: [Cout, Lout],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addNode({
+			id,
+			opType: "Conv1dFull",
+			inputs: [
+				input,
+				weightKey,
+				biasKey
+			],
+			outputs: [output],
+			attributes: {
+				Cin,
+				Cout,
+				L,
+				Lout,
+				K,
+				stride: 1,
+				padding,
+				dilation
+			}
+		});
+		return Lout;
+	}
+	/** Emit a full-channel Snake1d (alpha is [C], stored [1,C,1] → C). */
+	function snake(id, input, C, L, alphaKey, output) {
+		addTensor({
+			name: alphaKey,
+			shape: [C],
+			dtype: "f32",
+			storage: "constant",
+			safetensorsKey: alphaKey
+		});
+		addTensor({
+			name: output,
+			shape: [C, L],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addNode({
+			id,
+			opType: "Snake1d",
+			inputs: [input, alphaKey],
+			outputs: [output],
+			attributes: {
+				C,
+				L
+			}
+		});
+	}
+	/** Emit a strided ConvTranspose1d (weight [Cin, Cout, K]). */
+	function convTranspose(id, input, weightKey, biasKey, Cin, Cout, K, L, stride, padding, outPad, output) {
+		const Lout = convTransposeLen(L, stride, K, padding, outPad);
+		addTensor({
+			name: weightKey,
+			shape: [
+				Cin,
+				Cout,
+				K
+			],
+			dtype: "f32",
+			storage: "constant",
+			safetensorsKey: weightKey
+		});
+		addTensor({
+			name: biasKey,
+			shape: [Cout],
+			dtype: "f32",
+			storage: "constant",
+			safetensorsKey: biasKey
+		});
+		addTensor({
+			name: output,
+			shape: [Cout, Lout],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addNode({
+			id,
+			opType: "ConvTranspose1d",
+			inputs: [
+				input,
+				weightKey,
+				biasKey
+			],
+			outputs: [output],
+			attributes: {
+				Cin,
+				Cout,
+				L,
+				Lout,
+				K,
+				stride,
+				padding,
+				output_padding: outPad
+			}
+		});
+		return Lout;
+	}
+	/** Element-wise residual add of two equal-shape [C, L] activations. */
+	function add(id, a, b, C, L, output) {
+		addTensor({
+			name: output,
+			shape: [C, L],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addNode({
+			id,
+			opType: "Add",
+			inputs: [a, b],
+			outputs: [output],
+			attributes: {
+				count_tensor: a,
+				hidden_size: C * L
+			}
+		});
+	}
+	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++) {
+		const m = stage + 1;
+		const rate = DAC_DECODER_RATES[stage];
+		const outCh = channels / 2;
+		const upK = 2 * rate;
+		const upPad = Math.ceil(rate / 2);
+		const snakeOut = `dac_s${stage}_snake`;
+		snake(`dac_s${stage}_snake_op`, cur, channels, length, dacKey(`decoder.model.${m}.block.0.alpha`), snakeOut);
+		const upOut = `dac_s${stage}_up`;
+		length = convTranspose(`dac_s${stage}_convt`, snakeOut, dacKey(`decoder.model.${m}.block.1.weight`), dacKey(`decoder.model.${m}.block.1.bias`), channels, outCh, upK, length, rate, upPad, 0, upOut);
+		channels = outCh;
+		let h = upOut;
+		for (let r = 0; r < DAC_RESBLOCK_DILATIONS.length; r++) {
+			const ru = r + 2;
+			const dil = DAC_RESBLOCK_DILATIONS[r];
+			const p = `decoder.model.${m}.block.${ru}.block`;
+			const pad = Math.floor(6 * dil / 2);
+			const ia = `dac_s${stage}_r${r}_ia`;
+			snake(`${ia}_op`, h, channels, length, dacKey(`${p}.0.alpha`), ia);
+			const ic = `dac_s${stage}_r${r}_ic`;
+			conv1dFull(`${ic}_op`, ia, dacKey(`${p}.1.weight`), dacKey(`${p}.1.bias`), channels, channels, 7, length, dil, pad, ic);
+			const sa = `dac_s${stage}_r${r}_sa`;
+			snake(`${sa}_op`, ic, channels, length, dacKey(`${p}.2.alpha`), sa);
+			const sc = `dac_s${stage}_r${r}_sc`;
+			conv1dFull(`${sc}_op`, sa, dacKey(`${p}.3.weight`), dacKey(`${p}.3.bias`), channels, channels, 1, length, 1, 0, sc);
+			const resAdd = `dac_s${stage}_r${r}_res`;
+			add(`${resAdd}_op`, h, sc, channels, length, resAdd);
+			h = resAdd;
+		}
+		cur = h;
+	}
+	const postSnake = "dac_post_snake";
+	snake("dac_post_snake_op", cur, channels, length, dacKey("decoder.model.5.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);
+	return {
+		architecture: "DacSpeechDecoder",
+		config: {
+			hidden_size: DAC_DECODER_DIM,
+			num_layers: DAC_DECODER_RATES.length,
+			num_heads: 0,
+			num_kv_heads: 0,
+			head_dim: 0,
+			intermediate_size: 0,
+			vocab_size: 0,
+			context_length: pcmLen,
+			rms_norm_eps: 0,
+			norm_type: "rmsnorm",
+			rope_base: 0,
+			rope_dim: 0,
+			kv_layout: "LHSd",
+			is_moe: false,
+			has_vision_tower: false
+		},
+		capabilities: {
+			text: true,
+			vision: false,
+			moe: false
+		},
+		tensors,
+		nodes,
+		executionOrder,
+		inputs: ["audio_codes"],
+		outputs: [pcm]
+	};
+}
+/** Final decoded PCM length (samples) for a T-frame code grid, via the DAC stage chain. */
+function dacOutputLength(numFrames) {
+	let length = numFrames;
+	for (const rate of DAC_DECODER_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. */
+function conv1dLen(L, K, stride, pad, dilation) {
+	return Math.floor((L + 2 * pad - dilation * (K - 1) - 1) / stride) + 1;
+}
+/** Number of latent frames the encoder produces for `numSamples` of padded 24 kHz PCM. */
+function dacEncoderFrames(numSamples) {
+	let length = numSamples;
+	for (const rate of DAC_ENCODER_RATES) length = conv1dLen(length, 2 * rate, rate, Math.ceil(rate / 2), 1);
+	return length;
+}
+function generateDacSpeechEncoderGraph(opts) {
+	const L0 = opts.numSamples;
+	const tensors = {};
+	const nodes = [];
+	const executionOrder = [];
+	const addTensor = (desc) => {
+		tensors[desc.name] = desc;
+	};
+	const addNode = (node) => {
+		nodes.push(node);
+		executionOrder.push(node.id);
+	};
+	addTensor({
+		name: "pcm_in",
+		shape: [1, L0],
+		dtype: "f32",
+		storage: "activation"
+	});
+	/** Emit a Conv1dFull (symmetric padding) and return its output length. */
+	function conv1dFull(id, input, weightKey, biasKey, Cin, Cout, K, L, stride, dilation, padding, output) {
+		const Lout = conv1dLen(L, K, stride, padding, dilation);
+		addTensor({
+			name: weightKey,
+			shape: [
+				Cout,
+				Cin,
+				K
+			],
+			dtype: "f32",
+			storage: "constant",
+			safetensorsKey: weightKey
+		});
+		addTensor({
+			name: biasKey,
+			shape: [Cout],
+			dtype: "f32",
+			storage: "constant",
+			safetensorsKey: biasKey
+		});
+		addTensor({
+			name: output,
+			shape: [Cout, Lout],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addNode({
+			id,
+			opType: "Conv1dFull",
+			inputs: [
+				input,
+				weightKey,
+				biasKey
+			],
+			outputs: [output],
+			attributes: {
+				Cin,
+				Cout,
+				L,
+				Lout,
+				K,
+				stride,
+				padding,
+				dilation
+			}
+		});
+		return Lout;
+	}
+	/** Emit a full-channel Snake1d (alpha is [C], stored [1,C,1] → C). */
+	function snake(id, input, C, L, alphaKey, output) {
+		addTensor({
+			name: alphaKey,
+			shape: [C],
+			dtype: "f32",
+			storage: "constant",
+			safetensorsKey: alphaKey
+		});
+		addTensor({
+			name: output,
+			shape: [C, L],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addNode({
+			id,
+			opType: "Snake1d",
+			inputs: [input, alphaKey],
+			outputs: [output],
+			attributes: {
+				C,
+				L
+			}
+		});
+	}
+	/** Element-wise residual add of two equal-shape [C, L] activations. */
+	function add(id, a, b, C, L, output) {
+		addTensor({
+			name: output,
+			shape: [C, L],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addNode({
+			id,
+			opType: "Add",
+			inputs: [a, b],
+			outputs: [output],
+			attributes: {
+				count_tensor: a,
+				hidden_size: C * L
+			}
+		});
+	}
+	const encKey = (name) => dacKey(`encoder.${name}`);
+	let cur = "dac_enc_conv0";
+	let length = conv1dFull("dac_enc_conv0_op", "pcm_in", encKey("block.0.weight"), encKey("block.0.bias"), 1, DAC_ENCODER_DIM, 7, L0, 1, 1, 3, cur);
+	let channels = DAC_ENCODER_DIM;
+	for (let stage = 0; stage < DAC_ENCODER_RATES.length; stage++) {
+		const m = stage + 1;
+		const rate = DAC_ENCODER_RATES[stage];
+		let h = cur;
+		for (let r = 0; r < DAC_RESBLOCK_DILATIONS.length; r++) {
+			const dil = DAC_RESBLOCK_DILATIONS[r];
+			const p = `block.${m}.block.${r}.block`;
+			const pad = Math.floor(6 * dil / 2);
+			const ia = `dac_enc_s${stage}_r${r}_ia`;
+			snake(`${ia}_op`, h, channels, length, encKey(`${p}.0.alpha`), ia);
+			const ic = `dac_enc_s${stage}_r${r}_ic`;
+			conv1dFull(`${ic}_op`, ia, encKey(`${p}.1.weight`), encKey(`${p}.1.bias`), channels, channels, 7, length, 1, dil, pad, ic);
+			const sa = `dac_enc_s${stage}_r${r}_sa`;
+			snake(`${sa}_op`, ic, channels, length, encKey(`${p}.2.alpha`), sa);
+			const sc = `dac_enc_s${stage}_r${r}_sc`;
+			conv1dFull(`${sc}_op`, sa, encKey(`${p}.3.weight`), encKey(`${p}.3.bias`), channels, channels, 1, length, 1, 1, 0, sc);
+			const resAdd = `dac_enc_s${stage}_r${r}_res`;
+			add(`${resAdd}_op`, h, sc, channels, length, resAdd);
+			h = resAdd;
+		}
+		const snakeOut = `dac_enc_s${stage}_snake`;
+		snake(`${snakeOut}_op`, h, channels, length, encKey(`block.${m}.block.3.alpha`), snakeOut);
+		const outCh = channels * 2;
+		const downOut = `dac_enc_s${stage}_down`;
+		length = conv1dFull(`${downOut}_op`, snakeOut, encKey(`block.${m}.block.4.weight`), encKey(`block.${m}.block.4.bias`), channels, outCh, 2 * rate, length, rate, 1, Math.ceil(rate / 2), downOut);
+		channels = outCh;
+		cur = downOut;
+	}
+	const postSnake = "dac_enc_post_snake";
+	snake("dac_enc_post_snake_op", cur, channels, length, encKey("block.5.alpha"), postSnake);
+	const latent = "dac_enc_latent";
+	const T = conv1dFull("dac_enc_conv6_op", postSnake, encKey("block.6.weight"), encKey("block.6.bias"), channels, DAC_LATENT_DIM, 3, length, 1, 1, 1, latent);
+	addTensor({
+		name: dacKey("quantizer.in_proj.weight"),
+		shape: [
+			DAC_NUM_CODEBOOKS,
+			DAC_CODEBOOK_DIM,
+			DAC_LATENT_DIM
+		],
+		dtype: "f32",
+		storage: "constant",
+		safetensorsKey: dacKey("quantizer.in_proj.weight")
+	});
+	addTensor({
+		name: dacKey("quantizer.in_proj.bias"),
+		shape: [DAC_NUM_CODEBOOKS, DAC_CODEBOOK_DIM],
+		dtype: "f32",
+		storage: "constant",
+		safetensorsKey: dacKey("quantizer.in_proj.bias")
+	});
+	addTensor({
+		name: dacKey("quantizer.codebook"),
+		shape: [
+			DAC_NUM_CODEBOOKS,
+			DAC_CODEBOOK_SIZE,
+			DAC_CODEBOOK_DIM
+		],
+		dtype: "f32",
+		storage: "constant",
+		safetensorsKey: dacKey("quantizer.codebook")
+	});
+	addTensor({
+		name: dacKey("quantizer.out_proj.weight"),
+		shape: [
+			DAC_NUM_CODEBOOKS,
+			DAC_LATENT_DIM,
+			DAC_CODEBOOK_DIM
+		],
+		dtype: "f32",
+		storage: "constant",
+		safetensorsKey: dacKey("quantizer.out_proj.weight")
+	});
+	addTensor({
+		name: dacKey("quantizer.out_proj.bias"),
+		shape: [DAC_NUM_CODEBOOKS, DAC_LATENT_DIM],
+		dtype: "f32",
+		storage: "constant",
+		safetensorsKey: dacKey("quantizer.out_proj.bias")
+	});
+	addTensor({
+		name: "dac_codes",
+		shape: [DAC_NUM_CODEBOOKS, T],
+		dtype: "u32",
+		storage: "activation"
+	});
+	addNode({
+		id: "dac_rvq_encode",
+		opType: "RVQEncode",
+		inputs: [
+			latent,
+			dacKey("quantizer.in_proj.weight"),
+			dacKey("quantizer.in_proj.bias"),
+			dacKey("quantizer.codebook"),
+			dacKey("quantizer.out_proj.weight"),
+			dacKey("quantizer.out_proj.bias")
+		],
+		outputs: ["dac_codes"],
+		attributes: {
+			NCB: DAC_NUM_CODEBOOKS,
+			Cout: DAC_LATENT_DIM,
+			T,
+			D: DAC_CODEBOOK_DIM,
+			codebook_size: DAC_CODEBOOK_SIZE
+		}
+	});
+	return {
+		architecture: "DacSpeechEncoder",
+		config: {
+			hidden_size: DAC_LATENT_DIM,
+			num_layers: DAC_ENCODER_RATES.length,
+			num_heads: 0,
+			num_kv_heads: 0,
+			head_dim: 0,
+			intermediate_size: 0,
+			vocab_size: 0,
+			context_length: T,
+			rms_norm_eps: 0,
+			norm_type: "rmsnorm",
+			rope_base: 0,
+			rope_dim: 0,
+			kv_layout: "LHSd",
+			is_moe: false,
+			has_vision_tower: false
+		},
+		capabilities: {
+			text: true,
+			vision: false,
+			moe: false
+		},
+		tensors,
+		nodes,
+		executionOrder,
+		inputs: ["pcm_in"],
+		outputs: ["dac_codes"]
+	};
+}
+function generateOuteTtsBackboneGraph(rawConfig, dtype, groupSize, kvDtype) {
+	const cfg = parseOuteTtsConfig(rawConfig);
+	const useQ4 = dtype === "q4";
+	const groupSz = groupSize ?? DEFAULT_GROUP_SIZE;
+	const hidden_size = cfg.hidden_size;
+	const num_layers = cfg.num_layers;
+	const num_heads = cfg.num_heads;
+	const num_kv_heads = cfg.num_kv_heads;
+	const head_dim = cfg.head_dim;
+	const rope_dim = head_dim;
+	const rope_base = cfg.rope_base;
+	const rms_norm_eps = cfg.rms_norm_eps;
+	const intermediate_size = cfg.intermediate_size;
+	const vocab_size = cfg.vocab_size;
+	const q_dim = num_heads * head_dim;
+	const kv_dim = num_kv_heads * head_dim;
+	const kvCacheDtype = kvDtype ?? "f32";
+	const config = {
+		hidden_size,
+		num_layers,
+		num_heads,
+		num_kv_heads,
+		head_dim,
+		intermediate_size,
+		vocab_size,
+		context_length: cfg.max_position_embeddings,
+		rms_norm_eps,
+		norm_type: "rmsnorm",
+		rope_base,
+		rope_dim,
+		kv_layout: "LHSd",
+		is_moe: false,
+		has_vision_tower: false
+	};
+	const tensors = {};
+	const nodes = [];
+	const executionOrder = [];
+	const addTensor = (desc) => {
+		tensors[desc.name] = desc;
+	};
+	const addNode = (node) => {
+		nodes.push(node);
+		executionOrder.push(node.id);
+	};
+	const addLinear = (id, activationInput, weightName, weightShape, outputName, K, N) => {
+		if (useQ4) {
+			const totalElements = K * N;
+			addTensor({
+				name: `${weightName}.q`,
+				shape: [Math.ceil(totalElements / 8)],
+				dtype: "u32",
+				storage: "constant"
+			});
+			addTensor({
+				name: `${weightName}.scales`,
+				shape: [Math.ceil(totalElements / groupSz)],
+				dtype: "f32",
+				storage: "constant"
+			});
+			addTensor({
+				name: `${weightName}.zeros`,
+				shape: [Math.ceil(totalElements / groupSz)],
+				dtype: "f32",
+				storage: "constant"
+			});
+			addNode({
+				id,
+				opType: "MatMulInt4",
+				inputs: [
+					activationInput,
+					`${weightName}.q`,
+					`${weightName}.scales`,
+					`${weightName}.zeros`
+				],
+				outputs: [outputName],
+				attributes: {
+					M_tensor: activationInput,
+					K,
+					N,
+					group_size: groupSz
+				}
+			});
+			return;
+		}
+		addTensor({
+			name: weightName,
+			shape: weightShape,
+			dtype: "f32",
+			storage: "constant",
+			safetensorsKey: weightName
+		});
+		addNode({
+			id,
+			opType: "MatMul",
+			inputs: [activationInput, weightName],
+			outputs: [outputName],
+			attributes: {
+				M_tensor: activationInput,
+				K,
+				N
+			}
+		});
+	};
+	addTensor({
+		name: "input_ids",
+		shape: ["T"],
+		dtype: "u32",
+		storage: "activation"
+	});
+	addTensor({
+		name: "embed_out",
+		shape: ["T", hidden_size],
+		dtype: "f32",
+		storage: "activation"
+	});
+	addTensor({
+		name: CANONICAL_KEYS.EMBED,
+		shape: [vocab_size, hidden_size],
+		dtype: "f32",
+		storage: "constant",
+		safetensorsKey: CANONICAL_KEYS.EMBED
+	});
+	addNode({
+		id: "embed",
+		opType: "Embedding",
+		inputs: ["input_ids", CANONICAL_KEYS.EMBED],
+		outputs: ["embed_out"],
+		attributes: {
+			vocab_size,
+			hidden_size
+		}
+	});
+	let prevOutput = "embed_out";
+	for (let i = 0; i < num_layers; i++) {
+		const prefix = `layer${i}`;
+		const normW = CANONICAL_KEYS.layerInputNorm(i);
+		addTensor({
+			name: normW,
+			shape: [hidden_size],
+			dtype: "f32",
+			storage: "constant",
+			safetensorsKey: normW
+		});
+		const norm1Out = `${prefix}_norm1_out`;
+		addTensor({
+			name: norm1Out,
+			shape: ["T", hidden_size],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addNode({
+			id: `${prefix}_norm1`,
+			opType: "RMSNorm",
+			inputs: [prevOutput, normW],
+			outputs: [norm1Out],
+			attributes: {
+				hidden_size,
+				eps: rms_norm_eps,
+				seq_len_tensor: prevOutput
+			}
+		});
+		const qOut = `${prefix}_q`;
+		const kOut = `${prefix}_k`;
+		const vOut = `${prefix}_v`;
+		addTensor({
+			name: qOut,
+			shape: ["T", q_dim],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addTensor({
+			name: kOut,
+			shape: ["T", kv_dim],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addTensor({
+			name: vOut,
+			shape: ["T", kv_dim],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addLinear(`${prefix}_q_proj`, norm1Out, CANONICAL_KEYS.qProj(i), [q_dim, hidden_size], qOut, hidden_size, q_dim);
+		addLinear(`${prefix}_k_proj`, norm1Out, CANONICAL_KEYS.kProj(i), [kv_dim, hidden_size], kOut, hidden_size, kv_dim);
+		addLinear(`${prefix}_v_proj`, norm1Out, CANONICAL_KEYS.vProj(i), [kv_dim, hidden_size], vOut, hidden_size, kv_dim);
+		const qNormW = CANONICAL_KEYS.qNorm(i);
+		const kNormW = CANONICAL_KEYS.kNorm(i);
+		addTensor({
+			name: qNormW,
+			shape: [head_dim],
+			dtype: "f32",
+			storage: "constant",
+			safetensorsKey: qNormW
+		});
+		addTensor({
+			name: kNormW,
+			shape: [head_dim],
+			dtype: "f32",
+			storage: "constant",
+			safetensorsKey: kNormW
+		});
+		const qNormed = `${prefix}_q_normed`;
+		const kNormed = `${prefix}_k_normed`;
+		addTensor({
+			name: qNormed,
+			shape: ["T", q_dim],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addTensor({
+			name: kNormed,
+			shape: ["T", kv_dim],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addNode({
+			id: `${prefix}_q_norm`,
+			opType: "RMSNorm",
+			inputs: [qOut, qNormW],
+			outputs: [qNormed],
+			attributes: {
+				hidden_size: head_dim,
+				eps: rms_norm_eps,
+				seq_len_tensor: qOut
+			}
+		});
+		addNode({
+			id: `${prefix}_k_norm`,
+			opType: "RMSNorm",
+			inputs: [kOut, kNormW],
+			outputs: [kNormed],
+			attributes: {
+				hidden_size: head_dim,
+				eps: rms_norm_eps,
+				seq_len_tensor: kOut
+			}
+		});
+		addNode({
+			id: `${prefix}_rope`,
+			opType: "RoPE",
+			inputs: [qNormed, kNormed],
+			outputs: [qNormed, kNormed],
+			attributes: {
+				head_dim,
+				num_q_heads: num_heads,
+				num_kv_heads,
+				rope_base,
+				rope_dim,
+				seq_len_tensor: qNormed
+			}
+		});
+		const kCache = `${prefix}_k_cache`;
+		const vCache = `${prefix}_v_cache`;
+		addTensor({
+			name: kCache,
+			shape: ["L_max", kv_dim],
+			dtype: kvCacheDtype,
+			storage: "kv_cache"
+		});
+		addTensor({
+			name: vCache,
+			shape: ["L_max", kv_dim],
+			dtype: kvCacheDtype,
+			storage: "kv_cache"
+		});
+		addNode({
+			id: `${prefix}_kv_cache_k`,
+			opType: "KVCacheAppend",
+			inputs: [kNormed],
+			outputs: [kCache],
+			attributes: {
+				width: kv_dim,
+				T_tensor: kNormed
+			}
+		});
+		addNode({
+			id: `${prefix}_kv_cache_v`,
+			opType: "KVCacheAppend",
+			inputs: [vOut],
+			outputs: [vCache],
+			attributes: {
+				width: kv_dim,
+				T_tensor: vOut
+			}
+		});
+		const attnOut = `${prefix}_attn_out`;
+		addTensor({
+			name: attnOut,
+			shape: ["T", q_dim],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addNode({
+			id: `${prefix}_attn`,
+			opType: "Attention",
+			inputs: [
+				qNormed,
+				kCache,
+				vCache
+			],
+			outputs: [attnOut],
+			attributes: {
+				hidden_size: q_dim,
+				num_q_heads: num_heads,
+				num_kv_heads,
+				head_dim,
+				causal: true,
+				layer_index: i
+			}
+		});
+		const oProjOut = `${prefix}_o_proj_out`;
+		addTensor({
+			name: oProjOut,
+			shape: ["T", hidden_size],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addLinear(`${prefix}_o_proj`, attnOut, CANONICAL_KEYS.oProj(i), [hidden_size, q_dim], oProjOut, q_dim, hidden_size);
+		const resid1Out = `${prefix}_resid1`;
+		const postNormW = CANONICAL_KEYS.layerPostAttnNorm(i);
+		const norm2Out = `${prefix}_norm2_out`;
+		addTensor({
+			name: resid1Out,
+			shape: ["T", hidden_size],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addTensor({
+			name: postNormW,
+			shape: [hidden_size],
+			dtype: "f32",
+			storage: "constant",
+			safetensorsKey: postNormW
+		});
+		addTensor({
+			name: norm2Out,
+			shape: ["T", hidden_size],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addNode({
+			id: `${prefix}_resid1_norm2`,
+			opType: "ResidualRMSNorm",
+			inputs: [
+				prevOutput,
+				oProjOut,
+				postNormW
+			],
+			outputs: [resid1Out, norm2Out],
+			attributes: {
+				hidden_size,
+				eps: rms_norm_eps,
+				seq_len_tensor: prevOutput
+			}
+		});
+		const gateOut = `${prefix}_gate_out`;
+		const upOut = `${prefix}_up_out`;
+		const swigluOut = `${prefix}_swiglu_out`;
+		const mlpOut = `${prefix}_mlp_out`;
+		addTensor({
+			name: gateOut,
+			shape: ["T", intermediate_size],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addTensor({
+			name: upOut,
+			shape: ["T", intermediate_size],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addTensor({
+			name: swigluOut,
+			shape: ["T", intermediate_size],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addTensor({
+			name: mlpOut,
+			shape: ["T", hidden_size],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addLinear(`${prefix}_gate`, norm2Out, CANONICAL_KEYS.gateProj(i), [intermediate_size, hidden_size], gateOut, hidden_size, intermediate_size);
+		addLinear(`${prefix}_up`, norm2Out, CANONICAL_KEYS.upProj(i), [intermediate_size, hidden_size], upOut, hidden_size, intermediate_size);
+		addNode({
+			id: `${prefix}_swiglu`,
+			opType: "SwiGLU",
+			inputs: [gateOut, upOut],
+			outputs: [swigluOut],
+			attributes: { count_tensor: gateOut }
+		});
+		addLinear(`${prefix}_down`, swigluOut, CANONICAL_KEYS.downProj(i), [hidden_size, intermediate_size], mlpOut, intermediate_size, hidden_size);
+		const resid2Out = `${prefix}_resid2`;
+		addTensor({
+			name: resid2Out,
+			shape: ["T", hidden_size],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addNode({
+			id: `${prefix}_resid2`,
+			opType: "Add",
+			inputs: [resid1Out, mlpOut],
+			outputs: [resid2Out],
+			attributes: {
+				count_tensor: resid1Out,
+				hidden_size
+			}
+		});
+		prevOutput = resid2Out;
+	}
+	addTensor({
+		name: CANONICAL_KEYS.FINAL_NORM,
+		shape: [hidden_size],
+		dtype: "f32",
+		storage: "constant",
+		safetensorsKey: CANONICAL_KEYS.FINAL_NORM
+	});
+	addTensor({
+		name: "final_norm_out",
+		shape: ["T", hidden_size],
+		dtype: "f32",
+		storage: "activation"
+	});
+	addNode({
+		id: "final_norm",
+		opType: "RMSNorm",
+		inputs: [prevOutput, CANONICAL_KEYS.FINAL_NORM],
+		outputs: ["final_norm_out"],
+		attributes: {
+			hidden_size,
+			eps: rms_norm_eps,
+			seq_len_tensor: prevOutput
+		}
+	});
+	addTensor({
+		name: "final_norm_last",
+		shape: [1, hidden_size],
+		dtype: "f32",
+		storage: "activation"
+	});
+	addNode({
+		id: "slice_last_row",
+		opType: "SliceLastRow",
+		inputs: ["final_norm_out"],
+		outputs: ["final_norm_last"],
+		attributes: { width: hidden_size }
+	});
+	addTensor({
+		name: "logits",
+		shape: [1, vocab_size],
+		dtype: "f32",
+		storage: "activation"
+	});
+	addNode({
+		id: "lm_head",
+		opType: "MatMul",
+		inputs: ["final_norm_last", CANONICAL_KEYS.EMBED],
+		outputs: ["logits"],
+		attributes: {
+			M_tensor: "final_norm_last",
+			K: hidden_size,
+			N: vocab_size
+		}
+	});
+	return {
+		architecture: "Qwen3ForCausalLM",
+		config,
+		capabilities: {
+			text: true,
+			vision: false,
+			moe: false
+		},
+		tensors,
+		nodes,
+		executionOrder,
+		inputs: ["input_ids"],
+		outputs: ["logits"]
+	};
+}
+
+//#endregion
+//#region src/gpu/outetts-encode.ts
+/**
+* OuteTTS voice-clone helpers — prosody feature extraction + word alignment for
+* `OuteTTS.encodeSpeaker` (raw audio → OuteSpeaker). These are a faithful port of
+* outetts v3 `audio_processor.Features` (energy / spectral_centroid / pitch) and the
+* `create_speaker_from_dict` word loop, so the per-word feature tokens the prompt
+* 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`).
+*/
+const DAC_TPS = 75;
+const WHITESPACE_RE = /\s+/;
+const PITCH_MIN_FREQ = 75;
+const PITCH_MAX_FREQ = 600;
+const PITCH_FRAME_LEN = 400;
+const PITCH_HOP = 160;
+const PITCH_THRESHOLD = .3;
+const FEATURE_EPS = 1e-10;
+/** Round a [0,1] value to the [0,100] integer bucket the prompt builder expects. */
+function scaleValue(value) {
+	return Math.round(Math.min(Math.max(value, 0), 1) * 100);
+}
+/** Naive DFT magnitude spectrum of a real signal (length N → ⌊N/2⌋+1 bins). */
+function rfftMag(x) {
+	const N = x.length;
+	const bins = Math.floor(N / 2) + 1;
+	const mag = new Float32Array(bins);
+	for (let k = 0; k < bins; k++) {
+		let re = 0;
+		let im = 0;
+		const w = -2 * Math.PI * k / N;
+		for (let n = 0; n < N; n++) {
+			const a = w * n;
+			re += x[n] * Math.cos(a);
+			im += x[n] * Math.sin(a);
+		}
+		mag[k] = Math.hypot(re, im);
+	}
+	return mag;
+}
+/**
+* RMS energy of a clip, normalized to [0,1] (the reference clamps via scaleValue).
+* Matches `Features.extract_audio_features` energy = sqrt(mean(x^2)).
+*/
+function rmsEnergy(audio) {
+	let sum = 0;
+	for (let i = 0; i < audio.length; i++) sum += audio[i] * audio[i];
+	return audio.length ? Math.sqrt(sum / audio.length) : 0;
+}
+/**
+* Spectral centroid normalized to [0,1] of (sr/2). Matches the reference:
+* centroid = Σ f·|rfft(x)| / Σ|rfft(x)|, then / (sr/2).
+*/
+function spectralCentroid(audio, sr) {
+	if (audio.length === 0) return 0;
+	const spec = rfftMag(audio);
+	const nyquist = sr / 2;
+	const bins = spec.length;
+	let specSum = FEATURE_EPS;
+	let weighted = 0;
+	for (let k = 0; k < bins; k++) {
+		const freq = bins > 1 ? k / (bins - 1) * nyquist : 0;
+		weighted += freq * spec[k];
+		specSum += spec[k];
+	}
+	return weighted / specSum / nyquist;
+}
+/** Hann window of length N (periodic=false, matching torch.hann_window default). */
+function hannWindow(N) {
+	const w = new Float32Array(N);
+	for (let n = 0; n < N; n++) w[n] = .5 - .5 * Math.cos(2 * Math.PI * n / (N - 1));
+	return w;
+}
+/**
+* Autocorrelation-based average pitch normalized to [0,1] over [min,max] freq.
+* Faithful port of `calculate_pitch` + `extract_single_pitch_value`: framed Hann-
+* windowed autocorrelation, per-frame parabolic-interpolated peak in the valid lag
+* range, voicing threshold, then the mean over frames mapped to [0,1].
+*/
+/** Hann-windowed autocorrelation of one frame into `autocorr` (lag 0..frameLen-1). */
+function frameAutocorr(padded, off, window, frame, autocorr) {
+	for (let i = 0; i < PITCH_FRAME_LEN; i++) frame[i] = padded[off + i] * window[i];
+	for (let lag = 0; lag < PITCH_FRAME_LEN; lag++) {
+		let acc = 0;
+		for (let i = 0; i + lag < PITCH_FRAME_LEN; i++) acc += frame[i] * frame[i + lag];
+		autocorr[lag] = acc;
+	}
+}
+/** Voiced pitch (Hz) of one autocorrelation frame, or 0 if unvoiced. */
+function framePitch(autocorr, minIdx, maxIdx, sr) {
+	let peakIdx = minIdx;
+	let peakVal = Number.NEGATIVE_INFINITY;
+	for (let lag = minIdx; lag < maxIdx; lag++) if (autocorr[lag] > peakVal) {
+		peakVal = autocorr[lag];
+		peakIdx = lag;
+	}
+	const idx = Math.min(Math.max(peakIdx, 1), PITCH_FRAME_LEN - 2);
+	const alpha = autocorr[idx - 1];
+	const beta = autocorr[idx];
+	const gamma = autocorr[idx + 1];
+	let delta = .5 * (alpha - gamma) / (alpha - 2 * beta + gamma + 1e-8);
+	if (!(peakIdx > 0 && peakIdx < PITCH_FRAME_LEN - 1)) delta = 0;
+	const period = (peakIdx + delta) / sr;
+	let pitch = period > 0 ? 1 / period : 0;
+	if (!(peakVal / (autocorr[0] + 1e-8) > PITCH_THRESHOLD)) pitch = 0;
+	return Math.min(Math.max(pitch, PITCH_MIN_FREQ), PITCH_MAX_FREQ);
+}
+function averagePitch(audio, sr) {
+	const N = audio.length;
+	if (N < PITCH_FRAME_LEN) return 0;
+	const padLen = (PITCH_FRAME_LEN - N % PITCH_HOP) % PITCH_HOP;
+	const padded = new Float32Array(N + padLen);
+	padded.set(audio);
+	const numFrames = Math.floor((padded.length - PITCH_FRAME_LEN) / PITCH_HOP) + 1;
+	if (numFrames <= 0) return 0;
+	const window = hannWindow(PITCH_FRAME_LEN);
+	const minIdx = Math.max(1, Math.floor(sr / PITCH_MAX_FREQ));
+	const maxIdx = Math.min(PITCH_FRAME_LEN, Math.floor(sr / PITCH_MIN_FREQ));
+	const frame = new Float32Array(PITCH_FRAME_LEN);
+	const autocorr = new Float32Array(PITCH_FRAME_LEN);
+	let pitchSum = 0;
+	for (let f = 0; f < numFrames; f++) {
+		frameAutocorr(padded, f * PITCH_HOP, window, frame, autocorr);
+		pitchSum += framePitch(autocorr, minIdx, maxIdx, sr);
+	}
+	return (pitchSum / numFrames - PITCH_MIN_FREQ) / (PITCH_MAX_FREQ - PITCH_MIN_FREQ);
+}
+/**
+* Port of `Features.extract_audio_features`: energy (RMS), spectral_centroid (FFT
+* centroid), pitch (autocorrelation), each scaled to the [0,100] integer bucket.
+* Returns all-zero defaults for an empty/invalid clip (matching the reference).
+*/
+function extractAudioFeatures(audio, sr) {
+	if (audio.length === 0) return {
+		energy: 0,
+		spectral_centroid: 0,
+		pitch: 0
+	};
+	return {
+		energy: scaleValue(rmsEnergy(audio)),
+		spectral_centroid: scaleValue(spectralCentroid(audio, sr)),
+		pitch: scaleValue(averagePitch(audio, sr))
+	};
+}
+/**
+* Pragmatic word→frame alignment (no on-device Whisper): split the transcript into
+* whitespace words and distribute the `numFrames` encoded frames across them
+* proportionally to each word's character length. Returns contiguous [start,end)
+* frame spans covering the whole clip. This stands in for outetts' Whisper word-
+* timestamp slicing — the codes themselves are exact; only the per-word boundaries
+* are approximate.
+*/
+function alignWordsProportional(transcript, numFrames) {
+	const words = transcript.split(WHITESPACE_RE).filter((w) => w.length > 0);
+	if (words.length === 0) return [];
+	const weights = words.map((w) => w.length);
+	const totalWeight = weights.reduce((a, b) => a + b, 0);
+	const out = [];
+	let acc = 0;
+	for (let i = 0; i < words.length; i++) {
+		const startFrame = i === 0 ? 0 : Math.round(acc / totalWeight * numFrames);
+		acc += weights[i];
+		const endFrame = i === words.length - 1 ? numFrames : Math.round(acc / totalWeight * numFrames);
+		out.push({
+			word: words[i],
+			startFrame,
+			endFrame: Math.max(endFrame, startFrame)
+		});
+	}
+	return out;
+}
+
+//#endregion
+//#region src/gpu/outetts.ts
+/**
+* OuteTTS — native text-to-speech engine for Gerbil's WebGPU backend.
+*
+* OuteTTS-1.0-0.6B (OuteAI/OuteTTS-1.0-0.6B) is a two-stage codec-LM TTS, the same
+* shape as Kani-TTS but with a plain Qwen3-0.6B backbone and the descript-audio-codec
+* DAC.speech.v1.0 decoder (24 kHz, 2 codebooks):
+*
+*   1. CODEC-LM BACKBONE (Qwen3-0.6B): autoregressively emits interleaved audio codes
+*      <|c1_i|>/<|c2_i|> (one pair per 512-sample frame) into the same vocab as text,
+*      between <|audio_start|> and <|audio_end|>. Standard Qwen3 block math
+*      (RMSNorm/QK-RMSNorm/full RoPE/GQA/SwiGLU) with a KV-cache decode path
+*      (generateOuteTtsBackboneGraph) — simpler than Kani's LFM2 hybrid.
+*   2. DAC.speech.v1.0 DECODER: RVQ dequant (2× codebook lookup + out_proj) → latent
+*      [1024,T] → DacDecoder (Conv1d + 4 upsample blocks + Snake + tanh) → 24 kHz PCM.
+*      Validated bit-exact vs the torch DAC reference (scripts/engine/test-outetts-codec.mjs,
+*      latent max|err| 2.9e-6, PCM max|err| 1.3e-6, cos 1.0).
+*
+* The AR loop runs on the host with full-logit readback; each step samples the next
+* audio token constrained to the current codebook's valid window (c1 on even
+* positions, c2 on odd), until <|audio_end|>. The collected tokens are split into a
+* [2, T] code grid (audioTokensToDacCodes) and decoded once through the DAC graph.
+*
+* This is the FOUNDATION: a single preset voice (OuteTTS's bundled en-female-1-neutral
+* speaker, embedded as in-context reference codes). Cloning, int4, the speak()/useTTS
+* public surface, R2 mirror, and the playground are a later phase.
+*/
+const DEFAULT_MAX_NEW_TOKENS = 4096;
+const CONTROL_CHARS_RE = /[\x00-\x1F\x7F-\x9F­​-‍]/g;
+const HIRAGANA_RE = /[぀-ゟ]/;
+const KATAKANA_RE = /[゠-ヿ]/;
+const HAN_RE = /[一-鿿]/;
+const HTTP_URL_RE = /^https?:\/\//;
+const TRAILING_SLASH_RE = /\/$/;
+/** Port of PromptProcessor.text_normalizations (the ftfy step is approximated). */
+function normalizeOuteText(input) {
+	let text = input.normalize("NFKC");
+	text = text.replace(/…/g, "...");
+	text = text.replace(/\.{2,}/g, "...");
+	text = text.replace(/[“”„‟«»]/g, "\"");
+	text = text.replace(/[‘’‛‹›`´]/g, "'");
+	text = text.replace(/[–—―−‐]/g, "-");
+	text = text.replace(/-{2,}/g, "-");
+	text = text.replace(CONTROL_CHARS_RE, "");
+	text = text.replace(/\s+/g, " ");
+	text = text.replace(/\s+([,.?!:;])/g, "$1");
+	text = text.replace(/([,.?!:;])(?=[^\s,.?!:;])/g, "$1 ");
+	text = text.replace(/(\w)\s+'\s*(\w)/g, "$1'$2");
+	text = text.replace(/(\w)\s+'\s*([,.?!:;\s]|$)/g, "$1'$2");
+	text = text.replace(/(\w)\s*'\s*([tsdmreSNTDMRE])\b/gi, "$1'$2");
+	text = text.replace(/([?!])\1+/g, "$1");
+	text = text.replace(/\s+/g, " ");
+	text = text.replace(/"/g, "").trim();
+	return text;
+}
+/** Port of PromptProcessor._get_separator (CJK-aware). */
+function outeSeparator(text) {
+	const hasHiragana = HIRAGANA_RE.test(text);
+	const hasKatakana = KATAKANA_RE.test(text);
+	const hasHan = HAN_RE.test(text);
+	if (hasHiragana || hasKatakana || hasHan) return "。";
+	return ". ";
+}
+/**
+* Port of PromptProcessor.merge_speaker_text: prepend the (normalized) speaker
+* transcript in front of the target text, joined by the right separator, and return
+* the trailing-separator string that outetts appends to the speaker's LAST word.
+*/
+function mergeSpeakerText(inputText, speakerText) {
+	const sp = speakerText.trim();
+	const separator = outeSeparator(sp);
+	const allowedEnds = separator === "。" ? [
+		"。",
+		"？",
+		"！",
+		"?",
+		"!"
+	] : [
+		".",
+		"?",
+		"!"
+	];
+	let rs = "";
+	if (sp) {
+		const last = sp[sp.length - 1];
+		if (!allowedEnds.includes(last)) rs = separator;
+		else if (separator !== "。") rs = " ";
+	}
+	return {
+		merged: sp + rs + inputText.trim(),
+		sep: rs.trim()
+	};
+}
+/** Format one word's feature tokens (energy / spectral_centroid / pitch). */
+function outeFeatureTokens(f) {
+	return `<|energy_${f?.energy ?? 0}|><|spectral_centroid_${f?.spectral_centroid ?? 0}|><|pitch_${f?.pitch ?? 0}|>`;
+}
+/** Port of PromptProcessor.create_codes: one <|word_start|>…<|word_end|> block per word, "\n"-joined. */
+function createSpeakerCodes(words) {
+	const blocks = [];
+	for (const w of words) {
+		const duration = (w.duration ?? 0).toFixed(2);
+		let block = `${w.word}<|features|><|t_${duration}|>${outeFeatureTokens(w.features)}`;
+		const n = Math.min(w.c1.length, w.c2.length);
+		let pairs = "";
+		for (let i = 0; i < n; i++) pairs += `<|c1_${w.c1[i]}|><|c2_${w.c2[i]}|>`;
+		block += `<|code|>${pairs}`;
+		blocks.push(`<|word_start|>${block}<|word_end|>`);
+	}
+	return blocks.join("\n");
+}
+/**
+* Build the OuteTTS v3 completion prompt STRING (outetts get_completion_prompt). The
+* whole prompt — text section, speaker word blocks (word + time/energy/spectral/pitch
+* features + interleaved c1/c2 codes), and the dangling <|word_start|> cue — is
+* assembled with literal <|...|> markers; the caller tokenizes it in one pass. Exposed
+* for token-level validation against the Python reference (test-outetts-prompt.mjs).
+*/
+function buildOutePromptString(text, speaker) {
+	const normalized = normalizeOuteText(text);
+	let promptText = normalized;
+	let codes = "";
+	if (speaker) {
+		const { merged, sep } = mergeSpeakerText(normalized, speaker.text);
+		promptText = merged;
+		codes = createSpeakerCodes(speaker.words.map((w, i) => i === speaker.words.length - 1 ? {
+			...w,
+			word: w.word + sep
+		} : w));
+	}
+	let prompt = `<|im_start|>\n<|text_start|>${promptText}<|text_end|>\n<|audio_start|>\n`;
+	if (speaker) prompt += `${codes}\n<|word_start|>`;
+	return prompt;
+}
+/**
+* Load an OuteTTS preset speaker (the in-context reference voice). Accepts a full URL
+* (mirror), a local file path (Node), or a bare preset name resolved against
+* `baseURL/{name}.json`. The returned object is the OuteSpeaker the prompt builder
+* embeds (transcript + per-word c1/c2 reference codes + prosody features).
+*/
+async function loadOuteSpeaker(voiceOrUrl, baseURL) {
+	if (HTTP_URL_RE.test(voiceOrUrl)) {
+		const resp$1 = await fetch(voiceOrUrl);
+		if (!resp$1.ok) throw new Error(`Failed to fetch OuteTTS speaker ${voiceOrUrl}: ${resp$1.status}`);
+		return await resp$1.json();
+	}
+	if (voiceOrUrl.includes("/") || voiceOrUrl.endsWith(".json")) {
+		const fs = await import("node:fs").catch(() => null);
+		if (fs) return JSON.parse(fs.readFileSync(voiceOrUrl, "utf8"));
+	}
+	if (!baseURL) throw new Error(`loadOuteSpeaker: "${voiceOrUrl}" is a preset name but no baseURL was provided.`);
+	const url = `${baseURL.replace(TRAILING_SLASH_RE, "")}/${voiceOrUrl}.json`;
+	const resp = await fetch(url);
+	if (!resp.ok) throw new Error(`Failed to fetch OuteTTS preset "${voiceOrUrl}" from ${url}: ${resp.status}`);
+	return await resp.json();
+}
+/** Build a fresh map of just the constant weights a graph references (see kani-tts). */
+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;
+}
+/** Index of the maximum logit (greedy / argmax decode). */
+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;
+}
+/** In-place softmax of `scores`. */
+function softmaxInPlace(scores) {
+	let maxV = Number.NEGATIVE_INFINITY;
+	for (const v of scores) if (v > maxV) maxV = v;
+	let sum = 0;
+	for (let i = 0; i < scores.length; i++) {
+		const e = Math.exp(scores[i] - maxV);
+		scores[i] = e;
+		sum += e;
+	}
+	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;
+	const order = Array.from({ length: n }, (_, i) => i).sort((a, b) => probs[b] - probs[a]);
+	let cum = 0;
+	let cutoff = n;
+	for (let r = 0; r < n; r++) {
+		cum += probs[order[r]];
+		if (cum >= topP) {
+			cutoff = r + 1;
+			break;
+		}
+	}
+	let keepSum = 0;
+	for (let r = 0; r < cutoff; r++) keepSum += probs[order[r]];
+	let pick = Math.random() * keepSum;
+	for (let r = 0; r < cutoff; r++) {
+		pick -= probs[order[r]];
+		if (pick <= 0) return ids[order[r]];
+	}
+	return ids[order[0]];
+}
+/**
+* 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
+* (the DAC encoder is robust to the small interpolation error vs torchaudio's
+* sinc resampler — the cloned codes are stable).
+*/
+function resampleMono(audio, srcRate, targetRate) {
+	if (srcRate === targetRate) return audio;
+	const ratio = targetRate / srcRate;
+	const outLen = Math.max(1, Math.round(audio.length * ratio));
+	const out = new Float32Array(outLen);
+	for (let i = 0; i < outLen; i++) {
+		const srcPos = i / ratio;
+		const i0 = Math.floor(srcPos);
+		const i1 = Math.min(i0 + 1, audio.length - 1);
+		const frac = srcPos - i0;
+		out[i] = audio[i0] * (1 - frac) + audio[i1] * frac;
+	}
+	return out;
+}
+var OuteTTS = class OuteTTS {
+	ctx;
+	loaded;
+	tokenizer;
+	maxSeqLen;
 	backboneExec;
-	/** The attention layer indices (carry learnable α) and their α values. */
-	attnLayers;
-	layerAlpha;
-	headDim;
-	ropeBase;
+	speaker;
 	_destroyed = false;
-	/** Accent/voice tags the loaded checkpoint advertises (empty = single voice). */
-	voiceTags;
-	/** The loaded checkpoint's architecture string ("KaniTTS2ForCausalLM" or "Lfm2ForCausalLM"). */
-	architecture;
+	sampleRate = DAC_SAMPLE_RATE;
 	/** The selected backbone precision ("q4" or "f32"). */
 	dtype;
-	constructor(ctx, loaded, maxSeqLen, dtype) {
+	constructor(ctx, loaded, maxSeqLen, dtype, speaker) {
 		this.ctx = ctx;
 		this.loaded = loaded;
 		this.tokenizer = loaded.tokenizer;
-		this.rawConfig = loaded.rawConfig;
-		this.cfg = parseKaniConfig(loaded.rawConfig);
 		this.maxSeqLen = maxSeqLen;
-		this.dtype = loaded.preQuantized ? "q4" : dtype;
-		this.architecture = (loaded.rawConfig.architectures ?? [])[0] ?? "Lfm2ForCausalLM";
-		const langSettings = loaded.rawConfig.language_settings;
-		this.voiceTags = Array.isArray(langSettings?.language_tags_list) ? langSettings.language_tags_list.filter((v) => typeof v === "string") : [];
-		const hidden = this.rawConfig.hidden_size;
-		const heads = this.rawConfig.num_attention_heads;
-		this.headDim = this.rawConfig.head_dim ?? Math.floor(hidden / heads);
-		this.ropeBase = this.rawConfig.rope_theta ?? 1e6;
-		this.attnLayers = kaniAttentionLayerIndices(this.rawConfig);
-		this.layerAlpha = /* @__PURE__ */ new Map();
-		const useLearnable = this.rawConfig.use_learnable_rope ?? false;
-		for (const layer of this.attnLayers) {
-			let alpha = 1;
-			if (useLearnable) {
-				const w = loaded.backboneWeights.get(`learnable_rope_layers.${layer}.alpha_weight`);
-				alpha = kaniLayerAlpha(w ? w.data[0] ?? 0 : 0, this.cfg);
-			}
-			this.layerAlpha.set(layer, alpha);
-		}
-		this.backboneExec = this.buildBackbone(ctx, loaded, maxSeqLen);
-	}
-	/**
-	* Build the codec-LM backbone graph, quantize it when q4, and upload its weights
-	* into a fresh Executor. For a pre-quantized (gerbil-int4) checkpoint the linear
-	* projections already carry `.q`/`.scales`/`.zeros`, so quantizeKaniBackbone is an
-	* idempotent no-op (it skips any projection whose `.q` is already present) and the
-	* int4 weights are uploaded verbatim — no on-device re-quantization.
-	*/
-	buildBackbone(ctx, loaded, maxSeqLen) {
-		const useQ4 = this.dtype === "q4";
-		const graph = generateKaniTtsGraph(this.rawConfig, useQ4 ? "q4" : void 0);
-		if (useQ4) quantizeKaniBackbone(graph, loaded.backboneWeights);
+		this.speaker = speaker;
+		this.dtype = dtype;
+		const useQ4 = dtype === "q4";
+		const graph = generateOuteTtsBackboneGraph(loaded.rawConfig, useQ4 ? "q4" : void 0);
+		if (useQ4) quantizeBackboneInt4(graph, loaded.backboneWeights);
 		const exec = new Executor(ctx, graph, {
 			maxSeqLen,
 			kvMode: "f32"
 		});
 		exec.uploadWeightsMap(selectGraphWeights(graph, loaded.backboneWeights));
 		exec.initBindGroups();
-		return exec;
+		this.backboneExec = exec;
 	}
-	static async create(options = {}) {
+	static async create(options) {
 		const ctx = await initGPU();
-		const loaded = await loadKaniTTS({
+		const loaded = await loadOuteTTS({
 			repo: options.repo,
-			codecRepo: options.codecRepo,
+			codecWeightsPath: options.codecWeightsPath,
 			revision: options.revision,
 			hfToken: options.hfToken,
 			cacheDir: options.cacheDir,
 			onProgress: options.onProgress
 		});
-		const ctxLen = loaded.rawConfig.max_position_embeddings ?? 4096;
-		return new KaniTTS(ctx, loaded, Math.min(options.maxSeqLen ?? 2048, ctxLen), options.dtype ?? "q4");
-	}
-	/** Write per-layer cos/sin for token rows [rowStart, rowStart+positions.length). */
-	writeCosSin(positions, rowStart) {
-		const rowBytes = this.headDim * 4;
-		for (const layer of this.attnLayers) {
-			const alpha = this.layerAlpha.get(layer) ?? 1;
-			const { cos, sin } = buildKaniLayerCosSin(positions, this.headDim, this.ropeBase, alpha);
-			if (rowStart === 0) {
-				this.backboneExec.writeInput(kaniCosTensor(layer), cos);
-				this.backboneExec.writeInput(kaniSinTensor(layer), sin);
-			} else {
-				this.backboneExec.writeInputAt(kaniCosTensor(layer), cos, rowStart * rowBytes);
-				this.backboneExec.writeInputAt(kaniSinTensor(layer), sin, rowStart * rowBytes);
-			}
-		}
+		const ctxLen = loaded.rawConfig.max_position_embeddings ?? 40960;
+		return new OuteTTS(ctx, loaded, Math.min(options.maxSeqLen ?? 4096, ctxLen), options.dtype ?? "q4", options.speaker);
 	}
 	/**
-	* Accent/voice tags the loaded checkpoint supports. Multi-accent KaniTTS2
-	* checkpoints (kani-tts-2-en) return e.g. ["en_us","en_nyork","en_glasg", …];
-	* the plain LFM2 family (the Apache default) returns [] (one trained voice,
-	* selectable only by fine-tuning the backbone — there is no runtime voice/
-	* speaker-prompt knob, and zero-shot cloning is not wired).
+	* Build the synthesis prompt as a STRING (outetts v3 get_completion_prompt) and
+	* tokenize in one pass. With a speaker, the speaker transcript is merged in front of
+	* the target text (merge_speaker_text), the speaker's reference word blocks
+	* (word + <|features|> + <|t_dur|> + energy/spectral_centroid/pitch + <|code|> +
+	* c1/c2 pairs) are embedded in-context, and the prompt ends with a dangling
+	* <|word_start|> to cue generation. Without a speaker, a plain text-only prompt.
+	*
+	*   <|im_start|>\n<|text_start|>{text}<|text_end|>\n<|audio_start|>\n
+	*     [ {speaker word blocks "\n"-joined} \n <|word_start|> ]
+	*
+	* This reproduces the reference token layout EXACTLY (validated to the byte vs
+	* outetts.PromptProcessor — see scripts/engine/outetts-ref-prompt.py and
+	* test-outetts-prompt.mjs). The per-word time/feature tokens were the gating fix:
+	* the earlier foundation dropped them and the backbone produced incoherent audio.
 	*/
-	availableVoices() {
-		return [...this.voiceTags];
-	}
-	/** NanoCodec's fixed output sample rate (Hz). Not selectable — see SpeakResult. */
-	get sampleRate() {
-		return KANI_SAMPLE_RATE;
+	buildPrompt(text, speaker) {
+		return this.tokenizer.encode(buildOutePromptString(text, speaker ?? this.speaker));
 	}
 	/**
-	* Synthesize speech for `text`. Returns 22 kHz mono PCM.
+	* Synthesize speech for `text`. Returns 24 kHz mono PCM.
 	*
-	* Pipeline: build the [SOH]+text+[EOT,EOH] prompt → prefill the codec-LM →
-	* AR-decode 4-token frames (per-codebook constrained sampling) until end_of_speech
-	* → strip markers → codes → NanoCodec decode → PCM.
+	* Pipeline: build prompt → prefill backbone → AR-decode interleaved c1/c2 audio
+	* tokens until <|audio_end|> → split to a [2, T] DAC code grid → DAC decode → tanh
+	* → PCM.
 	*/
 	async speak(text, opts = {}) {
-		if (this._destroyed) throw new Error("KaniTTS has been destroyed.");
-		const temperature = opts.temperature ?? 1;
-		const topP = opts.topP ?? .95;
-		const topK = opts.topK ?? 0;
-		const repetitionPenalty = opts.repetitionPenalty ?? 1.1;
-		const maxNewTokens = Math.min(opts.maxNewTokens ?? DEFAULT_MAX_NEW_TOKENS, this.maxSeqLen);
-		const promptText = this.voiceTags.length > 0 ? `${(opts.languageTag ?? this.voiceTags[0]).trim()}: ${text}` : text;
-		const prompt = [
-			KANI_START_OF_HUMAN,
-			...this.tokenizer.encode(promptText),
-			KANI_END_OF_TEXT,
-			KANI_END_OF_HUMAN
-		];
-		if (prompt.length >= this.maxSeqLen) throw new Error(`Kani prompt is ${prompt.length} tokens >= maxSeqLen ${this.maxSeqLen}.`);
-		this.backboneExec.reset();
-		const promptPos = computeKaniPositions(prompt, this.cfg);
-		this.writeCosSin(promptPos, 0);
-		const { logits } = await this.backboneExec.forward(new Uint32Array(prompt));
+		if (this._destroyed) throw new Error("OuteTTS has been destroyed.");
 		const startTime = performance.now();
-		const { audioTokens, finished } = await this.runDecodeLoop(prompt, logits, {
-			temperature,
-			topP,
-			topK,
-			repetitionPenalty,
-			maxNewTokens,
-			maxFrames: opts.maxFrames ?? Number.POSITIVE_INFINITY
-		});
-		const usable = audioTokens.length - audioTokens.length % this.cfg.tokensPerFrame;
-		if (usable === 0) throw new Error(`Kani produced no complete audio frames (finished=${finished}, audioTokens=${audioTokens.length}). The codec-LM emitted no speech.`);
-		const { codes, numFrames } = audioTokensToCodes(audioTokens.slice(0, usable), this.cfg);
+		const audioTokens = await this.generateTokens(text, opts);
+		const { codes, numFrames } = audioTokensToDacCodes(audioTokens);
+		if (numFrames === 0) throw new Error(`OuteTTS produced no complete audio frames (audioTokens=${audioTokens.length}).`);
 		const pcm = await this.decodeCodes(codes, numFrames);
 		const totalTime = (performance.now() - startTime) / 1e3;
-		const audioSeconds = numFrames * KANI_HOP / KANI_SAMPLE_RATE;
-		console.log(`[kani] frames=${numFrames} audio=${audioSeconds.toFixed(2)}s wall=${totalTime.toFixed(2)}s RTF=${(audioSeconds / totalTime).toFixed(2)}x`);
+		const audioSeconds = pcm.length / DAC_SAMPLE_RATE;
+		console.log(`[outetts] frames=${numFrames} audio=${audioSeconds.toFixed(2)}s wall=${totalTime.toFixed(2)}s RTF=${(audioSeconds / totalTime).toFixed(2)}x`);
 		return {
 			pcm,
-			sampleRate: KANI_SAMPLE_RATE,
+			sampleRate: DAC_SAMPLE_RATE,
 			frames: numFrames,
 			audioSeconds
 		};
 	}
 	/**
-	* Autoregressive decode: from the prefill logits, emit one token per step —
-	* greedy for the structural markers ([SOA][SOS]) and per-codebook constrained
-	* sampling once in speech — collecting the audio tokens between SOS and EOS.
-	* Writes each step's per-layer cos/sin row (frame-level logical position) before
-	* the forward. Returns the collected audio tokens and whether EOS/cap was hit.
+	* Build an in-context speaker reference for voice cloning.
+	*
+	* Two inputs are supported:
+	*  1. A pre-encoded {@link OuteSpeaker} (transcript + per-word c1/c2 DAC codes +
+	*     prosody features — the preset-JSON shape). Returned verbatim.
+	*  2. Raw audio (Float32 PCM + transcript). The clip is resampled to 24 kHz mono,
+	*     hop-padded, run through the DAC.speech ENCODER + RVQ-encode on the GPU
+	*     (generateDacSpeechEncoderGraph; encoder latent validated bit-exact and codes
+	*     450/450 vs torch DAC.encode — scripts/engine/test-outetts-encode.mjs), then
+	*     split into per-word {@link OuteSpeakerWord} blocks with prosody features.
+	*
+	* 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.
+	*/
+	async encodeSpeaker(ref) {
+		if ("words" in ref && "text" in ref) return ref;
+		if (this._destroyed) throw new Error("OuteTTS has been destroyed.");
+		const { audio, sampleRate, transcript } = ref;
+		if (!audio || audio.length === 0) throw new Error("OuteTTS.encodeSpeaker: empty audio.");
+		if (!transcript || transcript.trim().length === 0) throw new Error("OuteTTS.encodeSpeaker: a transcript of the clip is required.");
+		const mono = resampleMono(audio, sampleRate, DAC_SAMPLE_RATE);
+		const paddedLen = Math.ceil(mono.length / DAC_HOP) * DAC_HOP;
+		const pcm = new Float32Array(paddedLen);
+		pcm.set(mono);
+		const numFrames = dacEncoderFrames(paddedLen);
+		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 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);
+			return {
+				word: a.word,
+				duration: Math.round((a.endFrame - a.startFrame) / DAC_TPS * 100) / 100,
+				c1: Array.from(c1All.subarray(a.startFrame, a.endFrame)),
+				c2: Array.from(c2All.subarray(a.startFrame, a.endFrame)),
+				features
+			};
+		});
+		return {
+			text: transcript.trim(),
+			words
+		};
+	}
+	/** Run the DAC.speech encoder + RVQ-encode graph → codebook-major codes[NCB·T] (u32). */
+	async encodeAudioToCodes(pcm, numFrames) {
+		const graph = generateDacSpeechEncoderGraph({ numSamples: pcm.length });
+		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("pcm_in", pcm);
+			const raw = await exec.runGraphOutput("dac_codes", DAC_NUM_CODEBOOKS * numFrames);
+			return new Uint32Array(raw.buffer, raw.byteOffset, DAC_NUM_CODEBOOKS * numFrames).slice();
+		} finally {
+			exec.destroy();
+		}
+	}
+	/** Build the prompt, prefill, and AR-decode the raw generated token stream. */
+	async generateTokens(text, opts) {
+		const prompt = this.buildPrompt(text, opts.speaker);
+		if (prompt.length >= this.maxSeqLen) throw new Error(`OuteTTS prompt is ${prompt.length} tokens >= maxSeqLen ${this.maxSeqLen}.`);
+		this.backboneExec.reset();
+		const { logits } = await this.backboneExec.forward(new Uint32Array(prompt));
+		return this.runDecodeLoop(prompt, logits, {
+			temperature: opts.temperature ?? .4,
+			topP: opts.topP ?? .9,
+			topK: opts.topK ?? 40,
+			repetitionPenalty: opts.repetitionPenalty ?? 1.1,
+			repetitionRange: opts.repetitionRange ?? 64,
+			maxNewTokens: Math.min(opts.maxNewTokens ?? DEFAULT_MAX_NEW_TOKENS, this.maxSeqLen),
+			greedy: opts.greedy ?? false
+		});
+	}
+	/** Test hook: return the raw generated token stream (no DAC decode). */
+	async generateTokensForTest(text, opts = {}) {
+		return this.generateTokens(text, opts);
+	}
+	/**
+	* Autoregressive decode: from the prefill logits, sample one token per step over the
+	* full vocab (greedy argmax, or temperature/top-k/top-p with repetition penalty).
+	* Stops at <|audio_end|>/<|im_end|> or the token cap. Returns the raw token stream
+	* (word-block structure + interleaved c1/c2 codes); audioTokensToDacCodes extracts
+	* the codes.
 	*/
 	async runDecodeLoop(prompt, prefillLogits, p) {
 		const seq = [...prompt];
-		const audioTokens = [];
-		const frameCap = p.maxFrames * this.cfg.tokensPerFrame;
+		const generated = [];
 		let logits = prefillLogits;
-		let inSpeech = false;
-		let finished = false;
 		for (let step = 0; step < p.maxNewTokens; step++) {
-			const nextToken = inSpeech ? this.sampleAudioToken(logits, audioTokens.length % this.cfg.tokensPerFrame, {
+			const next = p.greedy ? argmax$1(logits) : this.sampleToken(logits, {
 				temperature: p.temperature,
 				topP: p.topP,
 				topK: p.topK,
 				repetitionPenalty: p.repetitionPenalty,
-				previous: seq
-			}) : this.argmax(logits);
-			if (nextToken === this.cfg.startOfSpeech) inSpeech = true;
-			else if (nextToken === this.cfg.endOfSpeech) {
-				seq.push(nextToken);
-				finished = true;
-				break;
-			} else if (inSpeech && nextToken >= this.cfg.audioTokensStart) audioTokens.push(nextToken);
-			seq.push(nextToken);
-			if (inSpeech && audioTokens.length >= frameCap) {
-				finished = true;
-				break;
-			}
+				previous: seq.slice(-p.repetitionRange)
+			});
+			if (next === OUTETTS_AUDIO_END || next === OUTETTS_IM_END) break;
+			generated.push(next);
+			seq.push(next);
 			if (seq.length >= this.maxSeqLen) break;
-			this.writeCosSin(Float32Array.of(this.logicalPositionAt(seq)), this.backboneExec.currentSeqPos);
-			logits = (await this.backboneExec.forward(new Uint32Array([nextToken]))).logits;
-		}
-		return {
-			audioTokens,
-			finished
-		};
-	}
-	/** Logical (frame-level) position of the LAST token in `seq`. */
-	logicalPositionAt(seq) {
-		const positions = computeKaniPositions(seq, this.cfg);
-		return positions[positions.length - 1];
-	}
-	/** Greedy argmax over a logits row. */
-	argmax(logits) {
-		let best = 0;
-		let bestVal = logits[0];
-		for (let i = 1; i < logits.length; i++) if (logits[i] > bestVal) {
-			bestVal = logits[i];
-			best = i;
+			logits = (await this.backboneExec.forward(new Uint32Array([next]))).logits;
 		}
-		return best;
+		return generated;
 	}
 	/**
-	* Sample one audio token for codebook position `codebook`, constrained to that
-	* codebook's valid window [audio_tokens_start + 4032*c, +4032). Allows end_of_speech
-	* only at codebook 0 (frame boundary). Applies repetition penalty, temperature,
-	* optional top-k, then top-p nucleus sampling.
+	* Sample one token over the FULL vocab: repetition penalty over the recent window,
+	* then temperature → top-k → top-p nucleus. (OuteTTS emits structural word-block
+	* tokens interleaved with audio codes, so the sampler must not be window-restricted.)
 	*/
-	sampleAudioToken(logits, codebook, p) {
-		const winStart = this.cfg.audioTokensStart + this.cfg.codebookSize * codebook;
-		const winLen = this.cfg.codebookSize;
-		const allowEos = codebook === 0;
-		const n = winLen + (allowEos ? 1 : 0);
+	sampleToken(logits, p) {
+		const n = logits.length;
 		const ids = new Int32Array(n);
-		for (let i = 0; i < winLen; i++) ids[i] = winStart + i;
-		if (allowEos) ids[winLen] = this.cfg.endOfSpeech;
-		const prev = p.repetitionPenalty !== 1 ? new Set(p.previous) : null;
 		const scores = new Float32Array(n);
+		const prev = p.repetitionPenalty !== 1 ? new Set(p.previous) : null;
 		for (let i = 0; i < n; i++) {
-			let s = logits[ids[i]];
-			if (prev?.has(ids[i])) s = s > 0 ? s / p.repetitionPenalty : s * p.repetitionPenalty;
+			ids[i] = i;
+			let s = logits[i];
+			if (prev?.has(i)) s = s > 0 ? s / p.repetitionPenalty : s * p.repetitionPenalty;
 			scores[i] = s / p.temperature;
 		}
 		softmaxInPlace(scores);
@@ -1069,47 +2888,29 @@ var KaniTTS = class KaniTTS {
 		return nucleusSample(scores, ids, p.topP);
 	}
 	/**
-	* Decode NanoCodec codes [groups, T] (group-major) → PCM.
-	*
-	* The decoder graph carries concrete lengths, and the upsampled conv activations
-	* for long clips overflow WebGPU's 65535 per-dimension dispatch cap. The decoder
-	* is fully causal with a small (≤ a few frames) receptive field, so we decode in
-	* frame chunks with a left-context lookback and keep only each chunk's own output
-	* samples — numerically identical to a single decode, but bounded per dispatch.
+	* Decode the [2, T] DAC code grid (codebook-major) → PCM, applying the final tanh.
+	* The DAC decoder is non-causal (symmetric padding) and its odd rate-5 transpose
+	* makes interior windows position-dependent, so the whole clip is decoded in ONE
+	* pass (no chunking). The codec conv/Snake/Add kernels use 2D dispatch (the
+	* dispatch2D helper) so even multi-second clips stay under WebGPU's 65535 per-dim
+	* workgroup cap.
 	*/
 	async decodeCodes(codes, numFrames) {
-		const groups = 4;
-		const lookback = KANI_CODEC_LOOKBACK_FRAMES;
-		const chunk = KANI_CODEC_CHUNK_FRAMES;
-		const pcm = new Float32Array(numFrames * KANI_HOP);
-		for (let start = 0; start < numFrames; start += chunk) {
-			const ctxStart = Math.max(0, start - lookback);
-			const ctxFrames = start - ctxStart;
-			const end = Math.min(numFrames, start + chunk);
-			const winFrames = end - ctxStart;
-			const winCodes = new Uint32Array(groups * winFrames);
-			for (let g = 0; g < groups; g++) for (let t = 0; t < winFrames; t++) winCodes[g * winFrames + t] = codes[g * numFrames + (ctxStart + t)];
-			const win = await this.decodeCodesWindow(winCodes, winFrames);
-			const dropSamples = ctxFrames * KANI_HOP;
-			const keepSamples = (end - start) * KANI_HOP;
-			pcm.set(win.subarray(dropSamples, dropSamples + keepSamples), start * KANI_HOP);
-		}
-		for (let i = 0; i < pcm.length; i++) pcm[i] = Math.min(1, Math.max(-1, pcm[i]));
-		return pcm;
-	}
-	/** Run the NanoCodec decoder graph for a single (bounded) code window → PCM. */
-	async decodeCodesWindow(winCodes, winFrames) {
-		const graph = generateNanoCodecDecoderGraph({ numFrames: winFrames });
+		const graph = generateDacSpeechDecoderGraph({ numFrames });
+		const pcmLen = dacOutputLength(numFrames);
 		const exec = new Executor(this.ctx, graph, {
-			maxSeqLen: winFrames,
+			maxSeqLen: numFrames,
 			kvMode: "f32"
 		});
 		try {
 			exec.uploadWeightsMap(selectGraphWeights(graph, this.loaded.codecWeights));
 			exec.initBindGroups();
 			exec.reset();
-			exec.writeInput("audio_codes", winCodes);
-			return await exec.runGraphOutput(graph.outputs[0], winFrames * KANI_HOP);
+			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();
 		}
@@ -2476,6 +4277,10 @@ var WebGPUEngine = class WebGPUEngine {
 	_createOptions;
 	/** Lazily-created Kani-TTS engine (codec-LM + NanoCodec) backing speak(). */
 	_kaniTTS = null;
+	/** Lazily-created OuteTTS engine (Qwen3-0.6B codec-LM + DAC.speech) backing speak(). */
+	_outeTTS = null;
+	/** The preset voice the lazily-built OuteTTS engine was created with. */
+	_outeVoice = 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
@@ -3140,7 +4945,8 @@ var WebGPUEngine = class WebGPUEngine {
 	async speak(text, options = {}) {
 		this.checkDestroyed();
 		const repo = this._createOptions.repo ?? "";
-		if (!(this._architecture === "KaniTTS2ForCausalLM" || /kani-tts/i.test(repo) || /\btts\b/i.test(repo))) throw new Error(`speak() requires a Kani-TTS checkpoint (e.g. "${DEFAULT_MODELS.tts}"), loaded engine is "${this._architecture}" (repo "${repo}").`);
+		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({
 			repo: this._createOptions.repo,
 			revision: this._createOptions.revision,
@@ -3158,8 +4964,69 @@ var WebGPUEngine = class WebGPUEngine {
 			maxFrames: options.maxFrames
 		});
 	}
+	/**
+	* 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).
+	*/
+	async speakOute(text, options) {
+		await this.ensureOute(options);
+		return this._outeTTS.speak(text, {
+			temperature: options.temperature,
+			topP: options.topP,
+			topK: options.topK,
+			repetitionPenalty: options.repetitionPenalty,
+			speaker: options.cloneSpeaker
+		});
+	}
+	/**
+	* Lazily build (or reuse) the OuteTTS engine for the requested preset voice,
+	* rebuilding if the voice changed. Loads the preset speaker JSON + folded DAC
+	* codec weights from the mirror (or a locally-cached `{cacheDir}/{voice}.json`).
+	* Shared by {@link speakOute} and {@link encodeSpeaker}.
+	*/
+	async ensureOute(options) {
+		const voice = options.voice ?? OUTETTS_ASSETS.defaultVoice;
+		if (this._outeTTS && this._outeVoice !== voice) {
+			this._outeTTS.destroy();
+			this._outeTTS = null;
+		}
+		if (this._outeTTS) return;
+		const cacheDir = this._createOptions.cacheDir;
+		let speakerRef = voice;
+		if (cacheDir) {
+			const local = `${cacheDir.replace(/\/$/, "")}/${voice}.json`;
+			if ((await import("node:fs").catch(() => null))?.existsSync(local)) speakerRef = local;
+		}
+		const speaker = await loadOuteSpeaker(speakerRef, OUTETTS_ASSETS.speakersBaseURL);
+		this._outeTTS = await OuteTTS.create({
+			repo: this._createOptions.repo,
+			revision: this._createOptions.revision,
+			hfToken: this._createOptions.hfToken,
+			cacheDir: this._createOptions.cacheDir,
+			maxSeqLen: this.maxSeqLen,
+			dtype: options.dtype ?? "q4",
+			codecWeightsPath: options.codecWeightsPath ?? OUTETTS_ASSETS.codecWeightsURL,
+			speaker
+		});
+		this._outeVoice = voice;
+	}
+	/**
+	* OuteTTS voice cloning: encode a raw reference clip (mono PCM + its transcript)
+	* into a reusable speaker (DAC.speech encode → per-word c1/c2 codes + prosody).
+	* Pass the result to `speak(text, { cloneSpeaker })` to synthesize new text in that
+	* voice. Requires an OuteTTS checkpoint (the folded codec carries the encoder).
+	*/
+	async encodeSpeaker(ref) {
+		this.checkDestroyed();
+		const repo = this._createOptions.repo ?? "";
+		if (!(/outetts/i.test(repo) || /oute/i.test(this._architecture))) throw new Error(`encodeSpeaker() requires an OuteTTS checkpoint (e.g. "${DEFAULT_MODELS.ttsOute}"), loaded engine is "${this._architecture}" (repo "${repo}").`);
+		await this.ensureOute({});
+		return this._outeTTS.encodeSpeaker(ref);
+	}
 	/** Accent/voice tags the lazily-built TTS engine supports ([] = single voice). */
 	ttsVoices() {
+		if (/outetts/i.test(this._createOptions.repo ?? "") || /oute/i.test(this._architecture)) return [...OUTETTS_PRESET_VOICES];
 		return this._kaniTTS?.availableVoices() ?? [];
 	}
 	/**
@@ -3585,12 +5452,12 @@ var WebGPUEngine = class WebGPUEngine {
 			const f = data instanceof Float32Array ? data : new Float32Array(data.buffer);
 			let sum = 0;
 			let maxVal = -Infinity;
-			let argmax$1 = 0;
+			let argmax$2 = 0;
 			for (let i = 0; i < f.length; i++) {
 				sum += f[i];
 				if (f[i] > maxVal) {
 					maxVal = f[i];
-					argmax$1 = i;
+					argmax$2 = i;
 				}
 			}
 			const entry = {
@@ -3603,7 +5470,7 @@ var WebGPUEngine = class WebGPUEngine {
 					Math.round(f[2] * 1e6) / 1e6,
 					Math.round(f[3] * 1e6) / 1e6
 				],
-				argmax: argmax$1,
+				argmax: argmax$2,
 				maxVal: Math.round(maxVal * 1e4) / 1e4
 			};
 			checks.push(entry);
@@ -3857,6 +5724,7 @@ var WebGPUEngine = class WebGPUEngine {
 		this._destroyed = true;
 		this.executor.destroy();
 		this._kaniTTS?.destroy();
+		this._outeTTS?.destroy();
 		this.visionExecutor?.destroy();
 		clearPipelineCache(this.ctx.device);
 		this.ctx.device.destroy();
@@ -3867,5 +5735,5 @@ var WebGPUEngine = class WebGPUEngine {
 };
 
 //#endregion
-export { generateGemma4VisionGraph as C, dequantizeMLXProjection as S, resolveGemma4VisionInfo as T, smartResize as _, buildGemma4PosEmbeds as a, generateQwen3_5VisionGraph as b, buildMRoPECosSin as c, buildPositionIds as d, buildRotaryCosSin as f, preprocessImageGemma4 as g, preprocessImage as h, buildGemma4PoolMatrix as i, 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, patchGemma4VisionClips as w, dequantizeGemma4VisionProjection as x, KaniTTS as y };
-//# sourceMappingURL=gpu-BZHJDas1.mjs.map
+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