@tryhamster/gerbil 1.7.0 → 1.8.0

package/dist/{moonshine-stt-Teic6SbK.mjs → moonshine-stt-9wc6t11v.mjs}

@@ -10961,6 +10961,330 @@ function idbCacheAvailable() {
 	return idbAvailable();
 }
 
+//#endregion
+//#region src/gpu/safetensors.ts
+/**
+* Parse safetensors header from an ArrayBuffer.
+*
+* Can be called with just the header bytes (for streaming — parse header first,
+* then fetch tensor data by offset) or with the entire file.
+*/
+function parseSafetensorsHeader(buffer) {
+	if (buffer.byteLength < 8) throw new Error(`Buffer too small to contain safetensors header length (need 8 bytes, got ${buffer.byteLength}).`);
+	const view = new DataView(buffer);
+	const headerLength = Number(view.getBigUint64(0, true));
+	if (headerLength > buffer.byteLength - 8) throw new Error(`Safetensors header length (${headerLength}) exceeds buffer size (${buffer.byteLength - 8}). Pass at least the first ${headerLength + 8} bytes.`);
+	const headerBytes = new Uint8Array(buffer, 8, headerLength);
+	const headerStr = new TextDecoder().decode(headerBytes);
+	const header = JSON.parse(headerStr);
+	const dataStart = 8 + headerLength;
+	const entries = [];
+	let metadata = null;
+	for (const [name, info] of Object.entries(header)) {
+		if (name === "__metadata__") {
+			metadata = info;
+			continue;
+		}
+		const { dtype, shape, data_offsets } = info;
+		entries.push({
+			name,
+			dtype,
+			shape,
+			dataOffset: data_offsets[0],
+			dataLength: data_offsets[1] - data_offsets[0]
+		});
+	}
+	entries.sort((a, b) => a.dataOffset - b.dataOffset);
+	return {
+		headerLength,
+		dataStart,
+		entries,
+		metadata
+	};
+}
+/** Byte alignment required for each dtype. */
+function dtypeAlignment(dtype) {
+	switch (dtype) {
+		case "F64":
+		case "I64":
+		case "U64": return 8;
+		case "F32":
+		case "I32":
+		case "U32": return 4;
+		case "F16":
+		case "BF16":
+		case "I16":
+		case "U16": return 2;
+		case "I8":
+		case "U8":
+		case "BOOL": return 1;
+		default: return 1;
+	}
+}
+/**
+* Create a typed array for the given dtype.
+*
+* If `offset` is aligned to the element size, returns a zero-copy view
+* into `buffer`. Otherwise, copies the relevant slice into a new
+* properly-aligned ArrayBuffer.
+*/
+function makeTypedView(buffer, offset, byteLength, dtype) {
+	const aligned = offset % dtypeAlignment(dtype) === 0;
+	const src = aligned ? buffer : buffer.slice(offset, offset + byteLength);
+	const base = aligned ? offset : 0;
+	switch (dtype) {
+		case "F32": return new Float32Array(src, base, byteLength / 4);
+		case "F16": return new Uint16Array(src, base, byteLength / 2);
+		case "BF16": return new Uint16Array(src, base, byteLength / 2);
+		case "I32": return new Int32Array(src, base, byteLength / 4);
+		case "U32": return new Uint32Array(src, base, byteLength / 4);
+		case "I8": return new Int8Array(src, base, byteLength);
+		case "U8": return new Uint8Array(src, base, byteLength);
+		case "I16": return new Int16Array(src, base, byteLength / 2);
+		case "U16": return new Uint16Array(src, base, byteLength / 2);
+		case "F64": return new Float64Array(src, base, byteLength / 8);
+		case "I64": return new BigInt64Array(src, base, byteLength / 8);
+		case "U64": return new BigUint64Array(src, base, byteLength / 8);
+		case "BOOL": return new Uint8Array(src, base, byteLength);
+		default: throw new Error(`Unsupported safetensors dtype: ${dtype}`);
+	}
+}
+/**
+* Get a typed array view for a tensor entry from a complete safetensors buffer.
+* Zero-copy when the byte offset is properly aligned; copies otherwise.
+*/
+function getTensorData(buffer, file, entry) {
+	return makeTypedView(buffer, file.dataStart + entry.dataOffset, entry.dataLength, entry.dtype);
+}
+/**
+* Convert BF16 (bfloat16) data to F32.
+* BF16 is the upper 16 bits of an IEEE 754 float32, so conversion is a simple left-shift.
+*/
+function bf16ToF32(bf16Bytes) {
+	const bf16 = new Uint16Array(bf16Bytes.buffer, bf16Bytes.byteOffset, bf16Bytes.byteLength / 2);
+	const f32 = new Float32Array(bf16.length);
+	const u32 = new Uint32Array(f32.buffer);
+	for (let i = 0; i < bf16.length; i++) u32[i] = bf16[i] << 16;
+	return f32;
+}
+/**
+* Convert F16 (IEEE 754 half-precision) data to F32.
+*/
+function f16ToF32(f16View) {
+	const u16 = f16View instanceof Uint16Array ? f16View : new Uint16Array(f16View.buffer, f16View.byteOffset, f16View.byteLength / 2);
+	const f32 = new Float32Array(u16.length);
+	for (let i = 0; i < u16.length; i++) {
+		const h = u16[i];
+		const sign = h >> 15 & 1;
+		const exp = h >> 10 & 31;
+		const frac = h & 1023;
+		if (exp === 0) f32[i] = (sign ? -1 : 1) * 2 ** -14 * (frac / 1024);
+		else if (exp === 31) f32[i] = frac === 0 ? sign ? -Infinity : Infinity : NaN;
+		else f32[i] = (sign ? -1 : 1) * 2 ** (exp - 15) * (1 + frac / 1024);
+	}
+	return f32;
+}
+
+//#endregion
+//#region src/gpu/lora.ts
+function resolveAdapterBase(spec, revision) {
+	if (spec.startsWith("file:")) return {
+		base: spec.slice(5),
+		local: true
+	};
+	if (spec.startsWith("http://") || spec.startsWith("https://")) return {
+		base: spec,
+		local: false
+	};
+	return {
+		base: `https://huggingface.co/${spec.startsWith("hf:") ? spec.slice(3) : spec}/resolve/${revision}`,
+		local: false
+	};
+}
+async function readLocalFile(dir, name) {
+	try {
+		const fs = await import("node:fs");
+		const p = (await import("node:path")).join(dir, name);
+		if (!fs.existsSync(p)) return null;
+		const buf = fs.readFileSync(p);
+		return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+	} catch {
+		return null;
+	}
+}
+async function fetchFile(base, local, name, hfToken) {
+	if (local) return readLocalFile(base, name);
+	const headers = {};
+	if (hfToken) headers.Authorization = `Bearer ${hfToken}`;
+	const res = await fetch(`${base}/${name}`, { headers });
+	if (!res.ok) return null;
+	return res.arrayBuffer();
+}
+/** Convert a safetensors tensor slice to f32 (adapters are tiny; eager is fine). */
+function sliceToF32(buf, dataStart, entry) {
+	const start = dataStart + entry.dataOffset;
+	switch (entry.dtype) {
+		case "F32": return new Float32Array(buf.slice(start, start + entry.dataLength));
+		case "BF16": return bf16ToF32(new Uint8Array(buf, start, entry.dataLength));
+		case "F16": return f16ToF32(new Uint8Array(buf, start, entry.dataLength));
+		default: throw new Error(`LoRA: unsupported adapter tensor dtype ${entry.dtype}`);
+	}
+}
+/**
+* Download + parse an adapter (`adapter_config.json` + `adapter_model.safetensors`).
+* Returns null when the source has no adapter (so callers can no-op cleanly).
+*/
+async function fetchAdapter(spec, opts = {}) {
+	const { base, local } = resolveAdapterBase(spec, opts.revision ?? "main");
+	opts.onProgress?.(`Loading adapter ${spec}…`);
+	const configBuf = await fetchFile(base, local, "adapter_config.json", opts.hfToken);
+	if (!configBuf) throw new Error(`LoRA: no adapter_config.json at ${spec}. A flavor needs a PEFT adapter (adapter_config.json + adapter_model.safetensors).`);
+	const config = JSON.parse(new TextDecoder().decode(configBuf));
+	const weightsBuf = await fetchFile(base, local, "adapter_model.safetensors", opts.hfToken);
+	if (!weightsBuf) throw new Error(`LoRA: no adapter_model.safetensors at ${spec} (only .safetensors adapters are supported, not legacy .bin).`);
+	const file = parseSafetensorsHeader(weightsBuf);
+	const tensors = /* @__PURE__ */ new Map();
+	for (const entry of file.entries) {
+		if (!entry.name.includes("lora_A") && !entry.name.includes("lora_B")) continue;
+		tensors.set(entry.name, {
+			data: sliceToF32(weightsBuf, file.dataStart, entry),
+			shape: entry.shape
+		});
+	}
+	if (tensors.size === 0) throw new Error(`LoRA: adapter at ${spec} has no lora_A/lora_B tensors.`);
+	return {
+		config,
+		tensors,
+		label: spec
+	};
+}
+/**
+* Strip a PEFT tensor key down to its module path and canonicalize it to the
+* base weight key the engine uses.
+*
+* PEFT names a target like
+*   base_model.model.model.layers.0.self_attn.q_proj.lora_A.weight
+* We drop the PEFT wrapper prefix + the lora_A/B suffix to get the module path
+* (…layers.0.self_attn.q_proj), append ".weight", and run the SAME key mapper
+* the base load used — so Qwen ("model." strip), Gemma, and LFM2 (out_proj→
+* o_proj) all canonicalize identically to their base tensors.
+*/
+function canonicalWeightKey(peftKey, keyMapper) {
+	const marker = peftKey.includes(".lora_A") ? ".lora_A" : ".lora_B";
+	let stem = peftKey.slice(0, peftKey.indexOf(marker));
+	stem = stem.replace(/^base_model\.model\./, "").replace(/^base_model\./, "");
+	return keyMapper(`${stem.startsWith("model.") ? stem : `model.${stem}`}.weight`);
+}
+/** Longest matching suffix in a {moduleName: value} pattern map. */
+function patternLookup(patterns, peftStem) {
+	if (!patterns) return void 0;
+	let best;
+	let bestLen = -1;
+	for (const [name, val] of Object.entries(patterns)) if (peftStem.includes(name) && name.length > bestLen) {
+		best = val;
+		bestLen = name.length;
+	}
+	return best;
+}
+/**
+* Pair lora_A/lora_B tensors and resolve each to a canonical `LoRADelta`.
+* `keyMapper` must be the same mapper the base model load used.
+*/
+function buildLoRADeltas(adapter, keyMapper) {
+	const { config, tensors } = adapter;
+	const stems = /* @__PURE__ */ new Set();
+	for (const name of tensors.keys()) {
+		const marker = name.includes(".lora_A") ? ".lora_A" : ".lora_B";
+		stems.add(name.slice(0, name.indexOf(marker)));
+	}
+	const deltas = [];
+	for (const stem of stems) {
+		const A = tensors.get(`${stem}.lora_A.weight`) ?? tensors.get(`${stem}.lora_A`);
+		const B = tensors.get(`${stem}.lora_B.weight`) ?? tensors.get(`${stem}.lora_B`);
+		if (!A || !B) continue;
+		const key = canonicalWeightKey(`${stem}.lora_A.weight`, keyMapper);
+		if (!key) continue;
+		const r = A.shape[0];
+		const inFeatures = A.shape[1];
+		const outFeatures = B.shape[0];
+		if (B.shape[1] !== r) {
+			console.warn(`[gerbil] LoRA: rank mismatch on ${stem} (A r=${r}, B r=${B.shape[1]}); skipping.`);
+			continue;
+		}
+		const alpha = patternLookup(config.alpha_pattern, stem) ?? config.lora_alpha;
+		const effR = patternLookup(config.rank_pattern, stem) ?? r;
+		const scaling = config.use_rslora ? alpha / Math.sqrt(effR) : alpha / effR;
+		deltas.push({
+			key,
+			A: A.data,
+			B: B.data,
+			r,
+			inFeatures,
+			outFeatures,
+			scaling,
+			fanInFanOut: config.fan_in_fan_out === true
+		});
+	}
+	return deltas;
+}
+/**
+* Fold every resolved delta into the store's base weights in place
+* (W += scaling · B·A). Runs after weights are loaded and before architecture
+* transforms/quantization. Returns the count of tensors merged (for logging).
+*
+* Skips — loudly — any target whose base tensor is missing, shape-mismatched, or
+* not a float pack (a pre-quantized MLX/GPTQ base can't be merged this way).
+*/
+async function applyLoRAToStore(store, deltas, onProgress) {
+	let merged = 0;
+	let skipped = 0;
+	for (const d of deltas) {
+		const base = await store.get(d.key);
+		if (!base) {
+			skipped++;
+			continue;
+		}
+		if (!(base.data instanceof Float32Array)) {
+			console.warn(`[gerbil] LoRA: base tensor ${d.key} is not float (pre-quantized base?); skipping merge.`);
+			skipped++;
+			continue;
+		}
+		const [outF, inF] = base.shape;
+		const rows = d.fanInFanOut ? inF : outF;
+		const cols = d.fanInFanOut ? outF : inF;
+		if (rows !== d.outFeatures || cols !== d.inFeatures) {
+			console.warn(`[gerbil] LoRA: shape mismatch on ${d.key} (base ${base.shape}, delta ${d.outFeatures}×${d.inFeatures}); skipping.`);
+			skipped++;
+			continue;
+		}
+		const W = new Float32Array(base.data);
+		const { A, B, r, scaling, fanInFanOut } = d;
+		for (let o = 0; o < d.outFeatures; o++) {
+			const bRow = o * r;
+			for (let k = 0; k < r; k++) {
+				const bScaled = scaling * B[bRow + k];
+				if (bScaled === 0) continue;
+				const aRow = k * d.inFeatures;
+				if (fanInFanOut) for (let i = 0; i < d.inFeatures; i++) W[i * outF + o] += bScaled * A[aRow + i];
+				else {
+					const wRow = o * inF;
+					for (let i = 0; i < d.inFeatures; i++) W[wRow + i] += bScaled * A[aRow + i];
+				}
+			}
+		}
+		await store.set(d.key, {
+			data: W,
+			shape: base.shape
+		});
+		merged++;
+	}
+	onProgress?.(`Adapter merged into ${merged} tensors${skipped ? ` (${skipped} skipped)` : ""}.`);
+	return {
+		merged,
+		skipped
+	};
+}
+
 //#endregion
 //#region src/gpu/mlx-adapter.ts
 /**
@@ -11342,130 +11666,6 @@ async function opfsEvictStale() {
 	} catch {}
 }
 
-//#endregion
-//#region src/gpu/safetensors.ts
-/**
-* Parse safetensors header from an ArrayBuffer.
-*
-* Can be called with just the header bytes (for streaming — parse header first,
-* then fetch tensor data by offset) or with the entire file.
-*/
-function parseSafetensorsHeader(buffer) {
-	if (buffer.byteLength < 8) throw new Error(`Buffer too small to contain safetensors header length (need 8 bytes, got ${buffer.byteLength}).`);
-	const view = new DataView(buffer);
-	const headerLength = Number(view.getBigUint64(0, true));
-	if (headerLength > buffer.byteLength - 8) throw new Error(`Safetensors header length (${headerLength}) exceeds buffer size (${buffer.byteLength - 8}). Pass at least the first ${headerLength + 8} bytes.`);
-	const headerBytes = new Uint8Array(buffer, 8, headerLength);
-	const headerStr = new TextDecoder().decode(headerBytes);
-	const header = JSON.parse(headerStr);
-	const dataStart = 8 + headerLength;
-	const entries = [];
-	let metadata = null;
-	for (const [name, info] of Object.entries(header)) {
-		if (name === "__metadata__") {
-			metadata = info;
-			continue;
-		}
-		const { dtype, shape, data_offsets } = info;
-		entries.push({
-			name,
-			dtype,
-			shape,
-			dataOffset: data_offsets[0],
-			dataLength: data_offsets[1] - data_offsets[0]
-		});
-	}
-	entries.sort((a, b) => a.dataOffset - b.dataOffset);
-	return {
-		headerLength,
-		dataStart,
-		entries,
-		metadata
-	};
-}
-/** Byte alignment required for each dtype. */
-function dtypeAlignment(dtype) {
-	switch (dtype) {
-		case "F64":
-		case "I64":
-		case "U64": return 8;
-		case "F32":
-		case "I32":
-		case "U32": return 4;
-		case "F16":
-		case "BF16":
-		case "I16":
-		case "U16": return 2;
-		case "I8":
-		case "U8":
-		case "BOOL": return 1;
-		default: return 1;
-	}
-}
-/**
-* Create a typed array for the given dtype.
-*
-* If `offset` is aligned to the element size, returns a zero-copy view
-* into `buffer`. Otherwise, copies the relevant slice into a new
-* properly-aligned ArrayBuffer.
-*/
-function makeTypedView(buffer, offset, byteLength, dtype) {
-	const aligned = offset % dtypeAlignment(dtype) === 0;
-	const src = aligned ? buffer : buffer.slice(offset, offset + byteLength);
-	const base = aligned ? offset : 0;
-	switch (dtype) {
-		case "F32": return new Float32Array(src, base, byteLength / 4);
-		case "F16": return new Uint16Array(src, base, byteLength / 2);
-		case "BF16": return new Uint16Array(src, base, byteLength / 2);
-		case "I32": return new Int32Array(src, base, byteLength / 4);
-		case "U32": return new Uint32Array(src, base, byteLength / 4);
-		case "I8": return new Int8Array(src, base, byteLength);
-		case "U8": return new Uint8Array(src, base, byteLength);
-		case "I16": return new Int16Array(src, base, byteLength / 2);
-		case "U16": return new Uint16Array(src, base, byteLength / 2);
-		case "F64": return new Float64Array(src, base, byteLength / 8);
-		case "I64": return new BigInt64Array(src, base, byteLength / 8);
-		case "U64": return new BigUint64Array(src, base, byteLength / 8);
-		case "BOOL": return new Uint8Array(src, base, byteLength);
-		default: throw new Error(`Unsupported safetensors dtype: ${dtype}`);
-	}
-}
-/**
-* Get a typed array view for a tensor entry from a complete safetensors buffer.
-* Zero-copy when the byte offset is properly aligned; copies otherwise.
-*/
-function getTensorData(buffer, file, entry) {
-	return makeTypedView(buffer, file.dataStart + entry.dataOffset, entry.dataLength, entry.dtype);
-}
-/**
-* Convert BF16 (bfloat16) data to F32.
-* BF16 is the upper 16 bits of an IEEE 754 float32, so conversion is a simple left-shift.
-*/
-function bf16ToF32(bf16Bytes) {
-	const bf16 = new Uint16Array(bf16Bytes.buffer, bf16Bytes.byteOffset, bf16Bytes.byteLength / 2);
-	const f32 = new Float32Array(bf16.length);
-	const u32 = new Uint32Array(f32.buffer);
-	for (let i = 0; i < bf16.length; i++) u32[i] = bf16[i] << 16;
-	return f32;
-}
-/**
-* Convert F16 (IEEE 754 half-precision) data to F32.
-*/
-function f16ToF32(f16View) {
-	const u16 = f16View instanceof Uint16Array ? f16View : new Uint16Array(f16View.buffer, f16View.byteOffset, f16View.byteLength / 2);
-	const f32 = new Float32Array(u16.length);
-	for (let i = 0; i < u16.length; i++) {
-		const h = u16[i];
-		const sign = h >> 15 & 1;
-		const exp = h >> 10 & 31;
-		const frac = h & 1023;
-		if (exp === 0) f32[i] = (sign ? -1 : 1) * 2 ** -14 * (frac / 1024);
-		else if (exp === 31) f32[i] = frac === 0 ? sign ? -Infinity : Infinity : NaN;
-		else f32[i] = (sign ? -1 : 1) * 2 ** (exp - 15) * (1 + frac / 1024);
-	}
-	return f32;
-}
-
 //#endregion
 //#region src/gpu/tokenizer.ts
 /**
@@ -13054,6 +13254,20 @@ async function loadModel(options) {
 		filesLoaded++;
 	}
 	onProgress?.(95, 100, "Weights loaded.");
+	if (options.adapter) {
+		onProgress?.(95, 100, "Loading adapter…");
+		const adapter = await fetchAdapter(options.adapter, {
+			hfToken,
+			revision,
+			onProgress: (m) => onProgress?.(95, 100, m)
+		});
+		if (adapter) {
+			const deltas = buildLoRADeltas(adapter, keyMapper);
+			if (deltas.length === 0) console.warn(`[gerbil] LoRA: adapter ${adapter.label} resolved to 0 mergeable targets for ${architectureName}.`);
+			const { merged, skipped } = await applyLoRAToStore(store, deltas, (m) => onProgress?.(96, 100, m));
+			console.log(`[gerbil] adapter ${adapter.label}: merged ${merged} tensor(s)${skipped ? `, skipped ${skipped}` : ""}.`);
+		}
+	}
 	if (architectureName === "Qwen3_5ForConditionalGeneration") {
 		const textCfg = rawConfig.text_config ?? rawConfig;
 		const numLayers = textCfg.num_hidden_layers;
@@ -14282,5 +14496,5 @@ function selectGraphWeights(graph, weights) {
 }
 
 //#endregion
-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-Teic6SbK.mjs.map
+export { getOrCreatePipeline as C, destroyBuffers as S, verifyGPU as T, MATMUL_BIAS_F16C_SPEC as _, loadMoonshine as a, createStorageBuffer as b, quantizeBackboneInt4 as c, Tokenizer as d, applyLoRAToStore as f, KERNEL_REGISTRY as g, Executor as h, loadModel as i, quantizeKaniBackbone as l, fetchAdapter as m, MoonshineEncoderExecutor as n, loadOuteTTS as o, buildLoRADeltas as p, loadKaniTTS as r, loadParlerTTS as s, MoonshineSTT as t, remapPrunedToken as u, clearPipelineCache as v, initGPU as w, createUniformBuffer as x, createBindGroup as y };
+//# sourceMappingURL=moonshine-stt-9wc6t11v.mjs.map