@tryhamster/gerbil 1.11.1 → 1.11.2

package/dist/{moonshine-stt-CgDXoLFd.mjs → moonshine-stt-BI-5UmD_.mjs}

@@ -8842,6 +8842,381 @@ const KERNEL_REGISTRY = {
 	GroupNorm: groupnormSpec
 };
 
+//#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;
+}
+/**
+* Split a fused query+gate LoRA delta into two deltas (query, gate).
+*
+* Qwen3.5-style gated attention fuses the query projection and the attention
+* output-gate into ONE checkpoint tensor: `q_proj.weight` is
+* `[2·num_heads·head_dim, hidden]`, per-head interleaved — for each head the
+* first `head_dim` rows are query, the next `head_dim` rows are the gate. The
+* model loader deinterleaves this into two runtime linears (`q_proj` and
+* `attn_gate`), each `[num_heads·head_dim, hidden]`.
+*
+* A PEFT adapter trained on the FUSED checkpoint carries a single `q_proj`
+* `lora_B` of `[2·num_heads·head_dim, r]`, whose out-dim is exactly 2× either
+* split linear — so it matches neither at runtime. Because the base weight is
+* deinterleaved by a pure per-head row gather, the same gather applied to
+* `lora_B`'s rows yields the query and gate factors; `lora_A` (the input side)
+* is shared unchanged. This is mathematically identical to merging the fused
+* delta before the loader's split.
+*/
+function splitFusedQGateDelta(d, qKey, gateKey, headDim) {
+	const half = d.outFeatures / 2;
+	const numHeads = half / headDim;
+	const { r } = d;
+	const rowsPerHead = headDim * r;
+	const headBlock = 2 * rowsPerHead;
+	const Bq = new Float32Array(half * r);
+	const Bg = new Float32Array(half * r);
+	for (let h = 0; h < numHeads; h++) {
+		const srcQ = h * headBlock;
+		const srcG = srcQ + rowsPerHead;
+		const dst = h * rowsPerHead;
+		Bq.set(d.B.subarray(srcQ, srcQ + rowsPerHead), dst);
+		Bg.set(d.B.subarray(srcG, srcG + rowsPerHead), dst);
+	}
+	const shared = {
+		A: d.A,
+		r: d.r,
+		inFeatures: d.inFeatures,
+		outFeatures: half,
+		scaling: d.scaling,
+		fanInFanOut: d.fanInFanOut
+	};
+	return [{
+		...shared,
+		key: qKey,
+		B: Bq
+	}, {
+		...shared,
+		key: gateKey,
+		B: Bg
+	}];
+}
+/**
+* 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/executor.ts
 const MAP_MODE_READ$1 = 1;
@@ -9167,23 +9542,62 @@ var Executor = class Executor {
 	* the base weight buffers and bind groups are never touched or re-uploaded.
 	* Pass an empty list (or call {@link clearRuntimeLoRA}) to drop the overlay.
 	*/
+	/** Find the base linear (MatMulInt4 / MatMul) node whose weight is `key`. */
+	findBaseLinear(key) {
+		return this.graph.nodes.find((n) => {
+			if (n.opType !== "MatMulInt4" && n.opType !== "MatMul") return false;
+			const w = n.inputs[1];
+			if (!w) return false;
+			return (w.endsWith(".q") ? w.slice(0, -2) : w) === key;
+		});
+	}
+	/**
+	* Expand any fused query+gate delta into separate `q_proj` + `attn_gate`
+	* deltas so it can splice onto a deinterleaved runtime graph.
+	*
+	* Qwen3.5-style gated attention ships `q_proj.weight` fused as
+	* `[2·num_heads·head_dim, hidden]` (per-head: query rows then gate rows); the
+	* model loader splits it into two runtime linears (`q_proj`, `attn_gate`). An
+	* adapter trained on the fused checkpoint carries a single `q_proj` delta whose
+	* out-dim is 2× either split node, so it matches neither. When BOTH split
+	* linears exist and the delta is exactly their combined width, split it via the
+	* same per-head row deinterleave the loader uses; otherwise the delta passes
+	* through untouched (e.g. a base that never split the projection).
+	*/
+	expandFusedQGateDeltas(deltas) {
+		const out = [];
+		for (const d of deltas) {
+			const m = /^(layers\.\d+\.self_attn)\.q_proj\.weight$/.exec(d.key);
+			const gateKey = m ? `${m[1]}.attn_gate.weight` : null;
+			const qNode = m ? this.findBaseLinear(d.key) : void 0;
+			const gateNode = gateKey ? this.findBaseLinear(gateKey) : void 0;
+			if (!(m && gateKey && qNode && gateNode)) {
+				out.push(d);
+				continue;
+			}
+			const nQ = qNode.attributes.N;
+			const nGate = gateNode.attributes.N;
+			const headDim = this.graph.config.head_dim;
+			if (nQ !== nGate || d.outFeatures !== nQ + nGate || !headDim || nQ % headDim !== 0) {
+				out.push(d);
+				continue;
+			}
+			out.push(...splitFusedQGateDelta(d, d.key, gateKey, headDim));
+		}
+		return out;
+	}
 	applyRuntimeLoRA(deltas) {
 		this.clearRuntimeLoRA();
 		const overlay = /* @__PURE__ */ new Map();
 		let applied = 0;
 		let skipped = 0;
-		for (const d of deltas) {
+		for (const d of this.expandFusedQGateDeltas(deltas)) {
 			if (d.fanInFanOut) {
 				console.warn(`[executor] runtime LoRA: fan_in_fan_out target ${d.key} unsupported; skipping.`);
 				skipped++;
 				continue;
 			}
-			const node = this.graph.nodes.find((n) => {
-				if (n.opType !== "MatMulInt4" && n.opType !== "MatMul") return false;
-				const w = n.inputs[1];
-				if (!w) return false;
-				return (w.endsWith(".q") ? w.slice(0, -2) : w) === d.key;
-			});
+			const node = this.findBaseLinear(d.key);
 			if (!node) {
 				skipped++;
 				continue;
@@ -11043,586 +11457,262 @@ var Executor = class Executor {
 		}
 		return entries;
 	}
-	/** Lazily allocate a scratch storage buffer at least `minBytes` large. */
-	getBindingScratchBuffer(minBytes) {
-		if (!this.bindingScratchBuffer || this.bindingScratchBuffer.size < minBytes) this.bindingScratchBuffer = createStorageBuffer(this.ctx, "binding_scratch", Math.max(minBytes, 256));
-		return this.bindingScratchBuffer;
-	}
-};
-
-//#endregion
-//#region src/gpu/gptq-adapter.ts
-/**
-* Repack GPTQ tensors into Gerbil's flat INT4 format.
-*
-* This is pure data reshuffling — no quantization math. The 4-bit values,
-* scales, and zero points are preserved exactly.
-*/
-function repackGPTQ(gptq) {
-	const { qweight, scales: gptqScales, qzeros, K, N, groupSize } = gptq;
-	const totalElements = N * K;
-	const groupsPerCol = Math.ceil(K / groupSize);
-	const totalGroups = N * groupsPerCol;
-	const packed = new Uint32Array(Math.ceil(totalElements / 8));
-	const scales = new Float32Array(totalGroups);
-	const zeros = new Float32Array(totalGroups);
-	for (let k = 0; k < K; k++) {
-		const gptqRow = k >>> 3;
-		const gptqNibblePos = k & 7;
-		const gptqRowBase = gptqRow * N;
-		for (let col = 0; col < N; col++) {
-			const nibble = qweight[gptqRowBase + col] >>> gptqNibblePos * 4 & 15;
-			const flatIdx = col * K + k;
-			const packedIdx = flatIdx >>> 3;
-			const nibblePos = flatIdx & 7;
-			packed[packedIdx] |= nibble << nibblePos * 4;
-		}
-	}
-	for (let g = 0; g < groupsPerCol; g++) {
-		const srcRow = g * N;
-		for (let col = 0; col < N; col++) scales[col * groupsPerCol + g] = gptqScales[srcRow + col];
-	}
-	const zerosNDiv8 = N >>> 3;
-	for (let g = 0; g < groupsPerCol; g++) {
-		const srcRow = g * zerosNDiv8;
-		for (let col = 0; col < N; col++) {
-			const zeroVal = qzeros[srcRow + (col >>> 3)] >>> (col & 7) * 4 & 15;
-			zeros[col * groupsPerCol + g] = zeroVal + 1;
-		}
-	}
-	return {
-		packed,
-		scales,
-		zeros
-	};
-}
-
-//#endregion
-//#region src/gpu/idb-cache.ts
-/**
-* IndexedDB-backed blob cache for model weights.
-*
-* Why IndexedDB and not the Cache API / OPFS we hand-rolled before:
-*   - The Cache API ignores URL fragments in `match()`, which silently collapsed
-*     our per-tensor `${url}#t:start-len` keys onto one entry → wrong bytes → the
-*     `RRRR` garbage and `wt.data` crashes. IDB keys on the exact string.
-*   - OPFS via Worker (`createSyncAccessHandle`) is finicky on iOS Safari (OOM /
-*     transient failures) and added a lot of moving parts.
-* IndexedDB is the boring, proven large-binary store every browser supports. It
-* keys on arbitrary strings (no fragment footgun), stores ArrayBuffers directly,
-* and is durable (subject to the same per-origin quota as Cache/OPFS — install to
-* Home Screen lifts that ceiling; IDB doesn't change it, it just makes caching
-* actually CORRECT).
-*
-* Inert on Node (no indexedDB) — every export resolves to a miss/no-op so the
-* heap load path is unchanged off the browser.
-*/
-const DB_NAME = "gerbil-weights-v1";
-const STORE = "tensors";
-function idbAvailable() {
-	return typeof indexedDB !== "undefined";
-}
-/**
-* Ask the browser to mark this origin's storage as persistent (exempt from
-* eviction). On iOS Safari a plain tab's storage is evicted under pressure unless
-* persistence is granted (effectively only inside an installed PWA), which is the
-* primary reason a 404 MB model re-downloads on some reloads. We request it
-* up-front on the FIRST cache touch (read OR write) — not only on the first write
-* — so a warm-cache reload re-asserts the request before the browser has a chance
-* to evict mid-session. Best-effort and memoized: a single, idempotent call per
-* page that never throws and never blocks the load. Returns the resulting
-* persisted state (false when unsupported / not granted).
-*/
-let _persistRequested$1 = null;
-function idbRequestPersistence() {
-	if (_persistRequested$1) return _persistRequested$1;
-	_persistRequested$1 = (async () => {
-		try {
-			if (typeof navigator === "undefined") return false;
-			const storage = navigator?.storage;
-			if (!storage) return false;
-			if (await storage.persisted?.() === true) return true;
-			return await storage.persist?.() ?? false;
-		} catch {
-			return false;
-		}
-	})();
-	return _persistRequested$1;
-}
-let _dbPromise = null;
-/**
-* Per-op watchdog. iOS Safari can silently WEDGE an IndexedDB transaction after
-* a large (~400 MB) write session or under quota pressure — it fires NONE of
-* success/error/abort, so an awaiting caller hangs forever. That presents as the
-* load freezing at "reading model.safetensors header" (the first storage op
-* after that label) and is the #1 cause of the on-device load hang. Every op
-* races this timeout and degrades to its fallback (read → miss → network; write
-* → false → heap) instead of hanging.
-*/
-const IDB_OP_TIMEOUT_MS = 12e3;
-/**
-* Drop the memoized connection (and close it) so the NEXT op re-opens a fresh
-* one. A wedged/poisoned connection otherwise persists for the page's lifetime —
-* an in-page retry (no reload) reuses it and hangs again. Closing also aborts
-* the wedged transaction.
-*/
-function poisonConnection(db) {
-	_dbPromise = null;
-	try {
-		db?.close();
-	} catch {}
-}
-function openDB() {
-	if (_dbPromise) return _dbPromise;
-	_dbPromise = new Promise((resolve) => {
-		if (!idbAvailable()) {
-			resolve(null);
-			return;
-		}
-		idbRequestPersistence();
-		try {
-			const req = indexedDB.open(DB_NAME, 1);
-			req.onupgradeneeded = () => {
-				const db = req.result;
-				if (!db.objectStoreNames.contains(STORE)) db.createObjectStore(STORE);
-			};
-			req.onsuccess = () => {
-				const db = req.result;
-				db.onversionchange = () => poisonConnection(db);
-				db.onclose = () => {
-					_dbPromise = null;
-				};
-				resolve(db);
-			};
-			req.onerror = () => resolve(null);
-			req.onblocked = () => resolve(null);
-		} catch {
-			resolve(null);
-		}
-	});
-	return _dbPromise;
-}
-/** A single transaction operation, promisified. Resolves the fallback on any
-* error OR if the op wedges past IDB_OP_TIMEOUT_MS (and then poisons the
-* connection so the next op re-opens fresh). */
-function tx(mode, run, fallback) {
-	return openDB().then((db) => new Promise((resolve) => {
-		if (!db) {
-			resolve(fallback);
-			return;
-		}
-		let settled = false;
-		const finish = (value, poisoned) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			if (poisoned) poisonConnection(db);
-			resolve(value);
-		};
-		const timer = setTimeout(() => finish(fallback, true), IDB_OP_TIMEOUT_MS);
-		try {
-			const t = db.transaction(STORE, mode);
-			const req = run(t.objectStore(STORE));
-			req.onsuccess = () => finish(req.result ?? fallback, false);
-			req.onerror = () => finish(fallback, true);
-			t.onabort = () => finish(fallback, true);
-		} catch {
-			finish(fallback, true);
-		}
-	}));
-}
-/** Read a key's bytes, or null on miss / no IDB / any error. */
-async function idbGet(key) {
-	const v = await tx("readonly", (s) => s.get(key), null);
-	return v instanceof ArrayBuffer ? v : null;
-}
-/**
-* Size-verified read. Returns the bytes ONLY if the cached entry is at least
-* `minBytes` long; otherwise treats it as a corrupt/partial entry: deletes the
-* poisoned key (so a future load re-downloads it instead of trusting it again)
-* and returns null. This is the integrity gate that turns a half-written or
-* partially-evicted tensor into a clean cache-miss rather than wrong bytes (or a
-* later "No GPU buffer for tensor …" crash when get() returns undefined). Pass
-* minBytes <= 0 to skip the size check (behaves like idbGet).
-*/
-async function idbGetVerified(key, minBytes) {
-	const buf = await idbGet(key);
-	if (!buf) return null;
-	if (minBytes > 0 && buf.byteLength < minBytes) {
-		await idbDelete(key);
-		return null;
-	}
-	return buf;
-}
-/**
-* All cached keys, as a Set, in ONE transaction. Probing presence per-tensor
-* (hundreds of parallel getKey transactions) storms Safari's IndexedDB and hangs
-* the load; getAllKeys() does it in a single transaction so callers can check
-* membership in memory. Empty set on miss / no IDB / error.
-*/
-async function idbAllKeys() {
-	const keys = await tx("readonly", (s) => s.getAllKeys(), []);
-	return new Set((keys ?? []).map((k) => String(k)));
-}
-/** Write a key's bytes. Returns true on success, false on quota/error (caller
-* falls back to network — never throws). */
-async function idbPut(key, buf) {
-	return await tx("readwrite", (s) => s.put(buf, key), null) !== null;
-}
-/**
-* Atomic, verified write. Writes the bytes, then reads back the stored length and
-* confirms it matches what we wrote. iOS Safari can let a put() transaction
-* "succeed" yet store a truncated value under quota pressure (or wedge the
-* transaction, which the watchdog turns into a fallback) — leaving a present-but-
-* short entry that the size-blind presence probe would later trust. On any
-* mismatch we DELETE the key so it is never read back as a valid (wrong-size)
-* tensor, and return false so the caller keeps the network bytes. Returns true
-* only when the full-length value is provably persisted.
-*/
-async function idbPutVerified(key, buf) {
-	const expected = buf.byteLength;
-	if (!await idbPut(key, buf)) {
-		await idbDelete(key);
-		return false;
-	}
-	const back = await idbGet(key);
-	if (!back || back.byteLength !== expected) {
-		await idbDelete(key);
-		return false;
+	/** Lazily allocate a scratch storage buffer at least `minBytes` large. */
+	getBindingScratchBuffer(minBytes) {
+		if (!this.bindingScratchBuffer || this.bindingScratchBuffer.size < minBytes) this.bindingScratchBuffer = createStorageBuffer(this.ctx, "binding_scratch", Math.max(minBytes, 256));
+		return this.bindingScratchBuffer;
 	}
-	return true;
-}
-/** Delete a key (best-effort). */
-async function idbDelete(key) {
-	await tx("readwrite", (s) => s.delete(key), null);
-}
-/** True when IndexedDB is usable in this environment (browser, not Node). */
-function idbCacheAvailable() {
-	return idbAvailable();
-}
+};
 
 //#endregion
-//#region src/gpu/safetensors.ts
+//#region src/gpu/gptq-adapter.ts
 /**
-* Parse safetensors header from an ArrayBuffer.
+* Repack GPTQ tensors into Gerbil's flat INT4 format.
 *
-* Can be called with just the header bytes (for streaming — parse header first,
-* then fetch tensor data by offset) or with the entire file.
+* This is pure data reshuffling — no quantization math. The 4-bit values,
+* scales, and zero points are preserved exactly.
 */
-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;
+function repackGPTQ(gptq) {
+	const { qweight, scales: gptqScales, qzeros, K, N, groupSize } = gptq;
+	const totalElements = N * K;
+	const groupsPerCol = Math.ceil(K / groupSize);
+	const totalGroups = N * groupsPerCol;
+	const packed = new Uint32Array(Math.ceil(totalElements / 8));
+	const scales = new Float32Array(totalGroups);
+	const zeros = new Float32Array(totalGroups);
+	for (let k = 0; k < K; k++) {
+		const gptqRow = k >>> 3;
+		const gptqNibblePos = k & 7;
+		const gptqRowBase = gptqRow * N;
+		for (let col = 0; col < N; col++) {
+			const nibble = qweight[gptqRowBase + col] >>> gptqNibblePos * 4 & 15;
+			const flatIdx = col * K + k;
+			const packedIdx = flatIdx >>> 3;
+			const nibblePos = flatIdx & 7;
+			packed[packedIdx] |= nibble << nibblePos * 4;
+		}
+	}
+	for (let g = 0; g < groupsPerCol; g++) {
+		const srcRow = g * N;
+		for (let col = 0; col < N; col++) scales[col * groupsPerCol + g] = gptqScales[srcRow + col];
+	}
+	const zerosNDiv8 = N >>> 3;
+	for (let g = 0; g < groupsPerCol; g++) {
+		const srcRow = g * zerosNDiv8;
+		for (let col = 0; col < N; col++) {
+			const zeroVal = qzeros[srcRow + (col >>> 3)] >>> (col & 7) * 4 & 15;
+			zeros[col * groupsPerCol + g] = zeroVal + 1;
 		}
-		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
+		packed,
+		scales,
+		zeros
 	};
 }
-/** 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;
-	}
-}
+
+//#endregion
+//#region src/gpu/idb-cache.ts
 /**
-* Create a typed array for the given dtype.
+* IndexedDB-backed blob cache for model weights.
 *
-* 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.
+* Why IndexedDB and not the Cache API / OPFS we hand-rolled before:
+*   - The Cache API ignores URL fragments in `match()`, which silently collapsed
+*     our per-tensor `${url}#t:start-len` keys onto one entry → wrong bytes → the
+*     `RRRR` garbage and `wt.data` crashes. IDB keys on the exact string.
+*   - OPFS via Worker (`createSyncAccessHandle`) is finicky on iOS Safari (OOM /
+*     transient failures) and added a lot of moving parts.
+* IndexedDB is the boring, proven large-binary store every browser supports. It
+* keys on arbitrary strings (no fragment footgun), stores ArrayBuffers directly,
+* and is durable (subject to the same per-origin quota as Cache/OPFS — install to
+* Home Screen lifts that ceiling; IDB doesn't change it, it just makes caching
+* actually CORRECT).
+*
+* Inert on Node (no indexedDB) — every export resolves to a miss/no-op so the
+* heap load path is unchanged off the browser.
 */
-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}`);
-	}
+const DB_NAME = "gerbil-weights-v1";
+const STORE = "tensors";
+function idbAvailable() {
+	return typeof indexedDB !== "undefined";
 }
 /**
-* 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.
+* Ask the browser to mark this origin's storage as persistent (exempt from
+* eviction). On iOS Safari a plain tab's storage is evicted under pressure unless
+* persistence is granted (effectively only inside an installed PWA), which is the
+* primary reason a 404 MB model re-downloads on some reloads. We request it
+* up-front on the FIRST cache touch (read OR write) — not only on the first write
+* — so a warm-cache reload re-asserts the request before the browser has a chance
+* to evict mid-session. Best-effort and memoized: a single, idempotent call per
+* page that never throws and never blocks the load. Returns the resulting
+* persisted state (false when unsupported / not granted).
 */
-function getTensorData(buffer, file, entry) {
-	return makeTypedView(buffer, file.dataStart + entry.dataOffset, entry.dataLength, entry.dtype);
+let _persistRequested$1 = null;
+function idbRequestPersistence() {
+	if (_persistRequested$1) return _persistRequested$1;
+	_persistRequested$1 = (async () => {
+		try {
+			if (typeof navigator === "undefined") return false;
+			const storage = navigator?.storage;
+			if (!storage) return false;
+			if (await storage.persisted?.() === true) return true;
+			return await storage.persist?.() ?? false;
+		} catch {
+			return false;
+		}
+	})();
+	return _persistRequested$1;
 }
+let _dbPromise = null;
 /**
-* Convert BF16 (bfloat16) data to F32.
-* BF16 is the upper 16 bits of an IEEE 754 float32, so conversion is a simple left-shift.
+* Per-op watchdog. iOS Safari can silently WEDGE an IndexedDB transaction after
+* a large (~400 MB) write session or under quota pressure — it fires NONE of
+* success/error/abort, so an awaiting caller hangs forever. That presents as the
+* load freezing at "reading model.safetensors header" (the first storage op
+* after that label) and is the #1 cause of the on-device load hang. Every op
+* races this timeout and degrades to its fallback (read → miss → network; write
+* → false → heap) instead of hanging.
 */
-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;
-}
+const IDB_OP_TIMEOUT_MS = 12e3;
 /**
-* Convert F16 (IEEE 754 half-precision) data to F32.
+* Drop the memoized connection (and close it) so the NEXT op re-opens a fresh
+* one. A wedged/poisoned connection otherwise persists for the page's lifetime —
+* an in-page retry (no reload) reuses it and hangs again. Closing also aborts
+* the wedged transaction.
 */
-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) {
+function poisonConnection(db) {
+	_dbPromise = null;
 	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;
-	}
+		db?.close();
+	} catch {}
+}
+function openDB() {
+	if (_dbPromise) return _dbPromise;
+	_dbPromise = new Promise((resolve) => {
+		if (!idbAvailable()) {
+			resolve(null);
+			return;
+		}
+		idbRequestPersistence();
+		try {
+			const req = indexedDB.open(DB_NAME, 1);
+			req.onupgradeneeded = () => {
+				const db = req.result;
+				if (!db.objectStoreNames.contains(STORE)) db.createObjectStore(STORE);
+			};
+			req.onsuccess = () => {
+				const db = req.result;
+				db.onversionchange = () => poisonConnection(db);
+				db.onclose = () => {
+					_dbPromise = null;
+				};
+				resolve(db);
+			};
+			req.onerror = () => resolve(null);
+			req.onblocked = () => resolve(null);
+		} catch {
+			resolve(null);
+		}
+	});
+	return _dbPromise;
 }
-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();
+/** A single transaction operation, promisified. Resolves the fallback on any
+* error OR if the op wedges past IDB_OP_TIMEOUT_MS (and then poisons the
+* connection so the next op re-opens fresh). */
+function tx(mode, run, fallback) {
+	return openDB().then((db) => new Promise((resolve) => {
+		if (!db) {
+			resolve(fallback);
+			return;
+		}
+		let settled = false;
+		const finish = (value, poisoned) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			if (poisoned) poisonConnection(db);
+			resolve(value);
+		};
+		const timer = setTimeout(() => finish(fallback, true), IDB_OP_TIMEOUT_MS);
+		try {
+			const t = db.transaction(STORE, mode);
+			const req = run(t.objectStore(STORE));
+			req.onsuccess = () => finish(req.result ?? fallback, false);
+			req.onerror = () => finish(fallback, true);
+			t.onabort = () => finish(fallback, true);
+		} catch {
+			finish(fallback, true);
+		}
+	}));
 }
-/** 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}`);
-	}
+/** Read a key's bytes, or null on miss / no IDB / any error. */
+async function idbGet(key) {
+	const v = await tx("readonly", (s) => s.get(key), null);
+	return v instanceof ArrayBuffer ? v : null;
 }
 /**
-* Download + parse an adapter (`adapter_config.json` + `adapter_model.safetensors`).
-* Returns null when the source has no adapter (so callers can no-op cleanly).
+* Size-verified read. Returns the bytes ONLY if the cached entry is at least
+* `minBytes` long; otherwise treats it as a corrupt/partial entry: deletes the
+* poisoned key (so a future load re-downloads it instead of trusting it again)
+* and returns null. This is the integrity gate that turns a half-written or
+* partially-evicted tensor into a clean cache-miss rather than wrong bytes (or a
+* later "No GPU buffer for tensor …" crash when get() returns undefined). Pass
+* minBytes <= 0 to skip the size check (behaves like idbGet).
 */
-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
-		});
+async function idbGetVerified(key, minBytes) {
+	const buf = await idbGet(key);
+	if (!buf) return null;
+	if (minBytes > 0 && buf.byteLength < minBytes) {
+		await idbDelete(key);
+		return null;
 	}
-	if (tensors.size === 0) throw new Error(`LoRA: adapter at ${spec} has no lora_A/lora_B tensors.`);
-	return {
-		config,
-		tensors,
-		label: spec
-	};
+	return buf;
 }
 /**
-* 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.
+* All cached keys, as a Set, in ONE transaction. Probing presence per-tensor
+* (hundreds of parallel getKey transactions) storms Safari's IndexedDB and hangs
+* the load; getAllKeys() does it in a single transaction so callers can check
+* membership in memory. Empty set on miss / no IDB / error.
 */
-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`);
+async function idbAllKeys() {
+	const keys = await tx("readonly", (s) => s.getAllKeys(), []);
+	return new Set((keys ?? []).map((k) => String(k)));
 }
-/** 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;
+/** Write a key's bytes. Returns true on success, false on quota/error (caller
+* falls back to network — never throws). */
+async function idbPut(key, buf) {
+	return await tx("readwrite", (s) => s.put(buf, key), null) !== null;
 }
 /**
-* Pair lora_A/lora_B tensors and resolve each to a canonical `LoRADelta`.
-* `keyMapper` must be the same mapper the base model load used.
+* Atomic, verified write. Writes the bytes, then reads back the stored length and
+* confirms it matches what we wrote. iOS Safari can let a put() transaction
+* "succeed" yet store a truncated value under quota pressure (or wedge the
+* transaction, which the watchdog turns into a fallback) — leaving a present-but-
+* short entry that the size-blind presence probe would later trust. On any
+* mismatch we DELETE the key so it is never read back as a valid (wrong-size)
+* tensor, and return false so the caller keeps the network bytes. Returns true
+* only when the full-length value is provably persisted.
 */
-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)));
+async function idbPutVerified(key, buf) {
+	const expected = buf.byteLength;
+	if (!await idbPut(key, buf)) {
+		await idbDelete(key);
+		return false;
 	}
-	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
-		});
+	const back = await idbGet(key);
+	if (!back || back.byteLength !== expected) {
+		await idbDelete(key);
+		return false;
 	}
-	return deltas;
+	return true;
 }
-/**
-* 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
-	};
+/** Delete a key (best-effort). */
+async function idbDelete(key) {
+	await tx("readwrite", (s) => s.delete(key), null);
+}
+/** True when IndexedDB is usable in this environment (browser, not Node). */
+function idbCacheAvailable() {
+	return idbAvailable();
 }
 
 //#endregion
@@ -14836,5 +14926,5 @@ function selectGraphWeights(graph, weights) {
 }
 
 //#endregion
-export { destroyBuffers as C, verifyGPU as E, createUniformBuffer as S, initGPU as T, KERNEL_REGISTRY as _, loadModel as a, createBindGroup as b, loadParlerTTS as c, remapPrunedToken as d, Tokenizer as f, Executor as g, fetchAdapter as h, loadKaniTTS as i, quantizeBackboneInt4 as l, buildLoRADeltas as m, MoonshineEncoderExecutor as n, loadMoonshine as o, applyLoRAToStore as p, createKeyMapperForArch as r, loadOuteTTS as s, MoonshineSTT as t, quantizeKaniBackbone as u, MATMUL_BIAS_F16C_SPEC as v, getOrCreatePipeline as w, createStorageBuffer as x, clearPipelineCache as y };
-//# sourceMappingURL=moonshine-stt-CgDXoLFd.mjs.map
+export { createUniformBuffer as C, verifyGPU as D, initGPU as E, createStorageBuffer as S, getOrCreatePipeline as T, splitFusedQGateDelta as _, loadModel as a, clearPipelineCache as b, loadParlerTTS as c, remapPrunedToken as d, Tokenizer as f, fetchAdapter as g, buildLoRADeltas as h, loadKaniTTS as i, quantizeBackboneInt4 as l, applyLoRAToStore as m, MoonshineEncoderExecutor as n, loadMoonshine as o, Executor as p, createKeyMapperForArch as r, loadOuteTTS as s, MoonshineSTT as t, quantizeKaniBackbone as u, KERNEL_REGISTRY as v, destroyBuffers as w, createBindGroup as x, MATMUL_BIAS_F16C_SPEC as y };
+//# sourceMappingURL=moonshine-stt-BI-5UmD_.mjs.map