@tryhamster/gerbil 1.12.0 → 1.13.0

package/dist/{gpu-DRFhiv4R.mjs → gpu-CU_Mldk0.mjs}

@@ -1,6 +1,6 @@
-import { a as resolveDefaultRepo, i as isTTSRepo, n as OUTETTS_ASSETS, r as OUTETTS_PRESET_VOICES, t as DEFAULT_MODELS } from "./defaults-DfGx4d1m.mjs";
-import { A as kaniSinTensor, C as computeKaniPositions, D as kaniAttentionLayerIndices, E as generateNanoCodecDecoderGraph, F as CANONICAL_KEYS, I as DTYPE_BYTES, L as GEMMA4_VIS_KEYS, M as parseKaniConfig, N as DEFAULT_GROUP_SIZE, O as kaniCosTensor, S as buildKaniLayerCosSin, T as generateKaniTtsGraph, a as PARLER_DAC_LATENT_DIM, b as KANI_START_OF_HUMAN, c as PARLER_SAMPLE_RATE, d as generateParlerEncoderGraph, f as parseParlerConfig, i as PARLER_DAC_DECODER_DIM, k as kaniLayerAlpha, l as buildT5RelativeBias, o as PARLER_DECODER_RATES, p as revertDelayPattern, r as PARLER_BOS_TOKEN_ID, s as PARLER_EOS_TOKEN_ID, u as generateParlerDecoderGraph, x as audioTokensToCodes, y as KANI_END_OF_HUMAN } from "./architectures-BH_z6k9d.mjs";
-import { C as createUniformBuffer, D as verifyGPU, E as initGPU, S as createStorageBuffer, T as getOrCreatePipeline, a as loadModel, b as clearPipelineCache, c as loadParlerTTS, d as remapPrunedToken, g as fetchAdapter, h as buildLoRADeltas, i as loadKaniTTS, l as quantizeBackboneInt4, p as Executor, r as createKeyMapperForArch, s as loadOuteTTS, u as quantizeKaniBackbone, v as KERNEL_REGISTRY, w as destroyBuffers, x as createBindGroup, y as MATMUL_BIAS_F16C_SPEC } from "./moonshine-stt-B1kV5n1c.mjs";
+import { a as resolveDefaultRepo, i as isTTSRepo, n as OUTETTS_ASSETS, r as OUTETTS_PRESET_VOICES, t as DEFAULT_MODELS } from "./defaults-B0aQZJTM.mjs";
+import { A as kaniSinTensor, C as computeKaniPositions, D as kaniAttentionLayerIndices, E as generateNanoCodecDecoderGraph, F as CANONICAL_KEYS, I as DTYPE_BYTES, L as GEMMA4_VIS_KEYS, M as parseKaniConfig, N as DEFAULT_GROUP_SIZE, O as kaniCosTensor, S as buildKaniLayerCosSin, T as generateKaniTtsGraph, a as PARLER_DAC_LATENT_DIM, b as KANI_START_OF_HUMAN, c as PARLER_SAMPLE_RATE, d as generateParlerEncoderGraph, f as parseParlerConfig, i as PARLER_DAC_DECODER_DIM, k as kaniLayerAlpha, l as buildT5RelativeBias, o as PARLER_DECODER_RATES, p as revertDelayPattern, r as PARLER_BOS_TOKEN_ID, s as PARLER_EOS_TOKEN_ID, u as generateParlerDecoderGraph, x as audioTokensToCodes, y as KANI_END_OF_HUMAN } from "./architectures-DHwj9AQD.mjs";
+import { C as createStorageBuffer, D as initGPU, E as getOrCreatePipeline, O as verifyGPU, S as createBindGroup, T as destroyBuffers, _ as fetchAdapter, a as loadKaniTTS, b as MATMUL_BIAS_F16C_SPEC, c as loadOuteTTS, d as quantizeKaniBackbone, f as remapPrunedToken, g as buildLoRADeltas, i as loadGepardTTS, l as loadParlerTTS, m as Executor, o as loadModel, r as createKeyMapperForArch, u as quantizeBackboneInt4, w as createUniformBuffer, x as clearPipelineCache, y as KERNEL_REGISTRY } from "./moonshine-stt-COJeK2Zb.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$2(graph, weights) {
+function selectGraphWeights$3(graph, weights) {
 	const out = /* @__PURE__ */ new Map();
 	for (const [name, desc] of Object.entries(graph.tensors)) {
 		if (desc.storage !== "constant") continue;
@@ -891,7 +891,7 @@ var KaniTTS = class KaniTTS {
 			maxSeqLen,
 			kvMode: "f32"
 		});
-		exec.uploadWeightsMap(selectGraphWeights$2(graph, loaded.backboneWeights));
+		exec.uploadWeightsMap(selectGraphWeights$3(graph, loaded.backboneWeights));
 		exec.initBindGroups();
 		return exec;
 	}
@@ -1105,7 +1105,7 @@ var KaniTTS = class KaniTTS {
 			kvMode: "f32"
 		});
 		try {
-			exec.uploadWeightsMap(selectGraphWeights$2(graph, this.loaded.codecWeights));
+			exec.uploadWeightsMap(selectGraphWeights$3(graph, this.loaded.codecWeights));
 			exec.initBindGroups();
 			exec.reset();
 			exec.writeInput("audio_codes", winCodes);
@@ -1580,213 +1580,1264 @@ var RequestScheduler = class {
 				anyAdapter = true;
 			}
 		}
-		const last = this.lastLaneAdapterIds;
-		if (last === null) {
-			if (!anyAdapter) return;
-		} else if (ids.every((id, b) => id === last[b])) return;
-		this.host.executor.setBatchLaneAdapters(ids);
-		this.lastLaneAdapterIds = ids;
+		const last = this.lastLaneAdapterIds;
+		if (last === null) {
+			if (!anyAdapter) return;
+		} else if (ids.every((id, b) => id === last[b])) return;
+		this.host.executor.setBatchLaneAdapters(ids);
+		this.lastLaneAdapterIds = ids;
+	}
+	/**
+	* Admission: move the next queued request into a free slot when (a) a slot
+	* is free, (b) no other prefill is staged (the single-sequence prefill path
+	* stages SSM state in singleton buffers — one at a time), and (c) its
+	* worst-case block need fits the unreserved KV pool with headroom.
+	*/
+	admit() {
+		if (this.prefilling || this.queue.length === 0) return;
+		const slot = this.slots.indexOf(null);
+		if (slot === -1) return;
+		const req = this.queue[0];
+		const worstTokens = req.promptIds.length + req.maxTokens + PIPELINE_DEPTH;
+		const blocksNeeded = Math.ceil(worstTokens / this.blockSize);
+		const totalBlocks = this.host.executor.kvTotalBlocks;
+		if (this.reservedBlocks + blocksNeeded + this.blockHeadroom > totalBlocks) return;
+		this.queue.shift();
+		req.state = "prefilling";
+		req.slot = slot;
+		req.blocksReserved = blocksNeeded;
+		req.admittedAt = performance.now();
+		this.reservedBlocks += blocksNeeded;
+		this.slots[slot] = req;
+		this.prefilling = req;
+		if (req.adapterDeltas) {
+			const { applied } = this.host.executor.applyRuntimeLoRA(req.adapterDeltas);
+			if (applied === 0) throw new Error(`RequestScheduler: adapter "${req.adapterName}" resolved to 0 applicable prefill targets`);
+		}
+		this.host.executor.beginBatchSlot(slot);
+	}
+	/**
+	* Run one bounded prefill chunk for the staged request on the
+	* single-sequence path (into its slot's block-table row via tableBase).
+	* Intermediate chunks are submit-only; the final chunk reads logits, adopts
+	* the singleton SSM state into the slot's pool row, seeds the lane's first
+	* token, and flips the lane to decoding.
+	*/
+	async prefillChunkStep() {
+		const req = this.prefilling;
+		if (!req) return;
+		const ex = this.host.executor;
+		const end = Math.min(req.prefillPos + this.prefillChunk, req.promptIds.length);
+		const isLast = end === req.promptIds.length;
+		const chunk = req.promptIds.subarray(req.prefillPos, end);
+		const { logits } = await ex.forward(chunk, { readLogits: isLast });
+		req.prefillPos = end;
+		this.stats.prefillChunks++;
+		if (!isLast) return;
+		ex.finishBatchSlot(req.slot);
+		if (req.adapterDeltas) ex.clearRuntimeLoRA();
+		this.prefilling = null;
+		const first = this.host.remapToken(sampleToken(logits, { temperature: 0 }));
+		ex.injectBatchToken(req.slot, first);
+		req.state = "decoding";
+		req.firstTokenAt = performance.now();
+		this.consumeToken(req, first);
+	}
+	/** Read the oldest in-flight step and deliver its tokens. */
+	async readStep() {
+		const step = this.inFlight.shift();
+		if (!step) return;
+		const tokens = await this.host.executor.readBatchTokens(step.readbackSlot);
+		for (const { slot, req } of step.rows) {
+			if (this.slots[slot] !== req || req.state !== "decoding") continue;
+			this.consumeToken(req, tokens[slot]);
+		}
+	}
+	/** Append one generated token; finish + retire the lane when terminal. */
+	consumeToken(req, tokenId) {
+		req.generatedIds.push(tokenId);
+		this.stats.tokensGenerated++;
+		if (req.firstTokenAt === 0) req.firstTokenAt = performance.now();
+		const { eosTokenId, eotTokenId } = this.host;
+		if (eosTokenId !== null && tokenId === eosTokenId || eotTokenId !== null && tokenId === eotTokenId) {
+			req.finishReason = "eos";
+			this.finish(req);
+			return;
+		}
+		const piece = this.host.decodeToken(tokenId);
+		req.text += piece;
+		if (req.stopSequences.some((s) => req.text.includes(s))) {
+			for (const s of req.stopSequences) {
+				const idx = req.text.indexOf(s);
+				if (idx !== -1) req.text = req.text.slice(0, idx);
+			}
+			req.finishReason = "stop_sequence";
+			this.finish(req);
+			return;
+		}
+		req.onToken?.(piece, {
+			requestId: req.id,
+			tokenId,
+			generated: req.generatedIds.length
+		});
+		if (req.generatedIds.length >= req.maxTokens) {
+			req.finishReason = "max_tokens";
+			this.finish(req);
+		}
+	}
+	/** Retire the lane immediately: free KV blocks, open the slot, resolve. */
+	finish(req) {
+		req.state = "done";
+		if (req.slot >= 0 && this.slots[req.slot] === req) {
+			this.host.executor.retireBatchSlot(req.slot);
+			this.slots[req.slot] = null;
+		}
+		this.reservedBlocks -= req.blocksReserved;
+		this.stats.completed++;
+		const finishedAt = performance.now();
+		req.resolve({
+			requestId: req.id,
+			text: req.text,
+			tokenIds: [...req.generatedIds],
+			tokensGenerated: req.generatedIds.length,
+			finishReason: req.finishReason,
+			adapter: req.adapterName ?? void 0,
+			submittedAt: req.submittedAt,
+			admittedAt: req.admittedAt,
+			firstTokenAt: req.firstTokenAt,
+			finishedAt,
+			ttftMs: req.firstTokenAt - req.submittedAt,
+			e2eMs: finishedAt - req.submittedAt
+		});
+	}
+};
+
+//#endregion
+//#region src/gpu/batch/swarm.ts
+/** Default reduce: member-keyed map, disambiguating duplicated members. */
+function reduceToKeyedMap(results) {
+	const out = {};
+	const seen = /* @__PURE__ */ new Map();
+	for (const { member, result } of results) {
+		const n = (seen.get(member) ?? 0) + 1;
+		seen.set(member, n);
+		out[n === 1 ? member : `${member}#${n}`] = result;
+	}
+	return out;
+}
+/**
+* A swarm handle: registered members + plan/reduce over the engine's
+* scheduler. Create via {@link WebGPUEngine.createSwarm}.
+*/
+var Swarm = class {
+	scheduler;
+	memberSources;
+	plan;
+	reduce;
+	constructor(scheduler, options) {
+		if (Object.keys(options.members).length === 0) throw new Error("Swarm: members must contain at least one member");
+		this.scheduler = scheduler;
+		this.memberSources = { ...options.members };
+		this.plan = options.plan;
+		this.reduce = options.reduce;
+	}
+	/** Member names, declaration order. */
+	get members() {
+		return Object.keys(this.memberSources);
+	}
+	/**
+	* Run one input through the swarm: plan → concurrent fan-out (one batched
+	* pass across the scheduler's lanes) → reduce.
+	*
+	* @param input The task input handed to the plan (default plan: broadcast
+	*   it to every member as the prompt).
+	* @param options Per-request options applied to every sub-task (a task's
+	*   own `options` win field-by-field).
+	*/
+	async run(input, options = {}) {
+		const tasks = this.plan ? await this.plan(input, this.members) : this.members.map((member) => ({
+			member,
+			prompt: input
+		}));
+		if (tasks.length === 0) throw new Error("Swarm: plan produced no sub-tasks");
+		const results = await Promise.all(tasks.map(async (task) => {
+			const result = await this.submitFor(task.member, task.prompt, {
+				...options,
+				...task.options
+			});
+			return {
+				member: task.member,
+				result
+			};
+		}));
+		if (this.reduce) return this.reduce(results);
+		return reduceToKeyedMap(results);
+	}
+	/**
+	* Mode-A access: decode one prompt with a single member (no plan/reduce).
+	* Still rides the shared scheduler, so it batches with any concurrent work.
+	*/
+	generate(member, prompt, options = {}) {
+		return this.submitFor(member, prompt, options);
+	}
+	submitFor(member, prompt, options) {
+		if (!Object.hasOwn(this.memberSources, member)) throw new Error(`Swarm: unknown member "${member}" (members: ${this.members.join(", ")})`);
+		const adapter = this.memberSources[member] == null ? void 0 : member;
+		return this.scheduler.submit(prompt, {
+			...options,
+			adapter
+		});
+	}
+};
+
+//#endregion
+//#region src/gpu/architectures/gepard_tts.ts
+const GEPARD_START_OF_TEXT = 248073;
+const GEPARD_END_OF_TEXT = 248074;
+const GEPARD_START_OF_SPEECH = 248070;
+/** FSQ levels per dimension within each codec group (repeats per group). */
+const GEPARD_FSQ_LEVEL_PATTERN = [
+	8,
+	7,
+	6,
+	6
+];
+/** Number of codec groups (codebooks). */
+const GEPARD_NUM_GROUPS = 8;
+/** Total per-dimension channels per frame = groups × dims/group. */
+const GEPARD_NUM_CHANNELS = 32;
+/** NanoCodec 21.5 fps decoder geometry (codec_config.yaml, mlx-community mirror). */
+const GEPARD_CODEC_UP_SAMPLE_RATES = [
+	8,
+	8,
+	4,
+	2,
+	2
+];
+const GEPARD_CODEC_INPUT_DIM = 32;
+/** PCM samples per audio frame (product of the up-sample rates). */
+const GEPARD_HOP = 1024;
+const GEPARD_SAMPLE_RATE = 22050;
+/** Per-channel FSQ cardinalities in head order (channel c = group⌊c/4⌋, dim c%4). */
+function gepardChannelLevels() {
+	const out = [];
+	for (let g = 0; g < GEPARD_NUM_GROUPS; g++) out.push(...GEPARD_FSQ_LEVEL_PATTERN);
+	return out;
+}
+/** Matches `level_audio_{i}` head names (channel index = numeric suffix). */
+const LEVEL_AUDIO_RE = /^level_audio_(\d+)$/;
+/**
+* Parse gepard_config.json. Head order is recovered from the numeric suffix of
+* each `level_audio_{i}` key (NOT the serialized key order), so the wiring is
+* immune to any JSON round-trip that re-sorts keys.
+*/
+function parseGepardConfig(raw) {
+	const backboneConfig = raw.backbone_config;
+	if (!backboneConfig) throw new Error("gepard_config.json has no backbone_config — not a Gepard checkpoint.");
+	const audioHeads = raw.audio_heads ?? {};
+	const byIndex = [];
+	for (const [name, size] of Object.entries(audioHeads)) {
+		const m = LEVEL_AUDIO_RE.exec(name);
+		if (!m) throw new Error(`Unexpected audio head name "${name}" in gepard_config.json.`);
+		byIndex[Number(m[1])] = size;
+	}
+	if (byIndex.length === 0) throw new Error("gepard_config.json has no audio_heads.");
+	for (let i = 0; i < byIndex.length; i++) if (byIndex[i] == null) throw new Error(`gepard_config.json audio_heads is missing level_audio_${i}.`);
+	const special = raw.special_tokens ?? {};
+	const rep = raw.text_repetition ?? {};
+	const codec = raw.codec ?? {};
+	return {
+		backboneConfig,
+		vocabSizes: byIndex,
+		audioEmbedDim: raw.audio_embed_dim ?? 32,
+		startOfText: special.start_of_text ?? GEPARD_START_OF_TEXT,
+		endOfText: special.end_of_text ?? GEPARD_END_OF_TEXT,
+		startOfSpeech: special.start_of_speech ?? GEPARD_START_OF_SPEECH,
+		textRepetition: {
+			enabled: rep.enabled ?? false,
+			targetTextTokens: rep.target_text_tokens ?? 16,
+			applyBelow: rep.apply_below ?? 13,
+			maxRepeats: rep.max_repeats ?? 8
+		},
+		codecId: codec.codec_id ?? "nvidia/nemo-nano-codec-22khz-1.89kbps-21.5fps",
+		fsqLevels: codec.fsq_levels ?? [...GEPARD_FSQ_LEVEL_PATTERN],
+		sampleRate: codec.sample_rate ?? GEPARD_SAMPLE_RATE
+	};
+}
+/**
+* Build the (possibly repeated) text-id layout — mirrors the reference
+* TextRepeater byte-for-byte (text_repetition.py):
+*   R == 1 → [ SOT, *text, EOT, SOS ]
+*   R >  1 → [ SOT, *text, EOT ] × (R−1) + [ SOT, *text, EOT, SOS ]
+* Only the final (canonical) copy carries SOS. R is deterministic from the
+* text-token count: ceil(target / n) capped at maxRepeats, applied only when
+* n < applyBelow (short prompts derail without the extra text mass).
+*/
+function buildGepardTextLayout(textTokenIds, cfg) {
+	const rep = cfg.textRepetition;
+	const n = textTokenIds.length;
+	let repeats = 1;
+	if (rep.enabled && n > 0 && n < rep.applyBelow && n < rep.targetTextTokens) repeats = Math.max(1, Math.min(Math.ceil(rep.targetTextTokens / n), rep.maxRepeats));
+	const block = [
+		cfg.startOfText,
+		...textTokenIds,
+		cfg.endOfText
+	];
+	const out = [];
+	for (let r = 0; r < repeats - 1; r++) out.push(...block);
+	out.push(...block, cfg.startOfSpeech);
+	return out;
+}
+/**
+* Dequantize per-channel FSQ codes [32, T] (channel-major) into the decoder
+* latent [32, T] f32: value = (code − L//2) / (L//2), matching
+* UnfoldedCodecModel.decode_from_codes / codec_ops.dequantize_codes.
+*/
+function gepardCodesToLatent(codes, numFrames) {
+	const levels = gepardChannelLevels();
+	const latent = new Float32Array(GEPARD_NUM_CHANNELS * numFrames);
+	for (let c = 0; c < GEPARD_NUM_CHANNELS; c++) {
+		const scale = Math.max(1, Math.floor(levels[c] / 2));
+		const base = c * numFrames;
+		for (let t = 0; t < numFrames; t++) latent[base + t] = (codes[base + t] - scale) / scale;
+	}
+	return latent;
+}
+function generateGepardBackboneGraph(backboneConfig, dtype, groupSizeOverride, kvDtype) {
+	const hidden_size = backboneConfig.hidden_size;
+	const num_layers = backboneConfig.num_hidden_layers;
+	const num_heads = backboneConfig.num_attention_heads;
+	const num_kv_heads = backboneConfig.num_key_value_heads ?? num_heads;
+	const intermediate_size = backboneConfig.intermediate_size;
+	const context_length = backboneConfig.max_position_embeddings ?? 262144;
+	const rms_norm_eps = backboneConfig.rms_norm_eps ?? 1e-6;
+	const head_dim = backboneConfig.head_dim ?? Math.floor(hidden_size / num_heads);
+	const q_dim = num_heads * head_dim;
+	const kv_dim = num_kv_heads * head_dim;
+	const ropeParams = backboneConfig.rope_parameters;
+	const rope_base = ropeParams?.rope_theta ?? backboneConfig.rope_theta ?? 1e7;
+	const partialRotaryFactor = ropeParams?.partial_rotary_factor ?? backboneConfig.partial_rotary_factor ?? 1;
+	const rope_dim = Math.floor(head_dim * partialRotaryFactor);
+	const layerTypes = backboneConfig.layer_types ?? [];
+	for (let i = 0; i < num_layers; i++) if (layerTypes.length > i && layerTypes[i] !== "full_attention") throw new Error(`Gepard backbone expects all-full-attention layers; layer ${i} is "${layerTypes[i]}".`);
+	const config = {
+		hidden_size,
+		num_layers,
+		num_heads,
+		num_kv_heads,
+		head_dim,
+		intermediate_size,
+		vocab_size: hidden_size,
+		context_length,
+		rms_norm_eps,
+		norm_type: "rmsnorm",
+		rope_base,
+		rope_dim,
+		kv_layout: "LHSd",
+		is_moe: false,
+		has_vision_tower: false
+	};
+	const capabilities = {
+		text: true,
+		vision: false,
+		moe: 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 useQ4 = dtype === "q4";
+	const groupSize = groupSizeOverride ?? DEFAULT_GROUP_SIZE;
+	const addLinearOp = (id, activationInput, weightName, weightShape, outputName, K, N) => {
+		if (useQ4) {
+			const wQ = `${weightName}.q`;
+			const wScales = `${weightName}.scales`;
+			const wZeros = `${weightName}.zeros`;
+			const totalElements = K * N;
+			addTensor({
+				name: wQ,
+				shape: [Math.ceil(totalElements / 8)],
+				dtype: "u32",
+				storage: "constant"
+			});
+			addTensor({
+				name: wScales,
+				shape: [Math.ceil(totalElements / groupSize)],
+				dtype: "f32",
+				storage: "constant"
+			});
+			addTensor({
+				name: wZeros,
+				shape: [Math.ceil(totalElements / groupSize)],
+				dtype: "f32",
+				storage: "constant"
+			});
+			addNode({
+				id,
+				opType: "MatMulInt4",
+				inputs: [
+					activationInput,
+					wQ,
+					wScales,
+					wZeros
+				],
+				outputs: [outputName],
+				attributes: {
+					M_tensor: activationInput,
+					K,
+					N,
+					group_size: groupSize
+				}
+			});
+			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: "inputs_embeds",
+		shape: ["T", hidden_size],
+		dtype: "f32",
+		storage: "activation"
+	});
+	const buildAttentionBlock = (i, prefix, norm1Out) => {
+		const qOut = `${prefix}_q`;
+		const gateOut = `${prefix}_attn_gate`;
+		const kOut = `${prefix}_k`;
+		const vOut = `${prefix}_v`;
+		addTensor({
+			name: qOut,
+			shape: ["T", q_dim],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addTensor({
+			name: gateOut,
+			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"
+		});
+		addLinearOp(`${prefix}_q_proj`, norm1Out, CANONICAL_KEYS.qProj(i), [q_dim, hidden_size], qOut, hidden_size, q_dim);
+		addLinearOp(`${prefix}_gate_proj`, norm1Out, CANONICAL_KEYS.attnGate(i), [q_dim, hidden_size], gateOut, hidden_size, q_dim);
+		addLinearOp(`${prefix}_k_proj`, norm1Out, CANONICAL_KEYS.kProj(i), [kv_dim, hidden_size], kOut, hidden_size, kv_dim);
+		addLinearOp(`${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,
+				partial_rotary: true,
+				seq_len_tensor: qNormed
+			}
+		});
+		const kvCacheDtype = kvDtype ?? "f32";
+		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 gatedOut = `${prefix}_gated`;
+		addTensor({
+			name: gatedOut,
+			shape: ["T", q_dim],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addNode({
+			id: `${prefix}_sigmoid_gate`,
+			opType: "SigmoidGate",
+			inputs: [attnOut, gateOut],
+			outputs: [gatedOut],
+			attributes: { count_tensor: attnOut }
+		});
+		const oProjOut = `${prefix}_o_proj_out`;
+		addTensor({
+			name: oProjOut,
+			shape: ["T", hidden_size],
+			dtype: "f32",
+			storage: "activation"
+		});
+		addLinearOp(`${prefix}_o_proj`, gatedOut, CANONICAL_KEYS.oProj(i), [hidden_size, q_dim], oProjOut, q_dim, hidden_size);
+		return oProjOut;
+	};
+	let prevOutput = "inputs_embeds";
+	let pendingNorm1Out = null;
+	for (let i = 0; i < num_layers; i++) {
+		const prefix = `layer${i}`;
+		let norm1Out;
+		if (pendingNorm1Out) norm1Out = pendingNorm1Out;
+		else {
+			const normWeightName = CANONICAL_KEYS.layerInputNorm(i);
+			addTensor({
+				name: normWeightName,
+				shape: [hidden_size],
+				dtype: "f32",
+				storage: "constant",
+				safetensorsKey: normWeightName
+			});
+			norm1Out = `${prefix}_norm1_out`;
+			addTensor({
+				name: norm1Out,
+				shape: ["T", hidden_size],
+				dtype: "f32",
+				storage: "activation"
+			});
+			addNode({
+				id: `${prefix}_norm1`,
+				opType: "RMSNorm",
+				inputs: [prevOutput, normWeightName],
+				outputs: [norm1Out],
+				attributes: {
+					hidden_size,
+					eps: rms_norm_eps,
+					seq_len_tensor: prevOutput
+				}
+			});
+		}
+		const attnOutput = buildAttentionBlock(i, prefix, norm1Out);
+		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,
+				attnOutput,
+				postNormW
+			],
+			outputs: [resid1Out, norm2Out],
+			attributes: {
+				hidden_size,
+				eps: rms_norm_eps,
+				seq_len_tensor: prevOutput
+			}
+		});
+		const gateW = CANONICAL_KEYS.gateProj(i);
+		const upW = CANONICAL_KEYS.upProj(i);
+		const downW = CANONICAL_KEYS.downProj(i);
+		const mlpGateOut = `${prefix}_gate_out`;
+		const upOut = `${prefix}_up_out`;
+		const swigluOut = `${prefix}_swiglu_out`;
+		const mlpOut = `${prefix}_mlp_out`;
+		addTensor({
+			name: mlpGateOut,
+			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"
+		});
+		addLinearOp(`${prefix}_gate`, norm2Out, gateW, [intermediate_size, hidden_size], mlpGateOut, hidden_size, intermediate_size);
+		addLinearOp(`${prefix}_up`, norm2Out, upW, [intermediate_size, hidden_size], upOut, hidden_size, intermediate_size);
+		addNode({
+			id: `${prefix}_swiglu`,
+			opType: "SwiGLU",
+			inputs: [mlpGateOut, upOut],
+			outputs: [swigluOut],
+			attributes: { count_tensor: mlpGateOut }
+		});
+		addLinearOp(`${prefix}_down`, swigluOut, downW, [hidden_size, intermediate_size], mlpOut, intermediate_size, hidden_size);
+		const resid2Out = `${prefix}_resid2`;
+		addTensor({
+			name: resid2Out,
+			shape: ["T", hidden_size],
+			dtype: "f32",
+			storage: "activation"
+		});
+		if (i < num_layers - 1) {
+			const nextNormW = CANONICAL_KEYS.layerInputNorm(i + 1);
+			addTensor({
+				name: nextNormW,
+				shape: [hidden_size],
+				dtype: "f32",
+				storage: "constant",
+				safetensorsKey: nextNormW
+			});
+			const nextNorm1Out = `layer${i + 1}_norm1_out`;
+			addTensor({
+				name: nextNorm1Out,
+				shape: ["T", hidden_size],
+				dtype: "f32",
+				storage: "activation"
+			});
+			addNode({
+				id: `${prefix}_resid2_norm1`,
+				opType: "ResidualRMSNorm",
+				inputs: [
+					resid1Out,
+					mlpOut,
+					nextNormW
+				],
+				outputs: [resid2Out, nextNorm1Out],
+				attributes: {
+					hidden_size,
+					eps: rms_norm_eps,
+					seq_len_tensor: resid1Out
+				}
+			});
+			pendingNorm1Out = nextNorm1Out;
+		} else {
+			addNode({
+				id: `${prefix}_resid2`,
+				opType: "Add",
+				inputs: [resid1Out, mlpOut],
+				outputs: [resid2Out],
+				attributes: {
+					count_tensor: resid1Out,
+					hidden_size
+				}
+			});
+			pendingNorm1Out = null;
+		}
+		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: "logits",
+		shape: [1, hidden_size],
+		dtype: "f32",
+		storage: "activation"
+	});
+	addNode({
+		id: "slice_last_row",
+		opType: "SliceLastRow",
+		inputs: ["final_norm_out"],
+		outputs: ["logits"],
+		attributes: { width: hidden_size }
+	});
+	return {
+		architecture: "GepardForTTS",
+		config,
+		capabilities,
+		tensors,
+		nodes,
+		executionOrder,
+		inputs: ["inputs_embeds"],
+		outputs: ["logits"]
+	};
+}
+
+//#endregion
+//#region src/gpu/gepard-tts.ts
+/**
+* Gepard-1.0 — native streaming text-to-speech engine for Gerbil's WebGPU backend.
+*
+* Gepard (nineninesix/gepard-1.0, Apache-2.0) is a frame-synchronous multihead
+* codec-LM TTS. Unlike the token-serial Kani/Oute engines (which emit one codec
+* token per forward), Gepard emits ONE WHOLE AUDIO FRAME per backbone forward:
+*
+*   1. BACKBONE (GPU): stock Qwen3.5 full-attention body (14 layers, hidden 1024)
+*      run through generateGepardBackboneGraph — input is a host-written
+*      `inputs_embeds` row, output is the last position's final-norm hidden state.
+*   2. OVERLAY (host): 32 parallel classifier heads (cardinalities [8,7,6,6]×8,
+*      216 logits total) + a binary stop head read the hidden state; the sampled
+*      32 FSQ codes feed back through per-channel embeddings → concat → GELU MLP
+*      → affine-free LayerNorm → × audio_embed_scale as the next step's input.
+*   3. CODEC (GPU): NanoCodec 21.5 fps decoder (same validated CausalHiFiGAN
+*      graph family as Kani's codec, rates [8,8,4,2,2], hop 1024) turns the
+*      per-channel codes into 22.05 kHz PCM — decoded incrementally in chunks
+*      with left-context lookback, so audio streams out while the model is
+*      still generating (≈1.5 s of audio per 32-frame chunk).
+*
+* Mirrors gepard-inference (runner.py) semantics: adaptive text repetition,
+* SOS-seeded first frame, stop-head termination, independent per-head sampling
+* (temperature / top-k / windowed repetition penalty) in fp32. Voice cloning
+* (the ref_compressor speaker prefix) is NOT wired yet — the default voice ships
+* first; cloning is a documented follow-up.
+*/
+/** Codec decode chunking: 32 frames ≈ 1.49 s of audio per streamed chunk. */
+const GEPARD_CODEC_CHUNK_FRAMES = 32;
+/**
+* Left-context warm-up frames re-decoded (and discarded) per chunk. The decoder
+* is fully causal with a bounded receptive field; 64 frames (≈65k samples) of
+* lookback keeps chunked output numerically identical to a monolithic decode
+* while staying under the WebGPU per-dimension dispatch cap.
+*/
+const GEPARD_CODEC_LOOKBACK_FRAMES = 64;
+/** Hard ceiling on generated frames (the reference runner's max_frames). */
+const DEFAULT_MAX_FRAMES$1 = 2e3;
+/** PyTorch nn.LayerNorm default epsilon (audio_embed_proj's affine-free LN). */
+const LAYERNORM_EPS = 1e-5;
+/** Build a fresh map of just the constant weights a graph references. */
+function selectGraphWeights$2(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;
+}
+/** Abramowitz–Stegun 7.1.26 erf approximation (max |err| ≈ 1.5e-7). */
+function erf(x) {
+	const sign = x < 0 ? -1 : 1;
+	const ax = Math.abs(x);
+	const t = 1 / (1 + .3275911 * ax);
+	return sign * (1 - ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - .284496736) * t + .254829592) * t * Math.exp(-ax * ax));
+}
+/** Exact (erf-based) GELU, matching PyTorch nn.GELU()'s default. */
+function gelu(x) {
+	return .5 * x * (1 + erf(x / Math.SQRT2));
+}
+/** y = W·x + b for a row-major [out, in] weight. */
+function linear(w, b, x, outDim, inDim, out) {
+	for (let o = 0; o < outDim; o++) {
+		let acc = b ? b[o] : 0;
+		const base = o * inDim;
+		for (let k = 0; k < inDim; k++) acc += w[base + k] * x[k];
+		out[o] = acc;
+	}
+}
+var GepardTTS = class GepardTTS {
+	ctx;
+	loaded;
+	tokenizer;
+	cfg;
+	maxSeqLen;
+	hidden;
+	/** Backbone executor (built once; reused across speak() calls). */
+	backboneExec;
+	/** Cached codec executor for the steady-state window size (chunk + lookback). */
+	codecExecCache = /* @__PURE__ */ new Map();
+	_destroyed = false;
+	/** The selected backbone precision ("q4" or "f32"). */
+	dtype;
+	audioEmbTables;
+	projW0;
+	projB0;
+	projW2;
+	projB2;
+	audioEmbedScale;
+	headW;
+	headB;
+	stopW;
+	stopB;
+	constructor(ctx, loaded, maxSeqLen, dtype) {
+		this.ctx = ctx;
+		this.loaded = loaded;
+		this.tokenizer = loaded.tokenizer;
+		this.cfg = parseGepardConfig(loaded.gepardConfig);
+		this.maxSeqLen = maxSeqLen;
+		this.hidden = this.cfg.backboneConfig.hidden_size;
+		this.dtype = dtype;
+		const overlay = loaded.overlayWeights;
+		const need = (key) => {
+			const w = overlay.get(key);
+			if (!w) throw new Error(`Gepard overlay weight missing: ${key}`);
+			return w.data;
+		};
+		const n = this.cfg.vocabSizes.length;
+		if (n !== GEPARD_NUM_CHANNELS) throw new Error(`Gepard expects ${GEPARD_NUM_CHANNELS} audio heads, config has ${n}.`);
+		this.audioEmbTables = [];
+		this.headW = [];
+		this.headB = [];
+		for (let i = 0; i < n; i++) {
+			this.audioEmbTables.push(need(`audio_embeddings.${i}.weight`));
+			this.headW.push(need(`codebook_heads.${i}.weight`));
+			this.headB.push(need(`codebook_heads.${i}.bias`));
+		}
+		this.projW0 = need("audio_embed_proj.0.weight");
+		this.projB0 = need("audio_embed_proj.0.bias");
+		this.projW2 = need("audio_embed_proj.2.weight");
+		this.projB2 = need("audio_embed_proj.2.bias");
+		this.audioEmbedScale = need("audio_embed_scale")[0];
+		this.stopW = need("stop_head.weight");
+		this.stopB = need("stop_head.bias")[0];
+		const graph = generateGepardBackboneGraph(this.cfg.backboneConfig, this.dtype === "q4" ? "q4" : void 0);
+		if (this.dtype === "q4") quantizeBackboneInt4(graph, loaded.backboneWeights);
+		this.backboneExec = new Executor(ctx, graph, {
+			maxSeqLen,
+			kvMode: "f32"
+		});
+		this.backboneExec.uploadWeightsMap(selectGraphWeights$2(graph, loaded.backboneWeights));
+		this.backboneExec.initBindGroups();
+	}
+	static async create(options = {}) {
+		const ctx = await initGPU();
+		const loaded = await loadGepardTTS({
+			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 ?? 262144;
+		return new GepardTTS(ctx, loaded, Math.min(options.maxSeqLen ?? 2048, ctxLen), options.dtype ?? "q4");
+	}
+	/** NanoCodec's fixed output sample rate (Hz). */
+	get sampleRate() {
+		return this.cfg.sampleRate;
+	}
+	/** Preset voices. Gepard ships one default voice (cloning is a follow-up). */
+	availableVoices() {
+		return [];
+	}
+	/** Gather text-token rows from the raw BF16 embed table → f32 [T, hidden]. */
+	embedTextTokens(ids) {
+		const h = this.hidden;
+		const table = this.loaded.embedTokensBF16;
+		const out = new Float32Array(ids.length * h);
+		const view = new DataView(out.buffer);
+		for (let t = 0; t < ids.length; t++) {
+			const rowBase = ids[t] * h;
+			const dstBase = t * h;
+			for (let k = 0; k < h; k++) view.setUint32((dstBase + k) * 4, table[rowBase + k] << 16, true);
+		}
+		return out;
 	}
 	/**
-	* Admission: move the next queued request into a free slot when (a) a slot
-	* is free, (b) no other prefill is staged (the single-sequence prefill path
-	* stages SSM state in singleton buffers — one at a time), and (c) its
-	* worst-case block need fits the unreserved KV pool with headroom.
+	* Embed one audio frame (32 FSQ codes) through the overlay stack:
+	* per-channel lookup → concat → Linear→GELU→Linear → affine-free LayerNorm →
+	* × audio_embed_scale. Mirrors GepardModel._embed_audio.
 	*/
-	admit() {
-		if (this.prefilling || this.queue.length === 0) return;
-		const slot = this.slots.indexOf(null);
-		if (slot === -1) return;
-		const req = this.queue[0];
-		const worstTokens = req.promptIds.length + req.maxTokens + PIPELINE_DEPTH;
-		const blocksNeeded = Math.ceil(worstTokens / this.blockSize);
-		const totalBlocks = this.host.executor.kvTotalBlocks;
-		if (this.reservedBlocks + blocksNeeded + this.blockHeadroom > totalBlocks) return;
-		this.queue.shift();
-		req.state = "prefilling";
-		req.slot = slot;
-		req.blocksReserved = blocksNeeded;
-		req.admittedAt = performance.now();
-		this.reservedBlocks += blocksNeeded;
-		this.slots[slot] = req;
-		this.prefilling = req;
-		if (req.adapterDeltas) {
-			const { applied } = this.host.executor.applyRuntimeLoRA(req.adapterDeltas);
-			if (applied === 0) throw new Error(`RequestScheduler: adapter "${req.adapterName}" resolved to 0 applicable prefill targets`);
+	embedAudioFrame(codes) {
+		const h = this.hidden;
+		const dim = this.cfg.audioEmbedDim;
+		const x = new Float32Array(GEPARD_NUM_CHANNELS * dim);
+		for (let c = 0; c < GEPARD_NUM_CHANNELS; c++) {
+			const table = this.audioEmbTables[c];
+			const base = codes[c] * dim;
+			x.set(table.subarray(base, base + dim), c * dim);
 		}
-		this.host.executor.beginBatchSlot(slot);
+		const h1 = new Float32Array(h);
+		linear(this.projW0, this.projB0, x, h, x.length, h1);
+		for (let i = 0; i < h; i++) h1[i] = gelu(h1[i]);
+		const h2 = new Float32Array(h);
+		linear(this.projW2, this.projB2, h1, h, h, h2);
+		let mean = 0;
+		for (let i = 0; i < h; i++) mean += h2[i];
+		mean /= h;
+		let variance = 0;
+		for (let i = 0; i < h; i++) {
+			const d = h2[i] - mean;
+			variance += d * d;
+		}
+		variance /= h;
+		const inv = this.audioEmbedScale / Math.sqrt(variance + LAYERNORM_EPS);
+		for (let i = 0; i < h; i++) h2[i] = (h2[i] - mean) * inv;
+		return h2;
+	}
+	/** Stop-head probability for a hidden state. */
+	stopProbability(hidden) {
+		let acc = this.stopB;
+		for (let k = 0; k < this.hidden; k++) acc += this.stopW[k] * hidden[k];
+		return 1 / (1 + Math.exp(-acc));
 	}
 	/**
-	* Run one bounded prefill chunk for the staged request on the
-	* single-sequence path (into its slot's block-table row via tableBase).
-	* Intermediate chunks are submit-only; the final chunk reads logits, adopts
-	* the singleton SSM state into the slot's pool row, seeds the lane's first
-	* token, and flips the lane to decoding.
+	* Sample one audio frame: all 32 heads independently in fp32 —
+	* windowed repetition penalty → temperature → top-k → softmax → multinomial.
+	* Mirrors GepardRunner._sample_frame / _sample_head_logits.
 	*/
-	async prefillChunkStep() {
-		const req = this.prefilling;
-		if (!req) return;
-		const ex = this.host.executor;
-		const end = Math.min(req.prefillPos + this.prefillChunk, req.promptIds.length);
-		const isLast = end === req.promptIds.length;
-		const chunk = req.promptIds.subarray(req.prefillPos, end);
-		const { logits } = await ex.forward(chunk, { readLogits: isLast });
-		req.prefillPos = end;
-		this.stats.prefillChunks++;
-		if (!isLast) return;
-		ex.finishBatchSlot(req.slot);
-		if (req.adapterDeltas) ex.clearRuntimeLoRA();
-		this.prefilling = null;
-		const first = this.host.remapToken(sampleToken(logits, { temperature: 0 }));
-		ex.injectBatchToken(req.slot, first);
-		req.state = "decoding";
-		req.firstTokenAt = performance.now();
-		this.consumeToken(req, first);
+	sampleFrame(hidden, p, recentFrames) {
+		const frame = new Uint32Array(GEPARD_NUM_CHANNELS);
+		for (let c = 0; c < GEPARD_NUM_CHANNELS; c++) {
+			const L = this.cfg.vocabSizes[c];
+			const w = this.headW[c];
+			const b = this.headB[c];
+			const logits = new Float32Array(L);
+			for (let j = 0; j < L; j++) {
+				let acc = b[j];
+				const base = j * this.hidden;
+				for (let k = 0; k < this.hidden; k++) acc += w[base + k] * hidden[k];
+				logits[j] = acc;
+			}
+			if (p.repetitionPenalty !== 1 && recentFrames) for (const prev of recentFrames) {
+				const tok = prev[c];
+				logits[tok] = logits[tok] > 0 ? logits[tok] / p.repetitionPenalty : logits[tok] * p.repetitionPenalty;
+			}
+			if (p.temperature !== 1) for (let j = 0; j < L; j++) logits[j] /= p.temperature;
+			if (p.topK > 0 && p.topK < L) {
+				const threshold = [...logits].sort((a, b2) => b2 - a)[p.topK - 1];
+				for (let j = 0; j < L; j++) if (logits[j] < threshold) logits[j] = Number.NEGATIVE_INFINITY;
+			}
+			let maxV = Number.NEGATIVE_INFINITY;
+			for (let j = 0; j < L; j++) if (logits[j] > maxV) maxV = logits[j];
+			let sum = 0;
+			for (let j = 0; j < L; j++) {
+				const e = Math.exp(logits[j] - maxV);
+				logits[j] = e;
+				sum += e;
+			}
+			let pick$1 = Math.random() * sum;
+			let chosen = L - 1;
+			for (let j = 0; j < L; j++) {
+				pick$1 -= logits[j];
+				if (pick$1 <= 0) {
+					chosen = j;
+					break;
+				}
+			}
+			frame[c] = chosen;
+		}
+		return frame;
 	}
-	/** Read the oldest in-flight step and deliver its tokens. */
-	async readStep() {
-		const step = this.inFlight.shift();
-		if (!step) return;
-		const tokens = await this.host.executor.readBatchTokens(step.readbackSlot);
-		for (const { slot, req } of step.rows) {
-			if (this.slots[slot] !== req || req.state !== "decoding") continue;
-			this.consumeToken(req, tokens[slot]);
+	/**
+	* Synthesize speech for `text`. Returns 22.05 kHz mono PCM; when
+	* `opts.onChunk` is set, audio streams out chunk-by-chunk during generation.
+	*
+	* Pipeline: adaptive-repetition text layout → prefill (host-gathered text
+	* embeddings) → frame-synchronous AR loop (one frame = 32 codes per forward,
+	* stop head decides termination) → incremental NanoCodec decode → PCM.
+	*/
+	async speak(text, opts = {}) {
+		if (this._destroyed) throw new Error("GepardTTS has been destroyed.");
+		const temperature = opts.temperature ?? .4;
+		const topK = opts.topK ?? 0;
+		const stopThreshold = opts.stopThreshold ?? .5;
+		const repetitionPenalty = opts.repetitionPenalty ?? 1;
+		const repetitionWindow = opts.repetitionWindow ?? 32;
+		const layout = buildGepardTextLayout(this.tokenizer.encode(text), this.cfg);
+		if (layout.length + 2 >= this.maxSeqLen) throw new Error(`Gepard prompt is ${layout.length} tokens >= maxSeqLen ${this.maxSeqLen}.`);
+		const maxFrames = Math.min(opts.maxFrames ?? DEFAULT_MAX_FRAMES$1, this.maxSeqLen - layout.length - 1);
+		const startTime = performance.now();
+		this.backboneExec.reset();
+		this.backboneExec.writeInput("inputs_embeds", this.embedTextTokens(layout));
+		let { logits: hidden } = await this.backboneExec.forward(new Uint32Array(layout.length));
+		const frames = [this.sampleFrame(hidden, {
+			temperature,
+			topK,
+			repetitionPenalty
+		}, null)];
+		const streamer = new GepardChunkStreamer(this, opts.onChunk);
+		const sampleOpts = {
+			temperature,
+			topK,
+			repetitionPenalty
+		};
+		for (let step = 1; step < maxFrames; step++) {
+			const frameEmbed = this.embedAudioFrame(frames[frames.length - 1]);
+			this.backboneExec.writeInput("inputs_embeds", frameEmbed);
+			hidden = (await this.backboneExec.forward(new Uint32Array(1))).logits;
+			if (this.stopProbability(hidden) > stopThreshold) break;
+			const window = repetitionPenalty !== 1 ? frames.slice(repetitionWindow > 0 ? -repetitionWindow : 0) : null;
+			frames.push(this.sampleFrame(hidden, sampleOpts, window));
+			await streamer.maybeEmit(frames, false);
 		}
+		await streamer.maybeEmit(frames, true);
+		const pcm = streamer.assembled(frames.length);
+		const totalTime = (performance.now() - startTime) / 1e3;
+		const audioSeconds = frames.length * GEPARD_HOP / this.cfg.sampleRate;
+		console.log(`[gepard] frames=${frames.length} audio=${audioSeconds.toFixed(2)}s wall=${totalTime.toFixed(2)}s RTF=${(audioSeconds / totalTime).toFixed(2)}x`);
+		return {
+			pcm,
+			sampleRate: this.cfg.sampleRate,
+			frames: frames.length,
+			audioSeconds
+		};
 	}
-	/** Append one generated token; finish + retire the lane when terminal. */
-	consumeToken(req, tokenId) {
-		req.generatedIds.push(tokenId);
-		this.stats.tokensGenerated++;
-		if (req.firstTokenAt === 0) req.firstTokenAt = performance.now();
-		const { eosTokenId, eotTokenId } = this.host;
-		if (eosTokenId !== null && tokenId === eosTokenId || eotTokenId !== null && tokenId === eotTokenId) {
-			req.finishReason = "eos";
-			this.finish(req);
-			return;
+	/**
+	* Decode frames [from, to) of the utterance to PCM, re-decoding up to
+	* `GEPARD_CODEC_LOOKBACK_FRAMES` of left context as warm-up (discarded).
+	* The decoder is causal with a bounded receptive field, so chunked output
+	* matches a monolithic decode.
+	*/
+	async decodeFrameRange(frames, from, to) {
+		const ctxStart = Math.max(0, from - GEPARD_CODEC_LOOKBACK_FRAMES);
+		const winFrames = to - ctxStart;
+		const codes = new Uint32Array(GEPARD_NUM_CHANNELS * winFrames);
+		for (let t = 0; t < winFrames; t++) {
+			const frame = frames[ctxStart + t];
+			for (let c = 0; c < GEPARD_NUM_CHANNELS; c++) codes[c * winFrames + t] = frame[c];
 		}
-		const piece = this.host.decodeToken(tokenId);
-		req.text += piece;
-		if (req.stopSequences.some((s) => req.text.includes(s))) {
-			for (const s of req.stopSequences) {
-				const idx = req.text.indexOf(s);
-				if (idx !== -1) req.text = req.text.slice(0, idx);
-			}
-			req.finishReason = "stop_sequence";
-			this.finish(req);
-			return;
+		const latent = gepardCodesToLatent(codes, winFrames);
+		const win = await this.decodeLatentWindow(latent, winFrames);
+		const drop = (from - ctxStart) * GEPARD_HOP;
+		const keep = (to - from) * GEPARD_HOP;
+		const out = win.slice(drop, drop + keep);
+		for (let i = 0; i < out.length; i++) out[i] = Math.min(1, Math.max(-1, out[i]));
+		return out;
+	}
+	/** Run the codec graph for one latent window → raw PCM (pre-clamp). */
+	async decodeLatentWindow(latent, winFrames) {
+		const steady = winFrames === GEPARD_CODEC_CHUNK_FRAMES + GEPARD_CODEC_LOOKBACK_FRAMES;
+		let exec = steady ? this.codecExecCache.get(winFrames) : void 0;
+		let graphOutputs;
+		if (exec) graphOutputs = exec.graphOutputs;
+		else {
+			const graph = generateNanoCodecDecoderGraph({
+				numFrames: winFrames,
+				geometry: {
+					upSampleRates: GEPARD_CODEC_UP_SAMPLE_RATES,
+					inputDim: GEPARD_CODEC_INPUT_DIM
+				},
+				latentInput: true
+			});
+			exec = new Executor(this.ctx, graph, {
+				maxSeqLen: winFrames,
+				kvMode: "f32"
+			});
+			exec.uploadWeightsMap(selectGraphWeights$2(graph, this.loaded.codecWeights));
+			exec.initBindGroups();
+			graphOutputs = graph.outputs;
+			if (steady) this.codecExecCache.set(winFrames, exec);
 		}
-		req.onToken?.(piece, {
-			requestId: req.id,
-			tokenId,
-			generated: req.generatedIds.length
-		});
-		if (req.generatedIds.length >= req.maxTokens) {
-			req.finishReason = "max_tokens";
-			this.finish(req);
+		try {
+			exec.reset();
+			exec.writeInput("nc_latent", latent);
+			return await exec.runGraphOutput(graphOutputs[0], winFrames * GEPARD_HOP);
+		} finally {
+			if (!steady) exec.destroy();
 		}
 	}
-	/** Retire the lane immediately: free KV blocks, open the slot, resolve. */
-	finish(req) {
-		req.state = "done";
-		if (req.slot >= 0 && this.slots[req.slot] === req) {
-			this.host.executor.retireBatchSlot(req.slot);
-			this.slots[req.slot] = null;
-		}
-		this.reservedBlocks -= req.blocksReserved;
-		this.stats.completed++;
-		const finishedAt = performance.now();
-		req.resolve({
-			requestId: req.id,
-			text: req.text,
-			tokenIds: [...req.generatedIds],
-			tokensGenerated: req.generatedIds.length,
-			finishReason: req.finishReason,
-			adapter: req.adapterName ?? void 0,
-			submittedAt: req.submittedAt,
-			admittedAt: req.admittedAt,
-			firstTokenAt: req.firstTokenAt,
-			finishedAt,
-			ttftMs: req.firstTokenAt - req.submittedAt,
-			e2eMs: finishedAt - req.submittedAt
-		});
+	destroy() {
+		if (this._destroyed) return;
+		this._destroyed = true;
+		this.backboneExec.destroy();
+		for (const exec of this.codecExecCache.values()) exec.destroy();
+		this.codecExecCache.clear();
+		this.loaded.backboneWeights.clear();
+		this.loaded.overlayWeights.clear();
+		this.loaded.codecWeights.clear();
 	}
 };
-
-//#endregion
-//#region src/gpu/batch/swarm.ts
-/** Default reduce: member-keyed map, disambiguating duplicated members. */
-function reduceToKeyedMap(results) {
-	const out = {};
-	const seen = /* @__PURE__ */ new Map();
-	for (const { member, result } of results) {
-		const n = (seen.get(member) ?? 0) + 1;
-		seen.set(member, n);
-		out[n === 1 ? member : `${member}#${n}`] = result;
-	}
-	return out;
-}
 /**
-* A swarm handle: registered members + plan/reduce over the engine's
-* scheduler. Create via {@link WebGPUEngine.createSwarm}.
+* Incremental chunk decoder: every GEPARD_CODEC_CHUNK_FRAMES completed frames
+* it decodes the new span (with lookback) and emits it via `onChunk`, keeping
+* all emitted PCM so the final result is assembled without a second decode.
 */
-var Swarm = class {
-	scheduler;
-	memberSources;
-	plan;
-	reduce;
-	constructor(scheduler, options) {
-		if (Object.keys(options.members).length === 0) throw new Error("Swarm: members must contain at least one member");
-		this.scheduler = scheduler;
-		this.memberSources = { ...options.members };
-		this.plan = options.plan;
-		this.reduce = options.reduce;
-	}
-	/** Member names, declaration order. */
-	get members() {
-		return Object.keys(this.memberSources);
-	}
-	/**
-	* Run one input through the swarm: plan → concurrent fan-out (one batched
-	* pass across the scheduler's lanes) → reduce.
-	*
-	* @param input The task input handed to the plan (default plan: broadcast
-	*   it to every member as the prompt).
-	* @param options Per-request options applied to every sub-task (a task's
-	*   own `options` win field-by-field).
-	*/
-	async run(input, options = {}) {
-		const tasks = this.plan ? await this.plan(input, this.members) : this.members.map((member) => ({
-			member,
-			prompt: input
-		}));
-		if (tasks.length === 0) throw new Error("Swarm: plan produced no sub-tasks");
-		const results = await Promise.all(tasks.map(async (task) => {
-			const result = await this.submitFor(task.member, task.prompt, {
-				...options,
-				...task.options
+var GepardChunkStreamer = class {
+	tts;
+	onChunk;
+	decodedUpTo = 0;
+	chunks = [];
+	constructor(tts, onChunk) {
+		this.tts = tts;
+		this.onChunk = onChunk;
+	}
+	/** Decode + emit any complete pending chunk (or everything when `final`). */
+	async maybeEmit(frames, final) {
+		if (!(final || this.onChunk)) return;
+		while (frames.length - this.decodedUpTo >= GEPARD_CODEC_CHUNK_FRAMES || final) {
+			const from = this.decodedUpTo;
+			const to = final ? frames.length : Math.min(frames.length, from + GEPARD_CODEC_CHUNK_FRAMES);
+			if (to <= from) break;
+			const pcm = await this.tts.decodeFrameRange(frames, from, to);
+			this.chunks.push(pcm);
+			this.decodedUpTo = to;
+			this.onChunk?.({
+				pcm,
+				sampleRate: this.tts.sampleRate,
+				frameIndex: from,
+				isFinal: final && this.decodedUpTo >= frames.length
 			});
-			return {
-				member: task.member,
-				result
-			};
-		}));
-		if (this.reduce) return this.reduce(results);
-		return reduceToKeyedMap(results);
-	}
-	/**
-	* Mode-A access: decode one prompt with a single member (no plan/reduce).
-	* Still rides the shared scheduler, so it batches with any concurrent work.
-	*/
-	generate(member, prompt, options = {}) {
-		return this.submitFor(member, prompt, options);
+			if (final && this.decodedUpTo >= frames.length) break;
+		}
 	}
-	submitFor(member, prompt, options) {
-		if (!Object.hasOwn(this.memberSources, member)) throw new Error(`Swarm: unknown member "${member}" (members: ${this.members.join(", ")})`);
-		const adapter = this.memberSources[member] == null ? void 0 : member;
-		return this.scheduler.submit(prompt, {
-			...options,
-			adapter
-		});
+	/** Concatenate all emitted chunks into the full utterance PCM. */
+	assembled(totalFrames) {
+		const pcm = new Float32Array(totalFrames * GEPARD_HOP);
+		let offset = 0;
+		for (const chunk of this.chunks) {
+			pcm.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return pcm;
 	}
 };
 
@@ -5596,6 +6647,8 @@ var WebGPUEngine = class WebGPUEngine {
 	_batchAdapters = /* @__PURE__ */ new Map();
 	/** Lazily-created Parler-TTS engine (Flan-T5 encoder + decoder LM + dac_44khz). */
 	_parlerTTS = null;
+	/** Lazily-created Gepard-1.0 engine (Qwen3.5 multihead codec-LM + NanoCodec 21.5 fps). */
+	_gepardTTS = null;
 	/** Lazily-created continuous-batching scheduler (GERBIL_BATCH, Phase 5). */
 	_scheduler = null;
 	/**
@@ -6601,6 +7654,7 @@ var WebGPUEngine = class WebGPUEngine {
 		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 (/gepard/i.test(repo) || /gepard/i.test(this._architecture)) return this.speakGepard(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,
@@ -6645,6 +7699,31 @@ var WebGPUEngine = class WebGPUEngine {
 		return ParlerTTS.randomVoiceDescription();
 	}
 	/**
+	* Gepard-1.0 speak path: lazily build the Gepard engine (stock Qwen3.5
+	* full-attention codec-LM + 32 host-side FSQ classifier heads + NanoCodec
+	* 21.5 fps decoder) and synthesize `text`. Frame-synchronous: when `onChunk`
+	* is set, audio streams out during generation. Single default voice for now
+	* (voice cloning via the ref-compressor is a documented follow-up).
+	*/
+	async speakGepard(text, options) {
+		if (!this._gepardTTS) this._gepardTTS = await GepardTTS.create({
+			repo: this._createOptions.repo,
+			revision: this._createOptions.revision,
+			hfToken: this._createOptions.hfToken,
+			cacheDir: this._createOptions.cacheDir,
+			maxSeqLen: this.maxSeqLen,
+			dtype: options.dtype
+		});
+		return this._gepardTTS.speak(text, {
+			temperature: options.temperature,
+			topK: options.topK,
+			repetitionPenalty: options.repetitionPenalty,
+			maxFrames: options.maxFrames,
+			stopThreshold: options.stopThreshold,
+			onChunk: options.onChunk
+		});
+	}
+	/**
 	* 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).
@@ -7427,6 +8506,7 @@ var WebGPUEngine = class WebGPUEngine {
 		this._kaniTTS?.destroy();
 		this._outeTTS?.destroy();
 		this._parlerTTS?.destroy();
+		this._gepardTTS?.destroy();
 		this.visionExecutor?.destroy();
 		if (this._ctx) {
 			clearPipelineCache(this._ctx.device);
@@ -7461,5 +8541,5 @@ var WebGPUEngine = class WebGPUEngine {
 };
 
 //#endregion
-export { KaniTTS as A, audioTokensToDacCodes as C, parseOuteTtsConfig as D, generateOuteTtsBackboneGraph as E, patchGemma4VisionClips as F, resolveGemma4VisionInfo as I, dequantizeGemma4VisionProjection as M, dequantizeMLXProjection as N, Swarm as O, generateGemma4VisionGraph 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, generateQwen3_5VisionGraph as j, RequestScheduler 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-DRFhiv4R.mjs.map
+export { generateGepardBackboneGraph as A, generateGemma4VisionGraph as B, audioTokensToDacCodes as C, parseOuteTtsConfig as D, generateOuteTtsBackboneGraph as E, RequestScheduler as F, resolveGemma4VisionInfo as H, KaniTTS as I, generateQwen3_5VisionGraph as L, gepardCodesToLatent as M, parseGepardConfig as N, GepardTTS as O, Swarm as P, dequantizeGemma4VisionProjection as R, loadOuteSpeaker as S, generateDacSpeechDecoderGraph as T, patchGemma4VisionClips as V, 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, gepardChannelLevels as j, buildGepardTextLayout 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, dequantizeMLXProjection as z };
+//# sourceMappingURL=gpu-CU_Mldk0.mjs.map