@tryhamster/gerbil 1.11.4 → 1.13.0

package/dist/{gpu-CrzjQHv2.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-DmZMEFsA.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-BXoZaHJE.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);
@@ -1164,66 +1164,1682 @@ function stripRestatement(typed, suggestion, minWords = DEFAULT_RESTATEMENT_MIN_
 		if (normTyped.includes(phrase)) matched = n;
 		else break;
 	}
-	if (matched >= minWords) return words.slice(matched).join(" ");
-	return suggestion;
-}
-/**
-* Truncate `text` right before the first point where a span of `minRun` or more
-* consecutive words repeats a span seen earlier — the classic small-model loop
-* ("…endless sands …endless sands…"). Returns `text` unchanged (spacing
-* preserved) when no such repeat exists.
-*/
-function truncateInternalRepeat(text, minRun = DEFAULT_INTERNAL_REPEAT_MIN_RUN) {
-	const words = text.split(WHITESPACE_RUN).filter(Boolean);
-	const seen = /* @__PURE__ */ new Set();
-	for (let j = 0; j + minRun <= words.length; j++) {
-		const gram = words.slice(j, j + minRun).join(" ").toLowerCase();
-		if (seen.has(gram)) return words.slice(0, j).join(" ");
-		seen.add(gram);
+	if (matched >= minWords) return words.slice(matched).join(" ");
+	return suggestion;
+}
+/**
+* Truncate `text` right before the first point where a span of `minRun` or more
+* consecutive words repeats a span seen earlier — the classic small-model loop
+* ("…endless sands …endless sands…"). Returns `text` unchanged (spacing
+* preserved) when no such repeat exists.
+*/
+function truncateInternalRepeat(text, minRun = DEFAULT_INTERNAL_REPEAT_MIN_RUN) {
+	const words = text.split(WHITESPACE_RUN).filter(Boolean);
+	const seen = /* @__PURE__ */ new Set();
+	for (let j = 0; j + minRun <= words.length; j++) {
+		const gram = words.slice(j, j + minRun).join(" ").toLowerCase();
+		if (seen.has(gram)) return words.slice(0, j).join(" ");
+		seen.add(gram);
+	}
+	return text;
+}
+/**
+* Cap `text` to at most `max` characters, cutting on a word boundary when a
+* reasonable one exists in the back half of the window.
+*/
+function capLength(text, max) {
+	if (text.length <= max) return text;
+	const cut = text.slice(0, max);
+	const lastSpace = cut.lastIndexOf(" ");
+	return (lastSpace > max * .5 ? cut.slice(0, lastSpace) : cut).trimEnd();
+}
+/**
+* Turn a raw model completion into a clean inline ghost continuation:
+* 1. keep only the first line (when `singleLine`),
+* 2. strip wrapping quotes,
+* 3. drop a full verbatim echo of the typed text,
+* 4. drop a leading character overlap with the typed tail,
+* 5. drop a leading word-run that restates an earlier typed phrase,
+* 6. truncate an internal phrase loop,
+* 7. cap the length,
+* 8. add a single smart leading space so the ghost joins the caret naturally.
+*
+* Returns "" when nothing novel is left — the ghost then simply shows nothing,
+* which is the correct behavior for a suggestion that only repeats the input.
+*/
+function cleanSuggestion(raw, typed, options = {}) {
+	const { singleLine = true, maxChars = DEFAULT_MAX_SUGGESTION_CHARS } = options;
+	let s = singleLine ? raw.replace(AFTER_FIRST_NEWLINE, "") : raw;
+	s = s.replace(WRAPPING_QUOTES_START, "").replace(WRAPPING_QUOTES_END, "");
+	s = s.trim();
+	if (!s) return "";
+	const typedTrim = typed.trim();
+	if (typedTrim && s.startsWith(typedTrim)) s = s.slice(typedTrim.length).trimStart();
+	s = stripLeadingOverlap(typed, s).trimStart();
+	s = stripRestatement(typed, s);
+	s = truncateInternalRepeat(s);
+	s = capLength(s.trim(), maxChars).trim();
+	if (!s) return "";
+	const startsWithPunct = LEADING_PUNCT.test(s);
+	const typedEndsWithSpace = ENDS_WITH_SPACE.test(typed) || typed.length === 0;
+	return startsWithPunct || typedEndsWithSpace ? s : ` ${s}`;
+}
+
+//#endregion
+//#region src/gpu/sampler.ts
+/** mulberry32 — tiny deterministic PRNG for seeded sampling. */
+function mulberry32(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a = a + 1831565813 | 0;
+		let t = Math.imul(a ^ a >>> 15, 1 | a);
+		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/** Per-params seeded RNG streams (one stream per options object identity). */
+const seededStreams = /* @__PURE__ */ new WeakMap();
+function nextRandom(params) {
+	if (params.seed === void 0) return Math.random();
+	let rng = seededStreams.get(params);
+	if (!rng) {
+		rng = mulberry32(params.seed);
+		seededStreams.set(params, rng);
+	}
+	return rng();
+}
+let _heapIndices = null;
+let _heapValues = null;
+/**
+* Sample a token ID from logits.
+*
+* Pipeline: repetition penalty → temperature → top-k (min-heap) → softmax → top-p → sample.
+*/
+function sampleToken(logits, params = {}, previousTokens) {
+	const temperature = params.temperature ?? .7;
+	const topK = params.topK ?? 50;
+	const topP = params.topP ?? .9;
+	const repetitionPenalty = params.repetitionPenalty ?? 1;
+	if (temperature < 1e-6) return argmax$2(logits);
+	const N = logits.length;
+	const K = Math.min(topK > 0 ? topK : N, N);
+	if (!_heapIndices || _heapIndices.length < K) {
+		_heapIndices = new Uint32Array(K);
+		_heapValues = new Float32Array(K);
+	}
+	const hIdx = _heapIndices;
+	const hVal = _heapValues;
+	let penaltySet = null;
+	if (repetitionPenalty !== 1 && previousTokens?.length) penaltySet = new Set(previousTokens);
+	let heapSize = 0;
+	for (let i = 0; i < N; i++) {
+		let s = logits[i];
+		if (penaltySet?.has(i)) s = s > 0 ? s / repetitionPenalty : s * repetitionPenalty;
+		s /= temperature;
+		if (heapSize < K) {
+			hIdx[heapSize] = i;
+			hVal[heapSize] = s;
+			heapSize++;
+			if (heapSize === K) for (let j = (K >> 1) - 1; j >= 0; j--) siftDown(hIdx, hVal, j, K);
+		} else if (s > hVal[0]) {
+			hIdx[0] = i;
+			hVal[0] = s;
+			siftDown(hIdx, hVal, 0, K);
+		}
+	}
+	for (let i = 1; i < heapSize; i++) {
+		const vi = hVal[i];
+		const ii = hIdx[i];
+		let j = i - 1;
+		while (j >= 0 && hVal[j] < vi) {
+			hVal[j + 1] = hVal[j];
+			hIdx[j + 1] = hIdx[j];
+			j--;
+		}
+		hVal[j + 1] = vi;
+		hIdx[j + 1] = ii;
+	}
+	const maxScore = hVal[0];
+	let sumExp = 0;
+	for (let i = 0; i < heapSize; i++) {
+		const p = Math.exp(hVal[i] - maxScore);
+		hVal[i] = p;
+		sumExp += p;
+	}
+	const invSum = 1 / sumExp;
+	for (let i = 0; i < heapSize; i++) hVal[i] *= invSum;
+	let candidateCount = heapSize;
+	if (topP < 1) {
+		let cumulative$1 = 0;
+		for (let i = 0; i < heapSize; i++) {
+			cumulative$1 += hVal[i];
+			if (cumulative$1 >= topP) {
+				candidateCount = i + 1;
+				break;
+			}
+		}
+		let sum = 0;
+		for (let i = 0; i < candidateCount; i++) sum += hVal[i];
+		const inv = 1 / sum;
+		for (let i = 0; i < candidateCount; i++) hVal[i] *= inv;
+	}
+	const r = nextRandom(params);
+	let cumulative = 0;
+	for (let i = 0; i < candidateCount; i++) {
+		cumulative += hVal[i];
+		if (r <= cumulative) return hIdx[i];
+	}
+	return hIdx[candidateCount - 1];
+}
+/**
+* Return the index of the maximum value (greedy decoding).
+*/
+function argmax$2(arr) {
+	let maxIdx = 0;
+	let maxVal = arr[0];
+	for (let i = 1; i < arr.length; i++) if (arr[i] > maxVal) {
+		maxVal = arr[i];
+		maxIdx = i;
+	}
+	return maxIdx;
+}
+/** Min-heap sift down on parallel index/value typed arrays. */
+function siftDown(indices, values, i, n) {
+	while (true) {
+		let smallest = i;
+		const left = 2 * i + 1;
+		const right = 2 * i + 2;
+		if (left < n && values[left] < values[smallest]) smallest = left;
+		if (right < n && values[right] < values[smallest]) smallest = right;
+		if (smallest === i) break;
+		const ti = indices[i];
+		indices[i] = indices[smallest];
+		indices[smallest] = ti;
+		const tv = values[i];
+		values[i] = values[smallest];
+		values[smallest] = tv;
+		i = smallest;
+	}
+}
+
+//#endregion
+//#region src/gpu/batch/scheduler.ts
+const PIPELINE_DEPTH = 2;
+var RequestScheduler = class {
+	host;
+	batchSize;
+	maxSeqLen;
+	blockSize;
+	prefillChunk;
+	/** Free KV blocks kept unreserved as safety headroom. */
+	blockHeadroom;
+	nextId = 1;
+	queue = [];
+	/** slot → occupying request (prefilling or decoding). */
+	slots;
+	/** Sum of blocksReserved across live (admitted, unfinished) requests. */
+	reservedBlocks = 0;
+	prefilling = null;
+	inFlight = [];
+	/**
+	* The slot→adapter-id assignment last uploaded to the executor (null =
+	* nothing uploaded this batch session). Steps only re-upload when the
+	* assignment changes (admissions/retirements), and the very first upload is
+	* skipped entirely while every lane is bare base — an adapter-free serving
+	* session never touches the LoRA machinery.
+	*/
+	lastLaneAdapterIds = null;
+	stepCounter = 0;
+	loop = null;
+	closed = false;
+	stats = {
+		submitted: 0,
+		completed: 0,
+		stepsSubmitted: 0,
+		prefillChunks: 0,
+		tokensGenerated: 0,
+		busyMs: 0,
+		peakActiveLanes: 0
+	};
+	constructor(host, options = {}) {
+		this.host = host;
+		this.batchSize = host.executor.batchSize;
+		if (this.batchSize <= 0) throw new Error("RequestScheduler requires GERBIL_BATCH=N (N >= 2) on the Dawn path");
+		this.maxSeqLen = host.executor.maxSequenceLength;
+		this.blockSize = host.executor.kvBlockSizeTokens;
+		this.slots = new Array(this.batchSize).fill(null);
+		const envChunk = typeof process !== "undefined" ? Number(process.env?.GERBIL_PREFILL_CHUNK) : NaN;
+		this.prefillChunk = options.prefillChunkTokens ?? (Number.isFinite(envChunk) && envChunk >= 8 ? envChunk : 128);
+		this.blockHeadroom = 2;
+	}
+	/**
+	* Submit a request; resolves with the full result when it finishes.
+	* Tokens stream through options.onToken as they are decoded.
+	*/
+	submit(prompt, options = {}) {
+		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("RequestScheduler is closed"));
+		if ((options.sampling?.temperature ?? 0) >= 1e-6) return Promise.reject(/* @__PURE__ */ new Error("RequestScheduler: Phase 5 is greedy-only — pass sampling: { temperature: 0 }"));
+		let adapterReg = null;
+		if (options.adapter != null) {
+			if (!this.host.executor.batchLoraEnabled) return Promise.reject(/* @__PURE__ */ new Error("RequestScheduler: per-request adapters require GERBIL_BATCH_LORA=1 (with GERBIL_BATCH=N)"));
+			try {
+				adapterReg = this.host.resolveAdapter(options.adapter);
+			} catch (err) {
+				return Promise.reject(err instanceof Error ? err : new Error(String(err)));
+			}
+		}
+		const messages = typeof prompt === "string" ? [...options.systemPrompt ? [{
+			role: "system",
+			content: options.systemPrompt
+		}] : [], {
+			role: "user",
+			content: prompt
+		}] : options.systemPrompt ? [{
+			role: "system",
+			content: options.systemPrompt
+		}, ...prompt] : prompt;
+		const promptIds = new Uint32Array(this.host.encodeChat(messages));
+		const roomFor = this.maxSeqLen - promptIds.length - PIPELINE_DEPTH - 1;
+		if (roomFor < 1) return Promise.reject(/* @__PURE__ */ new Error(`RequestScheduler: prompt (${promptIds.length} tokens) leaves no room in maxSeqLen ${this.maxSeqLen}`));
+		const maxTokens = Math.min(options.maxTokens ?? 128, roomFor);
+		return new Promise((resolve, reject) => {
+			const req = {
+				id: this.nextId++,
+				promptIds,
+				maxTokens,
+				stopSequences: options.stopSequences ?? [],
+				adapterName: options.adapter ?? null,
+				adapterId: adapterReg?.id ?? -1,
+				adapterDeltas: adapterReg?.deltas ?? null,
+				onToken: options.onToken,
+				resolve,
+				reject,
+				state: "queued",
+				slot: -1,
+				prefillPos: 0,
+				blocksReserved: 0,
+				generatedIds: [],
+				text: "",
+				finishReason: "max_tokens",
+				submittedAt: performance.now(),
+				admittedAt: 0,
+				firstTokenAt: 0
+			};
+			this.queue.push(req);
+			this.stats.submitted++;
+			this.pump();
+		});
+	}
+	/** Resolves when every submitted request has completed. */
+	async drain() {
+		while (this.loop) await this.loop;
+	}
+	/** Stop accepting requests; resolves when in-flight work drains. */
+	async close() {
+		this.closed = true;
+		await this.drain();
+	}
+	getStats() {
+		return { ...this.stats };
+	}
+	pump() {
+		if (this.loop) return;
+		this.loop = this.run().finally(() => {
+			this.loop = null;
+			if (this.hasWork()) this.pump();
+		});
+	}
+	hasWork() {
+		return this.queue.length > 0 || this.prefilling !== null || this.inFlight.length > 0 || this.slots.some((s) => s !== null);
+	}
+	activeMask() {
+		const mask = new Uint8Array(this.batchSize);
+		const rows = [];
+		for (let b = 0; b < this.batchSize; b++) {
+			const req = this.slots[b];
+			if (req && req.state === "decoding") {
+				mask[b] = 1;
+				rows.push({
+					slot: b,
+					req
+				});
+			}
+		}
+		return {
+			mask,
+			rows
+		};
+	}
+	/** The serving loop. Holds the engine generation lock while live. */
+	async run() {
+		const release = await this.host.acquireLock();
+		const ex = this.host.executor;
+		const loopStart = performance.now();
+		ex.resetBatch();
+		this.stepCounter = 0;
+		this.lastLaneAdapterIds = null;
+		try {
+			while (this.hasWork()) {
+				this.admit();
+				const { mask, rows } = this.activeMask();
+				if (rows.length > 0 && this.inFlight.length < PIPELINE_DEPTH) {
+					const readbackSlot = this.stepCounter % PIPELINE_DEPTH;
+					this.syncLaneAdapters();
+					ex.submitBatchDecodeStepMasked(mask, readbackSlot);
+					this.stepCounter++;
+					this.inFlight.push({
+						readbackSlot,
+						rows
+					});
+					this.stats.stepsSubmitted++;
+					if (rows.length > this.stats.peakActiveLanes) this.stats.peakActiveLanes = rows.length;
+				}
+				if (this.prefilling) await this.prefillChunkStep();
+				const pipelineFull = this.inFlight.length >= PIPELINE_DEPTH;
+				const idleLanes = rows.length === 0 && this.prefilling === null;
+				if (this.inFlight.length > 0 && (pipelineFull || idleLanes)) await this.readStep();
+			}
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			if (this.prefilling?.adapterDeltas) try {
+				ex.clearRuntimeLoRA();
+			} catch {}
+			for (const req of [...this.queue, ...this.slots.filter((s) => s !== null)]) if (req.state !== "done") {
+				req.state = "done";
+				req.reject(error);
+			}
+			this.queue = [];
+			this.slots.fill(null);
+			this.prefilling = null;
+			this.inFlight = [];
+			this.reservedBlocks = 0;
+			throw error;
+		} finally {
+			this.stats.busyMs += performance.now() - loopStart;
+			release();
+		}
+	}
+	/**
+	* Upload the slot→adapter assignment for the step about to be submitted,
+	* when it differs from the last uploaded one. Called immediately before
+	* every decode-step submit: `queue.writeBuffer` is queue-ordered, so steps
+	* already in flight keep the assignment they were submitted under, and a
+	* retiring lane's slot can never leak its adapter into the slot's next
+	* occupant — the next occupant's assignment is re-derived from `slots`
+	* before its first decode step. Masked (free/prefilling) lanes are pinned
+	* to bare base; their output is discarded regardless.
+	*/
+	syncLaneAdapters() {
+		if (!this.host.executor.batchLoraEnabled) return;
+		const ids = new Int32Array(this.batchSize).fill(-1);
+		let anyAdapter = false;
+		for (let b = 0; b < this.batchSize; b++) {
+			const req = this.slots[b];
+			if (req && req.state === "decoding" && req.adapterId >= 0) {
+				ids[b] = req.adapterId;
+				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;
+	}
+	/**
+	* 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;
+	}
+	/**
+	* 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.
+	*/
+	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);
+		}
+		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));
+	}
+	/**
+	* 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.
+	*/
+	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;
+	}
+	/**
+	* 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
+		};
+	}
+	/**
+	* 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 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);
+		}
+		try {
+			exec.reset();
+			exec.writeInput("nc_latent", latent);
+			return await exec.runGraphOutput(graphOutputs[0], winFrames * GEPARD_HOP);
+		} finally {
+			if (!steady) exec.destroy();
+		}
+	}
+	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();
 	}
-	return text;
-}
-/**
-* Cap `text` to at most `max` characters, cutting on a word boundary when a
-* reasonable one exists in the back half of the window.
-*/
-function capLength(text, max) {
-	if (text.length <= max) return text;
-	const cut = text.slice(0, max);
-	const lastSpace = cut.lastIndexOf(" ");
-	return (lastSpace > max * .5 ? cut.slice(0, lastSpace) : cut).trimEnd();
-}
+};
 /**
-* Turn a raw model completion into a clean inline ghost continuation:
-* 1. keep only the first line (when `singleLine`),
-* 2. strip wrapping quotes,
-* 3. drop a full verbatim echo of the typed text,
-* 4. drop a leading character overlap with the typed tail,
-* 5. drop a leading word-run that restates an earlier typed phrase,
-* 6. truncate an internal phrase loop,
-* 7. cap the length,
-* 8. add a single smart leading space so the ghost joins the caret naturally.
-*
-* Returns "" when nothing novel is left — the ghost then simply shows nothing,
-* which is the correct behavior for a suggestion that only repeats the input.
+* 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.
 */
-function cleanSuggestion(raw, typed, options = {}) {
-	const { singleLine = true, maxChars = DEFAULT_MAX_SUGGESTION_CHARS } = options;
-	let s = singleLine ? raw.replace(AFTER_FIRST_NEWLINE, "") : raw;
-	s = s.replace(WRAPPING_QUOTES_START, "").replace(WRAPPING_QUOTES_END, "");
-	s = s.trim();
-	if (!s) return "";
-	const typedTrim = typed.trim();
-	if (typedTrim && s.startsWith(typedTrim)) s = s.slice(typedTrim.length).trimStart();
-	s = stripLeadingOverlap(typed, s).trimStart();
-	s = stripRestatement(typed, s);
-	s = truncateInternalRepeat(s);
-	s = capLength(s.trim(), maxChars).trim();
-	if (!s) return "";
-	const startsWithPunct = LEADING_PUNCT.test(s);
-	const typedEndsWithSpace = ENDS_WITH_SPACE.test(typed) || typed.length === 0;
-	return startsWithPunct || typedEndsWithSpace ? s : ` ${s}`;
-}
+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
+			});
+			if (final && this.decodedUpTo >= frames.length) break;
+		}
+	}
+	/** 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;
+	}
+};
 
 //#endregion
 //#region src/gpu/architectures/outetts.ts
@@ -2859,7 +4475,7 @@ function selectGraphWeights$1(graph, weights) {
 	return out;
 }
 /** Index of the maximum logit (greedy / argmax decode). */
-function argmax$2(logits) {
+function argmax$1(logits) {
 	let best = 0;
 	let bestV = logits[0];
 	for (let i = 1; i < logits.length; i++) if (logits[i] > bestV) {
@@ -3188,7 +4804,7 @@ var OuteTTS = class OuteTTS {
 		const generated = [];
 		let logits = prefillLogits;
 		for (let step = 0; step < p.maxNewTokens; step++) {
-			const next = p.greedy ? argmax$2(logits) : this.sampleToken(logits, {
+			const next = p.greedy ? argmax$1(logits) : this.sampleToken(logits, {
 				temperature: p.temperature,
 				topP: p.topP,
 				topK: p.topK,
@@ -3320,7 +4936,7 @@ function selectGraphWeights(graph, weights) {
 	return out;
 }
 /** Argmax over a logit row. */
-function argmax$1(logits) {
+function argmax(logits) {
 	let best = 0;
 	let bestV = logits[0];
 	for (let i = 1; i < logits.length; i++) if (logits[i] > bestV) {
@@ -3671,7 +5287,7 @@ var ParlerTTS = class ParlerTTS {
 						continue;
 					}
 					if (cb > frontier) logitRows[cb][PARLER_EOS_TOKEN_ID] = Number.NEGATIVE_INFINITY;
-					const code = opts.greedy ? argmax$1(logitRows[cb]) : sampleLogits(logitRows[cb], opts.temperature ?? 1, opts.topK ?? 0);
+					const code = opts.greedy ? argmax(logitRows[cb]) : sampleLogits(logitRows[cb], opts.temperature ?? 1, opts.topK ?? 0);
 					nextCodes[cb] = code;
 					grid[cb * maxSteps + step] = code < PARLER_CODEBOOK_SIZE ? code : 0;
 				}
@@ -3742,122 +5358,6 @@ function addPosition(row, posTable, pos, H) {
 	for (let i = 0; i < H; i++) row[i] += posTable[base + i];
 }
 
-//#endregion
-//#region src/gpu/sampler.ts
-let _heapIndices = null;
-let _heapValues = null;
-/**
-* Sample a token ID from logits.
-*
-* Pipeline: repetition penalty → temperature → top-k (min-heap) → softmax → top-p → sample.
-*/
-function sampleToken(logits, params = {}, previousTokens) {
-	const temperature = params.temperature ?? .7;
-	const topK = params.topK ?? 50;
-	const topP = params.topP ?? .9;
-	const repetitionPenalty = params.repetitionPenalty ?? 1;
-	if (temperature < 1e-6) return argmax(logits);
-	const N = logits.length;
-	const K = Math.min(topK > 0 ? topK : N, N);
-	if (!_heapIndices || _heapIndices.length < K) {
-		_heapIndices = new Uint32Array(K);
-		_heapValues = new Float32Array(K);
-	}
-	const hIdx = _heapIndices;
-	const hVal = _heapValues;
-	let penaltySet = null;
-	if (repetitionPenalty !== 1 && previousTokens?.length) penaltySet = new Set(previousTokens);
-	let heapSize = 0;
-	for (let i = 0; i < N; i++) {
-		let s = logits[i];
-		if (penaltySet?.has(i)) s = s > 0 ? s / repetitionPenalty : s * repetitionPenalty;
-		s /= temperature;
-		if (heapSize < K) {
-			hIdx[heapSize] = i;
-			hVal[heapSize] = s;
-			heapSize++;
-			if (heapSize === K) for (let j = (K >> 1) - 1; j >= 0; j--) siftDown(hIdx, hVal, j, K);
-		} else if (s > hVal[0]) {
-			hIdx[0] = i;
-			hVal[0] = s;
-			siftDown(hIdx, hVal, 0, K);
-		}
-	}
-	for (let i = 1; i < heapSize; i++) {
-		const vi = hVal[i];
-		const ii = hIdx[i];
-		let j = i - 1;
-		while (j >= 0 && hVal[j] < vi) {
-			hVal[j + 1] = hVal[j];
-			hIdx[j + 1] = hIdx[j];
-			j--;
-		}
-		hVal[j + 1] = vi;
-		hIdx[j + 1] = ii;
-	}
-	const maxScore = hVal[0];
-	let sumExp = 0;
-	for (let i = 0; i < heapSize; i++) {
-		const p = Math.exp(hVal[i] - maxScore);
-		hVal[i] = p;
-		sumExp += p;
-	}
-	const invSum = 1 / sumExp;
-	for (let i = 0; i < heapSize; i++) hVal[i] *= invSum;
-	let candidateCount = heapSize;
-	if (topP < 1) {
-		let cumulative$1 = 0;
-		for (let i = 0; i < heapSize; i++) {
-			cumulative$1 += hVal[i];
-			if (cumulative$1 >= topP) {
-				candidateCount = i + 1;
-				break;
-			}
-		}
-		let sum = 0;
-		for (let i = 0; i < candidateCount; i++) sum += hVal[i];
-		const inv = 1 / sum;
-		for (let i = 0; i < candidateCount; i++) hVal[i] *= inv;
-	}
-	const r = Math.random();
-	let cumulative = 0;
-	for (let i = 0; i < candidateCount; i++) {
-		cumulative += hVal[i];
-		if (r <= cumulative) return hIdx[i];
-	}
-	return hIdx[candidateCount - 1];
-}
-/**
-* Return the index of the maximum value (greedy decoding).
-*/
-function argmax(arr) {
-	let maxIdx = 0;
-	let maxVal = arr[0];
-	for (let i = 1; i < arr.length; i++) if (arr[i] > maxVal) {
-		maxVal = arr[i];
-		maxIdx = i;
-	}
-	return maxIdx;
-}
-/** Min-heap sift down on parallel index/value typed arrays. */
-function siftDown(indices, values, i, n) {
-	while (true) {
-		let smallest = i;
-		const left = 2 * i + 1;
-		const right = 2 * i + 2;
-		if (left < n && values[left] < values[smallest]) smallest = left;
-		if (right < n && values[right] < values[smallest]) smallest = right;
-		if (smallest === i) break;
-		const ti = indices[i];
-		indices[i] = indices[smallest];
-		indices[smallest] = ti;
-		const tv = values[i];
-		values[i] = values[smallest];
-		values[smallest] = tv;
-		i = smallest;
-	}
-}
-
 //#endregion
 //#region src/gpu/vision-executor.ts
 const MAP_MODE_READ = 1;
@@ -5143,8 +6643,14 @@ var WebGPUEngine = class WebGPUEngine {
 	_outeVoice = null;
 	/** Source of the runtime LoRA adapter currently applied on the static base, if any. */
 	_currentAdapter = null;
+	/** Named adapters registered for per-lane batched decode (GERBIL_BATCH_LORA). */
+	_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;
 	/**
 	* 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
@@ -5250,6 +6756,35 @@ var WebGPUEngine = class WebGPUEngine {
 		return this._currentAdapter;
 	}
 	/**
+	* Register a named LoRA adapter for per-lane batched decode (SGMV phase 1,
+	* `GERBIL_BATCH=N` + `GERBIL_BATCH_LORA=1`). The adapter's factors are
+	* fetched and packed into the executor's shared factor buffers ONCE; any
+	* number of batch lanes can then run it concurrently by passing its name in
+	* `generateBatch`'s per-lane `adapters` option. Registering the same name
+	* twice is a no-op.
+	*/
+	async registerAdapter(name, source) {
+		this.checkDestroyed();
+		if (!this.executor.batchLoraEnabled) throw new Error("registerAdapter requires GERBIL_BATCH=N (N >= 2) and GERBIL_BATCH_LORA=1 on the Dawn path");
+		if (this._batchAdapters.has(name)) return;
+		const adapter = await fetchAdapter(source, {
+			hfToken: this._createOptions.hfToken,
+			revision: this._createOptions.revision
+		});
+		if (!adapter) throw new Error(`No adapter found at ${source}.`);
+		const deltas = buildLoRADeltas(adapter, createKeyMapperForArch(this._architecture));
+		const id = this.executor.registerBatchAdapter(deltas);
+		this._batchAdapters.set(name, {
+			id,
+			deltas
+		});
+		console.log(`[engine] batch adapter "${name}" (${source}) registered as id ${id}.`);
+	}
+	/** Names of the adapters registered for per-lane batched decode. */
+	getRegisteredAdapters() {
+		return [...this._batchAdapters.keys()];
+	}
+	/**
 	* Write a coarse crash-phase breadcrumb that survives a GPU-process kill / page
 	* reload. The iPad harness reads `localStorage["gerbil-crash-phase"]` after a
 	* crash; without these, a describe-time crash only shows the last load phase
@@ -5580,6 +7115,186 @@ var WebGPUEngine = class WebGPUEngine {
 		}
 	}
 	/**
+	* Batched lockstep generation (GERBIL_BATCH=N — Phase 2 of the
+	* continuous-batching campaign, Dawn only).
+	*
+	* Prefills each prompt sequentially into its batch slot (KV into the slot's
+	* block-table row, SSM/conv state adopted into the slot's state-pool rows),
+	* then decodes all N sequences in lockstep: one batched dispatch stream per
+	* step produces one token per row. Greedy-only in Phase 2 (per-row GPU
+	* argmax); rows that hit EOS/stop keep decoding in lockstep with their
+	* output discarded until every row has finished — rows never interact, so
+	* per-row streams are token-exact vs single-sequence generation.
+	*
+	* Requires exactly `executor.batchSize` prompts (fixed lockstep batch; the
+	* Phase 3 scheduler will lift this).
+	*/
+	async generateBatch(prompts, options = {}) {
+		this.checkDestroyed();
+		const B = this.executor.batchSize;
+		if (B <= 0) throw new Error("generateBatch requires GERBIL_BATCH=N (N >= 2) on the Dawn path");
+		if (prompts.length !== B) throw new Error(`generateBatch: got ${prompts.length} prompts for a fixed batch of ${B} (set GERBIL_BATCH=${prompts.length})`);
+		if (this._multimodalGraph || this.executor.hasPleSource() || this.executor.hasRuntimeAdapter) throw new Error("generateBatch: multimodal, PLE, and runtime-LoRA models are Phase 2+ work");
+		const { maxTokens = 512, stopSequences = [], sampling = {}, systemPrompt } = options;
+		if ((sampling.temperature ?? .7) >= 1e-6) throw new Error("generateBatch: Phase 2 is greedy-only — pass sampling: { temperature: 0 }");
+		const laneAdapterNames = options.adapters;
+		if (laneAdapterNames && laneAdapterNames.length !== B) throw new Error(`generateBatch: got ${laneAdapterNames.length} lane adapters for a batch of ${B}`);
+		if ((laneAdapterNames?.some((a) => a != null) ?? false) && !this.executor.batchLoraEnabled) throw new Error("generateBatch: per-lane adapters require GERBIL_BATCH_LORA=1");
+		const laneAdapters = new Array(B).fill(null);
+		if (laneAdapterNames) for (let i = 0; i < B; i++) {
+			const name = laneAdapterNames[i];
+			if (name == null) continue;
+			const reg = this._batchAdapters.get(name);
+			if (!reg) throw new Error(`generateBatch: adapter "${name}" not registered (call registerAdapter first)`);
+			laneAdapters[i] = reg;
+		}
+		const release = await this._acquireGenLock();
+		try {
+			const startTime = performance.now();
+			this.executor.resetBatch();
+			const eosId = this.tokenizer.config.eosTokenId;
+			const eotId = this.resolveEndOfTurnId();
+			const keepPlan = this.config.vocabKeepPlan;
+			const remapTok = keepPlan ? (i) => remapPrunedToken(i, keepPlan) : (i) => i;
+			const rows = prompts.map((_p, i) => ({
+				generatedIds: [],
+				text: "",
+				finished: false,
+				finishReason: "max_tokens",
+				limit: options.maxTokensPerRow?.[i] ?? maxTokens
+			}));
+			const firstTokens = new Uint32Array(B);
+			for (let i = 0; i < B; i++) {
+				const p = prompts[i];
+				const messages = typeof p === "string" ? [...systemPrompt ? [{
+					role: "system",
+					content: systemPrompt
+				}] : [], {
+					role: "user",
+					content: p
+				}] : systemPrompt ? [{
+					role: "system",
+					content: systemPrompt
+				}, ...p] : p;
+				const inputIds = this.tokenizer.encodeChat(messages, { addGenerationPrompt: true });
+				const laneReg = laneAdapters[i];
+				if (laneReg) this.executor.applyRuntimeLoRA(laneReg.deltas);
+				try {
+					this.executor.beginBatchSlot(i);
+					const { logits } = await this.executor.forward(new Uint32Array(inputIds));
+					this.executor.finishBatchSlot(i);
+					firstTokens[i] = remapTok(sampleToken(logits, { temperature: 0 }));
+				} finally {
+					if (laneReg) this.executor.clearRuntimeLoRA();
+				}
+			}
+			if (this.executor.batchLoraEnabled) this.executor.setBatchLaneAdapters(laneAdapters.map((a) => a ? a.id : -1));
+			const consume = (row, tok) => {
+				if (row.finished) return;
+				row.generatedIds.push(tok);
+				if (eosId !== null && tok === eosId || eotId !== null && tok === eotId) {
+					row.finished = true;
+					row.finishReason = "eos";
+					return;
+				}
+				row.text += this.tokenizer.decode([tok], true);
+				if (stopSequences.some((s) => row.text.includes(s))) {
+					for (const s of stopSequences) {
+						const idx = row.text.indexOf(s);
+						if (idx !== -1) row.text = row.text.slice(0, idx);
+					}
+					row.finished = true;
+					row.finishReason = "stop_sequence";
+					return;
+				}
+				if (row.generatedIds.length >= row.limit) row.finished = true;
+			};
+			const decodeStart = performance.now();
+			for (let i = 0; i < B; i++) consume(rows[i], firstTokens[i]);
+			const depth = Executor.PIPELINE_DEPTH;
+			const lens = this.executor.batchSlotLengths;
+			let capacity = Number.POSITIVE_INFINITY;
+			for (let i = 0; i < B; i++) capacity = Math.min(capacity, this.maxSeqLen - lens[i] - 1);
+			const maxRowLimit = rows.reduce((a, r) => Math.max(a, r.limit), 0);
+			const stepsNeeded = Math.max(0, Math.min(maxRowLimit - 1, capacity));
+			let submitted = 0;
+			let consumedSteps = 0;
+			while (consumedSteps < stepsNeeded && !rows.every((r) => r.finished)) {
+				while (submitted < stepsNeeded && submitted < consumedSteps + depth) {
+					this.executor.submitBatchDecodeStep(submitted === 0 ? firstTokens : null, submitted % depth);
+					submitted++;
+				}
+				const toks = await this.executor.readBatchTokens(consumedSteps % depth);
+				consumedSteps++;
+				for (let i = 0; i < B; i++) consume(rows[i], toks[i]);
+			}
+			const decodeTime = performance.now() - decodeStart;
+			const totalTime = performance.now() - startTime;
+			return rows.map((r) => ({
+				text: r.text,
+				tokensGenerated: r.generatedIds.length,
+				tokensPerSecond: r.generatedIds.length / (totalTime / 1e3),
+				totalTime,
+				decodeTime,
+				finishReason: r.finishReason,
+				tokenIds: [...r.generatedIds]
+			}));
+		} finally {
+			release();
+		}
+	}
+	/**
+	* Continuous-batching scheduler (GERBIL_BATCH=N — Phase 5 of the batching
+	* campaign, Dawn only). Returns the engine's request scheduler (created on
+	* first call): submit many requests with independent prompts/limits and the
+	* scheduler multiplexes them over the batch lanes with dynamic admission,
+	* immediate lane retirement, and chunked prefill. Greedy-only; per-request
+	* output is token-exact vs single-sequence generate().
+	*/
+	createScheduler() {
+		this.checkDestroyed();
+		if (this._scheduler) return this._scheduler;
+		if (this.executor.batchSize <= 0) throw new Error("createScheduler requires GERBIL_BATCH=N (N >= 2) on the Dawn path");
+		if (this._multimodalGraph || this.executor.hasPleSource() || this.executor.hasRuntimeAdapter) throw new Error("createScheduler: multimodal, PLE, and runtime-LoRA models are unsupported");
+		const keepPlan = this.config.vocabKeepPlan;
+		this._scheduler = new RequestScheduler({
+			executor: this.executor,
+			encodeChat: (messages) => this.tokenizer.encodeChat(messages, { addGenerationPrompt: true }),
+			decodeToken: (id) => this.tokenizer.decode([id], true),
+			eosTokenId: this.tokenizer.config.eosTokenId,
+			eotTokenId: this.resolveEndOfTurnId(),
+			remapToken: keepPlan ? (i) => remapPrunedToken(i, keepPlan) : (i) => i,
+			resolveAdapter: (name) => {
+				const reg = this._batchAdapters.get(name);
+				if (!reg) throw new Error(`scheduler: adapter "${name}" not registered (call registerAdapter first)`);
+				return reg;
+			},
+			acquireLock: () => this._acquireGenLock()
+		});
+		return this._scheduler;
+	}
+	/**
+	* Create a swarm — the MoTA mode-B primitive (docs/research/slm-swarms.md):
+	* named members (LoRA adapters on this engine's shared base, or null for the
+	* bare base), an optional plan that fans an input out into per-member
+	* sub-tasks, and an optional reduce that joins the results. `swarm.run()`
+	* decodes every sub-task CONCURRENTLY through the continuous-batching
+	* scheduler with per-request adapters — one batched pass, so the fan-out
+	* costs roughly the slowest member, not the sum.
+	*
+	* Every non-null member source is registered via {@link registerAdapter}
+	* (downloads in parallel; factors packed into shared GPU buffers once).
+	* Requires `GERBIL_BATCH=N` (N >= 2) + `GERBIL_BATCH_LORA=1` on the Dawn
+	* path; greedy-only like the scheduler underneath.
+	*/
+	async createSwarm(options) {
+		this.checkDestroyed();
+		if (!this.executor.batchLoraEnabled) throw new Error("createSwarm requires GERBIL_BATCH=N (N >= 2) and GERBIL_BATCH_LORA=1 on the Dawn path");
+		const scheduler = this.createScheduler();
+		await Promise.all(Object.entries(options.members).map(([name, source]) => source == null ? Promise.resolve() : this.registerAdapter(name, source)));
+		return new Swarm(scheduler, options);
+	}
+	/**
 	* Resolve the end-of-turn stop token id, or null if the model has none.
 	*
 	* Chat models like Gemma 4 end an assistant turn with a dedicated end-of-turn
@@ -5665,18 +7380,34 @@ var WebGPUEngine = class WebGPUEngine {
 		if (isGreedy && !this.executor.needsMultiEncoder && !mmDecode && !streamsPle) {
 			const firstToken = remapTok(sampleToken(logits, sampling, [...inputIds, ...generatedIds]));
 			if (!consumeToken(firstToken)) {
-				const depth = Executor.PIPELINE_DEPTH;
 				const stepsNeeded = Math.min(maxTokens - 1, this.executor.decodeCapacityRemaining());
-				let submitted = 0;
-				let consumed = 0;
-				while (consumed < stepsNeeded) {
-					while (submitted < stepsNeeded && submitted < consumed + depth) {
-						this.executor.submitGreedyDecodeStep(submitted === 0 ? firstToken : null, submitted % depth);
-						submitted++;
+				const windowK = this.executor.decodeWindowK;
+				if (windowK > 0) {
+					let produced = 0;
+					let stopped = false;
+					while (!stopped && produced < stepsNeeded) {
+						const steps = Math.min(windowK, stepsNeeded - produced);
+						this.executor.submitGreedyDecodeWindow(produced === 0 ? firstToken : null, steps, 0);
+						const tokens = await this.executor.readDecodeWindow(0, steps);
+						produced += steps;
+						for (const tok of tokens) if (consumeToken(tok)) {
+							stopped = true;
+							break;
+						}
+					}
+				} else {
+					const depth = Executor.PIPELINE_DEPTH;
+					let submitted = 0;
+					let consumed = 0;
+					while (consumed < stepsNeeded) {
+						while (submitted < stepsNeeded && submitted < consumed + depth) {
+							this.executor.submitGreedyDecodeStep(submitted === 0 ? firstToken : null, submitted % depth);
+							submitted++;
+						}
+						const tok = await this.executor.readDecodeToken(consumed % depth);
+						consumed++;
+						if (consumeToken(tok)) break;
 					}
-					const tok = await this.executor.readDecodeToken(consumed % depth);
-					consumed++;
-					if (consumeToken(tok)) break;
 				}
 			}
 		} else {
@@ -5705,7 +7436,8 @@ var WebGPUEngine = class WebGPUEngine {
 			tokensGenerated,
 			tokensPerSecond,
 			totalTime,
-			finishReason
+			finishReason,
+			tokenIds: [...generatedIds]
 		};
 	}
 	/**
@@ -5922,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,
@@ -5966,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).
@@ -6214,7 +7972,8 @@ var WebGPUEngine = class WebGPUEngine {
 			tokensGenerated,
 			tokensPerSecond: tokensGenerated / (totalTime / 1e3),
 			totalTime,
-			finishReason
+			finishReason,
+			tokenIds: [...generatedIds]
 		};
 	}
 	/** Prepare + prefill + decode for a fully-specified multimodal token sequence. */
@@ -6299,7 +8058,8 @@ var WebGPUEngine = class WebGPUEngine {
 			tokensGenerated,
 			tokensPerSecond: tokensGenerated / (totalTime / 1e3),
 			totalTime,
-			finishReason
+			finishReason,
+			tokenIds: [...generatedIds]
 		};
 	}
 	/**
@@ -6746,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);
@@ -6780,5 +8541,5 @@ var WebGPUEngine = class WebGPUEngine {
 };
 
 //#endregion
-export { dequantizeGemma4VisionProjection as A, audioTokensToDacCodes as C, parseOuteTtsConfig as D, generateOuteTtsBackboneGraph as E, generateGemma4VisionGraph as M, patchGemma4VisionClips as N, KaniTTS as O, resolveGemma4VisionInfo as P, loadOuteSpeaker as S, generateDacSpeechDecoderGraph as T, smartResize as _, buildGemma4PosEmbeds as a, OuteTTS as b, buildMRoPECosSin as c, buildPositionIds as d, buildRotaryCosSin as f, preprocessImageGemma4 as g, preprocessImage as h, buildGemma4PoolMatrix as i, dequantizeMLXProjection as j, generateQwen3_5VisionGraph as k, buildMRoPEPositionIds as l, mropeFreqDims as m, GEMMA4_IMAGE_PROCESSOR as n, buildGemma4RotaryCosSin as o, buildVisionPositionTensors as p, QWEN3_5_IMAGE_PROCESSOR as r, buildGemma4VisionPositionTensors as s, WebGPUEngine as t, buildPosEmbeds as u, VisionExecutor as v, dacOutputLength as w, buildOutePromptString as x, ParlerTTS as y };
-//# sourceMappingURL=gpu-CrzjQHv2.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