@tryhamster/gerbil 1.3.1 → 1.4.0

package/dist/{moonshine-stt-BO5gZ_D6.mjs → moonshine-stt-BGmctcdO.mjs}

@@ -6608,6 +6608,142 @@ const crossAttentionSpec = {
 		]);
 	}
 };
+const t5AttentionSpec = {
+	shaderCode: `\
+const WG: u32 = 256u;
+const MAX_S: u32 = 2048u;
+
+struct Params {
+  S: u32,            // sequence length (query == key length)
+  num_heads: u32,
+  head_dim: u32,
+  _pad: u32,
+}
+
+@group(0) @binding(0) var<storage, read> Q: array<f32>;       // [S, num_heads*head_dim]
+@group(0) @binding(1) var<storage, read> K: array<f32>;       // [S, num_heads*head_dim]
+@group(0) @binding(2) var<storage, read> V: array<f32>;       // [S, num_heads*head_dim]
+@group(0) @binding(3) var<storage, read> bias: array<f32>;    // [num_heads, S, S]
+@group(0) @binding(4) var<storage, read_write> output: array<f32>; // [S, num_heads*head_dim]
+@group(0) @binding(5) var<storage, read> params: Params;
+
+var<workgroup> scores: array<f32, MAX_S>;
+var<workgroup> red: array<f32, WG>;
+
+@compute @workgroup_size(256)
+fn main(
+  @builtin(local_invocation_id) lid: vec3u,
+  @builtin(workgroup_id) wid: vec3u,
+) {
+  let q_pos = wid.x;
+  let head = wid.y;
+  if (q_pos >= params.S || head >= params.num_heads) { return; }
+
+  let tid = lid.x;
+  let hd = params.head_dim;
+  let S = params.S;
+  let stride = params.num_heads * hd;
+  let q_base = q_pos * stride + head * hd;
+  let bias_base = (head * S + q_pos) * S;
+
+  // ── Step 1: scores[k] = sum_d Q[q,d]*K[k,d] + bias[head,q,k] (each thread strides over k). ──
+  var k = tid;
+  while (k < S) {
+    let k_base = k * stride + head * hd;
+    var dot: f32 = 0.0;
+    for (var d: u32 = 0u; d < hd; d = d + 1u) {
+      dot = dot + Q[q_base + d] * K[k_base + d];
+    }
+    scores[k] = dot + bias[bias_base + k];
+    k = k + WG;
+  }
+  workgroupBarrier();
+
+  // ── Step 2: row max (parallel reduction over the WG threads' local maxima). ──
+  var local_max: f32 = -1e30;
+  k = tid;
+  while (k < S) {
+    local_max = max(local_max, scores[k]);
+    k = k + WG;
+  }
+  red[tid] = local_max;
+  workgroupBarrier();
+  var stride_r: u32 = WG / 2u;
+  while (stride_r > 0u) {
+    if (tid < stride_r) { red[tid] = max(red[tid], red[tid + stride_r]); }
+    workgroupBarrier();
+    stride_r = stride_r / 2u;
+  }
+  let row_max = red[0];
+  workgroupBarrier();
+
+  // ── Step 3: exponentiate in place, then sum. ──
+  k = tid;
+  while (k < S) {
+    scores[k] = exp(max(scores[k] - row_max, -80.0));
+    k = k + WG;
+  }
+  workgroupBarrier();
+  var local_sum: f32 = 0.0;
+  k = tid;
+  while (k < S) {
+    local_sum = local_sum + scores[k];
+    k = k + WG;
+  }
+  red[tid] = local_sum;
+  workgroupBarrier();
+  stride_r = WG / 2u;
+  while (stride_r > 0u) {
+    if (tid < stride_r) { red[tid] = red[tid] + red[tid + stride_r]; }
+    workgroupBarrier();
+    stride_r = stride_r / 2u;
+  }
+  let inv_sum = 1.0 / max(red[0], 1e-20);
+  workgroupBarrier();
+
+  // ── Step 4: output[q,d] = sum_k softmax(scores)[k] * V[k,d]. Thread tid owns dim
+  //    tid (+ WG strides for head_dim > 256). ──
+  var d = tid;
+  while (d < hd) {
+    var acc: f32 = 0.0;
+    for (var kk: u32 = 0u; kk < S; kk = kk + 1u) {
+      acc = acc + scores[kk] * V[kk * stride + head * hd + d];
+    }
+    output[q_base + d] = acc * inv_sum;
+    d = d + WG;
+  }
+}
+`,
+	entryPoint: "main",
+	bindings: [
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read" },
+		{ type: "storage-read-write" },
+		{ type: "uniform" }
+	],
+	getDispatchSize(op, resolvedShapes) {
+		const num_heads = op.attributes.num_heads;
+		const outShape = resolvedShapes[op.outputs[0]];
+		return [
+			outShape ? outShape[0] : op.attributes.S,
+			num_heads,
+			1
+		];
+	},
+	buildParams(op, resolvedShapes) {
+		const num_heads = op.attributes.num_heads;
+		const head_dim = op.attributes.head_dim;
+		const outShape = resolvedShapes[op.outputs[0]];
+		return buildUniformBuffer([
+			outShape ? outShape[0] : op.attributes.S,
+			num_heads,
+			head_dim,
+			0
+		]);
+	}
+};
 const KV_CACHE_APPEND_PACKED_F16_SPEC = {
 	shaderCode: WGSL_KV_CACHE_APPEND_PACKED_F16,
 	entryPoint: "main",
@@ -7918,6 +8054,7 @@ const KERNEL_REGISTRY = {
 	RoPE: ropeSpec,
 	Attention: attentionSpec,
 	CrossAttention: crossAttentionSpec,
+	T5Attention: t5AttentionSpec,
 	Softmax: softmaxSpec,
 	CausalConv1d: causalConv1dSpec,
 	CausalConv1dSiLU: causalConv1dSiluSpec,
@@ -8557,6 +8694,72 @@ var Executor = class Executor {
 		return out;
 	}
 	/**
+	* Autoregressive step for a multi-output decoder graph (e.g. Parler-TTS's 9 codebook
+	* lm_heads). Dispatches the whole graph ONCE at the current seqPos (so the per-layer
+	* KVCacheAppend writes at the right cache row), reads back each named output, then
+	* advances seqPos by `tokens` (default 1, for a prefilled prompt span pass tokens=T).
+	* The caller writes inputs (dec_input_embed + frozen cross-attn K/V) and reset()s
+	* before the first step. Unlike forward(), there is no single "logits" output —
+	* the caller decodes each codebook row itself.
+	*/
+	async runGraphStep(outputs, tokens = 1) {
+		const resolvedShapes = this.resolveShapes(tokens);
+		const runtimeContext = { seqPos: this.seqPos };
+		const entries = this.dispatchEntries;
+		const dispatchSizes = new Array(entries.length);
+		for (let i = 0; i < entries.length; i++) {
+			const entry = entries[i];
+			const paramsData = entry.spec.buildParams(entry.node, resolvedShapes, runtimeContext);
+			this.ctx.device.queue.writeBuffer(entry.uniformBuffer, 0, paramsData);
+			dispatchSizes[i] = entry.spec.getDispatchSize(entry.node, resolvedShapes, runtimeContext);
+		}
+		if (this.needsMultiEncoder) {
+			const group = this.webkitGroupSize;
+			for (let start = 0; start < entries.length; start += group) {
+				const enc = this.ctx.device.createCommandEncoder();
+				const end = Math.min(start + group, entries.length);
+				for (let i = start; i < end; i++) {
+					const pass = enc.beginComputePass();
+					pass.setPipeline(entries[i].pipeline);
+					pass.setBindGroup(0, entries[i].bindGroup);
+					pass.dispatchWorkgroups(...dispatchSizes[i]);
+					pass.end();
+				}
+				this.ctx.device.queue.submit([enc.finish()]);
+				await this.ctx.device.queue.onSubmittedWorkDone();
+			}
+		} else {
+			const encoder = this.ctx.device.createCommandEncoder({ label: "runGraphStep" });
+			const pass = encoder.beginComputePass({ label: "step_pass" });
+			for (let i = 0; i < entries.length; i++) {
+				pass.setPipeline(entries[i].pipeline);
+				pass.setBindGroup(0, entries[i].bindGroup);
+				pass.dispatchWorkgroups(...dispatchSizes[i]);
+			}
+			pass.end();
+			this.ctx.device.queue.submit([encoder.finish()]);
+		}
+		const results = [];
+		for (const { name, elemCount } of outputs) {
+			const outBuffer = this.getBuffer(name);
+			if (!outBuffer) throw new Error(`runGraphStep: no GPU buffer for output "${name}".`);
+			const byteLen = Math.min(elemCount * 4, outBuffer.size);
+			const readback = this.ctx.device.createBuffer({
+				size: byteLen,
+				usage: 9
+			});
+			const enc = this.ctx.device.createCommandEncoder();
+			enc.copyBufferToBuffer(outBuffer, 0, readback, 0, byteLen);
+			this.ctx.device.queue.submit([enc.finish()]);
+			await readback.mapAsync(MAP_MODE_READ$1, 0, byteLen);
+			results.push(new Float32Array(readback.getMappedRange(0, byteLen).slice(0)));
+			readback.unmap();
+			readback.destroy();
+		}
+		this.seqPos += tokens;
+		return results;
+	}
+	/**
 	* Greedy decode step: forward + GPU argmax. Returns token ID directly.
 	* Always uses matvec kernels (M=1). Reads back 4 bytes instead of vocab_size*4.
 	*/
@@ -10274,6 +10477,8 @@ const UNICODE_TO_BYTE = /* @__PURE__ */ new Map();
 		UNICODE_TO_BYTE.set(cs[i], bs[i]);
 	}
 }
+/** SentencePiece metaspace marker (U+2581, "▁") used by T5/Unigram tokenizers. */
+const METASPACE = "▁";
 var Tokenizer = class Tokenizer {
 	vocab;
 	vocabReverse;
@@ -10287,9 +10492,11 @@ var Tokenizer = class Tokenizer {
 	* raw bytes fall back to <0xHH> tokens. When false, GPT-2 byte-level BPE.
 	*/
 	spmMode;
+	/** Unigram (SentencePiece) model, set only when the tokenizer.json is Unigram. */
+	unigram;
 	config;
 	vocabSize;
-	constructor(vocab, vocabReverse, merges, specialTokens, addedTokens, config, vocabSize, spmMode) {
+	constructor(vocab, vocabReverse, merges, specialTokens, addedTokens, config, vocabSize, spmMode, unigram = null) {
 		this.vocab = vocab;
 		this.vocabReverse = vocabReverse;
 		this.merges = merges;
@@ -10297,6 +10504,7 @@ var Tokenizer = class Tokenizer {
 		this.addedTokens = addedTokens;
 		this.byteFallback = /* @__PURE__ */ new Map();
 		this.spmMode = spmMode;
+		this.unigram = unigram;
 		this.config = config;
 		this.vocabSize = vocabSize;
 		for (let b = 0; b < 256; b++) {
@@ -10309,7 +10517,8 @@ var Tokenizer = class Tokenizer {
 	*/
 	static fromJSON(tokenizerJSON, tokenizerConfigJSON) {
 		const model = tokenizerJSON.model;
-		if (!model || model.type !== "BPE") throw new Error(`Unsupported tokenizer type: ${model?.type ?? "unknown"}. Only BPE is supported.`);
+		if (model?.type === "Unigram") return Tokenizer.fromUnigramJSON(tokenizerJSON, tokenizerConfigJSON);
+		if (!model || model.type !== "BPE") throw new Error(`Unsupported tokenizer type: ${model?.type ?? "unknown"}. Only BPE and Unigram are supported.`);
 		const vocab = /* @__PURE__ */ new Map();
 		const vocabReverse = /* @__PURE__ */ new Map();
 		for (const [token, id] of Object.entries(model.vocab)) {
@@ -10358,6 +10567,60 @@ var Tokenizer = class Tokenizer {
 		}, vocab.size, spmMode);
 	}
 	/**
+	* Build a Unigram (SentencePiece) tokenizer from a `model.type === "Unigram"`
+	* tokenizer.json (e.g. Flan-T5, which fronts Parler-TTS). The Unigram model is a
+	* list of `[piece, log_score]` rows plus an `unk_id`; encoding runs Viterbi
+	* best-segmentation over the lattice (maximize summed log-scores), normalizing
+	* input NFKC-style + collapsing whitespace, replacing spaces with the metaspace
+	* marker (▁), and appending the post-processor's eos (</s>) like HF's T5Tokenizer.
+	*/
+	static fromUnigramJSON(tokenizerJSON, tokenizerConfigJSON) {
+		const model = tokenizerJSON.model;
+		const vocab = /* @__PURE__ */ new Map();
+		const vocabReverse = /* @__PURE__ */ new Map();
+		const pieces = /* @__PURE__ */ new Map();
+		const rawVocab = model.vocab;
+		for (let id = 0; id < rawVocab.length; id++) {
+			const [piece, score] = rawVocab[id];
+			vocab.set(piece, id);
+			vocabReverse.set(id, piece);
+			pieces.set(piece, {
+				id,
+				score
+			});
+		}
+		const specialTokens = /* @__PURE__ */ new Map();
+		const addedTokensMap = /* @__PURE__ */ new Map();
+		const addedTokensList = tokenizerJSON.added_tokens;
+		if (addedTokensList) for (const t of addedTokensList) {
+			vocab.set(t.content, t.id);
+			vocabReverse.set(t.id, t.content);
+			addedTokensMap.set(t.content, t.id);
+			if (t.special) specialTokens.set(t.content, t.id);
+		}
+		const preTok = tokenizerJSON.pre_tokenizer;
+		const prependMetaspace = preTok?.type === "Metaspace" ? (preTok.prepend_scheme ?? "always") !== "never" : true;
+		const eosToken = tokenizerConfigJSON?.eos_token ?? "</s>";
+		const eosId = vocab.get(eosToken) ?? null;
+		const unkId = model.unk_id ?? vocab.get("<unk>") ?? 0;
+		const config = {
+			bosToken: null,
+			eosToken,
+			bosTokenId: null,
+			eosTokenId: eosId,
+			chatTemplate: tokenizerConfigJSON?.chat_template ?? null,
+			addBosToken: false,
+			addEosToken: false
+		};
+		const unigram = {
+			pieces,
+			unkId,
+			prependMetaspace,
+			eosId
+		};
+		return new Tokenizer(vocab, vocabReverse, /* @__PURE__ */ new Map(), specialTokens, addedTokensMap, config, vocab.size, false, unigram);
+	}
+	/**
 	* Resolve a literal token string (e.g. "<|endoftext|>") to its vocab id,
 	* or null if it isn't in the vocabulary.
 	*/
@@ -10369,6 +10632,7 @@ var Tokenizer = class Tokenizer {
 	*/
 	encode(text) {
 		if (!text) return [];
+		if (this.unigram) return this.encodeUnigram(text);
 		const ids = [];
 		if (this.config.addBosToken && this.config.bosTokenId !== null) ids.push(this.config.bosTokenId);
 		const parts = this.splitOnSpecialTokens(text);
@@ -10396,6 +10660,10 @@ var Tokenizer = class Tokenizer {
 			if (skipSpecialTokens && this.specialTokens.has(token)) continue;
 			pieces.push(token);
 		}
+		if (this.unigram) {
+			const joined = pieces.join("").replace(/▁/g, " ");
+			return joined.startsWith(" ") ? joined.slice(1) : joined;
+		}
 		if (this.spmMode) {
 			let out = "";
 			let byteRun = [];
@@ -10588,7 +10856,127 @@ var Tokenizer = class Tokenizer {
 		}
 		return ids;
 	}
+	/**
+	* Encode text with the Unigram model: split on registered added/special tokens,
+	* normalize each plain span (NFKC + whitespace collapse), apply the metaspace
+	* pre-tokenizer (spaces → ▁, leading ▁ prepended), Viterbi-segment each ▁-word,
+	* then append the post-processor eos. Mirrors HF's T5Tokenizer id stream.
+	*/
+	encodeUnigram(text) {
+		const uni = this.unigram;
+		const ids = [];
+		for (const part of this.splitOnSpecialTokens(text)) {
+			if (part.special) {
+				const id = this.addedTokens.get(part.text);
+				if (id !== void 0) ids.push(id);
+				continue;
+			}
+			const normalized = normalizeUnigram(part.text);
+			if (!normalized) continue;
+			const encoded = ((uni.prependMetaspace ? " " : "") + normalized).replace(/ /g, METASPACE).replace(/^▁+/, METASPACE);
+			const words = this.splitMetaspaceWords(encoded);
+			for (const word of words) for (const id of this.viterbiEncode(word)) ids.push(id);
+		}
+		if (uni.eosId !== null) ids.push(uni.eosId);
+		return ids;
+	}
+	/** Split a ▁-encoded string into ▁-prefixed words (keep ▁ with the following run). */
+	splitMetaspaceWords(encoded) {
+		const chars = [...encoded];
+		const words = [];
+		let i = 0;
+		while (i < chars.length) {
+			let j = i + 1;
+			while (j < chars.length && chars[j] !== METASPACE) j++;
+			words.push(chars.slice(i, j).join(""));
+			i = j;
+		}
+		return words;
+	}
+	/**
+	* Viterbi best-segmentation of a single piece over the Unigram vocab: find the
+	* segmentation maximizing the sum of piece log-scores. Characters with no covering
+	* vocab piece fall back to the unk id (SentencePiece treats an unknown character
+	* as a single unk token).
+	*/
+	viterbiEncode(word) {
+		const uni = this.unigram;
+		const chars = [...word];
+		const n = chars.length;
+		if (n === 0) return [];
+		const NEG = Number.NEGATIVE_INFINITY;
+		const best = new Float64Array(n + 1).fill(NEG);
+		best[0] = 0;
+		const backLen = new Int32Array(n + 1).fill(0);
+		const backId = new Int32Array(n + 1).fill(uni.unkId);
+		const unkScore = this.unigramUnkScore;
+		for (let end = 1; end <= n; end++) {
+			const maxLen = Math.min(end, this.unigramMaxPieceLen);
+			for (let len = 1; len <= maxLen; len++) {
+				const start = end - len;
+				if (best[start] === NEG) continue;
+				const piece = chars.slice(start, end).join("");
+				const entry = uni.pieces.get(piece);
+				if (entry === void 0) continue;
+				const score = best[start] + entry.score;
+				if (score > best[end]) {
+					best[end] = score;
+					backLen[end] = len;
+					backId[end] = entry.id;
+				}
+			}
+			if (best[end - 1] !== NEG) {
+				const score = best[end - 1] + unkScore;
+				if (score > best[end]) {
+					best[end] = score;
+					backLen[end] = 1;
+					backId[end] = uni.unkId;
+				}
+			}
+		}
+		const out = [];
+		let pos = n;
+		while (pos > 0) {
+			const len = backLen[pos] || 1;
+			out.push(backId[pos]);
+			pos -= len;
+		}
+		out.reverse();
+		return out;
+	}
+	/** Lazily-computed longest vocab piece length (in codepoints). */
+	get unigramMaxPieceLen() {
+		if (this._unigramMaxPieceLen === void 0) {
+			let max = 1;
+			for (const piece of this.unigram.pieces.keys()) {
+				const len = [...piece].length;
+				if (len > max) max = len;
+			}
+			this._unigramMaxPieceLen = max;
+		}
+		return this._unigramMaxPieceLen;
+	}
+	_unigramMaxPieceLen;
+	/** Lazily-computed unk emission score (min vocab score − 10, SentencePiece-style). */
+	get unigramUnkScore() {
+		if (this._unigramUnkScore === void 0) {
+			let min = Number.POSITIVE_INFINITY;
+			for (const { score } of this.unigram.pieces.values()) if (score < min) min = score;
+			this._unigramUnkScore = (Number.isFinite(min) ? min : 0) - 10;
+		}
+		return this._unigramUnkScore;
+	}
+	_unigramUnkScore;
 };
+/**
+* Normalize text for the SentencePiece Unigram path: NFKC (matches T5's Precompiled
+* charsmap on the BMP) followed by whitespace normalization — every run of Unicode
+* whitespace collapses to a single ASCII space, and leading/trailing single spaces
+* are preserved (SentencePiece's remove_extra_whitespaces behaviour).
+*/
+function normalizeUnigram(text) {
+	return text.normalize("NFKC").replace(/\s+/g, " ");
+}
 
 //#endregion
 //#region src/gpu/vocab-prune.ts
@@ -10970,11 +11358,28 @@ async function initFs() {
 function getCachePath(cacheDir, filename) {
 	return _path.join(cacheDir, filename.replace(/\//g, "_"));
 }
+/** Node's writeSync/readSync cap a single call at 2 GiB − 1; chunk above this. */
+const FS_CHUNK = 1073741824;
 function readCachedFile(cacheDir, filename) {
 	if (!_fs || !_path) return null;
 	const p = getCachePath(cacheDir, filename);
 	try {
-		return _fs.readFileSync(p);
+		const size = _fs.statSync(p).size;
+		if (size <= FS_CHUNK) return _fs.readFileSync(p);
+		const buf = Buffer.allocUnsafe(size);
+		const fd = _fs.openSync(p, "r");
+		try {
+			let offset = 0;
+			while (offset < size) {
+				const len = Math.min(FS_CHUNK, size - offset);
+				const read = _fs.readSync(fd, buf, offset, len, offset);
+				if (read <= 0) break;
+				offset += read;
+			}
+			return offset === size ? buf : null;
+		} finally {
+			_fs.closeSync(fd);
+		}
 	} catch {
 		return null;
 	}
@@ -10985,9 +11390,22 @@ function writeCacheFile(cacheDir, filename, data) {
 	const p = getCachePath(cacheDir, filename);
 	let buf;
 	if (Buffer.isBuffer(data)) buf = data;
-	else if (data instanceof Uint8Array) buf = Buffer.from(data);
+	else if (data instanceof Uint8Array) buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
 	else buf = Buffer.from(data);
-	_fs.writeFileSync(p, buf);
+	if (buf.byteLength <= FS_CHUNK) {
+		_fs.writeFileSync(p, buf);
+		return;
+	}
+	const fd = _fs.openSync(p, "w");
+	try {
+		let offset = 0;
+		while (offset < buf.byteLength) {
+			const len = Math.min(FS_CHUNK, buf.byteLength - offset);
+			offset += _fs.writeSync(fd, buf, offset, len, offset);
+		}
+	} finally {
+		_fs.closeSync(fd);
+	}
 }
 const BROWSER_CACHE_NAME = "gerbil-models-v4";
 const TENSOR_CACHE_ENABLED = (typeof process === "undefined" || process.env?.GERBIL_TENSOR_CACHE !== "0") && globalThis.GERBIL_TENSOR_CACHE !== false;
@@ -12306,6 +12724,136 @@ async function loadOuteTTS(options) {
 		rawConfig
 	};
 }
+const PARLER_DEFAULT_REPO = "parler-tts/parler-tts-mini-v1";
+/** Fold a weight-norm conv (g [Cout,1,1] or [Cout,1], v [Cout,...]) → plain weight. */
+function foldDacWeightNorm(g, v, vShape) {
+	const cout = vShape[0];
+	const inner = v.length / cout;
+	const out = new Float32Array(v.length);
+	for (let o = 0; o < cout; o++) {
+		let norm = 0;
+		const base = o * inner;
+		for (let j = 0; j < inner; j++) {
+			const val = v[base + j];
+			norm += val * val;
+		}
+		norm = Math.sqrt(norm);
+		const scale = norm > 0 ? g[o] / norm : 0;
+		for (let j = 0; j < inner; j++) out[base + j] = v[base + j] * scale;
+	}
+	return out;
+}
+/**
+* Fold the parler `audio_encoder.model.*` DAC tensors into the canonical `dac.*`
+* decoder weight map (the same shape generateDacSpeechDecoderGraph consumes, with
+* numCodebooks 9 / rates [8,8,4,2]). Decoder-only (synthesis never runs the encoder).
+*/
+function buildParlerDacWeights(raw, numCodebooks) {
+	const out = /* @__PURE__ */ new Map();
+	const prefix = "audio_encoder.model.";
+	for (const [key, t] of raw) {
+		if (!key.startsWith(`${prefix}decoder.`)) continue;
+		const sub = key.slice(20);
+		if (sub.endsWith(".weight_v")) {
+			const base = sub.slice(0, -9);
+			const g = raw.get(`${prefix}${base}.weight_g`);
+			if (!g) throw new Error(`Parler DAC: missing weight_g for ${base}`);
+			out.set(`dac.${base}.weight`, {
+				data: foldDacWeightNorm(g.data, t.data, t.shape),
+				shape: t.shape
+			});
+		} else if (sub.endsWith(".weight_g")) {} else if (sub.endsWith(".bias")) out.set(`dac.${sub}`, {
+			data: t.data,
+			shape: t.shape
+		});
+		else if (sub.endsWith(".alpha")) out.set(`dac.${sub}`, {
+			data: t.data,
+			shape: [t.shape[1]]
+		});
+	}
+	const D = 8;
+	let latentDim = 1024;
+	const codebooks = [];
+	const outW = [];
+	const outB = [];
+	for (let c = 0; c < numCodebooks; c++) {
+		const qp = `${prefix}quantizer.quantizers.${c}`;
+		const cb = raw.get(`${qp}.codebook.weight`);
+		const owg = raw.get(`${qp}.out_proj.weight_g`);
+		const owv = raw.get(`${qp}.out_proj.weight_v`);
+		const ob = raw.get(`${qp}.out_proj.bias`);
+		if (!(cb && owg && owv && ob)) throw new Error(`Parler DAC: missing quantizer ${c} tensors`);
+		latentDim = owv.shape[0];
+		codebooks.push(cb.data);
+		outW.push(foldDacWeightNorm(owg.data, owv.data, owv.shape));
+		outB.push(ob.data);
+	}
+	const stack = (arrs) => {
+		const total = arrs.reduce((a, x) => a + x.length, 0);
+		const merged = new Float32Array(total);
+		let off = 0;
+		for (const a of arrs) {
+			merged.set(a, off);
+			off += a.length;
+		}
+		return merged;
+	};
+	out.set("dac.quantizer.codebook", {
+		data: stack(codebooks),
+		shape: [
+			numCodebooks,
+			PARLER_CODEBOOK_SIZE_F,
+			D
+		]
+	});
+	out.set("dac.quantizer.out_proj.weight", {
+		data: stack(outW),
+		shape: [
+			numCodebooks,
+			latentDim,
+			D
+		]
+	});
+	out.set("dac.quantizer.out_proj.bias", {
+		data: stack(outB),
+		shape: [numCodebooks, latentDim]
+	});
+	return out;
+}
+const PARLER_CODEBOOK_SIZE_F = 1024;
+async function loadParlerTTS(options) {
+	const revision = options.revision ?? "main";
+	const baseURL = await resolveModelBaseURL(options.repo ?? PARLER_DEFAULT_REPO, revision);
+	await initFs();
+	options.onProgress?.(0, 100, "Fetching config + tokenizer…");
+	const [rawConfig, tokenizerJSON] = await Promise.all([fetchJSON(baseURL, "config.json", options.hfToken, options.cacheDir), fetchJSON(baseURL, "tokenizer.json", options.hfToken, options.cacheDir)]);
+	const tokenizerConfig = await fetchJSON(baseURL, "tokenizer_config.json", options.hfToken, options.cacheDir).catch(() => null);
+	const tokenizer = Tokenizer.fromJSON(tokenizerJSON, tokenizerConfig);
+	options.onProgress?.(8, 100, "Downloading Parler weights…");
+	const buf = await fetchBinary(baseURL, "model.safetensors", options.hfToken, (loaded, total) => options.onProgress?.(8 + loaded / (total || 1) * 85, 100, "weights"), options.cacheDir);
+	const file = parseSafetensorsHeader(buf);
+	const modelWeights = /* @__PURE__ */ new Map();
+	const dacRaw = /* @__PURE__ */ new Map();
+	for (const entry of file.entries) {
+		const f32 = toF32(entry, buf, file);
+		if (entry.name.startsWith("audio_encoder.")) dacRaw.set(entry.name, {
+			data: f32,
+			shape: entry.shape
+		});
+		else modelWeights.set(entry.name, {
+			data: f32,
+			shape: entry.shape
+		});
+	}
+	const codecWeights = buildParlerDacWeights(dacRaw, (rawConfig.decoder ?? {}).num_codebooks ?? 9);
+	options.onProgress?.(100, 100, "Parler-TTS loaded.");
+	return {
+		modelWeights,
+		codecWeights,
+		tokenizer,
+		rawConfig
+	};
+}
 
 //#endregion
 //#region src/gpu/moonshine-executor.ts
@@ -12671,5 +13219,5 @@ function selectGraphWeights(graph, weights) {
 }
 
 //#endregion
-export { destroyBuffers as _, loadMoonshine as a, verifyGPU as b, quantizeKaniBackbone as c, KERNEL_REGISTRY as d, MATMUL_BIAS_F16C_SPEC as f, createUniformBuffer as g, createStorageBuffer as h, loadModel as i, remapPrunedToken as l, createBindGroup as m, MoonshineEncoderExecutor as n, loadOuteTTS as o, clearPipelineCache as p, loadKaniTTS as r, quantizeBackboneInt4 as s, MoonshineSTT as t, Executor as u, getOrCreatePipeline as v, initGPU as y };
-//# sourceMappingURL=moonshine-stt-BO5gZ_D6.mjs.map
+export { verifyGPU as S, createStorageBuffer as _, loadMoonshine as a, getOrCreatePipeline as b, quantizeBackboneInt4 as c, Tokenizer as d, Executor as f, createBindGroup as g, clearPipelineCache as h, loadModel as i, quantizeKaniBackbone as l, MATMUL_BIAS_F16C_SPEC as m, MoonshineEncoderExecutor as n, loadOuteTTS as o, KERNEL_REGISTRY as p, loadKaniTTS as r, loadParlerTTS as s, MoonshineSTT as t, remapPrunedToken as u, createUniformBuffer as v, initGPU as x, destroyBuffers as y };
+//# sourceMappingURL=moonshine-stt-BGmctcdO.mjs.map